实现一个具有Stream的链式、惰性特点的容器

最新推荐文章于 2022-04-03 11:07:25 发布
最新推荐文章于 2022-04-03 11:07:25 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： Java AlgoAndDataStructure 文章标签： java Stream 链式编程 lazy 容器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/alionsss/article/details/103941834
版权

文章目录

实现一个具有Stream的链式、惰性特点的容器

1. Stream 示例

  • 示例
    Stream.of(1,2,3,4)
      .map(i -> i * i)
      .filter(i2 -> i2 >= 4)
      .forEach(r -> System.out.println("r = " + r));

2. ChainCollection 链式-非惰性

2.1 定义function接口（你也可以用Java自带的）

  • MyConsumer
    public interface MyConsumer<In> {

    void accept(In element);

}
  • MyFunction
    public interface MyFunction<In, Out> {

    Out apply(In element);

}
  • MyPredicate
    public interface MyPredicate<In> {

    boolean test(In element);

}
  • MySupplier
    public interface MySupplier<Out> {

    Out get();

}

2.2 容器抽象接口

import com.skey.chainprogrammingdemo.func.MyConsumer;
import com.skey.chainprogrammingdemo.func.MyFunction;
import com.skey.chainprogrammingdemo.func.MyPredicate;

import java.util.Comparator;
import java.util.List;

public interface Chain<In> {

    /**
     * map操作
     * @param function Map函数 [one to one]
     * @param <Out> 返回的类型
     * @return Chain<Out>
     */
    <Out> Chain<Out> map(MyFunction<In, Out> function);

    /**
     * flatMap操作
     * @param function FlatMap函数 [one to multi]
     * @param <Out> 返回的类型
     * @return Chain<Out>
     */
    <Out> Chain<Out> flatMap(MyFunction<In, Iterable<Out>> function);

    /**
     * filter过滤操作
     * @param predicate Predicate函数 [one to one/zero]
     * @return Chain<In>
     */
    Chain<In> filter(MyPredicate<In> predicate);

    /**
     * sort排序操作
     * @param comparator 比较器 [multi to sorted multi]
     * @return Chain<In>
     */
    Chain<In> sort(Comparator<In> comparator);

    /**
     * distinct去重操作
     * @return Chain<In>
     */
    Chain<In> distinct();

    /**
     * 处理操作，无返回
     * @param consumer Consumer函数
     */
    void foreach(MyConsumer<In> consumer);

    /**
     * 获取处理结果
     * @return List<In>
     */
    List<In> collect();

}

2.3 实现容器

import com.skey.chainprogrammingdemo.func.MyConsumer;
import com.skey.chainprogrammingdemo.func.MyFunction;
import com.skey.chainprogrammingdemo.func.MyPredicate;

import java.util.*;

public class ChainCollection<In> implements Chain<In> {

    private ArrayList<In> list;

    private ChainCollection() {
        list = new ArrayList<>();
    }

    @SafeVarargs
    public static <T> Chain<T> valueOf(T... elements) {
        ChainCollection<T> collection = new ChainCollection<>();
        for (T element : elements) {
            collection.add(element);
        }

        return collection;
    }

    private void add(In element) {
        list.add(element);
    }

    @Override
    public <Out> Chain<Out> map(MyFunction<In, Out> function) {
        ChainCollection<Out> collection = new ChainCollection<>();
        for (In a : list) {
            collection.add(function.apply(a));
        }

        return collection;
    }

    @Override
    public <Out> Chain<Out> flatMap(MyFunction<In, Iterable<Out>> function) {
        ChainCollection<Out> collection = new ChainCollection<>();
        for (In a : list) {
            for (Out b : function.apply(a)) {
                collection.add(b);
            }
        }
        return collection;
    }

    @Override
    public Chain<In> filter(MyPredicate<In> predicate) {
        ChainCollection<In> collection = new ChainCollection<>();
        for (In a : list) {
            if (predicate.test(a)) {
                collection.add(a);
            }
        }

        return collection;
    }

