Check if string has a specific word

First of all, if is not a loop. So there is no point in labelling it so as use a labelled break.

Secondly, both of your code isn't really doing, what you said you want to do. Also, I don't understand why are you doing if (w.equals(s)) this test. And what is w used for.

You said: - w being the word to add, but again you are saying that, you will add the words from your string after splitting it on "\n", if it is not already in your array. So, you are adding many words, not just one word. Please re-read your post, and edit it if necessary.

As per your current problem statement, I would approach it like this: -

• First split your lines on "\n" to get an array with individual words.
• I would rather use StringBuilder or StringBuffer if I want to modify my string on each iteration.
• Now, on each iteration, check whether your StringBuilder already contains that word. If it does not contains, then append it, else leave it.
• At the end of your loop, print your StringBuilder instance.

Or, as you are saying, you can also use an ArrayList to store your words. Or if, you want unique words only, you should rather use a Set instead. That would not require you to do the test. It handles the duplicates on its own: -

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.
    }
}

And then print your ArrayList or Set by iterating over either of them.

I would store the distinct words you are adding in 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();
}      

I would suggest to use a 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();

// if u r trying to find a word/specific word in a string,this code will definitely help u..

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

}//class

You can use

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

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

which maintains the order of adding the words.

How about storing the words in an ArrayList and checking if the ArrayList contains the word before adding it? If the order isn't important then use a Set.

It'll be a lot easier to work with a collection and you can then convert it to a string when you need to display it. for eg:

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

Here is fast way to find the specific word in string. without splitting and looping it.

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

}

If you check whether new words are contained and the delimiter is \n then you will need regular expressions. Relying on contains alone would not add words with are sub-sequences of existing word.

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

To better understand the matter I have added a unit test for that scenario:

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

Or simply,

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