As a qualified programmer, how to make the code more concise and clear, and improve the coding speed.

Today, follow me to learn the application of java 8 stream.

Don't talk much nonsense, go straight to the point.

Considering the following business scenario, there are four personnel information, and we need to count the names of personnel according to their gender.

package com;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Test {
    public static void main(String[] args) {

        List<Map<String, String>> list = new ArrayList<>();
        Map<String, String> map = new HashMap<>();
        map.put("userName", "Zhang San");
        map.put("age", "18");
        map.put("sex", "male");
        list.add(map);

        Map<String, String> map1 = new HashMap<>();
        map1.put("userName", "Li Si");
        map1.put("age", "20");
        map1.put("sex", "female");
        list.add(map1);

        Map<String, String> map2 = new HashMap<>();
        map2.put("userName", "Wang Wu");
        map2.put("age", "15");
        map2.put("sex", "female");
        list.add(map2);

        Map<String, String> map3 = new HashMap<>();
        map3.put("userName", "Ruofeng");
        map3.put("age", "23");
        map3.put("sex", "male");
        list.add(map3);

        //Now we're going to count people by gender
        //Primary writing
        StringBuilder stringBuilder1 = new StringBuilder();
        StringBuilder stringBuilder2 = new StringBuilder();
        for (Map<String, String> item : list) {
            //map pointing to the current subscript
            System.out.println("item: " + item);
            if (item.get("sex").equals("male")) {
                //Names of persons with gender as male, separated by commas
                stringBuilder1.append(item.get("userName")).append(",");
            } else {
                //Names of persons with gender as female, separated by commas
                stringBuilder2.append(item.get("userName")).append(",");
            }
        }
        //Remove the last comma
        String userName_nan = stringBuilder1.deleteCharAt(stringBuilder1.length() - 1).toString();
        String userName_nv = stringBuilder2.deleteCharAt(stringBuilder2.length() - 1).toString();
        System.out.println("userName_nan: " + userName_nan);
        System.out.println("userName_nv: " + userName_nv);
    }
}

The printing records are as follows:

Does it feel that the code is not very elegant? Then we start to change our posture and use java8 Stream flow to operate.

package com;

import org.apache.commons.lang.StringUtils;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Test {
    public static void main(String[] args) {

        List<Map<String, String>> list = new ArrayList<>();
        Map<String, String> map = new HashMap<>();
        map.put("userName", "Zhang San");
        map.put("age", "18");
        map.put("sex", "male");
        list.add(map);

        Map<String, String> map1 = new HashMap<>();
        map1.put("userName", "Li Si");
        map1.put("age", "20");
        map1.put("sex", "female");
        list.add(map1);

        Map<String, String> map2 = new HashMap<>();
        map2.put("userName", "Wang Wu");
        map2.put("age", "15");
        map2.put("sex", "female");
        list.add(map2);

        Map<String, String> map3 = new HashMap<>();
        map3.put("userName", "Ruofeng");
        map3.put("age", "23");
        map3.put("sex", "male");
        list.add(map3);

        //Now we're going to count people by gender
        //Primary writing
//        StringBuilder stringBuilder1 = new StringBuilder();
//        StringBuilder stringBuilder2 = new StringBuilder();
//        for (Map<String, String> item : list) {
//            //map pointing to the current subscript
//            System.out.println("item: " + item);
//            if (item.get("sex").equals("men"){
//                //Names of persons with gender as male, separated by commas
//                stringBuilder1.append(item.get("userName")).append(",");
//            } else {
//                //Names of persons with gender as female, separated by commas
//                stringBuilder2.append(item.get("userName")).append(",");
//            }
//        }
//        //Remove the last comma
//        String userName_nan = stringBuilder1.deleteCharAt(stringBuilder1.length() - 1).toString();
//        String userName_nv = stringBuilder2.deleteCharAt(stringBuilder2.length() - 1).toString();
//        System.out.println("userName_nan: " + userName_nan);
//        System.out.println("userName_nv: " + userName_nv);

        //The writing method of java8 stream
        //First, define a Map to store the names of our personnel
        Map<String, String> userNameMap = new HashMap<>(4);
        //Start acting
        //
        list.stream().map(v1 -> {
            //Map can be understood as a new object. copy the data of the original List to a new List. When using map to modify the data, the original object will not be changed. Return value required!!!
            //v1 points to the map object of the current subscript
            System.out.println("v1: " + v1);
            //Define a new map to store people's names and gender
            Map<String, String> data = new HashMap<>();
            map.put("userName", v1.get("userName"));
            map.put("sex", v1.get("sex"));
            return map;
        }).reduce(userNameMap, (a, b) -> {
            //a can be understood as the return result of the last cycle
            //Bcurrent loop o b ject
            //Get the name of the person in the current cycle
            String thisUserName = b.get("userName");
            //Take out the gender of the person in the current cycle
            String thisSex = b.get("sex");
            if (thisSex.equals("male")) {
                //Take the return result of the last cycle. The first cycle has no value. The second cycle gets the return result of the first cycle, and so on.
                String val = a.get("newMenUserName");
                System.out.println("val: " + val);
                //In the first loop, val has no value. We assign an empty string,
                // In the second cycle, take out the value of newUserName returned by the first cycle, and add comma to splice the name of the current subscript
                String newUserName = (StringUtils.isBlank(val) ? StringUtils.EMPTY : val + ",") + thisUserName;
                //Add the spliced person name to the map
                System.out.println("newUserName: " + newUserName);
                a.put("newMenUserName", newUserName);
            } else {
                //Take the return result of the last cycle. The first cycle has no value. The second cycle gets the return result of the first cycle, and so on.
                String val = a.get("newWomenUserName");
                System.out.println("val: " + val);
                //In the first loop, val has no value. We assign an empty string,
                // In the second cycle, take out the value of newUserName returned by the first cycle, and add comma to splice the name of the current subscript
                String newUserName = (StringUtils.isBlank(val) ? StringUtils.EMPTY : val + ",") + thisUserName;
                System.out.println("newUserName: " + newUserName);
                //Add the spliced person name to the map
                a.put("newWomenUserName", newUserName);
            }
            //Returns the map of the current loop
            return a;
        });
        System.out.println("userNameMap: " + userNameMap);
        System.out.println("userName_nan: " + userNameMap.get("newMenUserName"));
        System.out.println("userName_nv: " + userNameMap.get("newWomenUserName"));

    }
}

