将 java 7 嵌套 for 循环转换为使用 java 8 流 API

Question

I have an example here which basically returns list based on simple logic

Given an input list and a list of grouping objects, which has a list field, the method should return a list that contains either all the members of grouping.list if the grouping.name matches any of the strings in the input list OR simply add the input string to the returning list.

After I writing this code, I am thinking it could be made simpler in Java 7 and a better example to use Java 8 Streaming API.

public class CollectorExample {

    public static void main(String[] args){

        List<String> input = new ArrayList<>();
        input.add("foo");
        input.add("bar");
        input.add("foobar");
        input.add("java");

        List<String> list1 = new ArrayList<>();
        list1.add("hello");
        list1.add("world");

        List<String> list2 = new ArrayList<>();
        list2.add("spring");
        list2.add("multi-threaded");


        Grouping g1 = new Grouping("foobar",list1);
        Grouping g2 = new Grouping("java",list2);

        List<Grouping> groupingList = new ArrayList<>();
        groupingList.add(g1);
        groupingList.add(g2);


        System.out.println(mapAndMerge(input,groupingList));


    }


    public static List<String> mapAndMerge(List<String> input, List<Grouping> groupingList){

        Set<String> returnDocs = new HashSet<>();
        Iterator<String> it = input.iterator();
        while(it.hasNext()){
            String doc = it.next();
            boolean found = false;
            for (Grouping lg : groupingList){
                if (lg.getName().equals(doc)){
                    returnDocs.addAll(lg.getList());
                    found=true;
                   }
                }
            if (!found){
                returnDocs.add(doc);
            }
        }
    return new ArrayList<>(returnDocs);
    }

}

class Grouping {

    List<String> list;
    String name;

    public Grouping(String name, List<String> list){
        this.list=list;
        this.name=name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<String> getList() {
        return list;
    }

    public void setList(List<String> list) {
        this.list = list;
    }


}

This outputs [spring, bar, world, foo, hello, multi-threaded] which is correct. Here is my Java 8 syntax that I tried and did NOT work;

//        List<String> mergedDocs = 
//                input.forEach(doc->
//                                 groupingList.stream().map( g -> g.getName().equals(doc) ? e.getList() : doc ).collect(Collectors.toList()));
//        return mergedDocs;

Answer 1

You can make this a lot simpler by not using your Grouping class but using a simple Map<String, List<String>> instead. This map would act as the grouping, holding the list for a given name. This also enables to have a much better performance since looking into the map is constant-time (whereas your solution is in linear time since it traverses the grouping to find a matching one).

If you have to use the List<Grouping> , you can still pre-process it to convert into an intermediate Map :

The mapAndMerge method simply becomes:

public static List<String> mapAndMerge(List<String> input, List<Grouping> groupingList) {
    Map<String, List<String>> map = groupingList.stream().collect(Collectors.toMap(Grouping::getName, Grouping::getList));
    return input.stream()
                .flatMap(s -> map.getOrDefault(s, Arrays.asList(s)).stream())
                .collect(Collectors.toList());
}

Each input is flat mapped to the list contained in the map or a default list containing the current element. Then this is collected to a new list. This code prints:

[foo, bar, hello, world, spring, multi-threaded]

Answer 2

You can re-write the mapAndMerge method following way using java 8. But it is not very concise as you like.

    public static List<String> mapAndMerge(List<String> input,
        List<Grouping> groupingList) {

      Set<String> returnDocs = input
        .stream()
        .map(t -> groupingList
            .stream()
            .filter(g -> g.getName().equals(t))
            .map(v -> v.getList())
            .findAny()
            .orElse(Arrays.asList(t)))
        .flatMap(t -> t.stream())
        .collect(Collectors.toSet());

      return new ArrayList<>(returnDocs);
    }

Answer 3

I think it would be much simple and clearer if you use Map instead of the Grouping class.

So that's what you'll have in the main() method:

    Map<String, List<String>> groupingMap = new HashMap<>();
    groupingMap.put("foobar", list1);
    groupingMap.put("java", list2);

    List<String> mergedDocs = new ArrayList<>();
    input.stream()
         .map(doc -> groupingMap.getOrDefault(doc, Collections.singletonList(doc)))
         .forEach(mergedDocs::addAll);

    System.out.println(mergedDocs);