Programa Java para imprimir todas las palabras únicas de una string

Programa Java para imprimir todas las palabras únicas presentes en la string . La tarea es imprimir todas las palabras que aparecen una sola vez en la string .

Ilustración:

Input  : Welcome to Geeks for Geeks.
Output : Welcome 
         to
         for
Input  : Java is great.Python is also great.
Output : Java
         Python
         also

Métodos: 

Esto se puede hacer de las siguientes maneras:

1. Uso de bucles anidados
2. Usando el mapa

Enfoque ingenuo: uso de bucles anidados

La idea de contar la aparición de la string en la string e imprimir si la cuenta es igual a uno

1. Extrae palabras de una string usando el método split( ) y guárdalas en una array.
2. Iterar sobre la array de palabras usando for loop.
3. Use otro ciclo para encontrar la ocurrencia de la palabra actual en la array.
4. Si se encuentra la segunda ocurrencia, incremente el conteo y establezca la palabra en «»
5. Si el recuento de la palabra actual es igual a uno, imprímalo

Ejemplo:

// Java Program to Print all unique words
// Using nested loops
 
// Main class
public class GFG {
 
    // Method 1
    // To print the unique words
    static void printUniqueWords(String str)
    {
        // Maintaining a count variable
        int count;
 
        // Extract words from string
        // using split() method
        String[] words = str.split("\\W");
 
        // Iterating over the words array
        for (int i = 0; i < words.length; i++) {
 
            // Setting count of current word to one
            count = 1;
 
            for (int j = i + 1; j < words.length; j++) {
                if (words[i].equalsIgnoreCase(words[j])) {
 
                    // If word found later in array
                    // increment the count variable
                    count++;
 
                    words[j] = "";
                }
            }
 
            // If count of current word is one print it
            if (count == 1 && words[i] != "")
 
                // Print statement
                System.out.println(words[i]);
        }
    }
 
    // Method 2
    // Main driver method
    public static void main(String[] args)
    {
        // Custom input string
        String str = "Welcome to geeks for geeks";
 
        // Calling the method 1 to print all unique words
        // in above string passed as argument
        printUniqueWords(str);
    }
}

Welcome
to
for

Nota: la complejidad del tiempo es de orden n^2 donde la complejidad del espacio es de orden n

Método 2: usar el mapa

Enfoque: La idea es utilizar Mapa para realizar un seguimiento de las palabras ya ocurridas. Pero primero, tenemos que extraer todas las palabras de una String, ya que una string puede contener muchas oraciones con signos de puntuación.

• Crea un mapa vacío.
• Extrae palabras de una string usando el método split() y guárdalas en una array.
• Iterar sobre la array de palabras.
• Compruebe si la palabra ya está presente en el Mapa o no.
• Si una palabra está presente en el mapa, incremente su valor en uno.
• De lo contrario, almacene la palabra como clave dentro del mapa con valor uno.
• Iterar sobre el mapa e imprimir palabras cuyo valor sea igual a uno.

Ejemplo:

// Java Program to Print all Unique Words
// Using Map
 
// Importing utility classes from java.util package
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
 
// Main class
public class GFG {
 
    // Method 1
    // To print all unique words in the string
    static void printUniqueWords(String str)
    {
        // Create a new Map by creating object of HashMap
        // class
        HashMap<String, Integer> map
            = new LinkedHashMap<String, Integer>();
 
        // Extract words from string
        // using split() method
        String[] words = str.split("\\W");
 
        // Iterating over the words array
        // using for each loop
        for (String word : words) {
 
            // If the word is present in array then
            //
            if (map.containsKey(word)) {
 
                //  Increment its value by one
                // using map.get() method
                map.put(word, map.get(word) + 1);
            }
 
            // Else store the word inside map
            // with value one
            else
                map.put(word, 1);
        }
 
        // Iterate over the map using for each loop
        for (Map.Entry<String, Integer> entry :
             map.entrySet()) {
 
            // If value of words equals unity
            if (entry.getValue() == 1)
 
                // Print all those words
                System.out.println(entry.getKey());
        }
    }
 
    // Method 2
    // Main driver method
    public static void main(String[] args)
    {
        // Custom input string
        String str = "Welcome to geeks for geeks";
 
        // Calling the Method1 to
        // print all unique words in above string
        printUniqueWords(str);
    }
}

Welcome
to
for

Nota: La complejidad del tiempo es del orden de n donde la complejidad del espacio es del orden de n. Por lo tanto, es el enfoque óptimo.