Java8新特性-Stream

于 2021-06-09 11:52:37 发布
阅读量165 收藏 1
点赞数 1
分类专栏： Java 文章标签： java stream jdk
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42322632/article/details/117571540
版权

什么是 Stream？

简介

Stream（流）是一个来自数据源的元素队列并支持聚合操作

  • 元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。
  • 数据源 流的来源。 可以是集合，数组，I/O channel， 产生器generator 等。
  • 聚合操作 类似SQL语句一样的操作， 比如filter, map, reduce, find, match, sorted等。

特点

Stream API的特点是：

  • Stream API提供了一套新的流式处理的抽象序列；
  • Stream API支持函数式编程和链式操作；
  • Stream可以表示无限序列，并且大多数情况下是惰性求值的。

stream内置的构造方法

public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
public static<T> Builder<T> builder()
public static<T> Stream<T> of(T t)
public static<T> Stream<T> empty()
public static<T> Stream<T> generate(Supplier<T> s)

Stream提供的常用操作

  • 转换操作：map()，filter()，sorted()，distinct()；

  • 合并操作：concat()，flatMap()；

  • 并行处理：parallel()；

  • 聚合操作：reduce()，collect()，count()，max()，min()，sum()，average()；

  • 其他操作：allMatch(), anyMatch(), forEach()。

创建Stream

如果是数组的话，可以使用 Arrays.stream() 或者 Stream.of() 创建流；如果是集合的话，可以直接使用 stream() 方法创建流，因为该方法已经添加到 Collection 接口中。

public class CreateStreamDemo {
    public static void main(String[] args) {
        String[] arr = new String[]{"武汉加油", "中国加油", "世界加油"};
        Stream<String> stream = Arrays.stream(arr);

        stream = Stream.of("武汉加油", "中国加油", "世界加油");

        List<String> list = new ArrayList<>();
        list.add("武汉加油");
        list.add("中国加油");
        list.add("世界加油");
        stream = list.stream();
    }
}

查看 Stream 源码的话，你会发现 of() 方法内部其实调用了 Arrays.stream() 方法。

public static<T> Stream<T> of(T... values) {
    return Arrays.stream(values);
}

另外，集合还可以调用 parallelStream() 方法创建并发流，默认使用的是 ForkJoinPool.commonPool()线程池。

List<Long> aList = new ArrayList<>();
Stream<Long> parallelStream = aList.parallelStream();

接口stream对元素的操作方法定义

过滤 filter

Stream<T> filter(Predicate<? super T> predicate)

Predicate是函数式接口，可以直接用lambda代替；如果有复杂的过滤逻辑，则用or、and、negate方法组合
示例

//简单过滤逻辑
List<String> list = new ArrayList<>();
list.add("周杰伦");
list.add("王力宏");
list.add("陶喆");
list.add("林俊杰");
Stream<String> stream = list.stream().filter(element -> element.contains("王"));
stream.forEach(System.out::println);


//复杂过滤逻辑
List<String> demo = Arrays.asList("a", "b", "c");
Predicate<String> f1 = item -> item.equals("a");
Predicate<String> f2 = item -> item.equals("b");
demo.stream().filter(f1.or(f2)).forEach(System.out::println);
-------result--------
a
b

filter() 方法接收的是一个 Predicate（Java 8 新增的一个函数式接口，接受一个输入参数返回一个布尔值结果）类型的参数，因此，我们可以直接将一个 Lambda 表达式传递给该方法，比如说 element -> element.contains(“王”) 就是筛选出带有“王”的字符串。

forEach() 方法接收的是一个 Consumer（Java 8 新增的一个函数式接口，接受一个输入参数并且无返回的操作）类型的参数，类名 :: 方法名是 Java 8 引入的新语法，System.out 返回 PrintStream 类，println 方法你应该知道是打印的。

映射转化 map

<R> Stream<R> map(Function<? super T, ? extends R> mapper)
IntStream mapToInt(ToIntFunction<? super T> mapper);
LongStream mapToLong(ToLongFunction<? super T> mapper);
DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper);

示例

