blocks|key|5243315|text|是的，包含区分大小写。您可以使用带有CASE_INSENSITIVE标志的java.util.regex.Pattern进行不区分大小写的匹配：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5243316|Pattern.compile(Pattern.quote(wantedStr),+Pattern.CASE_INSENSITIVE).matcher(source).find();|code-block|syntax|javascript|5243317|编辑：如果s2包含正则表达式特殊字符(有很多)，首先引用它是很重要的。我已经更正了我的答案，因为这是人们将看到的第一个答案，但投票支持Matt+Quail的答案，因为他指出了这一点。|offset|length|style|BOLD|5243318|entityMap^0|0|0|0|3|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Yes, contains is case sensitive. You can use java.util.regex.Pattern with the CASE_INSENSITIVE flag for case insensitive matching:

<pre><code>Pattern.compile(Pattern.quote(wantedStr), Pattern.CASE_INSENSITIVE).matcher(source).find();
</code></pre>

EDIT: If s2 contains regex special characters (of which there are many) it's important to quote it first. I've corrected my answer since it is the first one people will see, but vote up Matt Quail's since he pointed this out.

blocks|key|5243348|text|我不确定你的主要问题是什么，但是的，.contains区分大小写。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5243349|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I'm not sure what your main question is here, but yes, .contains is case sensitive.

blocks|key|5243414|text|the+answer+by+Dave+L.的一个问题是当s2包含\d等正则表达式标记时。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5243415|您希望在s2上调用Pattern.quote()：|5243416|Pattern.compile(Pattern.quote(s2),+Pattern.CASE_INSENSITIVE).matcher(s1).find();|code-block|syntax|javascript|5243417|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/86780/is-the-contains-method-in-java-lang-string-case-sensitive/86832#86832^0|W|2|0|L|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|G|5|6|7|10|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|11|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

One problem with <a href="https://stackoverflow.com/questions/86780/is-the-contains-method-in-java-lang-string-case-sensitive/86832#86832">the answer by Dave L.</a> is when s2 contains regex markup such as <code>\d</code>, etc.

You want to call Pattern.quote() on s2:

<pre><code>Pattern.compile(Pattern.quote(s2), Pattern.CASE_INSENSITIVE).matcher(s1).find();
</code></pre>

blocks|key|5243474|text|是的，这是可以实现的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5243475|String+s1+=+"abBaCca";
String+s2+=+"bac";

String+s1Lower+=+s1;

//s1Lower+is+exact+same+string,+now+convert+it+to+lowercase,+I+left+the+s1+intact+for+print+purposes+if+needed

s1Lower+=+s1Lower.toLowerCase();

String+trueStatement+=+"FALSE!";
if+(s1Lower.contains(s2))+{

++++//THIS+statement+will+be+TRUE
++++trueStatement+=+"TRUE!"
}

return+trueStatement;|code-block|syntax|javascript|5243476|此代码将返回字符串"TRUE!“因为它发现你的角色被控制住了。|5243477|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Yes, this is achievable:

<pre><code>String s1 = "abBaCca";
String s2 = "bac";

String s1Lower = s1;

//s1Lower is exact same string, now convert it to lowercase, I left the s1 intact for print purposes if needed

s1Lower = s1Lower.toLowerCase();

String trueStatement = "FALSE!";
if (s1Lower.contains(s2)) {

 //THIS statement will be TRUE
 trueStatement = "TRUE!"
}

return trueStatement;
</code></pre>

This code will return the String "TRUE!" as it found that your characters were contained.

blocks|key|2988632|text|String+x="abCd";
System.out.println(Pattern.compile("c",Pattern.CASE_INSENSITIVE).matcher(x).find());|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2988633|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>String x="abCd";
System.out.println(Pattern.compile("c",Pattern.CASE_INSENSITIVE).matcher(x).find());
</code></pre>

