lambda

代码1

package com.atguigu.day18;

import org.junit.Test;

public class Demo8 {
    @Test
    public void test1(){
        Runnable runnable=new Runnable() {
            @Override
            public void run() {
                System.out.println("just run");
            }
        };

        //普通方式，无参
        Thread thread=new Thread(runnable);
        thread.start();//just run
        //lambda方式，无参
        new Thread(()->{System.out.println("just run");}).start();//just run
    }

    @Test
    public void test2(){
        int a=10;
        int b=20;
        //普通方式
        show(a, b, new Calc() {
            @Override
            public int add(int a, int b) {
                return a+b;
            }
        });

        //使用lambda表达式，有参数
        show(a,b,(int c,int d)->{return c+d;});
    }

    static void show(int a,int b,Calc c){
        int sums=c.add(a,b);
        System.out.println(sums);
    }
}


interface Calc{
    int add(int a,int b);
}

代码2

package com.atguigu.day18;
/*
@FunctionalInterface
检验当前的接口是不是函数式接口，只能有一个抽象方法
* */

@FunctionalInterface
public interface Demo9 {
    public void show();
}

代码3

package com.atguigu.day18;

import org.junit.Test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

/*
消费型接口

* */
public class Demo10 {
    @Test
    public void test1(){
        ArrayList<String> list=new ArrayList<>();
        list.add("李白");
        list.add("杜甫");
        list.add("白居易");
        list.add("李商隐");
        //消费型接口
        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

        //lambda调用消费型接口
        list.forEach((l)->{
            System.out.println(l);
        });
        //当只有一个参数的时候，可以省略小括号
        list.forEach(l->{
            System.out.println(l);
        });
    }

    @Test
    public void test2(){
        Map<Integer,String> map=new HashMap<>();
        map.put(10,"张三丰");
        map.put(11,"张翠山");
        map.put(12,"张无忌");
        map.put(13,"张小忌");
        //消费接口
        map.forEach(new BiConsumer<Integer, String>() {
            @Override
            public void accept(Integer key, String v) {
                System.out.println(key+":"+v);
            }
        });
        //lambda调用消费型接口
        map.forEach((k,v)->{
            System.out.println(k+":"+v);
        });
    }
}

代码4

package com.atguigu.day18;

import org.junit.Test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.function.BiFunction;
import java.util.function.Predicate;
import java.util.function.Supplier;

public class Demo11 {

    //供给型接口
    @Test
    public void test1(){
        Supplier<String> s=new Supplier<String>() {
            @Override
            public String get() {
                return "hello";
            }
        };
        System.out.println(s.get());//hello
        //lambda供给型接口
        Supplier<String> s1=()->"hello tree";
        System.out.println(s1.get());//hello tree
    }

    //功能型接口
    @Test
    public void test2(){
        Map<Integer,String> map=new HashMap<>();
        map.put(10,"张三丰");
        map.put(11,"张翠山");
        map.put(12,"张无忌");
        map.put(13,"张小忌");

        map.replaceAll(new BiFunction<Integer, String, String>() {
            @Override
            public String apply(Integer integer, String s) {
                if (s.endsWith("忌")){
                    return "张有忌"+integer;
                }
                return s;
            }
        });
        System.out.println(map);//{10=张三丰, 11=张翠山, 12=张有忌12, 13=张有忌13}

        //lambda调用功能型接口
        Map<Integer,String> map2=new HashMap<>();
        map2.put(10,"张三丰");
        map2.put(11,"张翠山");
        map2.put(12,"张无忌");
        map2.put(13,"张小忌");

        map2.replaceAll((k,v)->{
            if (v.endsWith("忌")){
                return v+""+k;
            }return v;
        });
        System.out.println(map2);//{10=张三丰, 11=张翠山, 12=张无忌12, 13=张小忌13}
    }