static class User{
    public User(Integer id){this.id = id; }
    Integer id; public Integer getId() {  return id; }
}
public static void main(String[] args) {
    List<User> demo = Arrays.asList(new User(1), new User(2), new User(3));
    // User 转为 Integer(id)
    demo.stream().map(User::getId).forEach(System.out::println);
}
-------result--------
1
2
3

数据处理 peek

Stream<T> peek(Consumer<? super T> action);

与map的区别是其无返回值
示例

static class User{
    public User(Integer id){this.id = id; }
    Integer id;
    public Integer getId() {  return id; }
    public void setId(Integer id) {  this.id = id; }
}
public static void main(String[] args) {
    List<User> demo = Arrays.asList(new User(1), new User(2), new User(3));
    // id平方，User 转为 Integer(id)
    demo.stream().peek(user -> user.setId(user.id * user.id)).map(User::getId).forEach(System.out::println);
}
-------result--------
1
4
9

映射撵平 flatMap

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper);
LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper);
DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper);

flatMap：将元素为Stream类型的流撵平成一个元素类型为T的Stream流
示例

public static void main(String[] args) {
    List<Stream<Integer>> demo = Arrays.asList(Stream.of(5), Stream.of(2), Stream.of(1));
    demo.stream().flatMap(Function.identity()).forEach(System.out::println);
}
-------result--------
5
2
1

去重 distinct

Stream<T> distinct();

示例

List<Integer> demo = Arrays.asList(1, 1, 2);
demo.stream().distinct().forEach(System.out::println);
-------result--------
1
2

排序 sorted

Stream<T> sorted();
Stream<T> sorted(Comparator<? super T> comparator);

示例

List<Integer> demo = Arrays.asList(5, 1, 2);
//默认升序
demo.stream().sorted().forEach(System.out::println);
//降序
Comparator<Integer> comparator = Comparator.<Integer, Integer>comparing(item -> item).reversed();
demo.stream().sorted(comparator).forEach(System.out::println);
-------默认升序 result--------
1
2
5
-------降序 result--------
5
2
1

个数限制limit和跳过skip

//截取前maxSize个元素
Stream<T> limit(long maxSize);
//跳过前n个流
Stream<T> skip(long n);

示例

List<Integer> demo = Arrays.asList(1, 2, 3, 4, 5, 6);
//跳过前两个，然后限制截取两个
demo.stream().skip(2).limit(2).forEach(System.out::println);
-------result--------
3
4

JDK9提供的新操作

和filter的区别，takeWhile是取满足条件的元素，直到不满足为止；dropWhile是丢弃满足条件的元素，直到不满足为止

default Stream<T> takeWhile(Predicate<? super T> predicate);
default Stream<T> dropWhile(Predicate<? super T> predicate);

stream的终止操作action

遍历消费

//遍历消费
void forEach(Consumer<? super T> action);
//顺序遍历消费,和forEach的区别是forEachOrdered在多线程parallelStream执行，其顺序也不会乱
void forEachOrdered(Consumer<? super T> action);

示例

List<Integer> demo = Arrays.asList(1, 2, 3);
demo.parallelStream().forEach(System.out::println);
demo.parallelStream().forEachOrdered(System.out::println);
-------forEach result--------
2
3
1
-------forEachOrdered result--------
1
2
3

获取数组结果（输出为数组）

//流转成Object数组
Object[] toArray();
//流转成Ａ[]数组，指定类型A
<A> A[] toArray(IntFunction<A[]> generator)

示例

List<String> demo = Arrays.asList("1", "2", "3");
//<A> A[] toArray(IntFunction<A[]> generator)
String[] data = demo.stream().toArray(String[]::new);

最大最小值

//获取最小值
Optional<T> min(Comparator<? super T> comparator)
//获取最大值
Optional<T> max(Comparator<? super T> comparator)

示例

List<Integer> demo = Arrays.asList(1, 2, 3);
Optional<Integer> min = demo.stream().min(Comparator.comparing(item->item));
Optional<Integer> max = demo.stream().max(Comparator.comparing(item->item));
System.out.println(min.get()+"-"+max.get());
-------result--------
1-3

