Check if a String contains two words

Question

I have a problem with this exercise here:

Write a class that validates data (Validacao), with a method to validate a given name (ehNomeValido(nome)). The method must return true pass the following rules:

• If the parameter is not null.

• If the parameter is not a String empty

• If the parameter has two particles (two words separated by a space)

The problem is that the program only returns me the false in the case of the name I put as parameter the program should return true. Where am I wrong? I’ve rewritten the code several times in other ways and nothing.

 public class NOVOTESTE2{

     public static boolean validacao(String nome){
         if((nome != null) && (nome.isEmpty() == false) && (nome.indexOf(" ") == 1)){
             return true;
         }else{
             return false;
         }     
     }

  public static void main(String[] args){

        System.out.println(validacao("Rodrigo Moreira"));
  }  
}

Answer 1

This? It seems that the problem is that you are trying to check wrong thing if there is more than one word.

public static boolean validacao(String nome) {
    return nome != null && !nome.isEmpty() && new StringTokenizer(nome).countTokens() > 1;
}

After seeing the solutions and reading documentation, do some tests I think this form is the simplest and most reliable because it was made to meet precisely this demand. I’m still not sure if you have corner cases.

Behold working in the ideone. And in the repl it.. Also put on the Github for future reference.

StringTokenizer

Answer 2

A suggestion with regex, which will probably accept accentuation and will also work with CASE-INSENTIVE, would be using so:

public static boolean validacao(String nome){
    return nome != null && nome.matches("^\\p{L}+ [\\p{L} ]+$"));
}

Nor is it necessary to isEmpty in this case with REGEX, if you need exactly two words just change to:

nome.matches("^\\p{L}+ \\p{L}+$"))

If you don’t need an accent, then you can use the a-z, the \w may work too, but his problem is that he accepts underscore _, and this does not seem correct in a name validation, so the regex can look like this (using the (?i:...) for case-insensitive can help decrease complex regular expressions):

public static boolean validacao(String nome){
    return nome != null && nome.matches("^(?i:[a-z]+ [a-z ]+)$"));
}

If you need exactly 2 words change to:

nome.matches("^(?i:[a-z]+ [a-z]+)$"))

In both examples I did accept one or more surnames, ie two or more words in the string.

---

Explaining the regular expressions

To the ^\\p{L}+ [\\p{L} ]+$:

• ^ checks if the expression starts with
• \\p{L}+ checks words until you find a space (note that after the + has a space)
• [\\p{L} ]+$ checks words and spaces, ie can contain more than one word with space until you find the end of the string

To the ^(?i:[a-z]+ [a-z ]+)$:

• ^ checks if the expression starts with
• (?i: initiating a group case-insensitive
• [a-z]+ checks words with a-z letters until you find a space (note that after the + has a space)
• [a-z ]+) checks words with letters of a-z and spaces, ie may contain more than one word with space until you find the end of the group (group for case-insensitive)
• $ checks whether the string ends exactly according to the expression

Answer 3

indexOf(" ") returns the position the space is in String, therefore it will not necessarily be 1. It would be right to test if the value is different from -1, since this is the value returned if there are no spaces.

The problem is that indexOf only checks if there is any white space.
If the entrance is " " (multiple spaces), for example, or if the space is at the beginning or end, indexOf it won’t do any good.

One way to check if it has two words is to use what the @Maniero suggests in his reply. Another way is to use regular expression, to make sure that before and after space you actually have a word - assuming that "word" is a string of uppercase or lowercase letters:

public static boolean validacao(String nome){
    return (nome != null) && (! nome.isEmpty()) && nome.matches("^[a-zA-Z]+ [a-zA-Z]+$");
}

• ^ indicates the beginning of String
• [a-zA-Z]+ indicates one or more occurrences of upper or lower case letters
• $ indicates the beginning of String

See more details about regular expression in this tutorial. Also note that as the return of the method is a boolean, you can directly return the result of the checks (as well remembered in the comments).

One detail is that the regex will only work for exactly two words. But you can change the $ for .*, which then works for several words (and should have at least two).

And will not accept accented characters as pointed out in the comments.

Answer 4

The problem is in the index, It will return the position of space, that in the casó is 7.

I believe the approach below should be more assertive to find the word with only one space

    public static boolean validacao(String nome){
        if(nome != null && !nome.isEmpty() && nome.split(" ").length == 2){
            return true;
        }else{
            return false;
        }
    }

Answer 5

indexof will give -1 or the space the string shows the desired char. In his comparison he only verifies that the space comes after the first letter, example: j john would work, you just need in your comparison to check if the index(" ") is different from -1, so:

public static boolean validacao(String nome){
         if ((nome != null) && (nome.isEmpty() == false) && (nome.indexOf(" ") != -1)){
             return true;
         } else {
             return false;
         }     
     }

Answer 6

Gandalf, as you are learning, I took the liberty of tweaking the original code and running the necessary tests (very important).

Look at the code:

public static class NovoTeste2 {

    public static boolean validacao(String nome){
        return (nome != null) && (!nome.isEmpty()) && (nome.split(" ").length >= 2);
    }
}

In the above code, I simplified checking the name to be empty (you don’t need the == false) and, to validate whether the name has only two words, I split the String using the blank space, hoping that the array generated by the split has at least 2 elements. I also changed the class name to a Java default name (using Camelcase).

If you want to restrict to only two words, just change of length >= 2 for length == 2.

And finally, the code above with the tests for each case:

public class TemAoMenosDuasPalavrasTest {

    @Test
    public void nomeCorreto() {
        assertTrue(NovoTeste2.validacao("Augusto Nonato"));
    }

    @Test
    public void nomeComTresPalavras() {
        assertTrue(NovoTeste2.validacao("Augusto Nonato Junior"));
    }

    @Test
    public void nomeSemDuasPalavras() {
        assertFalse(NovoTeste2.validacao("Augusto"));
    }

    @Test
    public void nomeNulo() {
        assertFalse(NovoTeste2.validacao(null));
    }

    @Test
    public void nomeVazio() {
        assertFalse(NovoTeste2.validacao(""));
    }

    @Test
    public void nomeVazioComEspacos() {
        assertFalse(NovoTeste2.validacao("   "));
    }

    public static class NovoTeste2 {

        public static boolean validacao(String nome){
            return (nome != null) && (!nome.isEmpty()) && (nome.split(" ").length >= 2);
        }
    }
}

This makes it much easier to know if your code is working even after changes and for all expected cases.

Remembering that I did not treat all possible cases: valid name with more than one space between words, extra spaces at the beginning or end of the name, etc.