Counting word occurence with arrays stream in Java 8

Counting word occurence with arrays stream in Java 8

In Java 8, you can efficiently count word occurrences using streams and collectors. Here's a step-by-step approach to achieve this:

Example Scenario

Let's assume you have a list of words (List<String> words) and you want to count how many times each word appears in the list.

Implementation Steps

  1. Convert List to Stream:

    • Convert your list of words to a stream using stream() method.

  2. Use Collectors.groupingBy:

    • Use Collectors.groupingBy to group elements of the stream by their identity (in this case, the word itself).
    • Use Collectors.counting() as the downstream collector to count occurrences of each word.

  3. Collect the Results:

    • Collect the results into a Map<String, Long> where the key is the word and the value is the count of occurrences.

Java Code

Here's how you can implement this in Java 8:

import java.util.Arrays; import java.util.List; import java.util.Map; import java.util.stream.Collectors; public class WordCountExample { public static void main(String[] args) { List<String> words = Arrays.asList("apple", "banana", "apple", "orange", "banana", "apple"); // Using streams and collectors to count occurrences Map<String, Long> wordCounts = words.stream() .collect(Collectors.groupingBy(w -> w, Collectors.counting())); // Print word counts wordCounts.forEach((word, count) -> System.out.println(word + " : " + count)); } }

Explanation

  • words.stream(): Converts the list words to a stream of words.
  • Collectors.groupingBy(w -> w, Collectors.counting()):
    • groupingBy(w -> w): Groups elements by their identity (the word itself).
    • Collectors.counting(): Downstream collector that counts occurrences of each word.
  • wordCounts.forEach((word, count) -> System.out.println(word + " : " + count)):
    • Iterates over the wordCounts map and prints each word with its count.

Output

For the given example (List<String> words = Arrays.asList("apple", "banana", "apple", "orange", "banana", "apple");), the output will be:

apple : 3 banana : 2 orange : 1

Notes

  • Ensure your environment supports Java 8 or higher to use streams and lambda expressions.
  • This approach is efficient and leverages the parallel capabilities of streams if the data size is large.

By following this approach, you can easily count word occurrences using Java 8 streams and collectors, making your code concise and leveraging functional programming features effectively.

Examples

  1. "Java 8 stream count occurrences of words in list"

    • Description: Count occurrences of words in a list using Java 8 streams.
    • Code:
      List<String> words = Arrays.asList("apple", "banana", "apple", "orange", "banana", "apple"); Map<String, Long> wordCounts = words.stream() .collect(Collectors.groupingBy(Function.identity(), Collectors.counting())); System.out.println(wordCounts);

  2. "Java 8 stream count occurrences of words in string"

    • Description: Count occurrences of words in a string using Java 8 streams.
    • Code:
      String text = "java stream count words occurrence stream java"; Map<String, Long> wordCounts = Arrays.stream(text.split("\\s+")) .collect(Collectors.groupingBy(Function.identity(), Collectors.counting())); System.out.println(wordCounts);

  3. "Java 8 stream count occurrences of words ignoring case"

    • Description: Count occurrences of words in a list, ignoring case sensitivity, using Java 8 streams.
    • Code:
      List<String> words = Arrays.asList("Apple", "Banana", "apple", "Orange", "banana", "Apple"); Map<String, Long> wordCounts = words.stream() .map(String::toLowerCase) .collect(Collectors.groupingBy(Function.identity(), Collectors.counting())); System.out.println(wordCounts);

  4. "Java 8 stream count occurrences of words with filter"

    • Description: Count occurrences of words that meet a certain condition using Java 8 streams.
    • Code:
      List<String> words = Arrays.asList("apple", "banana", "apple", "orange", "banana", "apple"); Map<String, Long> wordCounts = words.stream() .filter(word -> word.startsWith("a")) // Example filter condition .collect(Collectors.groupingBy(Function.identity(), Collectors.counting())); System.out.println(wordCounts);

  5. "Java 8 stream count occurrences of words with parallelStream"

    • Description: Count occurrences of words in a list using parallel streams in Java 8.
    • Code:
      List<String> words = Arrays.asList("apple", "banana", "apple", "orange", "banana", "apple"); Map<String, Long> wordCounts = words.parallelStream() .collect(Collectors.groupingByConcurrent(Function.identity(), Collectors.counting())); System.out.println(wordCounts);

  6. "Java 8 stream count occurrences of words in file"

    • Description: Count occurrences of words in a text file using Java 8 streams.
    • Code:
      Path path = Paths.get("file.txt"); Map<String, Long> wordCounts = Files.lines(path) .flatMap(line -> Arrays.stream(line.split("\\s+"))) .collect(Collectors.groupingBy(Function.identity(), Collectors.counting())); System.out.println(wordCounts);

  7. "Java 8 stream count occurrences of words with TreeMap"

    • Description: Count occurrences of words in a list and store results in a sorted TreeMap using Java 8 streams.
    • Code:
      List<String> words = Arrays.asList("apple", "banana", "apple", "orange", "banana", "apple"); Map<String, Long> wordCounts = words.stream() .collect(Collectors.groupingBy(Function.identity(), TreeMap::new, Collectors.counting())); System.out.println(wordCounts);

  8. "Java 8 stream count occurrences of words with custom collector"

    • Description: Implement a custom collector to count occurrences of words using Java 8 streams.
    • Code:
      List<String> words = Arrays.asList("apple", "banana", "apple", "orange", "banana", "apple"); Map<String, Long> wordCounts = words.stream() .collect(Collectors.groupingBy(Function.identity(), HashMap::new, Collectors.counting())); System.out.println(wordCounts);

  9. "Java 8 stream count occurrences of words with BiConsumer"

    • Description: Count occurrences of words using a BiConsumer with Java 8 streams.
    • Code:
      List<String> words = Arrays.asList("apple", "banana", "apple", "orange", "banana", "apple"); Map<String, Long> wordCounts = words.stream() .collect(HashMap::new, (map, word) -> map.merge(word, 1L, Long::sum), HashMap::putAll); System.out.println(wordCounts);

  10. "Java 8 stream count occurrences of words with forEach"

    • Description: Count occurrences of words using a forEach method in Java 8 streams.
    • Code:
      List<String> words = Arrays.asList("apple", "banana", "apple", "orange", "banana", "apple"); Map<String, Long> wordCounts = new HashMap<>(); words.forEach(word -> wordCounts.merge(word, 1L, Long::sum)); System.out.println(wordCounts);

More Tags

instantiation onscroll expandoobject spring-3 bssid continuum marie exponentiation resolve python-venv

More Programming Questions

More Gardening and crops Calculators

More Trees & Forestry Calculators

More Pregnancy Calculators

More Bio laboratory Calculators