JAVA学习 流式编程

package review.Stream;

import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 * 函数式接口
 * Consumer 消费数据，传入数据重写了accept()
 * Supplier 生产数据，get()获取新的数据
 * Predicate 断言，返回布尔类型，重写的是test()
 * Function 转换，传入数据进行操作返回新的数据，默认的方法是apply()
 */

public class InterFaceFunctionPractice implements Function<String,String> {

    @Override
    public String apply(String s) {
        return s.toUpperCase();
    }

    public static void main(String[] args) {
        System.out.println(new InterFaceFunctionPractice().apply("abc"));

        Consumer<String> consumer1 = (s) -> System.out.println(s);
        Consumer<String> consumer2 = System.out::println;
        consumer1.accept("hello");

        Supplier<String> supplier = ()-> "hi";
        System.out.println(supplier.get());

        Predicate<String> predicate = (s) -> s.contains("a");
        System.out.println(predicate.test("abc"));

    }
}

package review.Stream;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * 创建流的方式
 */

public class createStream {

    public static void main(String[] args) {

        //集合的stream()
        List<Integer> list1 = new ArrayList();
        Stream<Integer> stream = list1.stream();

        Integer[] list2 = {1,2,3,4,5};
        Stream<Integer> stream1 = Arrays.stream(list2);

        //stream的静态方法 : concat,of
        Stream.concat(stream,stream1);
        Stream.of("hi","hello");

        //随机数组成的流
        IntStream ints = new Random().ints(10);

    }

}

package review.Stream;

public class Person {

    public String name;
    public Integer age;
    public double salary;
    public String gender;

    public Person() {
    }

    public Person(String name, Integer age, double salary, String gender) {
        this.name = name;
        this.age = age;
        this.salary = salary;
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                ", gender='" + gender + '\'' +
                '}';
    }

}

package review.Stream;

import org.junit.Before;
import org.junit.Test;

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

/**
 * 中间操作:
 * filter(predicate) 过滤
 * map(function)
 * peek(Consumer) 打印
 * sort(Comparator) 排序
 * limit(number) 取前几个数据
 * distinct 去重
 * skip(number) 跳过几个数据
 */

public class progressOperation {

    List<Person> personList = new ArrayList<Person>();
    List<Integer> nums = Arrays.asList(1,2,3,4,5,6,7,8);

    @Before
    public void putData(){
        personList.add(new Person("shan1",18,1000,"lady"));
        personList.add(new Person("shan2",18,2000,"gentleman"));
        personList.add(new Person("shan3",18,3000,"lady"));
        personList.add(new Person("shan4",18,4000,"gentleman"));

    }

    @Test
    public void filterTest(){
        personList.stream().filter(person -> person.getGender() == "lady")
                .collect(Collectors.toList()).forEach(System.out::println);

    }

    @Test
    public void mapTest(){
        personList.stream().map(person -> person.getSalary()).forEach(System.out::println);

        personList.stream().map(person -> {
            person.setSalary(person.getSalary() + 1000);
            return person;
        }).forEach(System.out::println);
    }

    @Test
    public void peekTest(){
        personList.stream().filter(person -> person.getGender() == "lady")
                .peek(System.out::println).collect(Collectors.toList());
    }

    @Test
    public void test(){
        personList.stream().sorted(((o1, o2) -> (int) (o2.getSalary() - o1.getSalary())))
                .limit(2).forEach(System.out::println);

        Stream.of(1,2,2,2,2,4,5,7,7,7,8,8).distinct().skip(2).forEach(System.out::println);

    }




}

package review.Stream;

import org.junit.Before;
import org.junit.Test;

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

