专栏首页小灰灰Java中两种分页遍历的使用姿势
原创

Java中两种分页遍历的使用姿势

Java中两种分页遍历的使用姿势

在日常开发中,分页遍历迭代的场景可以说非常普遍了,比如扫表,每次捞100条数据,然后遍历这100条数据,依次执行某个业务逻辑;这100条执行完毕之后,再加载下一百条数据,直到扫描完毕

那么要实现上面这种分页迭代遍历的场景,我们可以怎么做呢

本文将介绍两种使用姿势

  • 常规的使用方法
  • 借助Iterator的使用姿势

<!-- more -->

1. 数据查询模拟

首先mock一个分页获取数据的逻辑,直接随机生成数据,并且控制最多返回三页

public static int cnt = 0;

private static List<String> randStr(int start, int size) {
    ++cnt;
    if (cnt > 3) {
        return Collections.emptyList();
    } else if (cnt == 3) {
        cnt = 0;
        size -= 2;
    }

    System.out.println("======================= start to gen randList ====================");
    List<String> ans = new ArrayList<>(size);
    for (int i = 0; i < size; i++) {
        ans.add((start + i) + "_" + UUID.randomUUID().toString());
    }
    return ans;
}

2. 基本实现方式

针对这种场景,最常见也是最简单直观的实现方式

  • while死循环
  • 内部遍历
private static void scanByNormal() {
    int start = 0;
    int size = 5;
    while (true) {
        List<String> list = randStr(start, size);
        for (String str : list) {
            System.out.println(str);
        }

        if (list.size() < size) {
            break;
        }
        start += list.size();
    }
}

3. 迭代器实现方式

接下来介绍一种更有意思的方式,借助迭代器的遍历特性来实现,首先自定义一个通用分页迭代器

public static abstract class MyIterator<T> implements Iterator<T> {
    private int start = 0;
    private int size = 5;

    private int currentIndex;
    private boolean hasMore = true;
    private List<T> list;

    public MyIterator() {
    }

    @Override
    public boolean hasNext() {
        if (list != null && list.size() > currentIndex) {
            return true;
        }

        // 当前的数据已经加载完毕,尝试加载下一批
        if (!hasMore) {
            return false;
        }

        list = load(start, size);
        if (list == null || list.isEmpty()) {
            // 没有加载到数据,结束
            return false;
        }

        if (list.size() < size) {
            // 返回条数小于限制条数,表示还有更多的数据可以加载
            hasMore = false;
        }

        currentIndex = 0;
        start += list.size();
        return true;
    }

    @Override
    public T next() {
        return list.get(currentIndex++);
    }

    public abstract List<T> load(int start, int size);
}

接下来借助上面的迭代器可以比较简单的实现我们的需求了

private static void scanByIterator() {
    MyIterator<String> iterator = new MyIterator<String>() {
        @Override
        public List<String> load(int start, int size) {
            return randStr(start, size);
        }
    };

    while (iterator.hasNext()) {
        String str = iterator.next();
        System.out.println(str);
    }
}

那么问题来了,上面这种使用方式比前面的优势体现再哪儿呢?

  • 双层循环改为单层循环

接下来接入重点了,在jdk1.8引入了函数方法 + lambda之后,又提供了一个更简洁的使用姿势

public class IteratorTestForJdk18 {

    @FunctionalInterface
    public interface LoadFunc<T> {
        List<T> load(int start, int size);
    }

    public static class MyIterator<T> implements Iterator<T> {
        private int start = 0;
        private int size = 5;

        private int currentIndex;
        private boolean hasMore = true;
        private List<T> list;
        private LoadFunc<T> loadFunc;

        public MyIterator(LoadFunc<T> loadFunc) {
            this.loadFunc = loadFunc;
        }

        @Override
        public boolean hasNext() {
            if (list != null && list.size() > currentIndex) {
                return true;
            }

            // 当前的数据已经加载完毕,尝试加载下一批
            if (!hasMore) {
                return false;
            }

            list = loadFunc.load(start, size);
            if (list == null || list.isEmpty()) {
                // 没有加载到数据,结束
                return false;
            }

            if (list.size() < size) {
                // 返回条数小于限制条数,表示还有更多的数据可以加载
                hasMore = false;
            }

            currentIndex = 0;
            start += list.size();
            return true;
        }

        @Override
        public T next() {
            return list.get(currentIndex++);
        }
    }
}

在jdk1.8及之后的使用姿势,一行代码即可

private static void scanByIteratorInJdk8() {
    new MyIterator<>(IteratorTestForJdk18::randStr)
        .forEachRemaining(System.out::println);
}

这次对比效果是不是非常显眼了,从此以后分页迭代遍历再也不用冗长的双重迭代了

II. 其他

1. 一灰灰Bloghttps://liuyueyi.github.io/hexblog

一灰灰的个人博客,记录所有学习和工作中的博文,欢迎大家前去逛逛

2. 声明

尽信书则不如,以上内容,纯属一家之言,因个人能力有限,难免有疏漏和错误之处,如发现bug或者有更好的建议,欢迎批评指正,不吝感激

原创声明,本文系作者授权云+社区发表,未经许可,不得转载。

如有侵权,请联系 yunjia_community@tencent.com 删除。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Java中两种分页遍历的使用姿势

    在日常开发中,分页遍历迭代的场景可以说非常普遍了,比如扫表,每次捞100条数据,然后遍历这100条数据,依次执行某个业务逻辑;这100条执行完毕之后,再加载下一...

    一灰灰blog
  • 使用 matplotlib 的两种姿势

    熊猫本次用的是 Anaconda 的 jupyter notebook 编写的本文代码。今天用到的库都是已经集成好的,无须另行安装。每个库的版本号我列在下方了。...

    数据山谷
  • 在腾讯云中使用 knative 的两种姿势

    TCBR 是腾讯云的基于微信生态的 Serverless 应用部署神器,底层基于 knative。

    谢正伟
  • IntelliJ IDEA 最常用配置详细图解,新手入门必看!

    刚刚使用IntelliJ IDEA 编辑器的时候,会有很多设置,会方便以后的开发,磨刀不误砍柴工。

    Java技术栈
  • php文件包含漏洞分类目录文章标签友情链接联系我们

    用户1246209
  • Java 开发中如何正确的踩坑

    我们的做法是,要用最好的人。我一直都认为研发本身是很有创造性的,如果人不放松,或不够聪明,都很难做得好。你要找到最好的人,一个好的工程师不是顶10个,是顶100...

    好好学java
  • IntelliJ IDEA 最常用配置详细图解,新手入门必看!

    刚刚使用IntelliJ IDEA 编辑器的时候,会有很多设置,会方便以后的开发,磨刀不误砍柴工。

    java思维导图
  • IntelliJ IDEA 最常用配置详细图解,新手入门必看!

    如果你是初学者,或者是自学者!你可以加小编微信(xxf960326)!小编可以给你学习上,工作上的一些建议以可以给你(免费)提供学习资料!最重要我们还可以交个朋...

    Java学习
  • Java开发中如何正确踩坑

    之前在这个手册刚发布的时候看过一遍,当时感觉真是每个开发者都应该必读的一本手册,期间还写过一篇关于日志规约的文章:《下一个项目为什么要用 SLF4J》,最近由于...

    Java团长

扫码关注云+社区

领取腾讯云代金券