流使用函数式编程

Question

As was trying to resolve by Functional programming, however, I am stuck in to use more efficiently. Request if one can check out what can be done in this case.

For a given array of transactions, each with an item name,group group all transactions by item name. Return an array of strings where each string contains the item name followed by a space and then the number of transactions.Sort the array descending by transaction count, then ascending alphabetically by item name for items with matching transaction counts.

Example: list = ["bold","not","bold","bold"]

O/P:

bold 3

not 1

tried approach till descending, but confused on functional programming usages:

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

public class PYT {

    public static void main(String[] args) {            
        List<String> list = new ArrayList<String>();
        list.add("bold");
        list.add("not");
        list.add("bold");
        list.add("bold");
        System.out.println(grT(list));
    }

    private static List<String> grT(List<String> list) {  
        //here this is wrong, as throwing error
         Map<Integer, Long> frequencies = ((CharSequence) list).codePoints()  
                       .parallel()
                       .boxed()
                       .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

        // sort by descending frequency and collect code points into array
        int[] output = frequencies.entrySet()
                               .parallelStream()
                               .sorted(Map.Entry.<Integer, Long>comparingByValue().reversed())
                               .mapToInt(Map.Entry::getKey)
                               .toArray();

        // create output string from List of Strings.  
        // Could not think of a way to return a list of string --> Error
        return new String(output, 0, output.length);
    }
}

Will be helpful if one can explain how to check in this by using decomposition / functional prog. approach.

---

Update 1: After resolute to clean code, This looks much cleaner if not used by Functional Programming

private static List<String> ascendingOrder(List<String> list) {
    Map<String, Long> stringCount = new HashMap<>();
            for (String t : list) {
                stringCount.merge(t, 1L, Long::sum);
            }

            List<Map.Entry<String, Long>> toSort = new ArrayList<>();
            for (Map.Entry<String, Long> e : stringCount.entrySet()) {
                toSort.add(e);
            }
            toSort.sort(Map.Entry.<String, Long>comparingByValue().reversed().thenComparing(Map.Entry.comparingByKey()));
            List<String> refinedList = new ArrayList<>();
            for (Map.Entry<String, Long> e : toSort) {
                String s = e.getKey() + " " + e.getValue();
                refinedList.add(s);
            }

            return refinedList;
}

Answer 1

First create a map using tx name as the key and it's count as value. Then use this map to build the structure you need. Also notice that, when you use the Map.Entry.comparingByValue() along with another chained operator like reversed or thenComparing , the type inference is not powerful enough to figure the type out for itself, so we are forced to help it providing them explicitly. This is a reported bug and you may find it here .

private static final String SPACE = " ";

Map<String, Long> frequencyMap = tx.stream()
    .collect(Collectors.groupingBy(t -> t, Collectors.counting()));

List<String> formattedTx = frequencyMap.entrySet().stream()
    .sorted(Map.Entry.<String, Long>comparingByValue().reversed()
        .thenComparing(Map.Entry.comparingByKey()))
    .map(e -> e.getKey() + SPACE + e.getValue())
    .collect(Collectors.toList());