Pencocokan String Tidak Sensitif di Java

1. Gambaran keseluruhan

Terdapat banyak cara untuk memeriksa apakah String mengandungi substring. Dalam artikel ini, kita akan mencari substring dalam String sambil memusatkan perhatian pada penyelesaian peka huruf besar kecil ke String.contains () di Java. Yang paling penting, kami akan memberikan contoh bagaimana menyelesaikan masalah ini.

2. Penyelesaian Paling Mudah: String.toLowerCase

Penyelesaian paling mudah adalah dengan menggunakan String.toLowerCase () . Dalam kes ini, kami akan mengubah kedua rentetan menjadi huruf kecil dan kemudian menggunakan kaedah mengandung () :

assertTrue(src.toLowerCase().contains(dest.toLowerCase()));

Kita juga boleh menggunakan String.toUpperCase () dan ia akan memberikan hasil yang sama.

3. String.matches Dengan Ungkapan Biasa

Pilihan lain adalah dengan menggunakan String.matches () dengan ungkapan biasa:

assertTrue(src.matches("(?i).*" + dest + ".*"));

Kaedah match () memerlukan S tring untuk mewakili ungkapan biasa. (? i) membolehkan ketidakpekaan huruf besar dan . * menggunakan setiap watak kecuali pecahan baris.

4. String.regionMatches

Kita juga boleh menggunakan String.regionMatches () . Ia memeriksa apakah dua wilayah String cocok, menggunakan true untuk parameter ignease :

public static boolean processRegionMatches(String src, String dest) { for (int i = src.length() - dest.length(); i >= 0; i--) if (src.regionMatches(true, i, dest, 0, dest.length())) return true; return false; }
assertTrue(processRegionMatches(src, dest));

Untuk meningkatkan prestasi, ia mula sesuai dengan wilayah, dengan mempertimbangkan panjang String tujuan . Kemudian, ia mengurangkan iterator.

5. Corak Dengan Pilihan CASE_INSENSITIVE

The java.util.regex.Pattern kelas memberikan kita satu cara yang hampir sama tali menggunakan matcher () kaedah. Dalam kes ini, kita dapat menggunakan kaedah petikan () untuk melarikan diri dari sebarang watak khas, dan bendera CASE_INSENSITIVE . Mari kita lihat:

assertTrue(Pattern.compile(Pattern.quote(dest), Pattern.CASE_INSENSITIVE) .matcher(src) .find());

6. StringUtils Apache Commons.containsIgnoreCase

Akhirnya, kami akan memanfaatkan kelas Apache Commons StringUtils :

assertTrue(StringUtils.containsIgnoreCase(src, dest));

7. Perbandingan Prestasi

Seperti dalam artikel umum ini tentang memeriksa substring menggunakan metode berisi , kami menggunakan rangka kerja sumber terbuka Java Microbenchmark Harness (JMH) untuk membandingkan prestasi kaedah dalam nanodetik :

  1. Corak CASE_INSENSITIVE Ungkapan Biasa : 399.387 ns
  2. String toLowerCase : 434.064 ns
  3. String Apache CommonsUtils : 496.313 ns
  4. Pertandingan Wilayah String : 718.842 ns
  5. Rentetan rentetan dengan Ungkapan Biasa : 3964.346 ns

Seperti yang kita lihat, pemenangnya adalah Corak dengan bendera CASE_INSENSITIVE diaktifkan, diikuti dengan toLowerCase () . Kami juga melihat peningkatan yang jelas dalam prestasi antara Java 8 dan Java 11.

8. Kesimpulannya

Dalam tutorial ini, kami melihat beberapa cara yang berbeza untuk memeriksa String untuk substring, sambil mengabaikan casing di Java.

Kami melihat menggunakan String.toLowerCase () dan toUpperCase () , String.matches () , String.regionMatches () , Apache Commons StringUtils.containsIgnoreCase () , dan Pattern.matcher (). Cari () .

Juga, kami menilai prestasi setiap penyelesaian dan mendapati bahawa menggunakan kaedah kompilasi () dari java.util.regex.Pattern dengan bendera CASE_INSENSITIVE menunjukkan prestasi terbaik .

Seperti biasa, kodnya tersedia di GitHub.