我爱Java系列---【lambda表达式】

一.lambda表达式(必须掌握)
    1.函数式编程思想概念
          函数式思想则尽量忽略面向对象的复杂语法——强调做什么，而不是以什么形式做
     2.lambda表达式写法技巧:
         只需要按照匿名内部类的形式写出代码,然后保留抽象方法的()和{},在()和{}之间添加一个->
     3.lambda表达式组成   
        (1)一些参数
         (2)一个箭头
         (3)一段代码
    4.lambda表达式格式:
         (参数列表...)->{代码}

    5.lambda表达式格式解释:
         (1)(参数列表...): 和以前定义方法的参数列表(写在()中)是一致的
             没有参数()留空,有多个参数,用逗号隔开
         (2)->: 代表指向的动作,本质方法参数的传递
         (3){}: 和以前定义方法的{}中是一样的,代表的是方法体的内容
     6.Lambda表达式的省略格式
         (1)数据类型可以省略: (Person p1,Person p2): 省略格式(p1,p2)
         (2)()中只有一个参数,()可以省略: (Perons p): 省略格式(p)   最简化的省略格式: p
         (3)->: 永远不能省略
         (4){}中如果只有一条语句:
             那么{},return,分号 都可以省略
             但是要么全部省略,要么全部保留
     7.lambda表达式的前提
         (1)必须要有接口(函数式接口)
             要求接口中只能有一个(必须要被覆盖重写的)抽象方法,可以有默认方法,可以有静态方法
         (2)必须要有接口作为方法的参数
             @Override:  检测是否是对父类方法的覆盖重写
             @FunctionalInterface: 检测是否是函数式接口

二.常用的函数是接口

   1.消费型接口
         java.util.function.Consumer<T>: 消费型接口
             抽象方法:                                                                        必须掌握
                 public abstract void accept(T t): 消费一个指定泛型T类型的数据
                 注意:
                     什么叫做消费呢?

                因为accept方法是抽象的,只要做覆盖重写{}后,就叫消费了,至于{}中写了哪些代码,我不管


  2.判断型接口   
        java.util.function.Predicate<T>: 判断型接口
             抽象方法:     必须掌握
                 public abstract boolean test(T t): 根据T类型的参数t,返回一个boolean类型的结果

三.Stream流
    1.获取Stream流对象的方法(两种）
        (1)Collection<T>集合
             默认方法：必须由Collection接口的实现类(ArrayList/LinkedList/HashSet/LinkedHashSet)对象调用
            Stream<T> stream()  :获取Collection集合对象的Stream流对象

         代码演示：

                      //获取List集合的Stream对象
              List<String> list = new ArrayList<>();                                    
                 Stream<String> s1 = list.stream();
                 System.out.println(s1);

                 //获取Set集合的Stream对象
                 Set<Integer> set = new HashSet<>();
                 Stream<Integer> s2 = set.stream();
                 System.out.println(s2);

                 Map<String,String> map = new HashMap<>();

                //Map键的Set集合
                Set<String> set2 = map.keySet();
                Stream<String> s3 = set2.stream();
                System.out.println(s3);

                //Map值的Collection集合
                Collection<String> coll = map.values();
                Stream<String> s4 = coll.stream();
                System.out.println(s4);

               //Map键值对的Set集合
               Set<Map.Entry<String, String>> set3 = map.entrySet();
                Stream<Map.Entry<String, String>> s5 = set3.stream();
               System.out.println(s5);
               System.out.println("----------");
               String[] arr = {"Hello","World","java"};
                Stream<String> s6 = Stream.of(arr);
               System.out.println(s6);

               Stream<String> s7 = Stream.of("Hello", "World", "java");
               System.out.println(s7);

}
}

 

        
         (2)Stream接口的静态方法

            静态方法
             java.util.stream.Stream<T> 接口:
            public static <T> Stream<T> of(T ... t): 把方法的可变参数指定的具体数据,

              转换成Stream流对象
               参数:
                     T ... t: 可变参数 可以传递数组,参数列表,也可以不传递

                     Stream<String> s = Stream.of("大娃", "二娃", "娃"｝                            

     2.Stream流中的forEach方法
         void forEach(Consumer<T> action):  终结方法,调用此方法后,Stream流对象将不可以继续使用

            该方法接收一个Consumer接口函数，会将每一个流元素交给该函数进行处理,不保证顺序

        Consumer接口:
             抽象方法:
                 void accept(T t)
                 s->sout(s);System.out::println
     3.Stream流中的count方法
         long count() : 终结方法,调用此方法后,Stream流对象将不可以继续使用

        返回Stream流对象中的元素的个数,但是返回值类型是long
    4.Stream流中的filter方法
         Stream<T> filter(Predicate<T> predicate) :
             按照方法参数predicate对Stream流对象中的元素进行过滤,并返回新的Stream流对象

        Predicate<T>接口:
             抽象方法:
                 boolean test(T t)
     5.Stream流中的limit方法和skip方法
         Stream<T> limit(long n): 获取流对象中的前n个元素,返回新的Stream流对象
         Stream<T> skip(long n):  跳过流对象中的前n个元素,返回新的Stream流对象           
    
     6.Stream流中的静态concat方法
        static <T> Stream<T> concat(Stream<T> a, Stream<T> b):
             把两个流对象a和b合并成一个流对象,并返回

四、综合案例

/*
Stream综合案例
1. 第一个队伍只要名字为3个字的成员姓名；
2. 第一个队伍筛选之后只要前3个人；
3. 第二个队伍只要姓张的成员姓名；
4. 第二个队伍筛选之后不要前2个人；
5. 将两个队伍合并为一个队伍；
6. 打印整个队伍的姓名信息。

按照Stream流+匿名内部类的形式
*/

public class Demo02ListEach {
public static void main(String[] args) {
List<String> o = new ArrayList<>();
o.add("迪丽热巴");
o.add("宋远桥");
o.add("苏星河");
o.add("老子");
o.add("庄子");
o.add("孙子");
o.add("洪七公");

//获取第一个队伍的流对象
Stream<String> os1 = o.stream();

//1. 第一个队伍只要名字为3个字的成员姓名；
Stream<String> os2 = os1.filter(new Predicate<String>() {
@Override
public boolean test(String s) {
return s.length() == 3;
}
});

//2. 第一个队伍筛选之后只要前3个人；
Stream<String> os3 = os2.limit(3);

List<String> t = new ArrayList<>();
t.add("古力娜扎");
t.add("张无忌");
t.add("张三丰");
t.add("赵丽颖");
t.add("张二狗");
t.add("张天爱");
t.add("张三");
//获取第二个队伍的流对象
Stream<String> ts1 = t.stream();

//3. 第二个队伍只要姓张的成员姓名；
Stream<String> ts2 = ts1.filter(new Predicate<String>() {
@Override
public boolean test(String s) {
return s.startsWith("张");
}
});
//4. 第二个队伍筛选之后不要前2个人；
Stream<String> ts3 = ts2.skip(2);

//5. 将两个队伍合并为一个队伍；
Stream<String> ots = Stream.concat(os3, ts3);

//6. 打印整个队伍的姓名信息
ots.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});

}
}

          