blocks|key|750684|text|一种更简单的方法(不用担心模式匹配)是将两个String都转换为小写：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|750685|String+foobar+=+"fooBar";
String+bar+=+"FOO";
if+(foobar.toLowerCase().contains(bar.toLowerCase())+{
++++System.out.println("It's+a+match!");
}|code-block|syntax|javascript|750686|entityMap^0|M|6|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

A simpler way of doing this (without worrying about pattern matching) would be converting both <code>String</code>s to lowercase:

<pre><code>String foobar = "fooBar";
String bar = "FOO";
if (foobar.toLowerCase().contains(bar.toLowerCase()) {
 System.out.println("It's a match!");
}
</code></pre>

blocks|key|5243633|text|您可以使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5243634|org.apache.commons.lang3.StringUtils.containsIgnoreCase("AbBaCca",+"bac");|code-block|syntax|javascript|5243635|对于这类事情，Apache+Commons库非常有用。这个特殊的表达式可能比正则表达式更好，因为正则表达式在性能方面总是很昂贵。|offset|length|5243636|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Apache_Commons^0|0|0|7|E|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

You can use 

<pre><code>org.apache.commons.lang3.StringUtils.containsIgnoreCase("AbBaCca", "bac");
</code></pre>

The <a href="https://en.wikipedia.org/wiki/Apache_Commons" rel="noreferrer">Apache Commons</a> library is very useful for this sort of thing. And this particular one may be better than regular expressions as regex is always expensive in terms of performance.

blocks|key|3833191|text|您可以使用regular+expressions，它可以工作：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3833192|boolean+found+=+s1.matches("(?i).*"+%2B+s2%2B+".*");|code-block|syntax|javascript|3833193|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Regular_expression^0|5|J|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

You can use <a href="http://en.wikipedia.org/wiki/Regular_expression" rel="nofollow">regular expressions</a>, and it works:

<pre><code>boolean found = s1.matches("(?i).*" + s2+ ".*");
</code></pre>

blocks|key|747414|text|我做了一个测试，发现字符串不区分大小写。我有一个包含150,000个对象的Vector，所有对象都有一个字符串作为一个字段，希望找到与字符串匹配的子集。我尝试了三种方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|747415|747416|将全部转换为小写|ordered-list-item|747417|747418|对于(歌曲:歌曲){+if+(song.artist.toLowerCase().indexOf(pattern.toLowercase()+>+-1)+{+...+}}|747419|使用String+matches()方法|unordered-list-item|747420|747421|对于(SongInformation歌曲:歌曲){+if+(song.artist.matches("(?i).*“%2B+pattern+%2B+".*"))+{+...+}}|747422|使用正则表达式|747423|747424|Pattern+p=+Pattern.compile(pattern，Pattern.CASE_INSENSITIVE)；Matcher+m=+p.matcher("")；for+(SongInformation歌曲:歌曲){+m.reset(song.artist)；if+(m.find())+{+...+}+}|747425|计时结果为：|747426|747427|无尝试匹配:+20毫秒|747428|To+lower匹配:+182毫秒|747429|字符串匹配:+278+msecs|747430|Regular表达式:+65毫秒|747431|747432|对于这种用例，正则表达式看起来是最快的。|747433|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|19|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|1B|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|1D|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|1E|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1G|8|@]|9|@]|A|$]]|$1|O|3|P|5|K|7|1H|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|1J|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|1K|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]|$1|W|3|X|5|K|7|1M|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|K|7|1N|8|@]|9|@]|A|$]]|$1|10|3|11|5|K|7|1O|8|@]|9|@]|A|$]]|$1|12|3|13|5|K|7|1P|8|@]|9|@]|A|$]]|$1|14|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|15|3|16|5|6|7|1R|8|@]|9|@]|A|$]]|$1|17|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]]|18|$]]

I did a test finding a case-insensitive match of a string. I have a Vector of 150,000 objects all with a String as one field and wanted to find the subset which matched a string. I tried three methods:

<ol>
<li>Convert all to lower case

<pre><code>for (SongInformation song: songs) {
 if (song.artist.toLowerCase().indexOf(pattern.toLowercase() &gt; -1) {
 ...
 }
}
</code></pre></li>
<li>Use the String matches() method

<pre><code>for (SongInformation song: songs) {
 if (song.artist.matches("(?i).*" + pattern + ".*")) {
 ...
 }
}
</code></pre></li>
<li>Use regular expressions

<pre><code>Pattern p = Pattern.compile(pattern, Pattern.CASE_INSENSITIVE);
Matcher m = p.matcher("");
for (SongInformation song: songs) {
 m.reset(song.artist);
 if (m.find()) {
 ...
 }
}
</code></pre></li>
</ol>

Timing results are:

<ul>
<li>No attempted match: 20 msecs</li>
<li>To lower match: 182 msecs</li>
<li>String matches: 278 msecs</li>
<li>Regular expression: 65 msecs</li>
</ul>

The regular expression looks to be the fastest for this use case.

blocks|key|5243755|text|String+container+=+"+Case+SeNsitive+";
String+sub+=+"sen";
if+(rcontains(container,+sub))+{
++++System.out.println("no+case");
}

public+static+Boolean+rcontains(String+container,+String+sub)+{

++++Boolean+b+=+false;
++++for+(int+a+=+0;+a+<+container.length()+-+sub.length()+%2B+1;+a%2B%2B)+{
++++++++//System.out.println(sub+%2B+"+to+"+%2B+container.substring(a,+a%2Bsub.length()));
++++++++if+(sub.equalsIgnoreCase(container.substring(a,+a+%2B+sub.length())))+{
++++++++++++b+=+true;
++++++++}
++++}
++++return+b;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|5243756|基本上，它是一个接受两个字符串的方法。它应该是contains()的一个不区分大小写的版本。使用contains方法时，您希望查看一个字符串是否包含在另一个字符串中。|unstyled|5243757|此方法获取"sub“的字符串，并检查它是否等于容器字符串的子字符串，这些子字符串的长度与"sub”相同。如果查看for循环，您将看到它在容器字符串上的子字符串(即“sub”的长度)中迭代。|offset|length|style|CODE|5243758|每次迭代都会检查容器字符串的子字符串是否对该子字符串是equalsIgnoreCase。|5243759|entityMap^0|0|0|1K|3|0|R|G|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|R|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|F|7|V|8|@$I|W|J|X|K|L]]|9|@]|A|$]]|$1|O|3|-4|5|F|7|Y|8|@]|9|@]|A|$]]]|P|$]]

<pre><code>String container = " Case SeNsitive ";
String sub = "sen";
if (rcontains(container, sub)) {
 System.out.println("no case");
}

public static Boolean rcontains(String container, String sub) {

 Boolean b = false;
 for (int a = 0; a &lt; container.length() - sub.length() + 1; a++) {
 //System.out.println(sub + " to " + container.substring(a, a+sub.length()));
 if (sub.equalsIgnoreCase(container.substring(a, a + sub.length()))) {
 b = true;
 }
 }
 return b;
}
</code></pre>

Basically, it is a method that takes two strings. It is supposed to be a not-case sensitive version of contains(). When using the contains method, you want to see if one string is contained in the other.

This method takes the string that is "sub" and checks if it is equal to the substrings of the container string that are equal in length to the "sub". If you look at the <code>for</code> loop, you will see that it iterates in substrings (that are the length of the "sub") over the container string.

Each iteration checks to see if the substring of the container string is <code>equalsIgnoreCase</code> to the sub.

blocks|key|3833294|text|这里有一些Unicode友好的代码，如果您使用ICU4j，您可以创建它们。我猜“忽略大小写”对于方法名称来说是有问题的，因为尽管主要强度比较确实忽略了大小写，但它被描述为依赖于区域设置的细节。但它希望以用户期望的方式依赖于语言环境。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3833295|public+static+boolean+containsIgnoreCase(String+haystack,+String+needle)+{
++++return+indexOfIgnoreCase(haystack,+needle)+>=+0;
}

public+static+int+indexOfIgnoreCase(String+haystack,+String+needle)+{
++++StringSearch+stringSearch+=+new+StringSearch(needle,+haystack);
++++stringSearch.getCollator().setStrength(Collator.PRIMARY);
++++return+stringSearch.first();
}|code-block|syntax|javascript|3833296|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's some Unicode-friendly ones you can make if you pull in ICU4j. I guess "ignore case" is questionable for the method names because although primary strength comparisons do ignore case, it's described as the specifics being locale-dependent. But it's hopefully locale-dependent in a way the user would expect.

<pre><code>public static boolean containsIgnoreCase(String haystack, String needle) {
 return indexOfIgnoreCase(haystack, needle) &gt;= 0;
}

public static int indexOfIgnoreCase(String haystack, String needle) {
 StringSearch stringSearch = new StringSearch(needle, haystack);
 stringSearch.getCollator().setStrength(Collator.PRIMARY);
 return stringSearch.first();
}
</code></pre>

