Java-四大函数式接口和流计算

数据流的操作 ----链式编程+流式计算

一、作用

可以代替SQL删选对应条件的数据。代替重复查询单个表。因为代码计算是内存级别的

流(Stream) 到底是什么呢？

是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。

“集合讲的是数据，流讲的是计算！”

二、四大函数接口

1、Consumer 消费型接口 有输入参数，无返回值

2、Supplier     供给型接口   无输入参数，有返回值

3、Function    函数型接口  有输入，有返回值

4、Predicate  断定型接口  有输入参数 ，返回Boolean值

四、代码

package com.cb.demo.example;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Collectors;

@Data
@NoArgsConstructor
@AllArgsConstructor
class User{
    private int id;
    private String userName;
    private Integer age;
}

/**
 * 题目：请按照给出数据，找出满足以下条件的用户，也即以下条件全部满足
 *      偶数ID且年龄大于24且用户名转为大写且用户名字母排序
 *      值输出一个用户名字
 */
public class StreamDemo {
   public static void main(String[] args) {
       User u1=new User(11,"a",23);
       User u2=new User(12,"b",24);
       User u3=new User(13,"c",22);
       User u4=new User(14,"d",28);
       User u5=new User(16,"e",26);

       List<User> list= Arrays.asList(u1,u2,u3,u4,u5);

       //select userName from student where id  =  and age>24  and

       list.stream().filter(t->{
           return t.getId()%2==0;
       }).filter(t->{
           return t.getAge()>24;
       }).map(t->{
           return t.getUserName().toUpperCase();
       }).sorted((o1,o2)->{
           return  o2.compareTo(o1);
       }).limit(1).forEach(System.out::println);







     /* List<Integer> list1=Arrays.asList(1,2,3);

       list1 = list1.stream().map(t -> {
           return t * 2;
       }).collect(Collectors.toList());

       for (Integer element : list1) {
           System.out.println(element);
      }*/




    /*   Function<String,Integer> function=new Function<String, Integer>() {
           @Override
           public Integer apply(String s) {
               return 1024;
           }
       };
       System.out.println(function.apply("abc"));*/

     /*  Function<String,Integer> function=s -> {return s.length();};
       System.out.println(function.apply("abc"));
*/
       /**
        * lomdba 表达式 单参可省略类型和括号
        */
       /*Predicate<String> predicate=new Predicate<String>() {
           @Override
           public boolean test(String s) {
               return false;
           }
       };*/
     /*  Predicate<String> predicate=s -> {return s.isEmpty();};
       System.out.println(predicate.test("abc"));
       System.out.println(predicate.test("ccc"));*/

       /*Consumer<String> consumer=new Consumer<String>() {
           @Override
           public void accept(String s) {

           }
       };*/

   /*    Consumer<String> consumer=s -> { System.out.println("asdc");};
        consumer.accept("aaa");*/

       /*Supplier<String> supplier=new Supplier<String>() {
           @Override
           public String get() {
               return null;
           }
       };*/
     /*  Supplier<String> supplier=()->{return "2222";};
       System.out.println(supplier.get());*/
   }
}


interface MyInterface{
    public int myInt(int x);
    public String myString(String str);
    public boolean isOk(String str);
}