我如何在同一个 class 的不同方法中使用私有 static 方法（对象的扩展）的返回值？ （爪哇）

Question

I have a java project with 3 classes. 1 class is used as a static private method in another class. I need to add the results of that method to be added to a list in another method within that class.

Is there anyone who can send me in a good direction?

Answer 1

I understand that you want the implementation of method validWords() . The following works for me.

public static List<WordScore> validWords(final List<String> wordList, final int[] tileCounts) {
    return wordList.stream()
                   .map(word -> wordScore(word, tileCounts))
                   .collect(Collectors.toList());
}

The above code uses the stream API that was added in Java 8. You can also refer to the lesson entitled Aggregate Operations in Oracle's Java tutorials.

Method stream() that is inherited by interface java.util.List returns a "stream" of all the elements in wordList . Each element is a string.

Method map takes a single parameter which is a functional interface . A functional interface can be implemented by a lambda expression . The method that needs to be implemented takes a single string parameter and returns a WordScore object.

Method collect() also takes a single parameter that is a functional interface. Utility class Collectors contains an implementation that returns a List that contains all the elements in the stream. In this case the stream contains WordScore elements. Hence collect() in the above code returns the list that you want the method validWords() to return.

If this is not what you are looking for, let me know and I will delete it.

Answer 2

Member functions of the same class can call and pass data to each other. You just need to call wordScore() from validWords() for each string in the list.

public static List<WordScore> validWords (final List<String> wordList, final int[] tileCounts) {
    List<WordScore> results = new ArrayList<WordScore>();
    for(String word : wordList) {
        results.add(wordScore(word, tileCounts));
    }
    return results;
}

This is the simple way. @Abra's code also works, it uses the Stream API introduced in Java 8. Java 8 has also introduced lambda expressions which will help simplify your Comparator :

Collections.sort(list, new Comparator<WordScore>()
        {
            @Override
            public int compare(final WordScore wsA, final WordScore wsB)
            {
                return (wsA.score() == wsB.score())
                        ? 0
                        : (wsA.score() > wsB.score()) ? -1 : 1;
            }
        });

This can be rewritten as:

Collections.sort(list, (wsA) -> (wsA.score() == wsB.score())
                        ? 0
                        : (wsA.score() > wsB.score()) ? -1 : 1);
         
    

This works because Comparator is a functional interface, an interface that contains only one method compare() . Instead of creating an anonymous class and overriding compare() , what you do is simply specify the arguments in parantheses (type isn't required, the compiler is smart enough to infer them) followed by the -> operator. After this, you specify the return value, the return keyword can also be omitted.

You also don't have to do these multiple condition checks, simply return the difference of the scores:

Collections.sort(list, (wsA, wsB) ->  wsA.score() - wsB.score() );