1

MyString words包含一堆由 a 分隔的单词\n（并以 a 结尾\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";
}

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

4

9 回答 9

3

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

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

你说： - w being the word to add，但你又说"\n"，如果它不在你的array. 因此，您要添加许多单词，而不仅仅是一个单词。请重新阅读您的帖子，并在必要时对其进行编辑。

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

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

或者，正如您所说，您也可以使用 anArrayList来存储您的单词。或者，如果你unique只想要单词，你应该使用 aSet来代替。那将不需要您进行测试。它自己处理重复项：-

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

于 2012-11-21T08:54:51.760 回答
1

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

公共类 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

}//班级

于 2014-07-04T05:26:37.950 回答
1

我会将您添加的不同单词存储在列表中；

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();
}
于 2012-11-21T09:02:19.483 回答
1

我建议使用列表

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();
于 2012-11-21T09:06:30.723 回答
0

您可以使用

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

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

它保持添加单词的顺序。

于 2012-11-21T08:59:24.227 回答
0

或者简单地说，

public static void main(String[] args) {
String test = "test";
String test2 = "st";
if (test.contains(test2)) System.out.println("String found");
}
于 2013-04-19T13:52:35.223 回答
0

如何将单词存储在 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();
}
于 2012-11-21T08:57:39.520 回答
0

这是在字符串中查找特定单词的快速方法。无需拆分和循环。

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");
      }

}
于 2012-11-21T09:18:59.857 回答
0

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

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);
    }
}
于 2012-11-21T09:40:31.287 回答