blocks|key|3833391|text|一种更快的实现:利用String.regionMatches()|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3833392|使用regexp可能相对较慢。如果你只想在一种情况下进行检查，那么它(速度慢)并不重要。但是，如果您有一个数组或数千或数十万个字符串的集合，事情可能会变得相当慢。|3833393|下面介绍的解决方案既不使用正则表达式，也不使用toLowerCase()+(这也很慢，因为它创建了另一个字符串，并在检查后将其丢弃)。|3833394|该解决方案构建在似乎未知的方法之上。它检查两个String区域是否匹配，但重要的是，它还具有一个带有方便的ignoreCase参数的重载。|3833395|public+static+boolean+containsIgnoreCase(String+src,+String+what)+{
++++final+int+length+=+what.length();
++++if+(length+==+0)
++++++++return+true;+//+Empty+string+is+contained

++++final+char+firstLo+=+Character.toLowerCase(what.charAt(0));
++++final+char+firstUp+=+Character.toUpperCase(what.charAt(0));

++++for+(int+i+=+src.length()+-+length;+i+>=+0;+i--)+{
++++++++//+Quick+check+before+calling+the+more+expensive+regionMatches()+method:
++++++++final+char+ch+=+src.charAt(i);
++++++++if+(ch+!=+firstLo+&&+ch+!=+firstUp)
++++++++++++continue;

++++++++if+(src.regionMatches(true,+i,+what,+0,+length))
++++++++++++return+true;
++++}

++++return+false;
}|code-block|syntax|javascript|3833396|速度分析|3833397|这种速度分析并不意味着是火箭科学，只是粗略地描述了不同方法的速度。|3833398|我比较了5种方法。|3833399|通过将两个字符串转换为小写，调用String.contains().|3833400|By将源字符串转换为小写，并使用预缓存的小写的子字符串调用String.contains()来调用containsIgnoreCase()方法。|unordered-list-item|BOLD|3833401|
|3833402|。这个解决方案已经不那么灵活了，因为它测试了一个预定义的substring.|3833403|3833404|Using正则表达式(接受的答案是Pattern.compile().matcher().find()...)|3833405|3833406|Using正则表达式，但带有预先创建和缓存的Pattern。这个解决方案已经不那么灵活了，因为它测试了一个预定义的子串。|3833407|3833408|结果(通过调用该方法1000万次)：|3833409|3833410|我们的方法:+670毫秒|ordered-list-item|3833411|2x+toLowerCase()和contains()：2829毫秒|3833412|1x+toLowerCase()和contains()及其缓存子字符串:+2446毫秒|3833413|正则表达式:+7180毫秒|3833414|<代码>H133带有缓存的正则表达式<代码>D34：1845毫秒<代码>H235<代码>G236|3833415|表中的结果：|3833416|++++++++++++++++++++++++++++++++++++++++++++RELATIVE+SPEED+++1/RELATIVE+SPEED
+METHOD++++++++++++++++++++++++++EXEC+TIME++++TO+SLOWEST++++++TO+FASTEST+(#1)
------------------------------------------------------------------------------
+1.+Using+regionMatches()++++++++++670+ms+++++++10.7x++++++++++++1.0x
+2.+2x+lowercase%2Bcontains+++++++++2829+ms++++++++2.5x++++++++++++4.2x
+3.+1x+lowercase%2Bcontains+cache+++2446+ms++++++++2.9x++++++++++++3.7x
+4.+Regexp++++++++++++++++++++++++7180+ms++++++++1.0x+++++++++++10.7x
+5.+Regexp%2Bcached+pattern+++++++++1845+ms++++++++3.9x++++++++++++2.8x|3833417|我们的方法的比使用contains()快4倍，比使用正则表达式快10倍，也快3倍，即使Pattern是预先缓存的(并且失去了检查任意子字符串的灵活性)。|3833418|3833419|分析测试代码|3833420|如果您对分析是如何执行的感兴趣，下面是完整的可运行应用程序：|3833421|import+java.util.regex.Pattern;

public+class+ContainsAnalysis+{

++++//+Case+1+utilizing+String.regionMatches()
++++public+static+boolean+containsIgnoreCase(String+src,+String+what)+{
++++++++final+int+length+=+what.length();
++++++++if+(length+==+0)
++++++++++++return+true;+//+Empty+string+is+contained

++++++++final+char+firstLo+=+Character.toLowerCase(what.charAt(0));
++++++++final+char+firstUp+=+Character.toUpperCase(what.charAt(0));

++++++++for+(int+i+=+src.length()+-+length;+i+>=+0;+i--)+{
++++++++++++//+Quick+check+before+calling+the+more+expensive+regionMatches()
++++++++++++//+method:
++++++++++++final+char+ch+=+src.charAt(i);
++++++++++++if+(ch+!=+firstLo+&&+ch+!=+firstUp)
++++++++++++++++continue;

++++++++++++if+(src.regionMatches(true,+i,+what,+0,+length))
++++++++++++++++return+true;
++++++++}

++++++++return+false;
++++}

++++//+Case+2+with+2x+toLowerCase()+and+contains()
++++public+static+boolean+containsConverting(String+src,+String+what)+{
++++++++return+src.toLowerCase().contains(what.toLowerCase());
++++}

++++//+The+cached+substring+for+case+3
++++private+static+final+String+S+=+"i+am".toLowerCase();

++++//+Case+3+with+pre-cached+substring+and+1x+toLowerCase()+and+contains()
++++public+static+boolean+containsConverting(String+src)+{
++++++++return+src.toLowerCase().contains(S);
++++}

++++//+Case+4+with+regexp
++++public+static+boolean+containsIgnoreCaseRegexp(String+src,+String+what)+{
++++++++return+Pattern.compile(Pattern.quote(what),+Pattern.CASE_INSENSITIVE)
++++++++++++++++++++.matcher(src).find();
++++}

++++//+The+cached+pattern+for+case+5
++++private+static+final+Pattern+P+=+Pattern.compile(
++++++++++++Pattern.quote("i+am"),+Pattern.CASE_INSENSITIVE);

++++//+Case+5+with+pre-cached+Pattern
++++public+static+boolean+containsIgnoreCaseRegexp(String+src)+{
++++++++return+P.matcher(src).find();
++++}

++++//+Main+method:+perfroms+speed+analysis+on+different+contains+methods
++++//+(case+ignored)
++++public+static+void+main(String[]+args)+throws+Exception+{
++++++++final+String+src+=+"Hi,+I+am+Adam";
++++++++final+String+what+=+"i+am";

++++++++long+start,+end;
++++++++final+int+N+=+10_000_000;

++++++++start+=+System.nanoTime();
++++++++for+(int+i+=+0;+i+<+N;+i%2B%2B)
++++++++++++containsIgnoreCase(src,+what);
++++++++end+=+System.nanoTime();
++++++++System.out.println("Case+1+took+"+%2B+((end+-+start)+/+1000000)+%2B+"ms");

++++++++start+=+System.nanoTime();
++++++++for+(int+i+=+0;+i+<+N;+i%2B%2B)
++++++++++++containsConverting(src,+what);
++++++++end+=+System.nanoTime();
++++++++System.out.println("Case+2+took+"+%2B+((end+-+start)+/+1000000)+%2B+"ms");

++++++++start+=+System.nanoTime();
++++++++for+(int+i+=+0;+i+<+N;+i%2B%2B)
++++++++++++containsConverting(src);
++++++++end+=+System.nanoTime();
++++++++System.out.println("Case+3+took+"+%2B+((end+-+start)+/+1000000)+%2B+"ms");

++++++++start+=+System.nanoTime();
++++++++for+(int+i+=+0;+i+<+N;+i%2B%2B)
++++++++++++containsIgnoreCaseRegexp(src,+what);
++++++++end+=+System.nanoTime();
++++++++System.out.println("Case+4+took+"+%2B+((end+-+start)+/+1000000)+%2B+"ms");

++++++++start+=+System.nanoTime();
++++++++for+(int+i+=+0;+i+<+N;+i%2B%2B)
++++++++++++containsIgnoreCaseRegexp(src);
++++++++end+=+System.nanoTime();
++++++++System.out.println("Case+5+took+"+%2B+((end+-+start)+/+1000000)+%2B+"ms");
++++}

}|3833422|entityMap^0|A|M|0|0|N|D|0|N|6|1H|A|0|0|0|0|0|G|H|0|T|H|1D|K|0|0|0|0|H|Y|0|0|M|7|0|0|0|0|0|0|0|0|0|0|0|9|A|17|7|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|26|8|@$9|27|A|28|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|29|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|2A|8|@$9|2B|A|2C|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|2D|8|@$9|2E|A|2F|B|C]|$9|2G|A|2H|B|C]]|D|@]|E|$]]|$1|L|3|M|5|N|7|2I|8|@]|D|@]|E|$O|P]]|$1|Q|3|R|5|6|7|2J|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|2K|8|@]|D|@]|E|$]]|$1|U|3|V|5|6|7|2L|8|@]|D|@]|E|$]]|$1|W|3|X|5|6|7|2M|8|@$9|2N|A|2O|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|10|7|2P|8|@$9|2Q|A|2R|B|C]|$9|2S|A|2T|B|11]]|D|@]|E|$]]|$1|12|3|13|5|6|7|2U|8|@]|D|@]|E|$]]|$1|14|3|15|5|10|7|2V|8|@]|D|@]|E|$]]|$1|16|3|13|5|6|7|2W|8|@]|D|@]|E|$]]|$1|17|3|18|5|10|7|2X|8|@$9|2Y|A|2Z|B|C]]|D|@]|E|$]]|$1|19|3|13|5|6|7|30|8|@]|D|@]|E|$]]|$1|1A|3|1B|5|10|7|31|8|@$9|32|A|33|B|C]]|D|@]|E|$]]|$1|1C|3|-4|5|6|7|34|8|@]|D|@]|E|$]]|$1|1D|3|1E|5|6|7|35|8|@]|D|@]|E|$]]|$1|1F|3|-4|5|6|7|36|8|@]|D|@]|E|$]]|$1|1G|3|1H|5|1I|7|37|8|@]|D|@]|E|$]]|$1|1J|3|1K|5|1I|7|38|8|@]|D|@]|E|$]]|$1|1L|3|1M|5|1I|7|39|8|@]|D|@]|E|$]]|$1|1N|3|1O|5|1I|7|3A|8|@]|D|@]|E|$]]|$1|1P|3|1Q|5|6|7|3B|8|@]|D|@]|E|$]]|$1|1R|3|1S|5|6|7|3C|8|@]|D|@]|E|$]]|$1|1T|3|1U|5|N|7|3D|8|@]|D|@]|E|$O|P]]|$1|1V|3|1W|5|6|7|3E|8|@$9|3F|A|3G|B|C]|$9|3H|A|3I|B|C]]|D|@]|E|$]]|$1|1X|3|-4|5|6|7|3J|8|@]|D|@]|E|$]]|$1|1Y|3|1Z|5|6|7|3K|8|@]|D|@]|E|$]]|$1|20|3|21|5|6|7|3L|8|@]|D|@]|E|$]]|$1|22|3|23|5|N|7|3M|8|@]|D|@]|E|$O|P]]|$1|24|3|-4|5|6|7|3N|8|@]|D|@]|E|$]]]|25|$]]

