常用代码-streamAPI等

代码积累

常用代码积累

一、常用的函数式接口编程

Consumer 消费型接口 Consumer void accept(T t)
Supplier 供给型接口 Supplier T get()
Function 函数接口 Function<T,R> R apply(T t)
Predict 断言接口 Predict boolean test(T t)

1.consumer 消费型接口

    @Test
    void testconsumer(){
        happyTime(500, new Consumer<Double>() {
            @Override
            public void accept(Double aDouble) {
                System.out.println("花了"+aDouble);
            }
        });
        System.out.println("################################################################");
        happyTime(500, System.out::println);
        happyTime(500,money ->System.out.println("花了"+money));
    }

    public void happyTime(double money, Consumer<Double> consumer){
        consumer.accept(money);
    }

Supplier 供给型接口

    @Test
    void testSupplier() {
        List<String> list = sup(()->{ return "a";});
        System.out.println(list);
    }
    public <T> List<T> sup (Supplier<T> s){
        List<T> result = new ArrayList<T>();
        result.add(s.get());
        return result;
    }

Function 函数接口

    @Test
    void testFunction(){
        List<Integer> l = map(Arrays.asList("lamada","abc","b"),s -> s.length());
        System.out.println(l);
    }
    public <T, R> List<R> map(List<T> list, Function<T, R> f) {
        List<R> result = new ArrayList<R>();
        for (T t : list) {
            result.add(f.apply(t));
        }
        return result;
    }

Predict 断言接口

    @Test
    void testPredicate() {
        List<String> fileterStrings = Arrays.asList("北京","上海","南京");
        List<String> list1 = fileterString(fileterStrings, new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.contains("京");
            }
        });
        System.out.println(list1);
        System.out.println("################################");
        List<String> list2 = fileterString(fileterStrings, s -> s.contains("京"));
        System.out.println(list2);
    }


    public List<String> fileterString(List<String> str, Predicate<String> predicate) {
        ArrayList<String> list = new ArrayList<String>();
        for (String s : str) {
            if (predicate.test(s)) {
                list.add(s);
            }
        }
        return list;
    }

二、lambda方法引用

1.使用情景：给一个函数式接口赋对象的时候;要求接口中的抽象方法的形参列表和返回值类型和方法引用的形参列表和返回值相同。

2.使用

2.1情况1 对象：：实例方法

    @Test
    void testt1(){
        Consumer<String> con1 = str -> System.out.println(str);
        con1.accept("北京");
        System.out.println("################################");
        PrintStream ps = System.out;
        Consumer con2 = ps::println;
        con2.accept("南京");
    }

    @Test
    void testt2() {
        class Person {
            private String name;
            private int age;

            public Person(String name, int age) {
                this.name = name;
                this.age = age;
            }
            public String getName() {
                return name;
            }

        }
        Person p = new Person("北京", 18);

        Supplier<String> supplier1 = ()->p.getName();
        System.out.println(supplier1.get());
        Supplier<String> supplier = p::getName;
        System.out.println(supplier.get());
        System.out.println(p.getName());
    }

2.2 类：：静态方法

    @Test
    void testt3() {
        Comparator<Integer> com1 = (t1, t2) -> Integer.compare(t1, t2);
        System.out.println(com1.compare(11,21));
        Comparator<Integer> com2 = Integer::compare;
        System.out.println(com2.compare(11,21));

    }

2.3

三、java实现读取resource目录的几种方式

1.主要核心方法是使用getResource和getPath方法，这里的getResource(“”)里面是空字符串

    public void function1(String fileName) throws IOException {
        String path = this.getClass().getClassLoader().getResource("").getPath();//注意getResource("")里面是空字符串
        System.out.println(path);
      // /Users/spring-cloud-learn/spring-nacos-provider/target/classes/
        String filePath = path + fileName;
        System.out.println(filePath);
        getFileContent(filePath);
    }

2.主要核心方法是使用getResource和getPath方法，直接通过getResource(fileName)方法获取文件路径，注意如果是路径中带有中文一定要使用URLDecoder.decode解码。

    /**
     * 直接通过文件名getPath来获取路径
     *
     * @param fileName
     * @throws IOException
     */
    public void function2(String fileName) throws IOException {
        String path = this.getClass().getClassLoader().getResource(fileName).getPath();//注意getResource("")里面是空字符串
        System.out.println(path);
      ///Users/ll/Desktop/MAV/spring-cloud-learn/spring-nacos-provider/target/classes/bootstrap.yml
        String filePath = URLDecoder.decode(path, "UTF-8");//如果路径中带有中文会被URLEncoder,因此这里需要解码
        System.out.println(filePath);

    }

四、stream API

简述

JDK1.8开始，引入了一个全新的流式Stream API，它位于**java.util.stream**包中，StreamAPI用于帮我们更方便地操作集合，他的本质就是对数据的操作进行流水线式处理，也可以理解为一个更加高级的迭代器，主要的作用便是遍历其中每一个元素。

Stream的特点

和list等容器不同，Stream代表的是任意Java对象的序列，且stream输出的元素可能并没有预先存储在内存中，而是实时计算出来的。它可以“存储”有限个或无限个元素。

例如我们要表示一个全体自然数的集合，用List是不可能写出来的，因为自然数是无限的，内存再大也没法放到List中，但我们可以用stream做到，我们不考虑这个方法是如何实现的，我们只需关心现在这些自然数没有实时存在内存里，我们可以对这个自然数流进行平方、加减等操作，等我们需要部分有限的数据时，再通过API获得，也就是说真正的计算发生在流的最后。