The printed values are as follows:

Scenario 2. Take the intersection of two lists

package com;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class Test {
    public static void main(String[] args) {

//        Business scenario 2: take out two List Element with the same value (intersection)
        List<Integer> list1=new ArrayList<>();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        list1.add(4);
        List<Integer> list2=new ArrayList<>();
        list2.add(2);
        list2.add(4);
        //intersection
        List<Integer> list3=new ArrayList<>();
        //Primary writing
        for(Integer item:list1){
            if(list2.contains(item)){
                list3.add(item);
            }
        }
        System.out.println("for The result of the cycle");
        System.out.println("list3: "+list3);

        System.out.println("------------------------------------------------------------");

        //stream The writing method of flow
        //v1 Object representing the current subscript
        //filter  The filtering result is false Data for
        list3=list1.stream().filter(v1->list2.contains(v1)).collect(Collectors.toList());
        System.out.println("stream The result of the cycle");
        System.out.println("list3: "+list3);

        //list Own approach
        System.out.println("------------------------------------------------------------");
        System.out.println("old Data, list1: "+list1);
        System.out.println("old Data, list2: "+list2);
        list1.retainAll(list2);
        System.out.println("new Data, list1"+list1);
        System.out.println("new Data, list2"+list2);
    }
}

Print results:

Scenario 3. Sorting a List

package com;

import java.util.*;
import java.util.stream.Collectors;

public class Test {
    public static void main(String[] args) {

//        Business scenario 3: sorting List
        List<Map<String, String>> list = new ArrayList<>();
        Map<String, String> map = new HashMap<>();
        map.put("userName", "Zhang San");
        map.put("age", "18");
        map.put("sex", "male");
        list.add(map);

        Map<String, String> map1 = new HashMap<>();
        map1.put("userName", "Li Si");
        map1.put("age", "20");
        map1.put("sex", "female");
        list.add(map1);

        Map<String, String> map2 = new HashMap<>();
        map2.put("userName", "Wang Wu");
        map2.put("age", "15");
        map2.put("sex", "female");
        list.add(map2);

        Map<String, String> map3 = new HashMap<>();
        map3.put("userName", "Ruofeng");
        map3.put("age", "23");
        map3.put("sex", "male");
        list.add(map3);


        //The writing method of stream stream
        System.out.println("------------------------Before sorting--------------------------------");
        System.out.println("Before sorting,List :"+list);
        //sorted stream, where we sort by age and name
        //In Test::age Java 8, we can use the ':' keyword to access class construction methods, object methods, and static methods.
        //Start acting
        List<Map<String, String>> list2=list.stream().sorted(Comparator.comparing(Test::age).thenComparing(Comparator.comparing(Test::userName))).collect(Collectors.toList());
        System.out.println();
        System.out.println("------------------------After sorting--------------------------------");
        System.out.println("After sorting,list2 :"+list2);
    }
    private static String userName(Map<String,String> map){
        return map.get("userName");
    }
    private static Integer age(Map<String,String> map){
        return Integer.parseInt(map.get("age"));
    }
}

Print results:

Summary: