JAVA8 对集合的增强

发表于 | 分类于

Predicate 谓词对象

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

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

1
2
3
4
5
6
7
8
9
hashSet.removeIf(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                if (s.equals("hu")) {
                    return true;
                }
                return false;
            }
        });

Predicate 简化集合操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public static void main(String[] args) {
       ArrayList<String> list = new ArrayList<>();
       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步骤

1、使用Stream或XxxStream的builder()类方法创建该Stream对应的Builder

2、重复调用Builder的add()方法向该流中添加多个元素

3、Builder的build()获取对应的Stream

4、调用Stream的聚集方法(Stream提供了大量的聚集方法供用户调用 ) 每个Stream只能调用一次聚集方法，Stream调用聚集方法后流就会关闭，并且不可重用。

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

Stream API

中间方法

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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转换生成的所有元素

1
2
3
4
5
6
7
8
9
10
11
12
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()：该方法用于排序流中所有重复的元素(判断重复依据是equels())。返回由该流的不同元素组成的流

sorted()该方法用于排序流中的元素在后续的访问中处于有序状态。是有状态的方法

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

末端方法

forEach(Consumer action) 遍历流中所有元素，对每个元素执行action

toArray()：将流中所有元素转换为一个数组

reduce()：用于通过某种操作来合并流中的元素

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

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

count()：返回流中所有元素的数量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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条件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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条件

1
2
3
4
5
6
7
8
9
10
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条件

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

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

1
2
3
4
5
6
7
8
9
10
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() 返回流中的任意一个元素

1
2
3
4
5
6
7
8
9
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操作集合

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

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

1
2
3
4
5
6
7
8
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();

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

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

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

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

通过零散的数据获取流

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

filter方法 过滤

1
2
3
LinkedList<String> list = new LinkedList<>();
        list.stream().filter(s -> s.startsWith("张"))
                .forEach(s -> System.out.println(s));

count方法_统计个数

1
2
3
4
long zCount = list.stream()
               .filter(s -> s.startsWith("张"))
               .count();
       System.out.println("张姓学员数量有"+zCount);

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

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

skip方法_跳过前几个

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

map方法_转换

1
2
3
4
5
LinkedList<String> list = new LinkedList<>();
       list.add("10");
       list.add("26");
       list.stream().map(s -> Integer.parseInt(s) + 5)
               .forEach(s -> System.out.println(s));

concat方法_组合

1
2
3
List<String> list1 = new ArrayList<>();
      List<String> list2 = new ArrayList<>();
      Stream.concat(list1.stream(), list2.stream()).forEach(s -> System.out.println(s));

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

1
2
3
4
5
LinkedList<String> linkedList = new LinkedList<>();
       linkedList.add("s1");
       linkedList.add("s1");
       linkedList.add("s6");
       linkedList.stream().distinct().forEach(s -> System.out.println(s));

sorted() 排序方法

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

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

1
2
3
4
5
6
7
8
9
10
11
LinkedList<Integer> integers = new LinkedList<>();
       integers.add(1);
       integers.add(2);
       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()返回流中所有元素的最大值

1
2
3
4
5
6
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代表没有元素包含

1
2
3
4
5
6
7
8
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) 判断流中是否每个元素都符合条件

1
2
3
4
5
6
7
8
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条件

1
2
3
4
5
6
7
8
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() 返回流中的第一个元素

1
2
3
4
5
6
7
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() 返回流中的任意一个元素

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

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

1
2
3
collect(Collectors.toList()) 将流的结果转化为list
collect(Collectors.toSet()) 将流的结果转化为Set
toArray() 将流的结果提取到数组
分享到： 收藏夹 复制网址 邮件 微信 QQ空间 腾讯微博 豆瓣 一键分享 更多