/*
    Stream综合案例
        1. 第一个队伍只要名字为3个字的成员姓名；
        2. 第一个队伍筛选之后只要前3个人；
        3. 第二个队伍只要姓张的成员姓名；
        4. 第二个队伍筛选之后不要前2个人；
        5. 将两个队伍合并为一个队伍；
        6. 打印整个队伍的姓名信息。

    按照Stream流+lambda标准格式的形式(分4步完成)
 */
public class Demo04ListEach {
    public static void main(String[] args) {
        List<String> o = new ArrayList<>();
        o.add("迪丽热巴");
        o.add("宋远桥");
        o.add("苏星河");
        o.add("老子");
        o.add("庄子");
        o.add("孙子");
        o.add("洪七公");

        //获取第一个队伍的流对象

        //1. 第一个队伍只要名字为3个字的成员姓名；

        //2. 第一个队伍筛选之后只要前3个人；
        Stream<String> os1 = o.stream().filter(name -> name.length() == 3).limit(3);


        List<String> t = new ArrayList<>();
        t.add("古力娜扎");
        t.add("张无忌");
        t.add("张三丰");
        t.add("赵丽颖");
        t.add("张二狗");
        t.add("张天爱");
        t.add("张三");
        //获取第二个队伍的流对象


        //3. 第二个队伍只要姓张的成员姓名；

        //4. 第二个队伍筛选之后不要前2个人；

       Stream<String> ts1 = t.stream().filter(name -> name.startsWith("张")).skip(2);

        //5. 将两个队伍合并为一个队伍；
        Stream<String> ots = Stream.concat(os1, ts1);


        //6. 打印整个队伍的姓名信息
        ots.forEach(name-> System.out.println(name));


    }
}

/*
Stream综合案例
1. 第一个队伍只要名字为3个字的成员姓名；
2. 第一个队伍筛选之后只要前3个人；
3. 第二个队伍只要姓张的成员姓名；
4. 第二个队伍筛选之后不要前2个人；
5. 将两个队伍合并为一个队伍；
6. 打印整个队伍的姓名信息。

按照Stream流+lambda标准格式的形式(分1步完成)
*/
public class Demo05ListEach {
public static void main(String[] args) {
List<String> o = new ArrayList<>();
o.add("迪丽热巴");
o.add("宋远桥");
o.add("苏星河");
o.add("老子");
o.add("庄子");
o.add("孙子");
o.add("洪七公");

List<String> t = new ArrayList<>();
t.add("古力娜扎");
t.add("张无忌");
t.add("张三丰");
t.add("赵丽颖");
t.add("张二狗");
t.add("张天爱");
t.add("张三");

//获取第一个队伍的流对象
//1. 第一个队伍只要名字为3个字的成员姓名；
//2. 第一个队伍筛选之后只要前3个人；
//获取第二个队伍的流对象
//3. 第二个队伍只要姓张的成员姓名；
// 4. 第二个队伍筛选之后不要前2个人；
//5. 将两个队伍合并为一个队伍；
//6. 打印整个队伍的姓名信息

Stream.concat(
o.stream().filter(name->name.length()==3).limit(3),
t.stream().filter(name->name.startsWith("张")).skip(2)
).forEach(name-> System.out.println(name));

}
}