Cómo convertir una para la iteración con condicionamientos de Java 8 corriente

StatelessDev:

Actualmente, tengo este método, que quiero convertir a un estilo de flujo de Java 8 (tengo poco de práctica con esta API por cierto, que es el propósito de este pequeño ejercicio):

private static Map<Integer, List<String>> splitByWords(List<String> list) {
   for (int i = 0; i < list.size(); i++) { 
        if(list.get(i).length() > 30 && list.get(i).contains("-")) {
            mapOfElements.put(i, Arrays.stream(list.get(i).split("-")).collect(Collectors.toList()));
        } else if(list.get(i).length() > 30) {
            mapOfElements.put(i, Arrays.asList(new String[]{list.get(i)}));
        } else {
            mapOfElements.put(i, Arrays.asList(new String[]{list.get(i) + "|"}));
        }
   }

   return mapOfElements;
}

Esto es lo que he llegado tan lejos:

private static Map<Integer, List<String>> splitByWords(List<String> list) {
   Map<Integer, List<String>> mapOfElements = new HashMap<>();
   IntStream.range(0, list.size())
        .filter(i-> list.get(i).length() > 30 && list.get(i).contains("-"))
        .boxed()
        .map(i-> mapOfElements.put(i, Arrays.stream(list.get(i).split("-")).collect(Collectors.toList())));

//Copy/paste the above code twice, just changing the filter() and map() functions?

En la forma "antigua", sólo necesito una foriteración para hacer todo lo que necesito con respecto a mis condiciones. ¿Hay una manera de lograr que el uso de la API de corriente o, si quiero ser fiel a ella, tengo que repetir el código anterior simplemente cambiando el filtro () condiciones () y el mapa, por lo tanto, tener tres foriteraciones?

Lucio:

La solución actual con el bucle de ve bien. Ya que hay que distinguir tres casos, no hay necesidad de generalizar el procesamiento.

¿Debería haber más casos para distinguir, entonces podría tener sentido de refactorizar el código. Mi enfoque sería definir explícitamente las diferentes condiciones y su correspondiente procesamiento de cadenas. Permítanme explicarlo utilizando el código de la cuestión.

En primer lugar estoy definiendo las diferentes condiciones usando una enumeración.

  public enum StringClassification {
    CONTAINS_HYPHEN, LENGTH_GT_30, DEFAULT;

    public static StringClassification classify(String s) {
      if (s.length() > 30 && s.contains("-")) {
        return StringClassification.CONTAINS_HYPHEN;
      } else if (s.length() > 30) {
        return StringClassification.LENGTH_GT_30;
      } else {
        return StringClassification.DEFAULT;
      }
    }
  }

Usando esta enumeración defino los procesadores cadena correspondiente:

  private static final Map<StringClassification, Function<String, List<String>>> PROCESSORS;
  static {
    PROCESSORS = new EnumMap<>(StringClassification.class);
    PROCESSORS.put(StringClassification.CONTAINS_HYPHEN, l -> Arrays.stream(l.split("-")).collect(Collectors.toList()));
    PROCESSORS.put(StringClassification.LENGTH_GT_30, l -> Arrays.asList(new String[] { l }));
    PROCESSORS.put(StringClassification.DEFAULT, l -> Arrays.asList(new String[] { l + "|" }));
  }

En base a esto se puede hacer todo el procesamiento mediante el pedido IntStream:

  private static Map<Integer, List<String>> splitByWords(List<String> list) {
    return IntStream.range(0, list.size()).boxed()
      .collect(Collectors.toMap(Function.identity(), i -> PROCESSORS.get(StringClassification.classify(list.get(i))).apply(list.get(i))));
  }

El enfoque es para recuperar una cadena de la apropiada StringClassificationy luego a su vez el procesador de cadena correspondiente. Los procesadores de cuerda están implementando el patrón de estrategia , proporcionando una Function<String, List<String>>que mapea una Stringa un List<String>acuerdo con el StringClassification.

Un ejemplo rápido:

  public static void main(String[] args) {
    List<String> list = Arrays.asList("123",
      "1-2",
      "0987654321098765432109876543211",
      "098765432109876543210987654321a-b-c");
    System.out.println(splitByWords(list));
  }

La salida es:

{0=[123|], 1=[1-2|], 2=[0987654321098765432109876543211], 3=[098765432109876543210987654321a, b, c]}

Esto hace que sea fácil añadir o para eliminar las condiciones y los procesadores de cuerda.