编写isLike()方法，用以判断字符串是否匹配。

Question

“a*”: 以字符’a’开头的字符串 
“*bc*”: 包含字符串’bc’的字符串 
“A??”: 以字符’A’开头,且长度为3的字符串 
“?A?”: 以字符’A’居其间，且长度为3的字符串 
class MyString{ 
String str; 
//其它方法或成员定义 
//构造函数 
public Boolean isLike(String regex){ 
…… 
} 
} 
new MyString(“abcd”).isLike(“a*”)--true 
new MyString(“ABCD”).isLike(“*C*”)--true 
new MyString(“ABCD”).isLike(“ABC?”)--true 

Answer 1

public Boolean isLike(String regex){   Pattern pattern = Pattern.compile(regex.toString(), Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher(str);if(matcher.find()) {
  return true;
} 
return false;
}  

Answer 2

a*       ^a{1}.*
*bc*     ^.*bc.*
A??      ^A{1}.{2}
?A?      ^.{1}A.{1}

Answer 3

/**
 * 
 *  a*: 以字符’a’开头的字符串  
 *  *bc*: 包含字符串’bc’的字符串  
 *  A??: 以字符’A’开头,且长度为3的字符串  
 *  ?A?: 以字符’A’居其间，且长度为3的字符串  
 *
 */
public class MyString { private static String str;
public MyString(){

}
public MyString(String string){
str=string;
}
public void setStr(String string){
str=string;
}
public  boolean isLike(String regex){
String regexStr=regex;
if(regexStr.matches("^\\w+\\*$")){
regexStr=regexStr.replace("*", ".*");
}
if(regexStr.matches("^\\*\\w+\\*$")){
regexStr=regexStr.replaceFirst("\\*","^.*");
}
if(regexStr.contains("?")){
regexStr=regexStr.replaceAll("\\?", ".");
}
return str.matches(regexStr);
}

public static void main(String[] args){
System.out.println(new MyString("abcd").isLike("a*"));
System.out.println(new MyString("ABCD").isLike("*C*"));
System.out.println(new MyString("ABCD").isLike("ABC?"));
}
}去测试下，不符合再修改- -！

Answer 4

public class MyString {
private String s; public MyString(String s) {
this.s = s;
} public boolean isLike(String regex) {
regex = regex.replaceAll("[\\?]", "\\\\w");
regex = regex.replaceAll("\\*", ".*");
return s.matches(regex);
} public static void main(String[] args) {
boolean b1 = new MyString("abcd").isLike("a*");
boolean b2 = new MyString("ABCD").isLike("*C*");
boolean b3 = new MyString("ABCD").isLike("ABC?");
boolean b4 = new MyString("ABCD").isLike("??C?");
boolean b5 = new MyString("ABCD").isLike("a*");
System.out.println(b1);
System.out.println(b2);
System.out.println(b3);
System.out.println(b4);
System.out.println(b5);
}
}
输出:
true
true
true
true
false

Answer 5

差不多都是这种方法：public class MatchString {
    private String string;    public MatchString(String string) {
        this.string = string;
    }    public boolean isLike(String regex) {
        String re = regex;
        re = re.replaceAll("[*]", ".*");
        re = re.replaceAll("[?]", ".");
        Pattern p = Pattern.compile(re);
        Matcher m = p.matcher(string);
        return m.matches();
    }    /**
     * @param args
     */
    public static void main(String[] args) {
        MatchString s = new MatchString("#$**1a22b3c4dc5555");
        // 111a222b3c44444dc55555
        System.out.println(s.isLike("????*?a??b?c*dc*"));
    }}

Answer 6

并不像楼上所说的那么简单，正则表达式有 15 个元字符，在运用时需要转义。import java.util.regex.Pattern;public class Test {    public static void main(String[] args) {
        MyString s = new MyString("[bc2");
        System.out.println(s.isLike("[b*"));
    }
}class MyString {    // remove "?", "*"
    private final static char[] REGEX_CHAR = "\\.^${[()]}+|".toCharArray();    private String str;    public MyString(String str) {
        this.str = str;
    }    public boolean isNull() {
        return (str == null);
    }    public int length() {
        if(isNull()) {
            return -1;
        }
        return str.length();
    }    public boolean isLike(String pattern) {
        return isLike(pattern, true);
    }    public boolean isLike(String pattern, boolean isCaseInsensitive) {
        if(pattern == null) {
            throw new NullPointerException("pattern is null");
        }
        if(isNull()) {
            return false;
        }
        return toRegex(pattern, isCaseInsensitive).matcher(str).matches();
    }    private Pattern toRegex(String pattern, boolean isCaseInsensitive) {
        StringBuilder sb = new StringBuilder(pattern.length());
        char[] cs = pattern.toCharArray();
        for(int i = 0; i < cs.length; i++) {
            if(cs[i] == '?') {
                sb.append('.');
                continue;
            }
            if(cs[i] == '*') {
                sb.append('.').append('*');
                continue;
            }
            if(isRegexChar(cs[i])) {
                sb.append('\\');
            }
            sb.append(cs[i]);
        }
        if(isCaseInsensitive) {
            return Pattern.compile(sb.toString());
        } else {
            return Pattern.compile(sb.toString(), Pattern.CASE_INSENSITIVE);
        }
    }    private boolean isRegexChar(char c) {
        for(int i = 0; i < REGEX_CHAR.length; i++) {
            if(REGEX_CHAR[i] == c) {
                return true;
            }
        }
        return false;
    }
}