查找匹配

//任意一个匹配
boolean anyMatch(Predicate<? super T> predicate)
//全部匹配
boolean allMatch(Predicate<? super T> predicate)
//不匹配 
boolean noneMatch(Predicate<? super T> predicate)
//查找第一个
Optional<T> findFirst();
//任意一个
Optional<T> findAny();

合并

将两个Stream合并为一个Stream可以使用Stream的静态方法concat()：

Stream<String> s1 = List.of("A", "B", "C").stream();
Stream<String> s2 = List.of("D", "E").stream();
// 合并:
Stream<String> s = Stream.concat(s1, s2);
System.out.println(s.collect(Collectors.toList())); // [A, B, C, D, E]

归约合并

//两两合并
Optional<T> reduce(BinaryOperator<T> accumulator)
//两两合并，带初始值的
T reduce(T identity, BinaryOperator<T> accumulator)
//先转化元素类型再两两合并，带初始值的
<U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner)

我们来看一个简单的聚合方法：

public class Main {
    public static void main(String[] args) {
        int sum = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9).reduce(0, (acc, n) -> acc + n);
        System.out.println(sum); // 45
    }
}

reduce()方法传入的对象是BinaryOperator接口，它定义了一个apply()方法，负责把上次累加的结果和本次的元素 进行运算，并返回累加的结果：

@FunctionalInterface
public interface BinaryOperator<T> {
    // Bi操作：两个输入，一个输出
    T apply(T t, T u);
}

上述代码看上去不好理解，但我们用for循环改写一下，就容易理解了：

Stream<Integer> stream = ...
int sum = 0;
for (n : stream) {
    sum = (sum, n) -> sum + n;
}

可见，reduce()操作首先初始化结果为指定值（这里是0），紧接着，reduce()对每个元素依次调用(acc, n) -> acc + n，其中，acc是上次计算的结果：

// 计算过程:

acc = 0 // 初始化为指定值
acc = acc + n = 0 + 1 = 1 // n = 1
acc = acc + n = 1 + 2 = 3 // n = 2
acc = acc + n = 3 + 3 = 6 // n = 3
acc = acc + n = 6 + 4 = 10 // n = 4
acc = acc + n = 10 + 5 = 15 // n = 5
acc = acc + n = 15 + 6 = 21 // n = 6
acc = acc + n = 21 + 7 = 28 // n = 7
acc = acc + n = 28 + 8 = 36 // n = 8
acc = acc + n = 36 + 9 = 45 // n = 9

因此，实际上这个reduce()操作是一个求和。

如果去掉初始值，我们会得到一个Optional：


Optional<Integer> opt = stream.reduce((acc, n) -> acc + n);
if (opt.isPresent()) {
    System.out.println(opt.get());
}

这是因为Stream的元素有可能是0个，这样就没法调用reduce()的聚合函数了，因此返回Optional对象，需要进一步判断结果是否存在。

利用reduce()，我们可以把求和改成求积，代码也十分简单：


public class Main {
    public static void main(String[] args) {
        int s = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9).reduce(1, (acc, n) -> acc * n);
        System.out.println(s); // 362880
    }
}

注意：计算求积时，初始值必须设置为1。

除了可以对数值进行累积计算外，灵活运用reduce()也可以对Java对象进行操作。下面的代码演示了如何将配置文件的每一行配置通过map()和reduce()操作聚合成一个Map<String, String>：

public class Main {
    public static void main(String[] args) {
        // 按行读取配置文件:
        List<String> props = List.of("profile=native", "debug=true", "logging=warn", "interval=500");
        Map<String, String> map = props.stream()
                // 把k=v转换为Map[k]=v:
                .map(kv -> {
                    String[] ss = kv.split("\\=", 2);
                    return Map.of(ss[0], ss[1]);
                })
                // 把所有Map聚合到一个Map:
                .reduce(new HashMap<String, String>(), (m, kv) -> {
                    m.putAll(kv);
                    return m;
                });
        // 打印结果:
        map.forEach((k, v) -> {
            System.out.println(k + " = " + v);
        });
    }
}

