JAVA基础-JAVA8 对集合的增强

2019-10-13 本文已影响0人 So_ProbuING

Java8流、流操作集合

Predicate 谓词对象

Java8起为Collection集合新增了一个removeIf(Predicate)方法，该方法将会批量删除符合filter条件的所有元素。该方法需要一个Predicate对象作为参数

removeIf(Predicate pre) 该方法将会批量删除符合条件的所有元素

        HashSet<String> hashSet = new HashSet<>();
        hashSet.add("aa");
        hashSet.add("bb");
        hashSet.add("cc");
        hashSet.add("dd");
        hashSet.add("ee");
        hashSet.add("ff");
        hashSet.removeIf(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                if (s.equals("cc")) {
                    return true;
                }
                return false;
            }
        });

Predicate 中的test 表示判断的实现，返回值为true表示符合条件，返回false表示条件不符合

Predicate 简化集合操作

案例：统计集合中存储的符合条件的字符串个数

包含a字符的

长度大于5的

包含c字符的
使用Predicate 只需要单独定义条件进行判断即可，如果使用正常for循环，则需要写3次循环

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("abcdefg");
        list.add("e2131231");
        list.add("奥德赛阿萨德啊啊");
        list.add("cccc2132");
        System.out.println("list中包含a的个数" + total(list, ele -> ele.contains("a")));
        System.out.println("长度大于5的元素个数" + total(list, new Predicate<String>() {
            @Override
            public boolean test(String s) {
                if (s.length() > 5) {
                    return true;
                }
                return false;
            }
        }));
        System.out.println("集合中包含c的元素个数" + total(list, ele -> ele.contains("c")));
    }

    public static int total(Collection<String> collection, Predicate<String> p) {
        int total = 0;
        for (String s : collection) {
            if (p.test(s)) {
                total++;
            }
        }
        return total;
    }

Steam 流式API

Java8新增了Stream、InStream、LongStream、DoubleStream等流式API，这些API代表多个支持串行和并行聚集操作的元素。
Java8为上面每个流式API提供了对应的Builder

Stream 通用接口

Stream.Builder

IntSteam 对应的int类型的流

IntStream.Builder

LongStream 对应的long类型的流

LongStream.Builder

DoubleStream 对应的double类型的流

DoubleStream.Builder

使用Stream步骤

使用Stream或XxxStream的builder()类方法创建该Stream对应的Builder
重复调用Builder的add()方法向该流中添加多个元素
Builder的build()犯法获取对应的Stream
调用Stream的聚集方法(Stream提供了大量的聚集方法供用户调用 )

对于大部分聚集而言，每个Stream只能执行一次

也就是说每个Stream只能调用一次聚集方法，Stream调用聚集方法后流就会关闭，并且不可重用。

中间方法：中间操作允许流保持打开状态，并允许直接调用后续方法。
末端方法：末端方法是对流的最终操作。对某个流操作执行末端方法后，该流将被消耗，且不再可用。例如sum() count() average()等都是末端方法
有状态的方法：这种方法会给流增加一些新的属性。例如元素的唯一性、元素的最大数量、保证元素以排序的方式被处理等。

有状态的方法往往需要更大的性能开销
短路方法：短路方法可以尽早结束对流的操作，不必检查所有的元素

Stream API

中间方法：

filter(Predicate predicate) 过滤Stream中所有不符合Predicate的元素(也就是说返回一个符合Predicate条件的流)

 IntStream.Builder builder = IntStream.builder();
        builder.add(1);
        builder.add(2);
        builder.add(3);
        builder.add(4);

        IntStream stream = builder.build();
        IntStream filterStream = stream.filter(new IntPredicate() {
            @Override
            public boolean test(int value) {
                if (value % 2 == 0) {
                    return false;
                }
                return true;
            }
        });
        filterStream.forEach(i -> System.out.println(i));
        filterStream.close();

mapToXxx(ToXxxFunction mapper): 使用ToXxxFunction对流中的元素执行一对一的转换。该方法返回一个新Stream中包含了ToXxxFunction转换生成的所有元素

        LongStream.Builder builder = LongStream.builder();
        builder.add(4l);
        builder.add(10l);
        builder.add(9l);
        builder.add(7l);
        IntStream intStream = builder.build().mapToInt(new LongToIntFunction() {
            @Override
            public int applyAsInt(long value) {
                return (int) (value + 2);
            }
        });
        intStream.forEach(value -> System.out.println(value));

peek(Cosumer action) 依次对每个元素执行一些操作，返回的流与原有流包含相同的元素
distinct()：该方法用于排序流中所有重复的元素(判断重复依据是equeals())。有状态的方法