    //判断型接口
    @Test
    public void test3(){
        ArrayList<String> list=new ArrayList<>();
        list.add("李白");
        list.add("杜甫");
        list.add("白居易");
        list.add("李商隐");

        list.removeIf(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                if (s.startsWith("李")){
                    return true;
                }
                return false;
            }
        });
        System.out.println(list);//[杜甫, 白居易]

        //lambda方式调用判断型接口
        ArrayList<String> list2=new ArrayList<>();
        list2.add("李白");
        list2.add("杜甫");
        list2.add("白居易");
        list2.add("李商隐");
        list2.removeIf(s -> {
            if (s.startsWith("李")) {
                return true;
            }return false;
        });
        //或者
        //list2.removeIf(s -> s.startsWith("李")?true:false);
        System.out.println(list2);//[杜甫, 白居易]
    }
}

class EmpManager{
    public static void main(String[] args) {
        ArrayList<Employee> employeeArrayList=new ArrayList<>();
        employeeArrayList.add(new Employee(1,"刘能",50,1200));
        employeeArrayList.add(new Employee(2,"赵四",49,2500));
        employeeArrayList.add(new Employee(3,"大拿",61,3200));
        employeeArrayList.add(new Employee(4,"晓峰",38,3300));

        EmpManager empManager=new EmpManager();
        ArrayList<Employee> arrayList=empManager.getSalary(employeeArrayList);
        System.out.println(arrayList);//[Employee{num=3, name='大拿', age=61, salay=3200.0}, Employee{num=4, name='晓峰', age=38, salay=3300.0}]

        ArrayList<Employee> arrayList2=empManager.getYoung(employeeArrayList);
        System.out.println(arrayList2);//[Employee{num=4, name='晓峰', age=38, salay=3300.0}]
    }

    ArrayList<Employee> getSalary(ArrayList<Employee> employeeArrayList){
        ArrayList<Employee> newArr = new ArrayList<Employee>();
        employeeArrayList.forEach((Employee)->{
            if (Employee.getSalay()>3000){
                newArr.add(Employee);
            }
        });
        return newArr;
    }

    ArrayList<Employee> getYoung(ArrayList<Employee> employeeArrayList){
        ArrayList<Employee> newArr = new ArrayList<Employee>();
        employeeArrayList.forEach((Employee)->{
            if (Employee.getAge()<40){
                newArr.add(Employee);
            }
        });
        return newArr;
    }

}



class Employee{
    private int num;
    private String name;
    private int age;
    private double salay;

    public Employee() {
    }

    public Employee(int num, String name, int age, double salay) {
        this.num = num;
        this.name = name;
        this.age = age;
        this.salay = salay;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public double getSalay() {
        return salay;
    }

    public void setSalay(double salay) {
        this.salay = salay;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "num=" + num +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", salay=" + salay +
                '}';
    }
}

 代码5

package com.atguigu.day18;

import org.junit.Test;

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Comparator;
import java.util.function.Function;
import java.util.function.Supplier;

/*
方法引用的语法格式
1.实例对象名::实例方法
2.类名::静态方法
3.类名::实例方法
* */
public class Demo12 {
    @Test
    public void test1(){
        Employees employees=new Employees(1,"吴彦祖",23,1000.0);
        //lambda调用方法
        Supplier<String> name = ()->employees.getName();
        System.out.println(name.get());//吴彦祖

        //方法引用1
        Supplier<String> name2=employees::getName;
        System.out.println(name2.get());//吴彦祖
    }

    @Test
    public void test2(){
        String[] arr={"h","d","c","z","a"};
        //普通排序
        Arrays.sort(arr, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });
        System.out.println(Arrays.toString(arr));//[a, c, d, h, z]

        //lambda排序
        String[] arr2={"h","d","c","z","a"};
        //Arrays.sort(arr2,(o1, o2) ->o1.compareTo(o2));
        //方法引用
        Arrays.sort(arr2,String::compareTo);
        System.out.println(Arrays.toString(arr2));//[a, c, d, h, z]
    }

    //构造器引用
    @Test
    public void test3(){
        Supplier<Employees> e=new Supplier<Employees>() {
            @Override
            public Employees get() {
                return new Employees(1,"王熙凤",23,2000);
            }
        };
        System.out.println(e.get());//Employees{num=1, name='王熙凤', age=23, salay=2000.0}

        //无参构造应用
        Supplier<Employees> e2=Employees::new;
        System.out.println(e2.get());//Employees{num=0, name='null', age=0, salay=0.0}
    }