reduce()方法将一个Stream的每个元素依次作用于BinaryOperator，并将结果合并。

reduce()是聚合方法，聚合方法会立刻对Stream进行计算。
把Stream的每个元素收集到List的方法是调用collect()并传入Collectors.toList()对象，它实际上是一个Collector实例，通过类似reduce()的操作，把每个元素添加到一个收集器中（实际上是ArrayList）。

示例

List<Integer> demo = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
//数字转化为字符串，然后使用“-”拼接起来
String data = demo.stream().reduce("0", (u, t) -> u + "-" + t, (s1, s2) -> s1 + "-" + s2);
System.out.println(data);
-------result--------
0-1-2-3-4-5-6-7-8

计算元素个数

long count()

示例

List<Integer> demo = Arrays.asList(1, 2, 3, 4, 5, 6);
System.out.println(demo.stream().count());
-------result--------
6

对流的聚合处理

/**
 * supplier:返回结果类型的生产者
 * accumulator:元素消费者（处理并加入R）
 * combiner: 返回结果 R 怎么组合（多线程执行时，会产生多个返回值R，需要合并）
 */
<R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner);
/**
 * collector一般是由 supplier、accumulator、combiner、finisher、characteristics组合成的聚合类
 * Collectors 可提供一些内置的聚合类或者方法
 */
<R, A> R collect(Collector<? super T, A, R> collector);

Collector(聚合类)的工具类集Collectors

接口Collector和实现类CollectorImpl

//返回值类型的生产者
Supplier<A> supplier();
//流元素消费者
BiConsumer<A, T> accumulator();
//返回值合并器（多个线程操作时，会产生多个返回值，需要合并）
BinaryOperator<A> combiner();
//返回值转化器（最后一步处理，实际返回结果，一般原样返回）
Function<A, R> finisher();
//流的特性
Set<Characteristics> characteristics();

public static<T, A, R> Collector<T, A, R> of(Supplier<A> supplier,
	BiConsumer<A, T> accumulator, BinaryOperator<A> combiner,
	Function<A, R> finisher, Characteristics... characteristics)

流聚合转换成List, Set

//流转化成List
public static <T> Collector<T, ?, List<T>> toList()
//流转化成Set
public static <T> Collector<T, ?, Set<T>> toSet()

示例

List<Integer> demo = Arrays.asList(1, 2, 3);
List<Integer> col = demo.stream().collect(Collectors.toList());
Set<Integer> set = demo.stream().collect(Collectors.toSet());

流聚合转化成Map

//流转化成Map
public static <T, K, U> Collector<T, ?, Map<K,U>> toMap(
	Function<? super T, ? extends K> keyMapper,
    Function<? super T, ? extends U> valueMapper)
/**
 * mergeFunction:相同的key,值怎么合并
 */
public static <T, K, U> Collector<T, ?, Map<K,U>> toMap(
	Function<? super T, ? extends K> keyMapper,
	Function<? super T, ? extends U> valueMapper,
    BinaryOperator<U> mergeFunction)
/**
 * mergeFunction:相同的key,值怎么合并
 * mapSupplier：返回值Map的生产者
 */
public static <T, K, U, M extends Map<K, U>> Collector<T, ?, M> toMap(
	Function<? super T, ? extends K> keyMapper,
	Function<? super T, ? extends U> valueMapper,
	BinaryOperator<U> mergeFunction,
    Supplier<M> mapSupplier)

如果存在相同key的元素，会报错;或者使用groupBy
示例

List<User> demo = Arrays.asList(new User(1), new User(2), new User(3));
Map<Integer,User> map = demo.stream().collect(Collectors.toMap(User::getId,item->item));
System.out.println(map);
-------result-------
{1=TestS$User@7b23ec81, 2=TestS$User@6acbcfc0, 3=TestS$User@5f184fc6}

字符串流聚合拼接

//多个字符串拼接成一个字符串
public static Collector<CharSequence, ?, String> joining();
//多个字符串拼接成一个字符串（指定分隔符）
public static Collector<CharSequence, ?, String> joining(CharSequence delimiter)

