blocks|key|2293026|text|有一个重载版本的indexOf()，它接受一个索引来开始搜索。您可以使用它重复搜索相同的字符串，直到到达末尾。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2293027|请注意，您可以删除contains()的测试，这样就不会对字符串进行两次搜索。|style|CODE|2293028|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#indexOf(java.lang.String,%2520int)^0|8|9|0|0|9|A|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@$A|U|B|V|F|G]]|9|@]|C|$]]|$1|H|3|-4|5|6|7|W|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]]]

There is an overloaded version of <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#indexOf(java.lang.String,%20int)" rel="nofollow noreferrer">indexOf()</a> which takes an index to start the search at. You can use this to repeatedly search for the same string until you reach the end.

Note that you can remove your test for <code>contains()</code> so that you don't search the string twice.

blocks|key|2293242|text|将单词列表转换为正则表达式，并让正则表达式为您执行搜索。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2293243|例如，你的3个单词将是如下所示的正则表达式：|2293244|and%7Cof%7Cone|code-block|syntax|javascript|2293245|当然，您不需要部分单词，因此需要添加单词边界检查：|2293246|\b(and%7Cof%7Cone)\b|2293247|不需要(再次)捕获单词，因为整个匹配都是单词，所以使用非捕获组。您还可以轻松地使单词搜索不区分大小写。|2293248|尽管纯单词(全是字母)永远不会有问题，但通过使用Pattern.quote()引用单词来保护正则表达式是一个好主意。|offset|length|style|CODE|2293249|示例|2293250|String+doc+=+"one+of+the+car+and+bike+and+one+of+those";
String[]+words+=+{+"and",+"of",+"one"+};

//+Build+regex
StringJoiner+joiner+=+new+StringJoiner("%7C",+"\\b(?:",+")\\b");
for+(String+word+:+words)
++++joiner.add(Pattern.quote(word));
String+regex+=+joiner.toString();

//+Find+words
for+(Matcher+m+=+Pattern.compile(regex,+Pattern.CASE_INSENSITIVE).matcher(doc);+m.find();+)
++++System.out.println(m.group()+%2B+"-->"+%2B+m.start());|2293251|输出|2293252|one-->0
of-->4
and-->15
and-->24
one-->28
of-->32|2293253|2293254|如果您想对代码进行一点压缩(模糊处理)，您可以将其编写为Java+9%2B中的单个语句：|2293255|Pattern.compile(Stream.of(words).collect(joining("%7C",+"(?i)\\b(?:",+")\\b"))).matcher(doc).results().forEach(r+->+System.out.println(r.group()+%2B+"-->"+%2B+r.start()));|2293256|输出是相同的。|2293257|entityMap^0|0|0|0|0|0|0|O|F|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1B|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1C|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1D|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1E|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|1F|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|1G|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1H|8|@$Q|1I|R|1J|S|T]]|9|@]|A|$]]|$1|U|3|V|5|6|7|1K|8|@]|9|@]|A|$]]|$1|W|3|X|5|F|7|1L|8|@]|9|@]|A|$G|H]]|$1|Y|3|Z|5|6|7|1M|8|@]|9|@]|A|$]]|$1|10|3|11|5|F|7|1N|8|@]|9|@]|A|$G|H]]|$1|12|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]|$1|13|3|14|5|6|7|1P|8|@]|9|@]|A|$]]|$1|15|3|16|5|F|7|1Q|8|@]|9|@]|A|$G|H]]|$1|17|3|18|5|6|7|1R|8|@]|9|@]|A|$]]|$1|19|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]]|1A|$]]

Convert the list of words into a regex, and let the regex do the searching for you.

E.g. your 3 words would be a regex like this:

<pre class="lang-regex prettyprint-override"><code>and|of|one
</code></pre>

Of course, you wouldn't want partial words, so you'd add word boundary checks:

<pre class="lang-regex prettyprint-override"><code>\b(and|of|one)\b
</code></pre>

No need to capture the word (again), since the entire match is the word, so use a non-capturing group. You can also easily make the word search case-insensitive.

Although there will never be a problem with pure words (all letters), it's a good idea to guard the regex by quoting the words using <code>Pattern.quote()</code>.

Example

<pre><code>String doc = "one of the car and bike and one of those";
String[] words = { "and", "of", "one" };

// Build regex
StringJoiner joiner = new StringJoiner("|", "\\b(?:", ")\\b");
for (String word : words)
 joiner.add(Pattern.quote(word));
String regex = joiner.toString();

// Find words
for (Matcher m = Pattern.compile(regex, Pattern.CASE_INSENSITIVE).matcher(doc); m.find(); )
 System.out.println(m.group() + "--&gt;" + m.start());
</code></pre>

Output

<pre class="lang-none prettyprint-override"><code>one--&gt;0
of--&gt;4
and--&gt;15
and--&gt;24
one--&gt;28
of--&gt;32
</code></pre>

<hr>

If you want to compress (obfuscate) the code a bit, you can write it as a single statement in Java 9+:

<pre><code>Pattern.compile(Stream.of(words).collect(joining("|", "(?i)\\b(?:", ")\\b"))).matcher(doc).results().forEach(r -&gt; System.out.println(r.group() + "--&gt;" + r.start()));
</code></pre>

Output is the same.