    @Override
    public void foreach(MyConsumer<In> consumer) {
        for (In a : list) {
            consumer.accept(a);
        }
    }

    @Override
    public Chain<In> sort(Comparator<In> comparator) {
        // 自己实现以一个排序算法
        // 这里为了简便，直接调Java自带的排序算法

        ChainCollection<In> collection = new ChainCollection<>();
        for (In a : list) {
            collection.add(a);
        }

        collection.list.sort(comparator);

        return collection;
    }

    @Override
    public Chain<In> distinct() {
        ChainCollection<In> collection = new ChainCollection<>();
        HashSet<In> set = new HashSet<>(list);
        for (In a : set) {
            collection.add(a);
        }

        return collection;
    }

    @Override
    public List<In> collect() {
        return list;
    }

}

2.4 Test

ChainCollection.valueOf("5", "3", "16", "5", "2", "8")
        .map(Integer::valueOf)
        .map(i -> i * i)
        .filter(i2 -> i2 > 10)
        .sort((o1, o2) -> o2 - o1)
        .distinct()
        .foreach(System.out::println);

3. LazyChainCollection 链式-惰性

3.1 惰性节点

  • Node
    public class Node<Out> {

    public Node<?> pre;

    public Node<?> next;

    @Override
    public String toString() {
        return getClass().getSimpleName();
    }
    
}
  • FunctionNode
    import com.skey.chainprogrammingdemo.func.MyFunction;

public class FunctionNode<In, Out> extends Node<Out> {

    public MyFunction<In, Out> function;

    public FunctionNode(MyFunction<In, Out> function) {
        this.function = function;
    }

}
  • FlatFunctionNode
    import com.skey.chainprogrammingdemo.func.MyFunction;

public class FlatFunctionNode<In, Out> extends Node<Out> {

    public MyFunction<In, Iterable<Out>> flatFunction;

    public FlatFunctionNode(MyFunction<In, Iterable<Out>> flatFunction) {
        this.flatFunction = flatFunction;
    }

}
  • PredicateNode
    import com.skey.chainprogrammingdemo.func.MyPredicate;

public class PredicateNode<In> extends Node<In> {

    public MyPredicate<In> predicate;

    public PredicateNode(MyPredicate<In> predicate) {
        this.predicate = predicate;
    }

}
  • SortNode
    import java.util.Comparator;

public class SortNode<In> extends Node<In> {

	public Comparator<In> comparator;

	public SortNode(Comparator<In> comparator) {
		this.comparator = comparator;
	}

}
  • ConsumerNode
    import com.skey.chainprogrammingdemo.func.MyConsumer;

public class ConsumerNode<In> extends Node<In> {

	public MyConsumer<In> consumer;

	public ConsumerNode(MyConsumer<In> consumer) {
		this.consumer = consumer;
	}

}
  • DistinctNode
    public class DistinctNode<In> extends Node<In> {

    public DistinctNode() {
    }

}

3.2 Stage

  • Stage
    import com.skey.chainprogrammingdemo.node.Node;

public class Stage<T> {

    public Node<T> node;

    public Stage(Node<T> node) {
        this.node = node;
    }

    @Override
    public String toString() {
        return this.getClass().getSimpleName() + "[" + getNodeString(new StringBuilder(), node) + "]";
    }

    private String getNodeString(StringBuilder builder, Node<?> node) {
        if (node == null) {
            return builder.substring(0, builder.length() - 1);
        } else {
            return getNodeString(builder.append(node).append(","), node.next);
        }
    }

}
  • ShuffleMapStage
    import com.skey.chainprogrammingdemo.node.Node;

public class ShuffleMapStage<T> extends Stage<T> {

    public ShuffleMapStage(Node<T> node) {
        super(node);
    }

}
  • ResultStage
    import com.skey.chainprogrammingdemo.node.Node;

public class ResultStage<T> extends Stage<T> {

    public ResultStage(Node<T> node) {
        super(node);
    }

}

