Question

我的String words包含一串以\n分隔的单词（以\n结尾）。只有当单词不存在时，代码才会向字符串添加单词。这些代码块位于for循环内，w是要添加的单词。

我有

loop: if (w.contains("" + letter)) //This is just to test the words I want to add
{
  for (String s : words.split("\n"))
    if (w.equals(s))
      break loop;
  words += w + "\n";
}

和

if (w.contains("" + letter))
{
  if (!words.contains("\n"+w+"\n") && words.indexOf(w+"\n") != 0)
    words += w + "\n";
}

但两者都以自己的方式显得凌乱。还有另一种方法可以解决这个问题，或者哪种方法可以更快地执行。

Answer 1

首先，if不是循环。所以标记它是没有意义的，所以使用标记的中断。

其次，你的两个代码都没有真正做到，你说你想做什么。另外，我不明白你为什么要做if (w.equals(s))这个测试。什么是w用于。

您说： - w being the word to add，但您再说一遍，如果您的"\n"中的字词已经在array中，则会在"\n"上将其添加到字符串中。。所以，你要添加很多单词，而不只是一个单词。请重新阅读您的帖子，并在必要时进行编辑。

根据您当前的问题陈述，我会这样做： -

首先在StringBuilder上拆分行，以获得包含单个单词的数组。
如果我想在每次迭代时修改我的字符串，我宁愿使用StringBuffer或StringBuilder。
现在，在每次迭代时，检查您的word是否已包含StringBuilder。如果它不包含，则附加它，否则保留它。
在循环结束时，打印ArrayList实例。

或者，正如您所说，您也可以使用unique来存储您的文字。或者，如果您只需要Set个字词，则应该使用List<String> wordList = new ArrayList<String>(); Set<String> set = new LinkedHashSet<String>(); for (String s : words.split("\n")) { if (s.contains("" + letter)) { if (!wordList.contains(s)) { wordList.add(s); // Add to list. } set.add(s); // Add to set. } }代替。这不需要你做测试。它自己处理重复： -

ArrayList

然后通过迭代其中任何一个来打印您的Set或{{1}}。

Answer 2

我会在List中存储您添加的不同单词;

List<String> words = new ArrayList<String>();

void addWord(String word){
    if(!words.contains(word)){
        words.add(word);
    }
}

String listAsString(){
    StringBuilder buffer = new StringBuilder();
    for(String word: words){
        buffer.append(word);
        buffer.append("\n");
    }
    return buffer.toString();
}

Answer 3

我建议使用List

ArrayList<String> wordList = new ArrayList() ;
// to add
if (w.contains("" + letter) && wordList.contains(w) )
{
   wordList.add(w);
}
//at the end you can append \n
StringBuilder bdr = new StringBuilder() ;
for(String word : wordList)
{
     bdr.append(word).append("\n");
}
String words = bdr.toString();

Answer 4

//如果你试图在字符串中找到一个单词/特定单词，这段代码肯定会对你有帮助..

public class findWordFromString {

public static void main(String[] A)
{
    String str = "Manhattan is a great company";
    String search = "great";
    boolean flag= false;

// here first split or break the string,based on the space present btween each word
    String[] arr = str.split(" "); 
      for(int i=0;i<arr.length;i++)
     {

        if(arr[i].**equals**(search)) // here,never use == instead of equals()  
        {
          flag = true;
            break;
        }
     }//for loop

        if(flag)
        {
           System.out.println(search+" is present");    
        }else
        {
            System.out.println(search+" is not present");
        }
}//method

} //类

Answer 5

如何在ArrayList中存储单词并在添加之前检查ArrayList是否包含单词？如果订单不重要，请使用Set。

使用集合会更容易，然后您可以在需要显示它时将其转换为字符串。例如：

List wordList = new ArrayList();

public void addWord(String word){
    if(!wordList.contains(word)){
        wordList.add(word);
    }
}

public String displayWordsAsString(){
    StringBuilder builder = new StringBuilder();
    for(int i = 0; i < wordList.size(); i++){
        //add this condition if you only want a new line between words and not every time.
        if(i > 0)
            builder.append("\n");

        builder.append(word); 
    }

    return builder.toString();
}

Answer 6

您可以使用

Set<String> words = LinkedHashSet<String>();

if (words.add("" + letter)) {
    // Added.
}

维持添加单词的顺序。

Answer 7

这是在字符串中查找特定单词的快捷方法。没有分裂和循环它。

public static void main(String[] args) {
      String w = "This\nis\nTesting\nString\nthat\ncontains\nHelloWorld\n";
      String searchingWord = "HelloWorld";
      Pattern pattern= Pattern.compile("("+searchingWord+")");
      Matcher matcher = pattern.matcher(w);
      if(!matcher.find())
      {
         System.out.println("Word Not Found");
      }else
      {
         System.out.println("Word Found");
      }

}

Answer 8

如果检查是否包含新单词且分隔符是\ n那么您将需要正则表达式。依靠单独包含不会添加具有现有单词的子序列的单词。

public class AddWords {

    public String addWord(final String newWord, final String allWords) {
        String result = allWords;
        Pattern p = Pattern.compile(".*\n" + newWord + "\n.*");
        Matcher m = p.matcher(allWords);
        if (!m.find()) {
            StringBuffer buf = new StringBuffer();
            buf.append(allWords);
            buf.append(newWord);
            buf.append("\n");
            result = buf.toString();
        }
        return result;
    }
}

为了更好地理解这个问题，我为该场景添加了一个单元测试：

public class AddWordsTest {
    @Test
    public void addExistingWord() {
        String allWords = "\nfoo\nbar\n";
        String notNewWord = "foo";
        AddWords aw = new AddWords();
        String newAllWords = aw.addWord(notNewWord, allWords);
        Assert.assertEquals(allWords, newAllWords);
    }

    @Test
    //This would fail if you rely on contains!!!
    public void addNewWord() {
        String allWords = "\nfoobar\nbar\n";
        String newWord = "foo";
        AddWords aw = new AddWords();
        String newAllWords = aw.addWord(newWord, allWords);
        String expectedAllWords = "\nfoobar\nbar\nfoo\n";
        Assert.assertEquals(expectedAllWords, newAllWords);
    }
}

Answer 9

或者简单地说，

public static void main(String[] args) {
String test = "test";
String test2 = "st";
if (test.contains(test2)) System.out.println("String found");
}

检查字符串是否有特定的单词

9 个答案: