Java的stream流相关方法
allMatch(Predicate<? super T> predicate)
//通过实现predicate接口来对stream流中的所有元素进行自定义匹配，当所有匹配成功时，返回true boolean allMatch(Predicate<? super T> predicate);
实例
ArrayList<String> strings = new ArrayList<>(Arrays.asList("13","aa","88"));
boolean result = strings.stream().allMatch(new Predicate<String>() {
@Override
public boolean test(String s) {
if(s == "13")return true;
return false;
}
});
System.out.println(result);
anyMatch(Predicate<? super T> predicate);
//有任意元素匹配就会返回true boolean anyMatch(Predicate<? super T> predicate);
boolean noneMatch(Predicate<? super T> predicate);
//当没有元素匹配时返回true boolean noneMatch(Predicate<? super T> predicate);
collect(Collector<? super T, A, R> collector);
//通过collector将流中的元素创建一个新的List并返回，Collectors中有JDK定义好的Collector可以直接使用 <R, A> R collect(Collector<? super T, A, R> collector);
<R> R collect(Supplier<R> supplier,BiConsumer<R, ? super T> accumulator,BiConsumer<R, R> combiner);
//supplier用于生成存放元素的容器，accumulator遍历所有的元素进行操作，combiner用于对多线程产生的不同容器进行合并
<R> R collect(Supplier<R> supplier,
BiConsumer<R, ? super T> accumulator,
BiConsumer<R, R> combiner);
实例
//常规写法
List<Integer> result2 = list.stream().collect(
new Supplier<List<Integer>>() {
@Override
public List<Integer> get() {
return new ArrayList<>();
}
},
new BiConsumer<List<Integer>, Integer>() {
@Override
public void accept(List<Integer> integers, Integer integer) {
integers.add(integer);
}
},
new BiConsumer<List<Integer>, List<Integer>>() {
@Override
public void accept(List<Integer> integers, List<Integer> integers2) {
integers.addAll(integers2);
}
}
);
//Lamda表达式
List<Integer> result = list.stream().collect(
ArrayList::new,
(tempList,obj)->{
tempList.add(obj);
},
List::addAll
);
Stream<T> distinct();
//返回去除了重复元素后的流 Stream<T> distinct();
实例
List<Integer> list = new ArrayList<>(Arrays.asList(1,1,1,1,2,3,4,5));
List<Integer> result = list.stream().distinct().collect(Collectors.toList());
System.out.println(result);
Stream<T> filter(Predicate<? super T> predicate);
//对流中的元素进行自定义过滤，返回true的才能通过过滤 Stream<T> filter(Predicate<? super T> predicate);
实例
List<Integer> list = new ArrayList<>(Arrays.asList(1,1,1,1,2,3,4,5));
List<Integer> result = list.stream().filter(new Predicate<Integer>() {
@Override
public boolean test(Integer integer) {
if(integer > 2){
return true;
}
return false;
}
}).collect(Collectors.toList());
System.out.println(result);
Optional<T> findAny();
//从流中返回一个经过Optional类包装后的值，是显式不确定的，为了在并行操作中实现最大性能。 Optional<T> findAny();
实例
System.out.println(list.stream().findAny().get());
Optional<T> findFirst();
//返回流中第一个元素 Optional<T> findFirst();
<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
//对流内的元素进行重映射，并且对原来的一个一个元素可以映射为多个元素 <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
实例
List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,4,5));
List<Object> result = list.stream().flatMap(new Function<Integer, Stream<?>>() {
@Override
public Stream<?> apply(Integer integer) {
if(integer == 2){
return new ArrayList<Integer>(Arrays.asList(99,99,99)).stream();
}
else{
return new ArrayList<Integer>(Arrays.asList(integer)).stream();
}
}
}).collect(Collectors.toList());
System.out.println(result);
void forEach(Consumer<? super T> action);
//遍历流中所有元素 void forEach(Consumer<? super T> action);
实例
List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,4,5));
list.stream().forEach(element->{
System.out.println(element);
});
public static<T> Stream<T> generate(Supplier<T> s)
//返回无限连续无序流，其中的元素都是由Supplier生成。 public static<T> Stream<T> generate(Supplier<T> s)
实例
Stream.generate(()->{
try {
Thread.sleep(1000);
return new Random().nextInt(99) + 1;
}catch (Exception e){
e.printStackTrace();
}
return null;
}).forEach(element->{
System.out.println(element);
});
Stream<T> limit(long maxSize);
//返回最大元素个数的流 Stream<T> limit(long maxSize);
实例
List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,4,5));
list.stream().limit(2).forEach(el->{
System.out.println(el);
});
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
//对流中的元素进行重映射 <R> Stream<R> map(Function<? super T, ? extends R> mapper);
实例
List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,4,5));
list.stream().map(el->{
if(el < 3){
return -1;
}
return el;
}).forEach(el->{
System.out.println(el);
});
Optional<T> max(Comparator<? super T> comparator);
//通过传入的比较器返回流中最大的元素 Optional<T> max(Comparator<? super T> comparator);
实例
List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,4,5));
System.out.println(list.stream().max(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
if (o1 == o2) {
return 0;
}
return o1 > o2 ? 1 : -1;
}
}).get());
Optional<T> min(Comparator<? super T> comparator);
//获取流中最小的元素 Optional<T> min(Comparator<? super T> comparator);
Stream<T> sorted(Comparator<? super T> comparator);
//通过传入的比较器对流的元素进行排序 Stream<T> sorted(Comparator<? super T> comparator);
实例
List<Integer> list = new ArrayList<>(Arrays.asList(2,4,1,3,5));
list.stream().sorted(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
if(o1 == o2){
return 0;
}
return o1 > o2 ? 1 : -1;
}
}).forEach(el->{
System.out.println(el);
});
Object[] toArray();
//将流转换成数组 Object[] toArray();
List<Integer> list = new ArrayList<>(Arrays.asList(2,4,1,3,5));
Object[] result = list.stream().toArray();
System.out.println(new ArrayList<Object>(Arrays.asList(result)));
浙公网安备 33010602011771号