/**
 * 终止操作：
 * findFirst(Consumer)
 * findAny(Consumer)
 * allMatch(Predicate)
 * anyMatch(Predicate)
 * forEach(Consumer)
 * ifPresent(Consumer)
 * count 求总数
 * sum 求和
 * max 求一个最大值
 * min 求一个最小值
 * reduce 规约 identity代表初始化值 乘法的初始化值是1，加法是0，n1代表计算好的值，n2代表传入的数据
 * join(delimiter连接的符号) 连接
 * partitioningBy 传入map结构的分组，根据返回的布尔值分组的map
 * groupBy 传入比较的条件
 * toList 流转 list
 * toSet 流转 Set
 * toMap 传入map结构
 */

public class terminalOperation {
    List<Person> personList = new ArrayList<Person>();
    List<Integer> nums = Arrays.asList(1,2,3,4,5,6,7,8);

    @Before
    public void putData(){
        personList.add(new Person("shan1",18,1000,"lady"));
        personList.add(new Person("shan2",18,2000,"gentleman"));
        personList.add(new Person("shan3",18,3000,"lady"));
        personList.add(new Person("shan4",18,4000,"gentleman"));

    }

    //查找
    @Test
    public void findTest(){
        //单线程
        Optional<Person> first = personList.stream().findFirst();
        first.ifPresent(System.out::println);

        Optional<Person> any = personList.stream().findAny();
        any.ifPresent(System.out::println);

        //多线程
        Optional<Person> person = personList.parallelStream().findFirst();
        person.ifPresent(System.out::println);

        Optional<Person> person1 = personList.parallelStream().findAny();
        person1.ifPresent(System.out::println);

    }

    //条件查询
    @Test
    public void MatchTest(){
        boolean f1 = personList.stream().allMatch(person -> person.salary > 8000);
        System.out.println(f1);

        boolean f2 = personList.stream().anyMatch(person -> person.salary > 2000);
        System.out.println(f2);

    }

    //遍历
    @Test
    public void print(){
        personList.stream().forEach(System.out::println);
    }

    //计算
    @Test
    public void countTest(){
        System.out.println(nums.stream().count());

        OptionalDouble average = nums.stream().mapToInt(i -> i).average();
        average.ifPresent(System.out::println);

        int sum = IntStream.of(1, 2, 5, 6, 7, 8, 9).sum();
        System.out.println(sum);

        OptionalInt max = new Random().ints(10).max();
        max.ifPresent(System.out::println);

        OptionalInt min = new Random().ints(10).min();
        min.ifPresent(System.out::println);

    }

    //例子
    @Test
    public void MaxEmployeeSalary(){
        Optional<Person> max = personList.stream()
                .max((o1, o2) -> (int) (o1.salary - o2.salary));
        max.ifPresent(person -> System.out.println("MaxEmployeeSalary" + person));
    }

    //规约
    @Test
    public void reduceTest(){
        int reduce1 = IntStream.of(1, 2, 5, 6, 7, 8, 9)
                .reduce(1, (n1, n2) -> n1 * n2);
        System.out.println(reduce1);

        int reduce2 = IntStream.of(1, 2, 5, 6, 7, 8, 9).reduce(0, Integer::sum);
        System.out.println(reduce2);
    }

    @Test
    public void joinTest(){
        List<String> strings = Arrays.asList("hi","hello","world");
        String collect = strings.stream().collect(Collectors.joining("-"));
        System.out.println(collect);
    }

    //分组
    @Test
    public void collectTest(){
        //keyMap valueMap
        Map<Boolean, List<Person>> collect3 = personList.stream().
                collect(Collectors.partitioningBy(person -> person.salary > 2000));
        System.out.println(collect3);

        Map<String, List<Person>> collect4 = personList.stream().
                collect(Collectors.groupingBy(person -> person.getGender()));
        System.out.println(collect4);


        List<Integer> collect = nums.stream().collect(Collectors.toList());
        System.out.println(collect);
        Set<Integer> collect1 = nums.stream().collect(Collectors.toSet());
        System.out.println(collect1);

        Map<String, Person> collect2 = personList.stream().
                collect(Collectors.toMap(person -> person.getName(), person -> person));
        System.out.println("collect2.get(\"shan1\") = " + collect2.get("shan1"));
    }

}