Lambda表达式和Stream流操作

public interface PrintInterface {
    void print(String str);
}

public class PrintImpl {
    public static void print(String str,PrintInterface printInterface){
        printInterface.print(str);
    }
    public static void main(String[] args) {
        //匿名内部类
        print("hello " ,new PrintInterface() {
            @Override
            public void print(String str) {
                System.out.println(str);
            }
        });
        //lambda表达式
        print("hello",(str)->{
            System.out.println(str);
        });
        //省略写法
        print("hello",str -> System.out.println(str));
        //再省略写法
        print("hello", System.out::println);
    }

}

----------------------------------------------------------------------------------------------------------------------------

public class Person {
    String name;
    int age;

    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 Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public Person() {

    }

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

public interface GetPerson {
    Person getPerson(String name,int age);
}

public class GetPersonImpl {

    public static void method(String name,int age,GetPerson get){
        Person p=get.getPerson(name,age);
        System.out.println(p);
    }

    public static void main(String[] args) {

        //使用匿名内部类方法
        method("张三", 13, new GetPerson() {
            @Override
            public Person getPerson(String name, int age) {
                return new Person(name,age);
            }
        });

        //使用lambda表达式方法
        method("张三",13,(name ,age)->{
            return new Person(name,age);
        });

        //省略写法
        method("张三",13,(name, age) -> new Person(name,age) );

        //再省略写法
        method("张三",13,Person::new);
    }
}

---

public interface AddInterface {
    void addTwoNumber(int number1,int number2);
}

public class Father {
    public void fathermethod(int a,int b){
        System.out.println(a+b);
    }
}

public class Son extends Father{
    public  void add(int a,int b){
        System.out.println(a+b);
    }
    public static void method(int a ,int b,AddInterface addInterface){
        addInterface.addTwoNumber(a,b);
    }
    public void test() {
        //匿名内部类实现
        method(3, 2, new AddInterface() {
            @Override
            public void addTwoNumber(int number1, int number2) {
                System.out.println(number1+number2);
            }
        });

        //lambda表达式实现
        method(3,2,(a,b)->{
            System.out.println(a+b);
        });
        //省略写法
        method(3,2,super::fathermethod);
        method(3,2,this::add);
    }


}

---

public class StreamDemo {

    public static void main(String[] args) {
        //常见的stream操作
        List<Integer> list=new ArrayList<>();
        List<Integer> list_1=new ArrayList<>();
        for(int i=0;i<100;i++){
            list.add(i);
            list_1.add(i);
        }
        //遍历
        list.forEach(item->{
            System.out.println(item);
        });


        //获取大于20的元素,返回值是stream
        Stream<Integer> stream=list.stream().filter(item->item>20);
        List <Integer> list1=stream.collect(Collectors.toList());
        System.out.println(list1);
        //合并写法
        List<Integer> list3=list.stream().filter(item->item>20).collect(Collectors.toList());

        //获取list中有多少数大于20,返回值是lang类型
        long count=list.stream().filter(item->item>20).count();

        //合并两个list
        List<Integer> list_combine=Stream.concat(list.stream(),list_1.stream()).collect(Collectors.toList());

        //跳过n个元素
        list.stream().skip(3).forEach(System.out::println);

        //stream转数组
        Integer[]array=list.stream().toArray(size->new Integer[size]);
        //或者
        Integer []array_1=list.stream().toArray(Integer[]::new);


        //数组转stream
        int[] array_int={1,2,3,4,5};
        Stream stream1=Stream.of(array_int);
        String [] array_str={"mmm","nnn","bbb"};
        Stream stream2=Stream.of(array_str);


        //Map操作,将strings中大于25的人放到map中
        String[] strings={"张三,22","李四,30","王五,26","赵六,33"};
        Map<String ,Integer>map=Stream.of(strings)
                .filter(s -> Integer.parseInt(s.split(",")[1])>25)
                .collect(
                        Collectors.toMap(
                                s->s.split(",")[0],s->Integer.parseInt(s.split(",")[1]
                                )));
        Set<Map.Entry<String ,Integer>>set=map.entrySet();
        for(Map.Entry<String,Integer> m:set){
            System.out.println(m.getKey()+"  "+m.getValue());
        }


        //max min
        int[] array_test=new int[]{1,2,3,4,5};
        int max=Arrays.stream(array_test).max().getAsInt();
        int min=Arrays.stream(array_test).min().getAsInt();

        //limit
        List<Integer> list2=Arrays.asList(1,2,3,4);
        list2.stream().limit(3).forEach(System.out::println);

        //findfirst findany anymatch
        Optional<Integer> op1=list2.stream().filter(item->item>3).findFirst();
        Optional<Integer> op2=list2.stream().filter(item->item<2).findFirst();
        Boolean bool=list2.stream().anyMatch(item->item==2);




    }
}