    @Test
    public void test4(){
        Function<Integer,int[]> f=new Function<Integer, int[]>() {
            @Override
            public int[] apply(Integer integer) {
                return new int[integer];
            }
        };
        int[] apply=f.apply(2);
        System.out.println(apply.length);//2
        //构造器引用
        Function<Integer,int[]> f2 = int[]::new;
        int[] apply2=f2.apply(3);
        System.out.println(apply2.length);//3
    }
}


class Employees{
    private int num;
    private String name;
    private int age;
    private double salay;

    public Employees() {
    }

    public Employees(int num, String name, int age, double salay) {
        this.num = num;
        this.name = name;
        this.age = age;
        this.salay = salay;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public double getSalay() {
        return salay;
    }

    public void setSalay(double salay) {
        this.salay = salay;
    }

    @Override
    public String toString() {
        return "Employees{" +
                "num=" + num +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", salay=" + salay +
                '}';
    }
}

代码6

package com.atguigu.day18;

import org.junit.Test;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.stream.Stream;

/*
创建流
* */
public class Demo13 {
    @Test
    public void test1(){
        ArrayList<Integer> list=new ArrayList<>();
        list.add(10);
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
        list.add(60);

        //第一种创建流
        Stream<Integer> stream=list.stream();
        stream.forEach((t)->{
            System.out.println(Thread.currentThread().getName()+"==="+t);
        });

        //并行流
        Stream<Integer> stream1=list.parallelStream();
        stream1.forEach((t)->{
            System.out.println(Thread.currentThread().getName()+"=="+t);
        });

        //第二种创建流
        int[] arr2={11,12,13,14,15};
        Arrays.stream(arr2).forEach((i)->{
            System.out.println(Thread.currentThread().getName()+"--"+i);
        });
        //或者
        Arrays.stream(arr2).forEach(System.out::println);

        //第三种创建流
        Stream.of(11,12,13,14,15).forEach((i)->{
            System.out.println(Thread.currentThread().getName()+"******"+i);
        });
        //或者
        Stream.of(11,22,33,44,55).forEach(System.out::println);
    }
}

代码7

package com.atguigu.day18;


import org.junit.Test;

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

/*
中间操作
* */
public class Demo14 {
    @Test
    public void test1(){
        ArrayList<Integer> list=new ArrayList<>();
        list.add(10);
        list.add(11);
        list.add(12);
        list.add(13);
        list.add(14);

        Stream<Integer> stream= list.stream();
        Stream<Integer> stream1=stream.filter((s)->s%2==0);
        stream1.forEach(System.out::println);
        //或者
        list.stream().filter(s->s%2!=0).forEach(System.out::println);

    }

    @Test
    public void test2(){
        ArrayList<Integer> list=new ArrayList<>();
        list.add(10);
        list.add(11);
        list.add(12);
        list.add(13);
        list.add(14);
        //反向排序
        list.stream().sorted(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return -o1.compareTo(o2);
            }
        }).forEach(System.out::println);
        //或者
        list.stream().sorted((s1,s2)->{return s1.compareTo(s2);}).forEach(System.out::println);
    }
}

代码8

//终结操作

import org.junit.Test;

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

/*
中间操作可以有多个，终结操作只能有一个
* */
public class Demo15 {
    @Test
    public void test1(){
        long count= Stream.of(10,11,20,22,30,33,40,45,50).filter(s->s%2!=0).peek(System.out::println).count();
        System.out.println(count);
    }

    @Test
    public void test2(){
        //allMatch 所有元素是不是都是
        //anyMatch 任取一个是不是
        //noneMath 没有是
        boolean b=Stream.of(10,20,30,40).noneMatch(s->s==10);
        System.out.println(b);
    }

    @Test
    public void test3(){
        Optional<Integer> first=Stream.of(10,11,12,13,14,15).findFirst();
        System.out.println(first.get());
    }

    //collect将符合要求的收集
    @Test
    public void test4(){
        List<Integer> collect=Stream.of(10,11,12,13,14,15).filter((s)->s%2!=0).collect(Collectors.toList());
        System.out.println(collect);
    }
}

代码9