3.3 实现容器

  • 运行流程

    1. 先使用LazyChainCollection连接各个Node（Node代表一次函数操作）
    [Node/Collection链接示意图]
+-----------------------------------------+
| collection1 | collection2 | collection3 |
|      ↓      |      ↓      |      ↓      |
|    node1  -> <-  node2  -> <-  node3    |
|      ↓      |      ↓      |      ↓      |
|    func1    |    func2    |    func3    |
+-----------------------------------------+
    1. StageScheduler将Node链表按Shuffle切分为多个Stage
    [Stage划分示意图]
+-------------------------------------------------------------------------+
|    ShuffleMapStage1    |    ShuffleMapStage2    |      ResultStage3     |
|-------------------------------------------------------------------------|
| node1 -> node2 -> null |      node3 -> null     | node4 -> node5 -> ... |
+-------------------------------------------------------------------------+
    1. StageScheduler按顺序运行各个Stage
    [Stage运行与数据流转]
+--------------------------+
| Stage1 | Stage2 | Stage3 |
|--------------------------|
| data1 => data2 => data3  |
+--------------------------+

  • LazyChainCollection 代码

    /**
 * Description: 核心容器 惰性
 *
 * @author ALion
 */
public class LazyChainCollection<In> implements Chain<In> {

    Collection<Object> data;

    Node<?> currentNode;

    private LazyChainCollection(Collection<Object> data, Node<?> currentNode) {
        this.data = data;
        this.currentNode = currentNode;
    }

    @SafeVarargs
    public static <T> Chain<T> valueOf(T... elements) {
        return new LazyChainCollection<>(
                new ArrayList<>(Arrays.asList(elements)),
                new Node<>()
        );
    }

    @Override
    public <Out> Chain<Out> map(MyFunction<In, Out> function) {
        return link(new FunctionNode<>(function));
    }

    @Override
    public <Out> Chain<Out> flatMap(MyFunction<In, Iterable<Out>> function) {
        return link(new FlatFunctionNode<>(function));
    }

    @Override
    public Chain<In> filter(MyPredicate<In> predicate) {
        return link(new PredicateNode<>(predicate));
    }

    @Override
    public Chain<In> sort(Comparator<In> comparator) {
        return link(new SortNode<>(comparator));
    }

    @Override
    public Chain<In> distinct() {
        return link(new DistinctNode<>());
    }

    @Override
    public void foreach(MyConsumer<In> consumer) {
        LazyChainCollection<In> collection =
                (LazyChainCollection<In>) link(new ConsumerNode<>(consumer));
        new StageScheduler<>(collection).schedule();
    }

    @Override
    public List<In> collect() {
        List<In> result = new ArrayList<>();
        LazyChainCollection<In> collection =
                (LazyChainCollection<In>) link(new ConsumerNode<In>(result::add));
        new StageScheduler<>(collection).schedule();
        return result;
    }


    /**
    * 创建新的Collection，并与当前的node连接
    * <pre>
    *     [Node/Collection链接示意图]
    *     +-----------------------------------------+
    *     | collection1 | collection2 | collection3 |
    *     |      ↓      |      ↓      |      ↓      |
    *     |    node1  -> <-  node2  -> <-  node3    |
    *     |      ↓      |      ↓      |      ↓      |
    *     |    func1    |    func2    |    func3    |
    *     +-----------------------------------------+
    * </pre>
    *
    * @param node 新的Node
    * @param <X>  Node最终类型
    * @return Chain
    */
    private <X> Chain<X> link(Node<X> node) {
        LazyChainCollection<X> collection = new LazyChainCollection<>(
                data,
                node
        );

        this.currentNode.next = collection.currentNode;
        collection.currentNode.pre = this.currentNode;

        return collection;
    }

}

  • StageScheduler 代码

    /**
 * Description: Stage调度器
 *
 * @author ALion
 */
public class StageScheduler<T> {

    private LazyChainCollection<T> collection;

    public StageScheduler(LazyChainCollection<T> collection) {
        this.collection = collection;
    }

