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