<h2>A Faster Implementation: Utilizing <code>String.regionMatches()</code></h2>

Using regexp can be relatively slow. It (being slow) doesn't matter if you just want to check in one case. But if you have an array or a collection of thousands or hundreds of thousands of strings, things can get pretty slow.

The presented solution below doesn't use regular expressions nor <code>toLowerCase()</code> (which is also slow because it creates another strings and just throws them away after the check).

The solution builds on the <a href="http://docs.oracle.com/javase/8/docs/api/java/lang/String.html#regionMatches-boolean-int-java.lang.String-int-int-">String.regionMatches()</a> method which seems to be unknown. It checks if 2 <code>String</code> regions match, but what's important is that it also has an overload with a handy <code>ignoreCase</code> parameter.

<pre><code>public static boolean containsIgnoreCase(String src, String what) {
 final int length = what.length();
 if (length == 0)
 return true; // Empty string is contained

 final char firstLo = Character.toLowerCase(what.charAt(0));
 final char firstUp = Character.toUpperCase(what.charAt(0));

 for (int i = src.length() - length; i &gt;= 0; i--) {
 // Quick check before calling the more expensive regionMatches() method:
 final char ch = src.charAt(i);
 if (ch != firstLo &amp;&amp; ch != firstUp)
 continue;

 if (src.regionMatches(true, i, what, 0, length))
 return true;
 }

 return false;
}
</code></pre>

<h2>Speed Analysis</h2>

This speed analysis does not mean to be rocket science, just a rough picture of how fast the different methods are.

I compare 5 methods.

