JDK 8 函数式编程入门2-code

 

Collect.java

package constant;

import entity.User;

import java.util.ArrayList;
import java.util.List;

/**
 * @program: java8
 * @description:
 * @author: bugyun
 * @create: 2018-11-05 10:02
 */
public class Collect {



    public final static List<String> listStr = new ArrayList<>();
    public final static List<Integer> listInt = new ArrayList<>();
    public final static List<User> listEntiyJapan = new ArrayList<>();
    public final static List<User> listEntiyChina = new ArrayList<>();





    static {
        listStr.add("Google");
        listStr.add("Facebook");
        listStr.add("Microsoft");
        listStr.add("IBM");
        listStr.add("Yahoo");

/////////////////////////////////////////////
        listInt.add(25);
        listInt.add(21);
        listInt.add(50);
/////////////////////////////////////////////
        User one = new User();
        one.setId(111);
        one.setName("tom");
        one.setPassword("123456");

        User two = new User();
        two.setId(122);
        two.setName("jack");
        two.setPassword("123456");

        User three = new User();
        three.setId(333);
        three.setName("lisa");
        three.setPassword("123456");

        listEntiyJapan.add(three);
        listEntiyJapan.add(one);
        listEntiyJapan.add(two);
////////////////////////////////////////////

        User one1 = new User();
        one1.setId(9000);
        one1.setName("zhangsan");
        one1.setPassword("123456");

        User two1 = new User();
        two1.setId(9001);
        two1.setName("wangwu");
        two1.setPassword("123456");

        User three1 = new User();
        three1.setId(9002);
        three1.setName("zhaoliu");
        three1.setPassword("123456");

        listEntiyChina.add(three1);
        listEntiyChina.add(one1);
        listEntiyChina.add(two1);

    }


}

 

 

User.java

package entity;

/**
 * @program: java8
 * @description:
 * @author: bugyun
 * @create: 2018-11-05 10:19
 */
public class User {

    private Integer id ;
    private  String name ;
    private String password ;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

 

 

StreamMy.java

package lambda;

import constant.Collect;
import entity.User;

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

/**
 * @program: java8
 * @description:
 * @author: bugyun
 * @create: 2018-11-05 09:59
 */
public class StreamMy {

    public static void main(String[] args) {
//        long count = count(Collect.listEntiyJapan);
//        System.out.println(count);
//
//        List<String> collected = listStr("hello", " world ", " honey");
//        System.out.println(collected);
//
//        List<String> collectedMap = listMap("hello", " world ", " honey");
//        System.out.println(collectedMap);
//
//        List<User> poList = map(Collect.listEntiyJapan);
//        System.out.println(poList);
//
//        List<User> listTwo = listTwo(Collect.listEntiyChina, Collect.listEntiyJapan);
//        System.out.println(listTwo);
//
//         String max = max(Collect.listStr);
//        System.out.println(max);
//
//        Integer min = min(Collect.listInt);
//        System.out.println(min);
//
//        Integer reduce = reduce(Collect.listInt);
//        System.out.println(reduce);
//
//        Integer reduce = reduceSum(Collect.listInt);
//        System.out.println(reduce);

        Integer reduceParallel = reduceParallel(Collect.listInt);
        System.out.println(reduceParallel);


    }


    /**
     *  获取集合中id小于300的人数
     * @param list
     * @return
     */
    public static Long count(List<User> list) {
        Long result = list.stream()
                .filter(po -> po.getId() < 300)
                .count();
        return result;
    }

    /**
     * collect(toList())
     *  方法由 Stream 里的值生成一个列表，是一个及早求值操作。可以理解为 Stream 向 Collection 的转换。
     *
     * @param str
     * @return
     */
    public static List<String> list(String ... str){
        List<String> collected = Stream.of(str)
                                    .collect(Collectors.toList());
        return collected;
    }


    /**
     * map
     *  如果有一个函数可以将一种类型的值转换成另外一种类型，map 操作就可以使用该函数，将一个流中的值转换成一个新的流。
     *
     * @param strs
     * @return
     */
    public static List<String> listMap(String ... strs){
        List<String> collected = Stream.of(strs)
                                    .map(str -> str.toUpperCase())
                                    .collect(Collectors.toList());
        return collected;
    }

    /**
     * map
     *  如果有一个函数可以将一种类型的值转换成另外一种类型，map 操作就可以使用该函数，将一个流中的值转换成一个新的流。
     *
     * @param list
     * @return
     */
    public static List<User> map(List<User> list){
        List<User> result = list.stream()
                .filter(po -> po.getId() < 300)
                .collect(Collectors.toList());
        return result;
    }

    /**
     * flatMap
     *  合并多个 Collection。
     *
     * @param listOne
     * @param listTwo
     * @return
     */
    public static List<User> listTwo(List<User> listOne ,List<User> listTwo){
        List<User> result = Stream.of(listOne, listTwo)
                .flatMap(numbers -> numbers.stream())
                .collect(Collectors.toList());
        return result;
    }

    /**
     * max 返回的是一个 Optional 对象，可能为空。 String的话是按首字母排序的
     *
     * @param list
     * @return
     */
    public static String max(List<String> list) {
        String result = list.stream()
                .max(String::compareTo)    // 等同于 (str1, str2) -> str1.compareTo(str2)，且都是 String 类型
                .get();
        return result;
    }

    public static Integer min(List<Integer> list) {
        Integer result = list.stream()
                .min(Integer::compareTo)
                .get();
        return result;
    }

    public static Integer reduce(List<Integer> list) {
        Integer result = list.stream()
                .reduce(0, (one, two) -> one + two);
        return result;
    }

    public static Integer reduceSum(List<Integer> list) {
        Integer result = list.stream()
                .reduce(0,Integer::sum);
        return result;
    }

    /**
     * parallel()
     *
     *  数据并行化是指将数据分成块，为每块数据分配单独的处理单元
     *  a. 如果你去计算这段代码所花的时间，很可能比不加上 parallel() 方法花的时间更长
     *  b. 这是因为数据并行化会先对数据进行分块，然后对每块数据开辟线程进行运算，这些地方会花费额外的时间
     *  c. 并行化操作只有在 数据规模比较大 或者 数据的处理时间比较长 的时候才能体现出有事
     *  d. 所以并不是每个地方都需要让数据并行化，应该具体问题具体分析
     * @param list
     * @return
     */
    public static Integer reduceParallel(List<Integer> list) {
        Integer result = list.stream()
                .parallel()
                .reduce(Integer::sum)
                .get();
        return result;
    }

}