如何将带条件的迭代转换为Java 8流

目前,我有这个方法,我想转换为 Java 8流样式(我很少练习这个API btw,这就是这个小练习的目的)：

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

这是我到目前为止所得到的：

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?

以“老式”的方式,我只需要迭代一次就我的条件做我需要的一切.有没有办法使用Stream API实现这一点,或者,如果我想坚持下去,我必须重复上面的代码只是改变filter()和map()条件,因此迭代有三个？

解决方法

具有for循环的当前解决方案看起来很好.由于您必须仅区分三种情况,因此无需概括处理.

如果有更多的案例要区分,那么重构代码是有意义的.我的方法是明确定义不同的条件及其相应的字符串处理.让我用问题中的代码解释一下.

首先,我使用枚举来定义不同的条件.

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

使用这个枚举我定义了相应的字符串处理器：

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

基于此,我可以使用请求的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))));
  }

方法是为字符串检索适当的StringClassification,然后依次检索相应的字符串处理器.字符串处理器通过提供函数< String,List< String>>来实现strategy pattern.将String映射到List< String>根据StringClassification.

一个简单的例子：

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

输出是：

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

这样可以轻松添加或删除条件和字符串处理器.