    /**
     * 开始调度
     * <pre>
     *     [Stage运行与数据流转]
     *     +--------------------------+
     *     | Stage1 | Stage2 | Stage3 |
     *     |--------------------------|
     *     | data1 => data2 => data3  |
     *     +--------------------------+
     * </pre>
     */
    public void schedule() {
        System.out.println("---> 开始执行任务！解析Stage...");
        List<Stage<?>> stages = parseStage(collection.currentNode);
        System.out.println("---> Stage 解析完毕！stages = " + stages);
        System.out.println("---> 提交Stage ===>");

        // 数据存储点
        Collection<Object> data = collection.data;

        for (Stage<?> stage : stages) {
            System.out.println("---> Start Stage[" + stage + "]");
            if (stage instanceof ShuffleMapStage) {
                // 处理 ShuffleMapStage
                handleStageToStage(data, (ShuffleMapStage<?>) stage);
            } else if (stage instanceof ResultStage) {
                // 处理 ResultStage
                handleStage(data, stage);
            } else {
                throw new IllegalArgumentException(
                        "No such type Stage[" + stage + "]! " +
                                "Stage must be in [ShuffleMapStage,ResultStage]!"
                );
            }
        }
    }

    /**
     * 为Node链划分Stage
     * <pre>
     *     [Stage划分示意图]
     *     +-------------------------------------------------------------------------+
     *     |    ShuffleMapStage1    |    ShuffleMapStage2    |      ResultStage3     |
     *     |-------------------------------------------------------------------------|
     *     | node1 -> node2 -> null |      node3 -> null     | node4 -> node5 -> ... |
     *     +-------------------------------------------------------------------------+
     * </pre>
     *
     * @return Stage列表
     */
    private List<Stage<?>> parseStage(Node<?> node) {
        List<Stage<?>> stages = new ArrayList<>();

        // 找到第一个Node，构建第一个Stage
        Node<?> current = findFirstNode(node).next; // 不要起始node，因为LazyChainCollection创建时，该node是空的
        stages.add(new ShuffleMapStage<>(current)); // 添加第一个Node到stages中

        while (current != null) {
            Node<?> next = current.next;

            if (current instanceof SortNode || current instanceof DistinctNode) {
                // 切割Stage
                current.next = null; // 当前Node向后指向null
                next.pre = null; // 后一个Node向前指向null

                // 新起一个Stage
                stages.add(new ShuffleMapStage<>(next));
            } else if (current instanceof ConsumerNode) {
                // 如果找到ConsumerNode，更新最后的Stage为ResultStage
                Node<?> stageFirstNode = findFirstNode(current);
                stages.set(stages.size() - 1, new ResultStage<>(stageFirstNode));
            }

            // 移动指针到下一个节点
            current = next;
        }

        return stages;
    }

    /**
     * 向前查找第一个Node
     *
     * @param node 任意节点
     * @return 第一个Node
     */
    private Node<?> findFirstNode(Node<?> node) {
        if (node.pre == null) {
            return node;
        } else {
            return findFirstNode(node.pre);
        }
    }

    /**
     * 向后查找最后一个Node
     *
     * @param node 任意节点
     * @return 最后一个Node
     */
    private Node<?> findLastNode(Node<?> node) {
        if (node.next == null) {
            return node;
        } else {
            return findLastNode(node.next);
        }
    }