<ol>
<li>Our containsIgnoreCase() method.</li>
<li>By converting both strings to lower-case and call <code>String.contains()</code>.</li>
<li>By converting source string to lower-case and call <code>String.contains()</code> with the pre-cached, lower-cased substring. This solution is already not as flexible because it tests a predefiend substring.</li>
<li>Using regular expression (the accepted answer <code>Pattern.compile().matcher().find()</code>...)</li>
<li>Using regular expression but with pre-created and cached <code>Pattern</code>. This solution is already not as flexible because it tests a predefined substring.</li>
</ol>

Results (by calling the method 10 million times):

<ol>
<li>Our method: 670 ms</li>
<li>2x toLowerCase() and contains(): 2829 ms</li>
<li>1x toLowerCase() and contains() with cached substring: 2446 ms</li>
<li>Regexp: 7180 ms</li>
<li>Regexp with cached <code>Pattern</code>: 1845 ms</li>
</ol>

Results in a table:

<pre><code> RELATIVE SPEED 1/RELATIVE SPEED
 METHOD EXEC TIME TO SLOWEST TO FASTEST (#1)
------------------------------------------------------------------------------
 1. Using regionMatches() 670 ms 10.7x 1.0x
 2. 2x lowercase+contains 2829 ms 2.5x 4.2x
 3. 1x lowercase+contains cache 2446 ms 2.9x 3.7x
 4. Regexp 7180 ms 1.0x 10.7x
 5. Regexp+cached pattern 1845 ms 3.9x 2.8x
</code></pre>

Our method is 4x faster compared to lowercasing and using <code>contains()</code>, 10x faster compared to using regular expressions and also 3x faster even if the <code>Pattern</code> is pre-cached (and losing flexibility of checking for an arbitrary substring).

<hr>

<h2>Analysis Test Code</h2>

If you're interested how the analysis was performed, here is the complete runnable application:

<pre><code>import java.util.regex.Pattern;

public class ContainsAnalysis {

 // Case 1 utilizing String.regionMatches()
 public static boolean containsIgnoreCase(String src, String what) {
 final int length = what.length();
 if (length == 0)
 return true; // Empty string is contained

 final char firstLo = Character.toLowerCase(what.charAt(0));
 final char firstUp = Character.toUpperCase(what.charAt(0));

 for (int i = src.length() - length; i &gt;= 0; i--) {
 // Quick check before calling the more expensive regionMatches()
 // method:
 final char ch = src.charAt(i);
 if (ch != firstLo &amp;&amp; ch != firstUp)
 continue;

 if (src.regionMatches(true, i, what, 0, length))
 return true;
 }

 return false;
 }

 // Case 2 with 2x toLowerCase() and contains()
 public static boolean containsConverting(String src, String what) {
 return src.toLowerCase().contains(what.toLowerCase());
 }

 // The cached substring for case 3
 private static final String S = "i am".toLowerCase();

 // Case 3 with pre-cached substring and 1x toLowerCase() and contains()
 public static boolean containsConverting(String src) {
 return src.toLowerCase().contains(S);
 }

 // Case 4 with regexp
 public static boolean containsIgnoreCaseRegexp(String src, String what) {
 return Pattern.compile(Pattern.quote(what), Pattern.CASE_INSENSITIVE)
 .matcher(src).find();
 }

 // The cached pattern for case 5
 private static final Pattern P = Pattern.compile(
 Pattern.quote("i am"), Pattern.CASE_INSENSITIVE);

 // Case 5 with pre-cached Pattern
 public static boolean containsIgnoreCaseRegexp(String src) {
 return P.matcher(src).find();
 }

 // Main method: perfroms speed analysis on different contains methods
 // (case ignored)
 public static void main(String[] args) throws Exception {
 final String src = "Hi, I am Adam";
 final String what = "i am";

 long start, end;
 final int N = 10_000_000;

 start = System.nanoTime();
 for (int i = 0; i &lt; N; i++)
 containsIgnoreCase(src, what);
 end = System.nanoTime();
 System.out.println("Case 1 took " + ((end - start) / 1000000) + "ms");

 start = System.nanoTime();
 for (int i = 0; i &lt; N; i++)
 containsConverting(src, what);
 end = System.nanoTime();
 System.out.println("Case 2 took " + ((end - start) / 1000000) + "ms");

 start = System.nanoTime();
 for (int i = 0; i &lt; N; i++)
 containsConverting(src);
 end = System.nanoTime();
 System.out.println("Case 3 took " + ((end - start) / 1000000) + "ms");

 start = System.nanoTime();
 for (int i = 0; i &lt; N; i++)
 containsIgnoreCaseRegexp(src, what);
 end = System.nanoTime();
 System.out.println("Case 4 took " + ((end - start) / 1000000) + "ms");

 start = System.nanoTime();
 for (int i = 0; i &lt; N; i++)
 containsIgnoreCaseRegexp(src);
 end = System.nanoTime();
 System.out.println("Case 5 took " + ((end - start) / 1000000) + "ms");
 }

}
</code></pre>

blocks|key|747548|text|如果您必须在另一个ASCII字符串中搜索ASCII字符串，例如URL，您会发现我的解决方案更好。我测试了icza的方法和我的方法的速度，结果如下：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|747549|747550|Case+1耗时2788毫秒-+regionMatches|unordered-list-item|747551|Case+2耗时1520毫秒-+my|747552|747553|代码：|747554|public+static+String+lowerCaseAscii(String+s)+{
++++if+(s+==+null)
++++++++return+null;

++++int+len+=+s.length();
++++char[]+buf+=+new+char[len];
++++s.getChars(0,+len,+buf,+0);
++++for+(int+i=0;+i<len;+i%2B%2B)+{
++++++++if+(buf[i]+>=+'A'+&&+buf[i]+<=+'Z')
++++++++++++buf[i]+%2B=+0x20;
++++}

++++return+new+String(buf);
}

public+static+boolean+containsIgnoreCaseAscii(String+str,+String+searchStr)+{
++++return+StringUtils.contains(lowerCaseAscii(str),+lowerCaseAscii(searchStr));
}|code-block|syntax|javascript|747555|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Uniform_resource_locator^0|V|3|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@$A|10|B|11|1|12]]|C|$]]|$1|D|3|-4|5|6|7|13|8|@]|9|@]|C|$]]|$1|E|3|F|5|G|7|14|8|@]|9|@]|C|$]]|$1|H|3|I|5|G|7|15|8|@]|9|@]|C|$]]|$1|J|3|-4|5|6|7|16|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|17|8|@]|9|@]|C|$]]|$1|M|3|N|5|O|7|18|8|@]|9|@]|C|$P|Q]]|$1|R|3|-4|5|6|7|19|8|@]|9|@]|C|$]]]|S|$T|$5|U|V|W|C|$X|Y]]]]

