Lambda表达式和Stream流

最新推荐文章于 2023-03-05 14:55:03 发布

qq_40840390

最新推荐文章于 2023-03-05 14:55:03 发布

阅读量149

点赞数

本文链接：https://blog.csdn.net/qq_40840390/article/details/104968920

版权

Lambda表达式

称为函数的编程思想以一种尽量简化的格式简化面向对象中的格式

  public static void main(String[] args) {
            //创建匿名内部类对象
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("开始执行。。。");
                }
            }).start();
            //使用lambda达式
            new Thread(()->{System.out.println("开始执行。。。。");
            }).start();
        }

Lambda表达式的格式
（参数列表）->{方法体；返回值；}
（参数列表）就是方法中传入的参数如果空参的话那么写个（）
->固定用法拿着参数去使用
{}先些计算过程，然后返回值如果没就可以省略
public static void main(String[] args) {

  public static void main(String[] args) {
            //创建匿名内部类对象
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("开始执行。。。");
                }
            }).start();
            //使用lambda达式
            new Thread(()->{System.out.println("开始执行。。。。");
            }).start();
        }
 //创建匿名内部类对象
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("开始执行。。。");
            }
        }).start();
        //使用lambda达式
        new Thread(()->{System.out.println("开始执行。。。。");
        }).start();
    }

Lambda参数和返回值

public class Demo01 {
    public static void main(String[] args) {
        //创建数组
        Integer[] arr={10,12,52,47,85};
        //对数组进性默认排序
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        //对数组进行比较排序
        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        System.out.println(Arrays.toString(arr));
        //使用Lambda表达式
        Arrays.sort(arr,(Integer o1,Integer o2 )->{return o1-o2;});
        System.out.println(Arrays.toString(arr));
    }
}

自定义对象

    public static void main(String[] args) {
      //创建person对象数组
        Person[] p=new Person[4];
        p[0]=new Person("张三",10);
        p[1]=new Person("王五",20);
        p[2]=new Person("麻子",30);
        p[3]=new Person("李四",40);
        Arrays.sort(p, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.age-o2.age;
            }
        });
        System.out.println(Arrays.toString(p));
        //使用Lambda表达式
        Arrays.sort(p,(Person o1,Person o2)->{return o2.age-o1.age; });
        //省略格式
        Arrays.sort(p,( o1, o2)->o2.age-o1.age);
        for (Person person : p) {
            System.out.println(person);
        }
    }

Lambda省略格式
1.可以省略参数的类型
2.如果参数只有一个可以省略括号
3.如果{}中的代码就一句话那么{}，return 和；可以同时省略

    public static void main(String[] args) {
        //创建线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("开始执行。。。。");
            }
        }).start();
        //使用Lambda表达式
        new Thread(()-> System.out.println("开始执行。。。")).start();
    }
}

Lambda的使用前提
只能用于替换有且只有一个抽象方法的接口的匿名内部类对象这种接口称为函数式接口
该表达具有上下文推断的功能所以出现了省略格式

Stream流

Collection集合获取流
Stream s=集合对象.stream();
Map集合不能直接获取流但是能间接获取流
map.entrySet().stream();获取Map的键值对
map.keySet().stream();获取map键流
map.value(),stream();获取Map值
数组获取流
Stream<数组中的元素类型> s=Stream.of(数据类型变…量名)；

//创建单列集合
        ArrayList<Integer> arr = new ArrayList<>();
        //添加流
        Stream<Integer> sArray = arr.stream();
        //创建一i个Map对象
        HashMap<Integer, String> map = new HashMap<>();
        //获取keySet流
        Stream<Integer> keys = map.keySet().stream();
        //获取Vlaue流
        Stream<String> streamVlaue = map.values().stream();
        //获取entrySet流
        Stream<Map.Entry<Integer, String>> streamStream = map.entrySet().stream();
        //数组流
        Integer[] arr1=new Integer[5];
        //获取流
        Stream<Integer> arr11 = Stream.of(arr1);

