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