java 8 集合_JAVA基础-JAVA8 对集合的增强

Java8流、流操作集合

Predicate 谓词对象

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

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

HashSet 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() {

@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 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() {

@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 collection, Predicate 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获取流

Collection接口中，有一个“默认方法”：stream()，可以获取一个流对象

List list = new ArrayList<>();

……

Stream stream = list.stream();

----------------------------------------------

Set set = new HashSet<>();

……

Stream stream = set.stream();

通过Map获取

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

Map map = new HashMap<>();

……

//1.获取“键”的流：

Stream keysSteram = map.keySet().stream();

//2.获取“值”的流：

Stream valueStream = map.values().stream();

//3.获取“键值对”的流：

Stream> entryStream = map.entrySet().stream();

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

Integer[] arr = {1,2,3,432,3,2,324,32};

Stream intStream = Stream.of(arr);

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

int[] arr = {1,4,234,32,32,523,432};

IntStream intStream = IntStream.of(arr);

通过零散的数据获取流

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

Stream流_常用方法

filter方法 过滤

LinkedList 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 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 list1 = new ArrayList<>();

list1.add("孙无忌");

list1.add("周芷若");

list1.add("张敏");

list1.add("张强");

list1.add("张三丰");

List 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 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 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 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() {

@Override

public int compare(Integer o1, Integer o2) {

return o2 - o1;

}

}).get();

System.out.println("最小值为" + minInt);

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

Integer minInt = integers.stream().max(new Comparator() {

@Override

public int compare(Integer o1, Integer o2) {

return o1 - o2;

}

}).get();

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

LinkedList 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 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 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 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 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() 将流的结果提取到数组