由于某些原因，流过滤器不起作用

Question

My first post here, im very new with java (and with any programming) as you can see below :)

I need to print out a word from list, but for some reason my stream command cannot find parameter(String word) after using filter(), even when the word exist in list. (i tried sout() whole list without filter and found it in input).

private List<String> lines;

public reviews(List<String> lines) { 
    this.lines = lines;
}

public void NumberOfWords(String theWord) {

    lines.stream()
            .map(lines -> lines.split(" "))
            .map(words -> Arrays.toString(words))
            .map(word -> word.trim().toLowerCase())
            .filter(word -> word.equals(theWord))   // Something wrong with this line?
            .forEach(word -> System.out.println(word));

}

Without stream filter() the output looks like this:

[1, a, series, of, escapades, demonstrating, the, adage, that, what, is, good, for, the, goose, is, also, good , for, the, gander, ,, some, of, which, occasionally, amuses, but, none, of, which, amounts, to, much, of, a, story, . ] [4, this, quiet, ,, introspective, and, entertaining, independent, is, worth, seeking, . ] [1, even, fans, of, ismail, merchant, 's, work, ,, i, suspect, ,, would, have, a, hard, time, sitting, through, this, one, . ] [3, a, positively //etc........

and with filter, lets say we would have parameter word: " good ". it exist, but method doesnt print it.

Answer 1

You have a logical mistake here:

.map(words -> Arrays.toString(words))
.map(word -> word.trim().toLowerCase())

The first line here will return a string representation of an array so the result will be something like : from "I am a newbie !" to "I, am, a, newbie, !" Then trimming this string will result to the very same string -> "I, am, a, newbie, !" After that you are filtering this very same string(composite one, and not a simple word) to the key word. This will lead to an empty list in the end.

In the case where you would like to print the matching word each time there is a hit then you could use a flatMap to do so in the following manner:

lines.stream()
    .map(line -> line.split(" "))
    .flatMap(Arrays::stream)
    .map(word -> word.trim().toLowerCase())
    .filter(word -> word.equals(theWord))
    .forEach(System.out::println);

And in the case you would like to print out the total occurrences of the desired word just use this one:

System.out.println(lines.stream()
    .map(line -> line.split(" "))
    .flatMap(Arrays::stream)
    .map(word -> word.trim().toLowerCase())
    .filter(word -> word.equals(theWord))
    .count());

Answer 2

Your non-filtered output says it all. You are unintentionally comparing a string of an entire array of words instead of one word.

The problem lies in the map to Arrays.toString(words) . In this case, every element of your stream becomes a string similar to: [1, a, series, of, escapades, demonstrating, the, adage, that, what, is, good, for, the, goose, is, also, good, for, the, gander, ,, some, of, which, occasionally, amuses, but, none, of, which, amounts, to, much, of, a, story, . ] [1, a, series, of, escapades, demonstrating, the, adage, that, what, is, good, for, the, goose, is, also, good, for, the, gander, ,, some, of, which, occasionally, amuses, but, none, of, which, amounts, to, much, of, a, story, . ] (This is one element.)

Instead, you're looking to flatMap your lines of words into single words like so:

 lines.stream()                                     // Stream each line (each line is a string)
        .map(line -> line.split(" "))               // Map to an array of words per line
        .flatMap(lineArr -> Arrays.stream(lineArr)) // Map each word array into a stream of single words, and flatten each stream into a single one
        ...                                         // Now you can work with a stream of "single words"

Note that by "single words" above I mean anything that is between two spaces. As you can see in the above array example, you have some empty or punctuation-only entries, but that shouldn't affect your later equals comparison.