返回由该流的不同元素组成的流
sorted()该方法用于排序流中的元素在后续的访问中处于有序状态。是有状态的方法
limit(long maxSize) 该方法用于保证对该流的后续访问中最大允许的访问的元素个数。是一个有状态的、短路的方法。

末端方法

forEach(Consumer action) 遍历流中所有元素，对每个元素执行action
toArray()：将流中所有元素转换为一个数组
reduce()：用于通过某种操作来合并流中的元素
min()：返回流中所有元素的最小值
max()：返回流中所有元素的最大值
count()：返回流中所有元素的数量

 IntStream.Builder builder = IntStream.builder();
        builder.add(1);
        builder.add(2);
        builder.add(3);
        builder.add(4);
        builder.add(5);
        IntStream intStream = builder.build();
        OptionalInt max = intStream.max();
        int min = intStream.min().getAsInt();
                int sum = intStream.sum();
        long count = intStream.count();
        double average = intStream.average().getAsDouble();
        System.out.println("最大值"+max.getAsInt());
        System.out.println("最小值" + min);
        System.out.println("元素个数"+count);
                System.out.println("元素总和"+sum);
                System.out.println("所有元素的平均值" + average);

anyMatch(Predicate predicate) 判断流中是否至少包含一个元素符合predicate条件

 IntStream.Builder builder = IntStream.builder();
        builder.add(1);
        builder.add(2);
        builder.add(3);
        builder.add(4);
        builder.add(5);
        builder.add(6);
        IntStream build = builder.build();
        boolean b = build.anyMatch(new IntPredicate() {
            @Override
            public boolean test(int value) {
                if (value % 2 == 0) {
                    return true;
                }
                return false;
            }
        });

allMatch(Predicate predicate): 判断流中是否每个元素都符合predicate条件

  boolean allMatch = build.allMatch(new IntPredicate() {
            @Override
            public boolean test(int value) {
                if (value % 1 == 0) {
                    return true;
                }
                return false;
            }
        });
        System.out.println("all"+allMatch);

anyMatch(Predicate predicate)：判断流中是否每个元素都符合Predicate条件

 boolean b = build.anyMatch(new IntPredicate() {
            @Override
            public boolean test(int value) {
                if (value % 2 == 0) {
                    return true;
                }
                return false;
            }
        });

noneMatch(Predicate predicate) 判断流中是否所有元素都不符合predicate条件

boolean b = build.noneMatch(new IntPredicate() {
            @Override
            public boolean test(int value) {
                if (value / 7 == 0) {
                    return true;
                }
                return false;
            }
        });
        System.out.println(b);

findFirst() 返回流中的第一个元素

findAny() 返回流中的任意一个元素

LongStream.Builder builder = LongStream.builder();
builder.add(10);
builder.add(20);
builder.add(30);
builder.add(40);
builder.add(50);
builder.add(60);
LongStream longStream = builder.build();
System.out.println(longStream.findAny().getAsLong());

Stream操作集合(Stream在集合中的应用)

Java8使用流式API操作集合，Collection接口中提供了一个stream()默认方法，该方法可以返回该集合对应的流，接下来即可通过流式API来操作

Stream流获取流的方式

通过List、Set获取流
1. Collection接口中，有一个“默认方法”：stream()，可以获取一个流对象

            List<String> list = new ArrayList<>();
            ……
            Stream<String> stream = list.stream();
            ----------------------------------------------
            Set<String> set = new HashSet<>();
            ……
            Stream<String> stream = set.stream();

通过Map获取

Map不能直接获取流，必须通过键的集合、键值对的集合获取Set的流

Map<Integer,String> map = new HashMap<>();
        ……
        //1.获取“键”的流：
        Stream<Integer> keysSteram = map.keySet().stream();
        //2.获取“值”的流：
        Stream<String> valueStream = map.values().stream();
        //3.获取“键值对”的流：
        Stream<Map.Entry<Integer,String>> entryStream = map.entrySet().stream();

通过引用类型的数组获取流

Integer[] arr = {1,2,3,432,3,2,324,32};
            Stream<Integer> intStream = Stream.<Integer>of(arr);

通过基本类型的数组获取流

int[] arr = {1,4,234,32,32,523,432};
            IntStream intStream = IntStream.of(arr);

通过零散的数据获取流

    Stream<Integer> intStream = Stream.of(1,3,2,43,24,325,43,324,325,24,2);

Stream流_常用方法

filter方法过滤

 LinkedList<String> list = new LinkedList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");
        list.stream().filter(s -> s.startsWith("张"))
                .forEach(s -> System.out.println(s));

count方法_统计个数

集合同上
 long zCount = list.stream()
                .filter(s -> s.startsWith("张"))
                .count();
        System.out.println("张姓学员数量有"+zCount);

