Uso corriente de Programación Funcional

piso D'Souza:

Como estaba tratando de resolver mediante la programación funcional, sin embargo, estoy atascado en un uso más eficiente. Solicitar si se puede comprobar lo que se puede hacer en este caso.

Para una gama dada de transacciones, cada uno con un nombre de elemento, grupo grupo todas las transacciones por nombre de elemento. Devolver una matriz de cadenas, donde cada cadena contiene el nombre del elemento seguido de un espacio y el número de la transactions.Sort descendente matriz por número de transacciones, entonces ascendente en orden alfabético por nombre de artículo para los artículos a juego con los recuentos de transacción.

Ejemplo: list = [ "negrita", "no", "negrita", "negrita"]

O / P:

negrita 3

no 1

enfoque intentado hasta descendente, pero confundido sobre usos de programación funcional:

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);
    }
}

Será útil si se puede explicar cómo comprobar en esta usando la descomposición prog / funcional. Acercarse.

---

Actualización 1: Después resuelta a un código limpio, esto se ve mucho más limpio si no es utilizado por la programación funcional

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;
}

Ravindra Ranwala:

En primer lugar crear un mapa mediante tx nombre como la clave y de recuento como el valor. A continuación, utilice este mapa para construir la estructura que necesita. Observe también que, cuando se utiliza el Map.Entry.comparingByValue()junto con otro operador encadenado como reversedo thenComparing, el tipo de inferencia no es lo suficientemente potente como para averiguar el tipo a cabo por sí mismo, por lo que nos vemos obligados a proporcionar ayuda que explícitamente. Se trata de un informe de errores y es posible encontrarlo aquí .

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());