示例

List<String> demo = Arrays.asList("c", "s", "c","w","潜行前行");
String name = demo.stream().collect(Collectors.joining("-"));
System.out.println(name);
-------result-------
c-s-c-w-潜行前行

映射处理再聚合流

相当于先map再collect

/**
 * mapper:映射处理器
 * downstream:映射处理后需要再次聚合处理
 */
public static <T, U, A, R> Collector<T, ?, R> mapping(Function<? super T, ? extends U> mapper, 
		Collector<? super U, A, R> downstream);

示例

List<String> demo = Arrays.asList("1", "2", "3");
List<Integer> data = demo.stream().collect(Collectors.mapping(Integer::valueOf, Collectors.toList()));
System.out.println(data);
-------result-------
[1, 2, 3]

聚合后再转换结果

/**
 * downstream:聚合处理
 * finisher:结果转换处理
 */
public static<T,A,R,RR> Collector<T,A,RR> collectingAndThen(Collector<T,A,R> downstream,
		Function<R, RR> finisher);

示例

List<Integer> demo = Arrays.asList(1, 2, 3, 4, 5, 6);
//聚合成List,最后提取数组的size作为返回值
Integer size = demo.stream().collect(Collectors.collectingAndThen(Collectors.toList(), List::size));
System.out.println(size);
---------result----------
6

流分组（Map是HashMap）

/**
 * classifier 指定T类型某一属性作为Key值分组
 * 分组后，使用List作为每个流的容器
 */
public static <T, K> Collector<T, ?, Map<K, List<T>>> groupingBy(
		Function<? super T, ? extends K> classifier);           
/**
 * classifier: 流分组器
 * downstream: 每组流的聚合处理器
 */
public static <T, K, A, D> Collector<T, ?, Map<K, D>> groupingBy(
		Function<? super T, ? extends K> classifier， 
		Collector<? super T, A, D> downstream)
/**
 * classifier: 流分组器
 * mapFactory: 返回值map的工厂（Map的子类）
 * downstream: 每组流的聚合处理器
 */
public static <T, K, D, A, M extends Map<K, D>> Collector<T, ?, M> groupingBy(
		Function<? super T, ? extends K> classifier,
		Supplier<M> mapFactory,
		Collector<? super T, A, D> downstream)

示例

public static void main(String[] args) throws Exception {
    List<Integer> demo = Stream.iterate(0, item -> item + 1)
            .limit(15)
            .collect(Collectors.toList());
    // 分成三组，并且每组元素转化为String类型        
    Map<Integer, List<String>> map = demo.stream()
            .collect(Collectors.groupingBy(item -> item % 3,
                    HashMap::new,
                    Collectors.mapping(String::valueOf, Collectors.toList())));
    System.out.println(map);
}
---------result----------    
{0=[0, 3, 6, 9, 12], 1=[1, 4, 7, 10, 13], 2=[2, 5, 8, 11, 14]}

流分组(分组使用的Map是ConcurrentHashMap)

/**
 * classifier: 分组器 ； 分组后，使用List作为每个流的容器
 */
public static <T, K> Collector<T, ?, ConcurrentMap<K, List<T>>> groupingByConcurrent(
		Function<? super T, ? extends K> classifier);
/**
 * classifier: 分组器
 * downstream: 流的聚合处理器
 */
public static <T, K, A, D> Collector<T, ?, ConcurrentMap<K, D>> groupingByConcurrent(
		Function<? super T, ? extends K> classifier, Collector<? super T, A, D> downstream)
/**
 * classifier: 分组器
 * mapFactory: 返回值类型map的生产工厂（ConcurrentMap的子类）
 * downstream: 流的聚合处理器
 */
public static <T, K, A, D, M extends ConcurrentMap<K, D>> Collector<T, ?, M> groupingByConcurrent(
		Function<? super T, ? extends K> classifier, 
		Supplier<M> mapFactory,
		Collector<? super T, A, D> downstream);`在这里插入代码片`

拆分流，一变二（相当于特殊的groupingBy）