创建Stream

1、Stream.of静态方法可以直接手动生成一个stream

Stream<String> stream = Stream.of("A", "B", "C", "D");

很简单，不过也没什么实际用途

2、基于数组或Collection

把数组变成stream使用Arrays.stream()方法。对于Collection（List、Set、Queue等)，直接调用stream()方法就可以获得stream。

Stream<String> stream1 = Arrays.stream(new String[] { "A", "B", "C" });
Stream<String> stream2 = List.of("X", "Y", "Z").stream();

3、基于Supplier

基于Supplier创建的Stream会不断调用Supplier.get()方法来不断产生下一个元素，这种Stream保存的不是元素，而是算法，它可以用来表示无限序列。例如我们可以用supplier来创建一个自然数stream

public class Main {
    public static void main(String[] args) {
        Stream<Integer> natual = Stream.generate(new NatualSupplier());//自然数stream
    }
}

class NatualSupplier implements Supplier<Integer> {
    int n = 0;
    public Integer get() {
        n++;
        return n;
    }
}

中间操作

1.筛选与切片

filter(Predicate p) 、limit(long maxSize)、skip(long n)、distinct

package com.example.springnacosprovider;

import lombok.AllArgsConstructor;
import lombok.Data;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.autoconfigure.data.cassandra.DataCassandraTest;

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

/**
 * @author l	iw
 * @date 2022-10-22
 */


public class StreamTest {

    public static List<Employee> getEmployees(){
        List<Employee> employees = new ArrayList<Employee>();
        employees.add(new Employee(1,"张飞",2000));
        employees.add(new Employee(2,"李四",7000));
        employees.add(new Employee(3,"王五",5000));
        employees.add(new Employee(3,"王五",5000));
        return employees;
    }
    @Test
    void testStream1(){
        List<Employee> employees = getEmployees();
        Stream<Employee> stream = employees.stream();
        //filter 里面有个成员-Predicate
        stream.filter(e -> e.getSalary() > 5000).forEach(System.out::println);
        System.out.println("######################");
        employees.stream().limit(1).forEach(System.out::println);
        System.out.println("######################");
        employees.stream().skip(1).forEach(System.out::println);
        System.out.println("######################");
        employees.stream().distinct().forEach(System.out::println);
    }

}
@Data
@AllArgsConstructor
class Employee{
    private int id;
    private String name;
    private double salary;

    public Employee(int id, String name) {
        this.id = id;
    }
}

2.映射

map(Function f)、mapToDouble(ToDoubleFunction f)

mapToInt(ToIntFunction f)

mapToLong（ToLongFunction f）

flatMap（Function f）

@Test
void testMaps() {
    List<String> str = Arrays.asList("a", "b", "c", "d");
    str.stream().map(s -> s.toUpperCase()).forEach(System.out::print);
    System.out.println("######################");
    List<Employee> employees = getEmployees();
    //获取员工名字大于3的员工的姓名
    employees.stream().map(Employee::getName).filter(name->name.length()>3).forEach(System.out::println);
    //flatMap 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流


}

3.排序

sorted（） 、sorted（Comparator com）

@Test
public void testSort() {
    List<Integer> list = Arrays.asList(12, 10, 23, 4, 5, 6, 17,9);
    list.stream().sorted().forEach(System.out::print);

    List<Employee> employees = getEmployees();
    employees.stream().sorted((e1,e2)->Double.compare(e1.getSalary(),e2.getSalary())).forEach(System.out::print);
}

终止操作

1.匹配与查找

allMatch（Predicate p）

anyMatch（Predicate p）
noneMatch（Predicate p）

findFirst()

findAny（）

Count()

Max()

min()

forEach()

@Test
    void testEnd(){
        List<Employee> employees = getEmployees();
        boolean b1 = employees.stream().allMatch(e->e.getAge()>10);
        boolean b2 = employees.stream().anyMatch(e->e.getAge()>10);
        boolean b3 = employees.stream().noneMatch(e->e.getAge()>100);
        Employee employee1 = employees.stream().findFirst().get();
        Employee employee2 = employees.stream().findAny().get();
        long l1 = employees.stream().count();
        int age1 = employees.stream().map(Employee::getAge).max((e1, e2) -> Integer.compare(e1, e2)).get();
        int age2 = employees.stream().map(Employee::getAge).min((e1, e2) -> Integer.compare(e1, e2)).get();

        System.out.println("b1 : "+b1);
        System.out.println("b2 : "+b2);
        System.out.println("b3 : "+b3);
        System.out.println("employee1 : "+employee1);
        System.out.println("employee2 : "+employee2);
        System.out.println(l1);
        System.out.println(age1);
        System.out.println(age2);

    }

2.归约

reduce（T iden,BinaryOperator b）

Reduce(BinaryOperator b)

@Test
void testReduce(){
    List<Integer> list = Arrays.asList(1,2,3);
    Integer res = list.stream().reduce(0,(a,b)->a+b);
    System.out.println(res);

    List<Employee> employees = getEmployees();
    int i = employees.stream().map(Employee::getAge).reduce(0,Integer::sum);
    System.out.println(i);

}

3.收集

collect（Collect c）

@Test
void testCollector() {
    List<Employee> employees = getEmployees();
    List<Employee> employees2 = employees.stream().filter(e ->e.getAge()>3).collect(Collectors.toList());
    System.out.println(employees2);
}