Trong Java, làm cách nào để kiểm tra xem chuỗi có chứa chuỗi con (bỏ qua trường hợp) không?

Question

Tôi có hai String s, str1 và str2. Làm cách nào để kiểm tra xem str2 có nằm trong phạm vi str1, bỏ qua trường hợp không?

Answer 1

str1.toLowerCase().contains(str2.toLowerCase()) 

Answer 2

Bạn có thể sử dụng phương pháp toLowerCase():

public boolean contains(String haystack, String needle) { 
    haystack = haystack == null ? "" : haystack; 
    needle = needle == null ? "" : needle; 

    // Works, but is not the best. 
    //return haystack.toLowerCase().indexOf(needle.toLowerCase()) > -1 

    return haystack.toLowerCase().contains(needle.toLowerCase()) 
} 

Sau đó gọi nó là sử dụng:

if(contains(str1, str2)) { 
    System.out.println("Found " + str2 + " within " + str1 + "."); 
} 

ý rằng bằng cách tạo ra phương pháp riêng của mình, bạn có thể tái sử dụng nó. Sau đó, khi ai đó chỉ ra rằng bạn nên sử dụng contains thay vì indexOf, bạn chỉ có một dòng mã để thay đổi.

Answer 3

Tôi muốn sử dụng kết hợp phương pháp chứa và phương thức toUpper là một phần của lớp Chuỗi. Một ví dụ là dưới đây:

String string1 = "AAABBBCCC"; 
String string2 = "DDDEEEFFF"; 
String searchForThis = "AABB"; 

System.out.println("Search1="+string1.toUpperCase().contains(searchForThis.toUpperCase())); 

System.out.println("Search2="+string2.toUpperCase().contains(searchForThis.toUpperCase())); 

này sẽ trở lại:

Search1 = true
Search2 = false

Answer 4

Làm thế nào về matches()?

String string = "Madam, I am Adam"; 

// Starts with 
boolean b = string.startsWith("Mad"); // true 

// Ends with 
b = string.endsWith("dam");    // true 

// Anywhere 
b = string.indexOf("I am") >= 0;  // true 

// To ignore case, regular expressions must be used 

// Starts with 
b = string.matches("(?i)mad.*"); 

// Ends with 
b = string.matches("(?i).*adam"); 

// Anywhere 
b = string.matches("(?i).*i am.*"); 

Answer 5

Nếu bạn có thể sử dụng org.apache.commons.lang.StringUtils, tôi đề nghị sử dụng như sau:

String container = "aBcDeFg"; 
String content = "dE"; 
boolean containerContainsContent = StringUtils.containsIgnoreCase(container, content); 

Answer 6

Tôi cũng ủng hộ giải pháp RegEx. Mã sẽ sạch hơn nhiều. Tôi sẽ ngần ngại sử dụng toLowerCase() trong các tình huống mà tôi biết các chuỗi sẽ lớn, vì các chuỗi không thay đổi và sẽ phải được sao chép. Ngoài ra, các giải pháp match() có thể gây nhầm lẫn bởi vì nó có một biểu thức chính quy như là một đối số (tìm kiếm "Cần $ le" lạnh có vấn đề).

xây dựng trên một số các ví dụ trên:

public boolean containsIgnoreCase(String haystack, String needle) { 
    if(needle.equals("")) 
    return true; 
    if(haystack == null || needle == null || haystack .equals("")) 
    return false; 

    Pattern p = Pattern.compile(needle,Pattern.CASE_INSENSITIVE+Pattern.LITERAL); 
    Matcher m = p.matcher(haystack); 
    return m.find(); 
} 

example call: 

String needle = "Need$le"; 
String haystack = "This is a haystack that might have a need$le in it."; 
if(containsIgnoreCase(haystack, needle)) { 
    System.out.println("Found " + needle + " within " + haystack + "."); 
} 

(Lưu ý:. Bạn có thể muốn để xử lý chuỗi NULL và trống rỗng khác nhau tùy thuộc vào nhu cầu của bạn tôi nghĩ rằng họ cách tôi có nó là gần gũi hơn với spec Java cho dây.)

Các giải pháp quan trọng tốc độ có thể bao gồm lặp qua ký tự haystack bằng ký tự tìm kiếm ký tự đầu tiên của kim. Khi ký tự đầu tiên được khớp (trường hợp không liên tục), bắt đầu lặp lại thông qua ký tự kim theo ký tự, tìm kiếm ký tự tương ứng trong haystack và trả về "true" nếu tất cả các ký tự được khớp. Nếu gặp phải một ký tự không khớp, hãy tiếp tục lặp lại thông qua haystack ở ký tự tiếp theo, trả về "false" nếu đạt được vị trí> haystack.length() - needle.length().