public static <T> Collector<T, ?, Map<Boolean, List<T>>> partitioningBy(
		Predicate<? super T> predicate)
/**
 * predicate: 二分器
 * downstream: 流的聚合处理器
 */
public static <T, D, A> Collector<T, ?, Map<Boolean, D>> partitioningBy(
		Predicate<? super T> predicate, Collector<? super T, A, D> downstream)

示例

List<Integer> demo = Arrays.asList(1, 2,3,4, 5,6);
// 奇数偶数分组
Map<Boolean, List<Integer>> map = demo.stream()
	.collect(Collectors.partitioningBy(item -> item % 2 == 0));
System.out.println(map);
---------result----------
{false=[1, 3, 5], true=[2, 4, 6]}

聚合求平均值

// 返回Double类型
public static <T> Collector<T, ?, Double> averagingDouble(ToDoubleFunction<? super T> mapper)
// 返回Long 类型
public static <T> Collector<T, ?, Double> averagingLong(ToLongFunction<? super T> mapper)
//返回Int 类型
public static <T> Collector<T, ?, Double> averagingInt(ToIntFunction<? super T> mapper)

示例

List<Integer> demo = Arrays.asList(1, 2, 5);
Double data = demo.stream().collect(Collectors.averagingInt(Integer::intValue));
System.out.println(data);
---------result----------
2.6666666666666665

流聚合查找最大最小值

//最小值
public static <T> Collector<T, ?, Optional<T>> minBy(Comparator<? super T> comparator) 
//最大值
public static <T> Collector<T, ?, Optional<T>> maxBy(Comparator<? super T> comparator)

示例

List<Integer> demo = Arrays.asList(1, 2, 5);
Optional<Integer> min = demo.stream().collect(Collectors.minBy(Comparator.comparing(item -> item)));
Optional<Integer> max = demo.stream().collect(Collectors.maxBy(Comparator.comparing(item -> item)));
System.out.println(min.get()+"-"+max.get());
---------result----------
1-5

聚合计算统计结果

可以获得元素总个数，元素累计总和，最小值，最大值，平均值

//返回Int 类型
public static <T> Collector<T, ?, IntSummaryStatistics> summarizingInt(
		ToIntFunction<? super T> mapper)
//返回Double 类型
public static <T> Collector<T, ?, DoubleSummaryStatistics> summarizingDouble(
		ToDoubleFunction<? super T> mapper)
//返回Long 类型
public static <T> Collector<T, ?, LongSummaryStatistics> summarizingLong(
		ToLongFunction<? super T> mapper)

示例