If you have to search an ASCII string in another ASCII string, such as a <a href="http://en.wikipedia.org/wiki/Uniform_resource_locator" rel="nofollow">URL</a>, you will find my solution to be better. I've tested icza's method and mine for the speed and here are the results:

<ul>
<li>Case 1 took 2788 ms - regionMatches</li>
<li>Case 2 took 1520 ms - my</li>
</ul>

The code:

<pre><code>public static String lowerCaseAscii(String s) {
 if (s == null)
 return null;

 int len = s.length();
 char[] buf = new char[len];
 s.getChars(0, len, buf, 0);
 for (int i=0; i&lt;len; i++) {
 if (buf[i] &gt;= 'A' &amp;&amp; buf[i] &lt;= 'Z')
 buf[i] += 0x20;
 }

 return new String(buf);
}

public static boolean containsIgnoreCaseAscii(String str, String searchStr) {
 return StringUtils.contains(lowerCaseAscii(str), lowerCaseAscii(searchStr));
}
</code></pre>

blocks|key|3833499|text|您可以简单地执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3833500|String+s1+=+"AbBaCca";
String+s2+=+"bac";
String+toLower+=+s1.toLowerCase();
return+toLower.contains(s2);|code-block|syntax|javascript|3833501|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You could simply do something like this:

<pre><code>String s1 = "AbBaCca";
String s2 = "bac";
String toLower = s1.toLowerCase();
return toLower.contains(s2);
</code></pre>

blocks|key|5243990|text|import+java.text.Normalizer;

import+org.apache.commons.lang3.StringUtils;

public+class+ContainsIgnoreCase+{

++++public+static+void+main(String[]+args)+{

++++++++String+in+=+"+++Annulée+";
++++++++String+key+=+"annulee";

++++++++//+100%25+java
++++++++if+(Normalizer.normalize(in,+Normalizer.Form.NFD).replaceAll("[\\p{InCombiningDiacriticalMarks}]",+"").toLowerCase().contains(key))+{
++++++++++++System.out.println("OK");
++++++++}+else+{
++++++++++++System.out.println("KO");
++++++++}

++++++++//+use+commons.lang+lib
++++++++if+(StringUtils.containsIgnoreCase(Normalizer.normalize(in,+Normalizer.Form.NFD).replaceAll("[\\p{InCombiningDiacriticalMarks}]",+""),+key))+{
++++++++++++System.out.println("OK");
++++++++}+else+{
++++++++++++System.out.println("KO");
++++++++}

++++}

}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|5243991|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>import java.text.Normalizer;

import org.apache.commons.lang3.StringUtils;

public class ContainsIgnoreCase {

 public static void main(String[] args) {

 String in = " Annulée ";
 String key = "annulee";

 // 100% java
 if (Normalizer.normalize(in, Normalizer.Form.NFD).replaceAll("[\\p{InCombiningDiacriticalMarks}]", "").toLowerCase().contains(key)) {
 System.out.println("OK");
 } else {
 System.out.println("KO");
 }

 // use commons.lang lib
 if (StringUtils.containsIgnoreCase(Normalizer.normalize(in, Normalizer.Form.NFD).replaceAll("[\\p{InCombiningDiacriticalMarks}]", ""), key)) {
 System.out.println("OK");
 } else {
 System.out.println("KO");
 }

 }

}
</code></pre>

blocks|key|3833533|text|"AbCd".toLowerCase().contains("abcD".toLowerCase())|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3833534|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>"AbCd".toLowerCase().contains("abcD".toLowerCase())
</code></pre>