###流的常用方法

forEach() 逐个处理

//获取流
        Stream<String> stringStream = Stream.of("1111", "22", "333", "4444444");
        //使用匿名内部类
        stringStream.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

2.skip 跳过前几个

Stream<String> skip = stringStream.skip(3);
        skip.forEach(s-> System.out.println(s));

3.limit() 抓取前几个

Stream<String> limit = stringStream.limit(2);
        limit.forEach(s-> System.out.println(s));

4.concat()合并流

Stream<String> one = Stream.of("one", "two");
        Stream<Integer> two = Stream.of(1, 2);
        Stream<Object> concat = Stream.concat(one, two);
        concat.forEach(s-> System.out.println(s));

5.map 映射

Stream<Integer> integerStream = stringStream.map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return s.length();
            }
        });
       
       //简化
        /*Stream<Integer> integerStream = stringStream.map(s -> s.length());
        integerStream.forEach(s-> System.out.println(s));*/

6.filter过滤

Stream<String> stringStream1 = stringStream.filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length()>2;
            }
        });
        Stream<String> stringStream1 = stringStream.filter(s ->s.length()>2);
        System.out.println(stringStream1.count());

7.count 统计

System.out.println(stringStream.count());

使用Stream

  List<String> one = new ArrayList<>();
        one.add("迪丽热巴");
        one.add("宋远桥");
        one.add("苏星河");
        one.add("老子");
        one.add("庄子");
        one.add("孙子");
        one.add("洪七公");
        List<String> two = new ArrayList<>();
        two.add("古力娜扎");
        two.add("张无忌");
        two.add("张三丰");
        two.add("赵丽颖");
        two.add("张二狗");
        two.add("张天爱");
        two.add("张三");
//        1. 第一个队伍只要名字为3个字的成员姓名；
//        2. 第一个队伍筛选之后只要前3个人；
        Stream<String> s1 = one.stream().filter(s -> s.length() == 3).limit(3);
//        3. 第二个队伍只要姓张的成员姓名；
//        4. 第二个队伍筛选之后不要前2个人；
        Stream<String> s2 = two.stream().filter(s -> s.startsWith("张")).skip(2);

//        5. 将两个队伍合并为一个队伍；
        ArrayList<String> arrayList = new ArrayList<>();
        Stream<String> concat = Stream.concat(s1,s2);

//        6. 根据姓名创建 Person 对象； string -- person
        Stream<Person> personStream = concat.map(s -> new Person(s));

//        7. 打印整个队伍的Person对象信息
         personStream.forEach(s-> System.out.println(s));
         package Stream_Test;

public class Person {
    String name;

    public Person(String name) {
        this.name = name;
    }

    public Person() {

    }

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

函数拼接和终结的方法
函数的拼接：由于方法返回的是流对象，所以支持链式编程 skip concat limit map filter 该方法啊返回的流对象
终结：由于终结方法返回的不是流不支持链式编程所以当某个流对象调用 forEach count方法就会关闭流
收集Stream的结果
可以将流收集到集合中去方法Collectors.toList()
收集到数组中去 .Conllectors.toSet();
一个流智能收集一次
如果收集到数组中去收集的对象是Object

 //创建流对象
        Stream<String> s = Stream.of("张三", "李四", "王二");
        //将流收集到集合中去
        List<String> list=s.collect(Collectors.toList());
        System.out.println(list);
        Object[] objects = list.toArray();
        for (Object object : objects) {
            System.out.println(object);
        }
        //将流收集到数组中去
        Set<String> set=s.collect(Collectors.toSet());
        Object[] ob = set.toArray();
        for (Object o : ob) {
            System.out.println(o);
        }

qq_40840390

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Lambda表达式和Stream流

Lambda表达式称为函数的编程思想以一种尽量简化的格式简化面向对象中的格式 public static void main(String[] args) { //创建匿名内部类对象 new Thread(new Runnable() { @Override public v...
复制链接

扫一扫