List<Integer> demo = Arrays.asList(1, 2, 5);
IntSummaryStatistics data = demo.stream().collect(Collectors.summarizingInt(Integer::intValue));
System.out.println(data);
---------result----------
IntSummaryStatistics{count=3, sum=8, min=1, average=2.666667, max=5}
〆、风神
关注
专栏目录
java新特性之Stream流
sdgames的博客
07-20 253
java8给为我们提供了一个叫Stream流的东西，那么什么是 Stream流了，它是java JDK1.8中处理集合的关键抽象概念，Lambda和Stream是JDK1.8中新增的函数式编程中最有靓点的特性了，它可以实现对集合的各种操作，可以执行非常复杂的查询，过滤映射数据等操作。使用StreamApi对集合数据进行操作，就类似于使用Sql执行的数据库查询。Stream Api可以极大提高java程序员的生产力，让程序员写出高效率，高逼格，非常nice的代码。 我们说这个之前，想下生活中的场景：流水线
实习记录-Java实现生产者消费者问题
kara_luoleo的博客
10-16 193
实习记录-Java实现生产者消费者问题实习记录-Java实现生产者消费者问题生产者消费者问题解决方法引出的问题 实习记录-Java实现生产者消费者问题 生产者消费者问题 经典多线程问题 生产者生产消息并存放入共享队列中，消费者从共享队列取得消息并且消费。 在多并发条件下对同一资源的控制，同时当缓存区空时，消费者阻塞，缓存区满时，生产者阻塞 解决方法 同步机制-锁和管道 1.通过wait和notify方法。利用对象（共享缓存区）锁和wait以及notify方法，条件不满足时wait挂起线程并释放锁，同
java8 stream 树_java stream的几种"另类"用法
weixin_33520865的博客
02-25 310
除了用于简化对List, Set, Map等集合类型的操作外，java stream其实还可以抽象很多其他数据类型，然后在这一抽象的基础上做一些非常规操作。这些另类操作用好了，有时可以极大简化你的代码，当然也可能导致你被同事殴打。计算斐波那契数Fibonacci数是计算机教材中非常经典的几个示例之一，由于其天生的递归式定义，所以总是被当做介绍递归的入门问题。除了直接的递归式解法外，常见的还有迭代法...
java negate_Java Predicate Negate Example
weixin_31451617的博客
03-06 334
Predicate negate求反返回predicate ，该predicate表示给定谓词的逻辑否定 。 否定谓词返回流中被原始谓词过滤掉的所有元素。1. Java predicate negate() methodlogical negation 。import java.util.Arrays;import java.util.List;import java.util.function...
Java9系列第6篇-Stream流API的增强
字母哥博客
10-19 813
我计划在后续的一段时间内，写一系列关于java 9的文章，虽然java 9 不像Java 8或者Java 11那样的核心java版本，但是还是有很多的特性值得关注。期待您能关注我，我将把java 9 写成一系列的文章，大概十篇左右，本文是第6篇。 java9系列文章访问地址 本文带大家快速的了解一下在Java 9 种集合类Colleaction子类都发生了哪些比较有用的变化与增强。 在Java 9中对Java Util Stream的语法进行了优化和增强，下面我就和大家一起看一下有哪些比较有价值的使用.
677.675.JAVA基础教程_动态代理与Java8新特性-Stream API的概述(677).rar
11-09
本教程将深入探讨两个关键的Java技术：动态代理和Java 8的新特性——Stream API。这两个主题都是现代Java开发中不可或缺的部分，它们极大地提升了代码的可读性和效率。 首先，让我们来了解一下动态代理。动态代理在...
678.676.JAVA基础教程_动态代理与Java8新特性-Stream的实例化(678).rar
11-09
本教程将深入探讨两个关键的Java概念：动态代理和Java 8的新特性，特别是Stream API的实例化。我们将从这两个主题出发，展开详细的讨论。 首先，让我们了解一下Java动态代理。动态代理是在运行时创建一个接口的实现...
679.677.JAVA基础教程_动态代理与Java8新特性-Stream的中间操作：筛选(679).rar
11-09
本教程聚焦于Java的基础部分，特别是Java动态代理和Java 8的新特性——Stream API，尤其是Stream的中间操作——筛选。 动态代理是Java提供的一种机制，允许我们在运行时创建具有特定接口的代理类实例。这主要通过...
680.678.JAVA基础教程_动态代理与Java8新特性-Stream的中间操作：映射(680).rar
11-09
在Java编程语言中，动态代理和Java 8的新特性，如Stream API，是现代Java开发中的重要组成部分。本文将深入探讨这两个主题，并特别关注Stream API的中间操作——映射（Map）。 首先，让我们理解什么是动态代理。在...
681.679.JAVA基础教程_动态代理与Java8新特性-Stream的中间操作：排序(681).rar
11-09
在Java编程语言中，动态代理和Java 8的新特性，如Stream API，是现代Java开发者必须掌握的关键概念。本教程将深入探讨这两个主题，特别是Stream API的中间操作——排序。 首先，让我们了解一下Java中的动态代理。...
java filter讲解_使用filter
weixin_28876369的博客
03-04 1255
Stream.filter()是Stream的另一个常用转换方法。所谓filter()操作，就是对一个Stream的所有元素一一进行测试，不满足条件的就被“滤掉”了，剩下的满足条件的元素就构成了一个新的Stream。例如，我们对1，2，3，4，5这个Stream调用filter()，传入的测试函数f(x) = x % 2 != 0用来判断元素是否是奇数，这样就过滤掉偶数，只剩下奇数，因此我们得到了...
Java8中 stream，filter 等功能代替for循环（及）isPresent( ) 和 ifPresent() 简单应用
热门推荐
_夜渐凉
09-28 9万+
直接上代码，比较实在。 对象A public Class A{ private Long id; private String userName; ....省略get和set方法 } 在List<A>中，查找 userName 为 "小明" 的对象 A。 在java8中，我们可以这么玩 1，查找集合中符合条件的第一个对象，如果可以明确条...
Stream流中的常用方法filter的用法
qq_33351986的博客
08-15 4万+
filter：主要是流的过滤 可以通过filter 方法将一个流转换成另一个子集流。查看方法签名： Stream<T> filter(Predicate<? super T> predicate); 该接口接收一个Predicate 函数式接口参数（可以是一个Lambda或方法引用）作为筛选条件。 复习Predicate接口 此前我们已经学习过java.util.stream.Predicate 函数式接口，其中唯一的抽象方法为： boolean test(T t); 可以看出该
stream filter_用Stream来帮助你更加优雅的处理各种集合数据
weixin_39628945的博客
11-26 483
Stream是Java 8引入的新特性，它配合Java 8的lambda语法能够更加高效和优雅的处理集合。今天我们就来看看Stream的基本用法，下一篇文章详细介绍Stream的实现原理。一个Stream的使用小示例首先我们用一个小示例来直观的感受一下使用Stream和不使用Stream处理集合类的区别。示例中会对一个字符串列表进行处理，首先过滤出字符串长度为4的元素，然后判断是否为小写字母开头，...
stream().filter匹配过滤总结
亲测，只为展现最完美的有效！
05-28 3万+
stream().filter过滤，stream().filter
绕开概念直接干之 stream中filter
qq_36792526的博客
05-25 800
你要知道： 1.stream就是用来遍历的，和for循环什么的差不多就是写法不同。 2.filter就是用来写循环里的过滤条件的，和你自己加区别不大就是看着更方便点。 3.filter （）里操作的结果必须是true or false。 来个最简单的： 对，说白了就是把你写的过滤条件过滤下来。 那问题来了，我有很多逻辑需要过滤怎么办？写个方法放进去呗 注意： 1.filter(StreamTest::myFilter)，其实就是把遍历的每个对象当做参数传给:myFilter 去过滤。
java 数组取最小值_Java获取一维数组的最小值
weixin_35079944的博客
02-12 1596
编写程序，实现接受用户在文本框中输入的单行数据。这些数据都是整数数字，以空格进行分隔，空格数量不限。并将这些数据分割成一维数组，再从数组中提取最小值显示在界面中。思路是先对用户的输入进行验证，即先用trim()函数过滤用户输入字符串的左右空格，若结果为空字符串则用JOptionPane类的showMessageDialog方法提示用户"请输入数字内容"。若用户输入非空则使用charAt函数对用户输...
实现O(1)获取最大最小值的栈----java
毛毛虫的小哈
08-09 1万+
实现O(1)获取最大最小值的栈和队列----java 一.如何实现包含获取最小值函数的栈 问题：定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的getMin函数。在该栈中，调用getMin、push及pop的时间复杂度都是O(1). 最小值思路：用一个辅助栈stack2记住每次入栈stack1的当前最小值:在stack1入栈时，往stack2中加入当前最小值；st
java快速寻找一个数组的最大值或最小值， min， max，三种方法
weixin_30394669的博客
09-19 8366
java 中 寻找一个数组中的最大值或最小，除了自己专门编写一个 min 或 max 函数外，还有几种方式方便使用。 1. 使用 stream 将一个数组放进 stream 里面，然后直接调用 stream 里的 min 或 max 函数得到最大值或最小值。 2. 使用 collection 将数组转化为对象数组，即 int 转化为 Integer （需要使用 toO...
Java8新特性：Lambda表达式与StreamAPI详解
"Java8新特性概述" Java8是2014年发布的一个重大版本，它为Java语言带来了许多关键改进和创新，旨在提高开发效率、性能和简洁性。以下重点介绍Java8中的两大核心新特性：Lambda表达式和Stream API。 Lambda表达式 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值