blocks|key|2293510|text|如果你想减少迭代，还有另一个解决方案，这段代码遍历字符串一次。我想要一个字符一个字符地访问字符串。我使用了一个StringBuilder来添加每个字符，当您获得空格时，只需将该字符串添加到最终的答案列表中，并添加索引。我已经将我的方法描述如下，我认为它只访问每个字符一次，这段代码的时间复杂度是O(n)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2293511|StringBuilder+sb=new+StringBuilder();
++++ArrayList<String>+answer=new+ArrayList<>();
++++ArrayList<Integer>+index=new+ArrayList<>();
++++HashSet<String>+setW+=+new+HashSet<>();
++++setW.add("and");
++++setW.add("of");
++++setW.add("one");
++++index.add(0);
++++String+doc+=+"one+of+the+car+and+bike+and+one+of+those";
++++for(int+i=0;i<doc.length();i%2B%2B){
++++++++if(i==doc.length()+%7C%7C+doc.charAt(i)=='+'){
++++++++++++index.add(i%2B1);
++++++++++++answer.add(sb.toString());
++++++++++++sb=new+StringBuilder();
++++++++++++i%2B%2B;
++++++++}
++++++++sb.append(doc.charAt(i));
++++++++if(i==doc.length()-1){
++++++++++++if(setW.contains(sb.toString())){
++++++++++++++++answer.add(sb.toString());
++++++++++++};
++++++++}
++++}
++++for(int+i=0;i<answer.size();i%2B%2B){
++++++++if(setW.contains(answer.get(i))){
++++++++++++System.out.println(answer.get(i)%2B"-->"%2Bindex.get(i));
++++++++}
++++}|code-block|syntax|javascript|2293512|我基于这个想法得到了预期的输出，提交这个问题的答案背后的原因是为了获得另一个可能的解决方案。(在回答HashSet时，我们将得到setW中存在的每个单词的索引，所以如果您不想这样做，可以使用一个if(!setW.contains(answer.get(i))条件将其删除。)|2293513|输出|2293514|one-->0
of-->4
and-->15
and-->24
one-->28
of-->32|2293515|entityMap^0|0|0|0|0|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|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Well, There is another solution if you want to make less iteration, this code traverses the string once. I thought of accessing a string character by character. I took one StringBuilder to append each character and check when you get the whitespace just append that string to the final answer list, as well as add the index too. 
I have described my approach as below and I think it's just visiting each character once, the time complexity for this code is O(n).

<pre><code>StringBuilder sb=new StringBuilder();
 ArrayList&lt;String&gt; answer=new ArrayList&lt;&gt;();
 ArrayList&lt;Integer&gt; index=new ArrayList&lt;&gt;();
 HashSet&lt;String&gt; setW = new HashSet&lt;&gt;();
 setW.add("and");
 setW.add("of");
 setW.add("one");
 index.add(0);
 String doc = "one of the car and bike and one of those";
 for(int i=0;i&lt;doc.length();i++){
 if(i==doc.length() || doc.charAt(i)==' '){
 index.add(i+1);
 answer.add(sb.toString());
 sb=new StringBuilder();
 i++;
 }
 sb.append(doc.charAt(i));
 if(i==doc.length()-1){
 if(setW.contains(sb.toString())){
 answer.add(sb.toString());
 };
 }
 }
 for(int i=0;i&lt;answer.size();i++){
 if(setW.contains(answer.get(i))){
 System.out.println(answer.get(i)+"--&gt;"+index.get(i));
 }
 }
</code></pre>

I got the expected output based on this idea, the reason behind submitting my answer to this question is to get another possible solution. (In answer HashSet we will end up with an index of every word not only which are exist in setW, so If you don't want that you can remove it using one if(!setW.contains(answer.get(i)) condition.)

Output

<pre><code>one--&gt;0
of--&gt;4
and--&gt;15
and--&gt;24
one--&gt;28
of--&gt;32
</code></pre>

BACKGROUND

I have a string of text and a hash set that contains words that i am looking for.

Given

<pre><code>String doc = "one of the car and bike and one of those";
String [] testDoc = doc.split("\\s+");
HashSet&lt;String&gt; setW = new HashSet&lt;&gt;();
setW.add("and");
setW.add("of");
setW.add("one");
</code></pre>

OBJECTIVE

The objective is to scan the string and each time we come across a word that is in the hash set we are to store the word and the position of the starting index.

In the above case we should be able to store the following

<pre><code>one--&gt;0 

of--&gt;4 

and--&gt;15 

and--&gt;24, 

one--&gt;28, 

of--&gt;32
</code></pre>

`
ATTEMPT

<pre><code>//create hashmap
for(int i = 0; i&lt;testDoc.length; i++){
 if(setW.contains(testDoc[i])) {
 doc.indexOf(testDoc[i]);
 //add string and its index to hashmap
 }
</code></pre>

That is what i have thought of so far the only problem is that the indexOf method only looks at the first occurrence of a word so i am not sure what to do. If i keep trimming the string after each word scanned then i will not the get index position of a word in the original string.

I would love some input here.

Find multiple occurrences of words in a string and store the respective staring indices

Java

背景我有一个文本字符串和一个哈希集，其中包含我正在查找的单词。给定的String doc = "one of the car and bike and one of those";String [] testDoc = doc.split("\\s+");HashSet<String> setW = new HashS...

问查找字符串中出现的多个单词，并存储相应的起始索引
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问查找字符串中出现的多个单词，并存储相应的起始索引EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问查找字符串中出现的多个单词，并存储相应的起始索引
EN