    /**
     * 处理ShuffleMapStage到下一个Stage的操作
     *
     * @param data  数据容器
     * @param stage 当前Stage
     */
    private <In> void handleStageToStage(Collection<In> data, ShuffleMapStage<?> stage) {
        Node<?> lastNode = findLastNode(stage.node);
        if (lastNode instanceof SortNode) {
            SortNode<In> sortNode = (SortNode<In>) lastNode;

            // TreeSet代表了接下来的 排序Shuffle
            // 最好找一个只排序不去重的容器(更快)，这里为了便利使用TreeSet
            TreeSet<In> treeSet = new TreeSet<>(new Comparator<In>() {
                @Override
                public int compare(In o1, In o2) {
                    // 防止去重
                    int num = sortNode.comparator.compare(o1, o2);
                    return num == 0 ? 1 : num;
                }
            });

            // 切换Stage最后一个Node为ConsumerNode[添加结果到treeSet]
            lastNode.pre.next = new ConsumerNode<>(treeSet::add);

            // 开始处理
            handleStage(data, stage);

            System.out.println("------> Current Stage: shuffle[sort] => data");
            data.clear();
            data.addAll(treeSet);
        } else if (lastNode instanceof DistinctNode) {
            // HashSet代表了接下来的 去重Shuffle
            HashSet<In> hashSet = new HashSet<>();

            // 切换Stage最后一个Node为ConsumerNode[添加结果到hashSet]
            lastNode.pre.next = new ConsumerNode<>(hashSet::add);

            // 开始处理
            handleStage(data, stage);

            System.out.println("------> Current Stage: shuffle[distinct] => data");
            data.clear();
            data.addAll(hashSet);
        } else {
            // 除了Sort/distinct外，可能你还有其他shuffle需求，在else处修改
            throw new IllegalArgumentException(
                    "No such type Node[" + lastNode + "]! " +
                            "Shuffle Node must be in [DistinctNode,SortNode]!"
            );
        }
    }

    /**
     * 处理 Stage
     */
    private <A> void handleStage(Collection<A> list, Stage<?> stage) {
        for (A element : list) {
            handleStageNode(element, stage.node);
        }
        System.out.println("------> Current Stage: map over");
    }

    /**
     * 递归处理Node后续所有节点
     */
    private <A, B> void handleStageNode(A element, Node<B> node) {
        if (node != null) {
            if (node instanceof FunctionNode) {
                FunctionNode<A, B> functionNode = (FunctionNode<A, B>) node;
                B apply = functionNode.function.apply(element);

                handleStageNode(apply, node.next);
            } else if (node instanceof FlatFunctionNode) {
                FlatFunctionNode<A, B> flatFunctionNode = (FlatFunctionNode<A, B>) node;
                Iterable<B> iter = flatFunctionNode.flatFunction.apply(element);
                for (B b : iter) {
                    handleStageNode(b, node.next);
                }
            } else if (node instanceof PredicateNode) {
                PredicateNode<A> predicateNode = (PredicateNode<A>) node;
                boolean test = predicateNode.predicate.test(element);
                if (test) {
                    handleStageNode(element, node.next);
                }
            } else if (node instanceof ConsumerNode) {
                ConsumerNode<A> consumerNode = (ConsumerNode<A>) node;
                consumerNode.consumer.accept(element);
            } else {
                throw new IllegalArgumentException(
                        "No such type Node[" + node + "]! " +
                                "Map Node must be in [FunctionNode,FlatFunctionNode,PredicateNode,ConsumerNode]!"
                );
            }
        }
    }

}

