«

Java中集合的迭代方式是什么

时间:2024-7-12 11:14     作者:韩俊     分类: Java


本文小编为大家详细介绍“Java中集合的迭代方式是什么”,内容详细,步骤清晰,细节处理妥当,希望这篇“Java中集合的迭代方式是什么”文章能帮助大家解决疑惑,下面跟着小编的思路慢慢深入,一起来学习新知识吧。

    集合的迭代

    流使得程序员得以站在更高的抽象层次上对集合进行操作。

    传统的迭代方法

    直接看代码:

            List<Dog> dogs = new ArrayList<>();
            dogs.add(new Dog("大黄", 2));
            dogs.add(new Dog("小黑", 3));
            dogs.add(new Dog("小哈",1));
    
            //最原始的 for 循环
            for (int i = 0; i < dogs.size(); i++) {
                System.out.println(dogs.get(i));
            }
            //增强 for 循环
            for (Dog dog1 : dogs) {
                System.out.println(dog1);
            }
            //使用迭代器
            Iterator<Dog> it = dogs.iterator();
            while (it.hasNext()) {
                Dog dog2 = it.next();
                System.out.println(dog2);
            }

    说明:
    增强 for 循环,只是一个语法糖(Syntax Sugar),它的本质就是使用 迭代器进行迭代。所以在,增强 for 循环里面,无法修改集合。这里也可以使用 while 来迭代 ,但是 while 还没有 for 循环方便呢。

    Stream 和 Lambda 进行集合迭代

    //使用 Stream 和 Lambda 表达式进行迭代
    dogs.stream().forEach(System.out::println);
    
    //只使用 Lambda 表达式进行迭代
    dogs.forEach(System.out::println);

    这样看似乎是下面这个更简单点,但是 Stream 的作用远不止于此,它可以将多个操作,串联起来,使用 链式编程的方法,实现很复杂的操作。下面这个只是使用 Lambda 进行遍历操作而已。

    流和集合

    流(Stream)是一种内部迭代方式,可以通过集合直接获取到相应的 流(Stream),例如:

    Stream<Dog> stream = dogs.stream();
    ,当然了也可以从流获取集合
    List<Dog> dogs = stream.collect(Collectors.toList());
    .。这里只是以 List 集合为例,Map 和 Set 也是可以的。准确的说,流 开启了操作集合的新的方法,使用函数式编程来重构以前的代码,也是非常的不错的。

    这个只举一个简单的例子:就可以看出使用 Stream 是多么的方便了。
    有一个集合里面存储了 数字和非数字字符串,现在想要求这些数字字符串的和:
    “1” “2” “3” “a” “4” “5” “c” “6” “7” “8” “d” “9” "10"

    方式一:推荐使用,采用函数式编程(链式编程):

    List<String> mixStr = new ArrayList<String>(Arrays.asList("1", "2", "3", "a", "4", "5", "c", "6", "7", "8", "d", "9", "10"));
    int sumary = mixStr.
            stream().
            filter(s->s.matches("^[0-9]*$")).
            map(Integer::parseInt).
            reduce(0, (acc, e)->acc+e);
    System.out.println("方式一(推荐):"+sumary);
    
    //有时候,一行太长了,可以分开写,这样增加了可读性。
    sumary = mixStr.stream().filter(s->s.matches("^[0-9]*$")).map(Integer::parseInt).reduce(0, (acc, e)->acc+e);

    方式二:不推荐使用,采用函数式编程(不使用链式编程):

    Stream<String> filter = mixStr.stream().filter(s->s.matches("^[0-9]*$"));
    Stream<Integer> map = filter.map(Integer::parseInt);
    Integer reduce = map.reduce(0, (acc, e)->acc+e);
    System.out.println(""+reduce);
    System.out.println("方式二(不推荐):"+reduce);

    这样做增加了很多繁琐的步骤和临时变量,这和函数式编程的思想是相反的,但是这样可以帮助我们学习,理解函数式编程。

    方式三:传统的集合操作

    sumary = 0;
    for (String s : mixStr) {
        if (s.matches("^[0-9]*$")) {
            sumary += Integer.parseInt(s);
        }
    }
    System.out.println("传统的方式:"+sumary);

    这样看似乎,还是传统的方式比较简单,可能和这个例子有关,但是仔细分析还是能看出流和集合操作的差异,在流中每一步都是明确的,而且每一步(中间操作,不是终结操作,这个可以自己了解)都是返回一个流,而集合却将这些都耦合到一起了,所以很难修改,而流就很简单了,替换一个中间步骤是很简单的。
    例如,只是将reduce过程去掉,换成 forEach 遍历,这需要改变最后一个操作即可,是不是很方便。

    //流的用处很多。
    mixStr.stream().filter(s->s.matches("^[0-9]*$")).map(Integer::parseInt).forEach(System.out::print);

    运行截图:

    标签: java

    热门推荐