limit (long maxSize) 该方法用于保证对该流的后续访问中最大允许访问的元素个数，短路的有状态的方法

 list.stream()
                .filter(s -> s.startsWith("张"))
                .limit(3)
                .forEach(s -> System.out.println(s));

skip方法_跳过前几个

list.stream()
                .filter(s->s.startsWith("张"))
                .skip(2)
                .forEach(s-> System.out.println(s));

map方法_转换

 LinkedList<String> list = new LinkedList<>();
        list.add("10");
        list.add("26");
        list.add("78");
        list.add("11");
        list.add("42");
        list.stream().map(s -> Integer.parseInt(s) + 5)
                .forEach(s -> System.out.println(s));

concat方法_组合

  List<String> list1 = new ArrayList<>();
        list1.add("孙无忌");
        list1.add("周芷若");
        list1.add("张敏");
        list1.add("张强");
        list1.add("张三丰");


        List<String> list2 = new ArrayList<>();
        list2.add("10");
        list2.add("26");
        list2.add("78");
        list2.add("11");
        list2.add("42");
        Stream.concat(list1.stream(), list2.stream()).forEach(s -> System.out.println(s));

distinct() 用于排除流中所有重复的元素，去重使用，有状态的方法

 LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("s1");
        linkedList.add("s1");
        linkedList.add("s1");
        linkedList.add("s1");
        linkedList.add("s2");
        linkedList.add("s3");
        linkedList.add("s4");
        linkedList.add("s5");
        linkedList.add("s6");
        linkedList.stream().distinct().forEach(s -> System.out.println(s));

sorted() 排序方法

  LinkedList<Integer> integers = new LinkedList<>();
        integers.add(1);
        integers.add(2);
        integers.add(3);
        integers.add(4);
        //使用sorted排序
        integers.stream().sorted().forEach(s -> System.out.println(s));

min() 返回流中所有元素的最小值

 LinkedList<Integer> integers = new LinkedList<>();
        integers.add(1);
        integers.add(2);
        integers.add(3);
        integers.add(300);
        integers.add(400);
        integers.add(5000);
        Integer minInt = integers.stream().min(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        }).get();
        System.out.println("最小值为" + minInt);

max()返回流中所有元素的最大值

 Integer minInt = integers.stream().max(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        }).get();

anyMatch(Predicate pre) 判断流中是否至少包含一个元素符合Predicate条件，返回true代表有元素包含，返回false代表没有元素包含

   LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        boolean match = list.stream().anyMatch(i -> i > 2);
        System.out.println(match);

allMatch(Predicate predicate) 判断流中是否每个元素都符合条件

 LinkedList<Integer> list = new LinkedList<>();
        list.add(2);
        list.add(4);
        list.add(6);
        list.add(8);
        //查看是否元素全部包含
        boolean b = list.stream().allMatch(i -> i % 2 == 0);
        System.out.println("集合中全部元素是否" + b);

noneMatch(Predicate predicate) 判断流中是否所有元素都不符合Predicate条件

LinkedList<Integer> integers = new LinkedList<>();
        integers.add(1);
        integers.add(2);
        integers.add(3);
        integers.add(4);
        integers.add(5);
        boolean b = integers.stream().noneMatch(i -> i > 6);
        System.out.println(b);

findFirst() 返回流中的第一个元素

 LinkedList<Integer> integers = new LinkedList<>();
        integers.offer(2);
        integers.offer(4);
        integers.offer(6);
        integers.offer(8);
        Integer firtst = integers.stream().findFirst().get();
        System.out.println(firtst);

findAny() 返回流中的任意一个元素

  LinkedList<Integer> list = new LinkedList<>();
        list.add(2);
        list.add(4);
        list.add(6);
        list.add(8);
        Integer integer = list.stream().findAny().get();

Stream流的结果手机到集合和数组中

collect(Collectors.toList()) 将流的结果转化为list
collect(Collectors.toSet()) 将流的结果转化为Set
toArray() 将流的结果提取到数组

JAVA基础-JAVA8 对集合的增强

Java8流、流操作集合

Predicate 谓词对象

Steam 流式API

使用Stream步骤

Stream API

中间方法：

末端方法

Stream操作集合(Stream在集合中的应用)

Stream流获取流的方式

Stream流_常用方法

Stream流的结果手机到集合和数组中

猜你喜欢

热点阅读

JAVA基础-JAVA8 对集合的增强

Java8流、流操作集合

Predicate 谓词对象

Steam 流式API

使用Stream步骤

Stream API

中间方法：

末端方法

Stream操作集合(Stream在集合中的应用)

Stream流 获取流的方式

Stream流_常用方法

Stream流的结果手机到集合和数组中

猜你喜欢

热点阅读

Stream流获取流的方式