3.4 Test

  • Person
    public class Person {
    String name;
    int age;
    String address;

    Person(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }
}
  • Test1 不会被触发
    LazyChainCollection.valueOf(
        "1,2,4",
        "2,6",
        "3,2,8,10",
        "4,8"
)
.flatMap(str -> Arrays.asList(str.split(",")))
.map(c -> Integer.parseInt(c))
.map(i -> i * i)
.filter(i2 -> i2 > 10)
.sort((o1, o2) -> o2 - o1)
  • Test 2 会被触发
    LazyChainCollection.valueOf(
        "xiaowang,26,chongqing",
        "XIAOMING,18,beijing",
        "zhongsi,26,beijing",
        "xiaoli,a2x7,chengdu",
        "ZHANGSAN,16,guangzhou",
        "hanhan,19,chongqing",
        "LISI,23,changsha",
        "lisi,29,shanghai"
).map(line -> line.toLowerCase())
.filter(line -> !line.startsWith("xiao"))
.flatMap(line -> {
    List<Person> personList = new ArrayList<>();

    try {
        String[] fields = line.split(",");
        String name = fields[0];
        int age = Integer.parseInt(fields[1]);
        String address = fields[2];

        // 添加一个过滤条件
        if (age > 18) {
            personList.add(new Person(name, age, address));
        }
    } catch (NumberFormatException e) {
        // int 解析异常，不要该数据，直接忽略
        // e.printStackTrace();
    }

    return personList;
})
.sort((p1, p2) -> p2.age - p1.age)
.map(p -> p.name.toUpperCase())
.distinct()
.collect()
.forEach(System.out::println);
蒋含竹
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Java容器
animatelife的博客
04-13 443
Java容器
Streamlit 讲解专栏（九）：深入探索布局和容器
最新发布
蓝色是天的博客
08-14 7406
欢迎来到《最全Streamlit教程》系列的新篇章！本篇博文将深入研究 Streamlit 的布局和容器，为您呈现一个精彩的界面设计世界。从侧边栏到选项卡，再到折叠面板，我们将探索如何通过 st.sidebar、st.columns、st.tabs 和 st.expander 等组件，实现交互元素的巧妙排布。同时，我们还将介绍 st.container 和 st.empty 的使用，让您能够更好地管理和组织应用中的内容。通过本文，您将掌握如何创造出独特、富有动感的界面，为您的 Streamlit 应用注入新
Stream流运算和链式编程
市民景先生
03-16 914
官方概念：支持顺序和并行操作的一系列元素。 Stream文档中方法很多都是函数式接口，所以在写的时候可以通过lambda表达式 步骤 步骤1.把集合转换成流 步骤2.进行计算 Stream不会存储东西，只能计算，相当于简便了我们命平时写for、if等计算和判断的代码 ...
Stream流学习记录
VVAIVG的博客
04-03 739
Stream流的学习记录
Java的惰性初始化——代码实例
q19149的博客
04-02 472
Java的惰性初始化 代码实例 编译器不会简单地为每一个引用都创建默认对象。否则会增加不必要的负担，如果要初始化这些引用，可以在下列位置进行： 在定义对象的地方，这意味着它将在构造器调用之前调用。 在类的构造器中。 就在正要使用这些对象之前。在生成对象不值得及不必每次都生成对象的情况下，这种方式可以减少不必要的负担。 使用实例初始化。 这里我们主要讲惰性初始化，也就是上面的第三条。 《Thin...
Java8的Stream流详解
开心博客
09-29 492
首先，Stream流有一些特性： Stream流不是一种数据结构，不保存数据，它只是在原数据集上定义了一组操作。 这些操作是惰性的，即每当访问到流中的一个元素，才会在此元素上执行这一系列操作。 Stream不保存数据，故每个Stream流只能使用一次。 关于应用在Stream流上的操作，可以分成两种：Intermediate(中间操作)和Terminal(终止操作)。中间操作的返回结果都是Stream，故可以多个中间操作叠加；终止操作用于返回我们最终需要的数据，只能有一个终止操作。至于哪些方法是中间操作，哪
node.js入门教程（适合小白、2020年4月录制）
04-13
简单的说 Node.js 就是运行在服务端的 JavaScript。Node.js 是一个基于Chrome JavaScript 运行时建立的一个平台。Node.js是一个事件驱动I/O服务端JavaScript环境，基于Google的V8引擎，V8引擎执行Javascript的速度非常快，性能非常好。本课程主要讲解node.js 的基础语法
java8 stream中的惰性求值
qq_44761854的博客
03-18 565
https://blog.csdn.net/qq_32961235/article/details/80080980
关于java新特性.stream()链式编程的常用点汇总
o_nianchenzi_o的博客
07-01 1279
1.Java8对List集合对象某个字段进行排序 （1）单一属性排序 // 根据年龄倒叙，不写reversed()，默认升序 List<StudentInfo> collect = studentList.stream().sorted(Comparator.comparing(StudentInfo::getAge).reversed()).collect(Collectors.toList()); //排序后输出 StudentInfo.printStudents(studentsSor
Stream流式惰性计算
lonelyVM的博客
07-26 561
要求是编写一个能输出斐波拉契数列（Fibonacci）的LongStream： 因为Java的范型不支持基本类型，所以我们无法用Stream<long>这样的类型，会发生编译错误。为了保存long，只能使用Stream<Long>，但这样会产生频繁的装箱、拆箱操作。 为了提高效率，Java标准库提供了IntStream、LongStream和DoubleStream这三种使用基本类型的Stream，它们的使用方法和范型Stream没有大的区别 public class Main {
Java不可变集合与Stream流
赵广陆
09-30 1374
目录 1 可变参数 2 创建不可变集合 3 Stream流 3.1 体验Stream流 3.2 Stream流的常见生成方式 3.3 Stream流中间操作方法 3.4 Stream流终结操作方法 3.5 Stream流的收集操作 3.6 Stream流综合练习 1 可变参数 可变参数介绍 可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了 方法的参数类型已经确定,个数不确定,我们可以使用可变参数 可变参数定义格式
java-一道面试题（链式+stream编程）
感性企鹅的专栏
05-08 455
题目要求：一分钟内完成此题，只能用一行代码实现。 现在有5个用户，筛选： 1、ID必须是偶数 2、年龄必须大于23岁 3、用户名转换为大写 4、用户名字母倒排序 5、只输出一个用户 public class MyTest { User user1 = new User(1, "AB", 24); User user2 = new User(2, "cd", 25); User user3 = new User(3, "ef", 23); List<User> list = Arra.
链式编程stream()
weixin_43260335的博客
10-08 194
新时代的程序员必须掌握：Lambda和Stream()流，简化代码极为方便 打印用户 年龄>15 倒序 姓名大写 输出两个 import java.util.Arrays; import java.util.List; public class Stream_user { public static void main(String[] args) { User a = new User(1, 14, "a"); User b = new User(2.
java8 惰性求值原理_Java8 Stream流使用及其基本原理
weixin_39531834的博客
02-28 714
Stream流，是对集合对象操作的增强基本使用比如有一个Person类的集合：List personList，可以通过stream()对集合中的元素进行操作，下面的操作流程可以归纳为 过滤-映射-收集。List personIdList = personList.stream()//选出年龄大于20的Person对象.filter(person -> person.getAge() >...
Java8 Stream（一）：Stream概述特点
周帅傅
01-30 1624
Java8 Stream流概述、特点
初学线性回归--R语言
weixin_44282033的博客
09-16 1016
链式编程(Java写法)
热门推荐
非淡泊无以明志 非宁静无以致远
01-02 2万+
在我们编写代码过程中听到过很多说法 如:面向切面编程，函数式编程，面向对象编程，泛式编程等等 接着我来说下链式编程 普通： 　　1：维护性强 　　2：对方法的返回类型无要求 　　3：对程序员的业务要求适中 链式： 　　1：编程性强 　　2：可读性强 　　3：代码简洁 　　4：对程序员的业务能力要求高 　　5：不太利于代码调试 　　在ｊａｖａ中String
java stream实现 list根据另一个list排序
05-31
使用Java 8中的Stream API，同样可以实现根据另一个List排序的功能。可以使用Stream的sorted()方法结合Comparator自定义排序规则来实现： ```java List<String> sortList = new ArrayList<>(); sortList.add("apple"); sortList.add("banana"); sortList.add("orange"); sortList.add("pear"); List<String> referenceList = new ArrayList<>(); referenceList.add("pear"); referenceList.add("apple"); referenceList.add("banana"); referenceList.add("orange"); List<String> sortedList = sortList.stream() .sorted(Comparator.comparingInt(referenceList::indexOf)) .collect(Collectors.toList()); System.out.println(sortedList); ``` 上述代码中，使用Stream的sorted()方法对需要排序的List进行排序，其中传入了一个自定义的Comparator对象，该对象的compare()方法中根据排序参照的List中元素的索引来比较需要排序的List中元素的大小关系，最终实现了按照参照List中元素的顺序进行排序的功能。最后通过collect()方法将排序后的元素重新收集到一个List中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值