blocks|key|750902|text|我们可以在anyMatch和Java8的容器中使用stream|type|unstyled|depth|inlineStyleRanges|entityRanges|data|750903|public+class+Test2+{
++++public+static+void+main(String[]+args)+{

++++++++String+a+=+"Gina+Gini+Protijayi+Soudipta";
++++++++String+b+=+"Gini";

++++++++System.out.println(WordPresentOrNot(a,+b));
++++}//+main

++++private+static+boolean+WordPresentOrNot(String+a,+String+b)+{
++++//contains+is+case+sensitive.+That's+why+change+it+to+upper+or+lower+case.+Then+check
++++++++//+Here+we+are+using+stream+with+anyMatch
++++++++boolean+match+=+Arrays.stream(a.toLowerCase().split("+")).anyMatch(b.toLowerCase()::contains);
++++++++return+match;
++++}

}|code-block|syntax|javascript|750904|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

We can use stream with anyMatch and contains of Java 8

<pre><code>public class Test2 {
 public static void main(String[] args) {

 String a = "Gina Gini Protijayi Soudipta";
 String b = "Gini";

 System.out.println(WordPresentOrNot(a, b));
 }// main

 private static boolean WordPresentOrNot(String a, String b) {
 //contains is case sensitive. That's why change it to upper or lower case. Then check
 // Here we are using stream with anyMatch
 boolean match = Arrays.stream(a.toLowerCase().split(" ")).anyMatch(b.toLowerCase()::contains);
 return match;
 }

}
</code></pre>

blocks|key|2989209|text|有一种简单而简洁的方法，使用regex标志(不区分大小写{i})：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2989210|+String+s1+=+"hello+abc+efg";
+String+s2+=+"ABC";
+s1.matches(".*(?i)"%2Bs2%2B".*");

/*
+*+.*++denotes+every+character+except+line+break
+*+(?i)+denotes+case+insensitivity+flag+enabled+for+s2+(String)
+*+*/|code-block|syntax|javascript|2989211|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

There is a simple concise way, using regex flag (case insensitive {i}):

<pre><code> String s1 = "hello abc efg";
 String s2 = "ABC";
 s1.matches(".*(?i)"+s2+".*");

/*
 * .* denotes every character except line break
 * (?i) denotes case insensitivity flag enabled for s2 (String)
 * */
</code></pre>

blocks|key|5244187|text|或者，您可以使用一种简单的方法，将字符串的大小写转换为子字符串的大小写，然后使用contains方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5244188|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

or you can use a simple approach and just convert the string's case to substring's case and then use contains method.

blocks|key|5244263|text|一种方法是使用toLowerCase()或toUpperCase()方法将两个字符串转换为小写或大写，然后进行测试。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5244264|public+class+Sample+{
+++public+static+void+main(String+args[]){
++++++String+str+=+"Hello+Welcome+to+insensitive+Container";
++++++String+test+=+"Java+Testing";
++++++Boolean+bool+=+str.toLowerCase().contains(test.toLowerCase());
++++++System.out.println(bool);
+++}
}|code-block|syntax|javascript|5244265|这里是使用带有CASE_INSENSITIVE标志的java.util.regex.Pattern进行不区分大小写匹配的另一种方法。|5244266|Pattern.compile(Pattern.quote(s2),+Pattern.CASE_INSENSITIVE).matcher(s1).find();|5244267|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

One way to do it to convert both strings to lower or upper case using toLowerCase() or toUpperCase() methods and test.
<pre><code>public class Sample {
 public static void main(String args[]){
 String str = &quot;Hello Welcome to insensitive Container&quot;;
 String test = &quot;Java Testing&quot;;
 Boolean bool = str.toLowerCase().contains(test.toLowerCase());
 System.out.println(bool);
 }
}
</code></pre>
Here is another way for case insensitive matching using java.util.regex.Pattern with the CASE_INSENSITIVE flag.
<pre><code>Pattern.compile(Pattern.quote(s2), Pattern.CASE_INSENSITIVE).matcher(s1).find();
</code></pre>

Say I have two strings,

<pre><code>String s1 = "AbBaCca";
String s2 = "bac";
</code></pre>

I want to perform a check returning that <code>s2</code> is contained within <code>s1</code>. I can do this with:

<pre><code>return s1.contains(s2);
</code></pre>

I am pretty sure that <code>contains()</code> is case sensitive, however I can't determine this for sure from reading the documentation. If it is then I suppose my best method would be something like:

<pre><code>return s1.toLowerCase().contains(s2.toLowerCase());
</code></pre>

All this aside, is there another (possibly better) way to accomplish this without caring about case-sensitivity?

How to check if a String contains another String in a case insensitive manner in Java?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

假设我有两根弦，String s1 = "AbBaCca";String s2 = "bac";我想执行一个检查，返回s1中包含的s2。我可以使用以下命令来实现：return s1.contains(s2);我非常确定contains()是区分大小写的，但是通过阅读文档，我不能确定这一点。如果是这样，那么我想我最好的方...

问如何在Java中检查一个字符串是否包含另一个不区分大小写的字符串？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Java中检查一个字符串是否包含另一个不区分大小写的字符串？EN