超高效率的处理 两个集合

简介: 超高效率的处理 两个集合

超高效率的处理 两个集合

一种是for循环方式,一种是 stream 方式;在处理数据量很大是会相差上千倍。


image.png


处理数据量大时,使用stream 方式,很小的数据用for就可以;

处理100000条数据处理结果:

image.png

处理100条数据处理结果:

image.png

示例代码:kotlin

import java.util.*
import java.util.stream.Collectors
import kotlin.collections.ArrayList
class Test {
    companion object {
        private var i0 = 0
        private var i02 = 0
        private var i1 = 0
        @JvmStatic
        fun main(args: Array<String>) {
            println("---------START---------")
            val i=99999
//              val i = 99
            val r = Random()
            val sList = ArrayList<String>()
            for (i in 0..i) {
                sList.add(java.lang.String.valueOf(r.nextInt(500000) + 1))
            }
            val cList = ArrayList<String>()
            for (i in 0..i) {
                cList.add((i + 1).toString())
            }
            val s1 = System.currentTimeMillis()
            doubleForMethod(sList, cList)
            val e1 = System.currentTimeMillis()
            println("FOR--->" + (e1 - s1) + "ms ---->" + i0)
            val s2 = System.currentTimeMillis()
            streamMethod(sList, cList)
            val e2 = System.currentTimeMillis()
            println("STREAM--->" + (e2 - s2) + "ms ---->" + i1)
            val s3 = System.currentTimeMillis()
            doubleForMethod2(sList, cList)
            val e3 = System.currentTimeMillis()
            println("FOR 2 --->" + (e3 - s3) + "ms ---->" + i02)
            println("----------END--------")
        }
        private fun streamMethod(sList: List<String>, aList: List<String>) {
            // 把班级列表转成map,那么班级id就是唯一的id
            val noClassMap: Map<String, String> =
                aList.stream().collect(Collectors.toMap({ t -> t }) { t -> t })
            sList.stream().forEach { h: String ->
                if (noClassMap.containsKey(h)) {
                    i1++
                }
            }
        }
        // for双层循环的方式
        private fun doubleForMethod(sList: List<String>, aList: List<String>) {
            for (i in sList.indices) {
                val student = sList[i]
                for (j in aList.indices) {
                    val noClass = aList[j]
                    if (student == noClass) {
                        i0++
                    }
                }
            }
        }
        // for双层循环的方式
        private fun doubleForMethod2(sList: List<String>, aList: List<String>) {
            sList.forEach {
                if (aList.contains(it)) {
                    i02++
                }
            }
        }
    }
}


示例代码:Java

public class Run {
    private static  int i0=0;
    private static  int i1=0; 
    public static void main(String[] args) {
        Random r = new Random();
        ArrayList sList = new ArrayList<String>();
        for (int i = 0; i < 100000; i++) {
            sList.add(String.valueOf(r.nextInt(500000) + 1));
        }
        ArrayList cList = new ArrayList<String>();
        for (int i = 0; i < 100000; i++) {
            cList.add(String.valueOf(i + 1));
        }
        long s1 = System.currentTimeMillis();
        doubleForMethod(sList, cList);
        long e1 = System.currentTimeMillis();
        System.out.println("FOR--->" + (e1 - s1) + "---->" + i0);
        long s2 = System.currentTimeMillis();
        streamMethod(sList, cList);
        long e2 = System.currentTimeMillis();
        System.out.println("STREAM--->" + (e2 - s2) + "---->" + i1);
    // for双层循环的方式
    private static void doubleForMethod(List<String> sList, List<String> fList) {
        for (int i = 0; i < sList.size(); i++) {
            String student = sList.get(i);
            for (int j = 0; j < fList.size(); j++) {
                String noClass = fList.get(j);
                if (student.equals(noClass)) {
                    i0++;
                }
            }
        }
    }
    private static void streamMethod(List<String> sList, List<String> fList) {
        // 把班级列表转成map,那么班级id就是唯一的id
        Map<String, String> noClassMap = fList.stream().collect(Collectors.toMap(t -> t, t -> t));
        sList.stream().forEach(h -> {
            if (noClassMap.containsKey(h)) {
                i1++;
            }
        });
    }
}
目录
相关文章
|
6月前
|
存储 安全 Java
深度解析ArrayList:灵活高效的动态数组实现
在 Java 集合框架中,ArrayList 是一个常用而强大的类,它提供了动态数组的实现,允许在运行时动态调整数组的大小。 ArrayList 是 List 接口的实现类,基于动态数组的数据结构。它可以存储任意类型的对象,并提供了丰富的方法,包括添加、删除、遍历等,使其在各种场景下都能发挥重要作用。
135 1
深度解析ArrayList:灵活高效的动态数组实现
|
6天前
|
Java 数据处理 API
JDK 21中的序列集合:有序数据处理的新篇章
JDK 21引入了序列集合(Sequenced Collections),这是一种维护元素插入顺序的新型集合。本文介绍了序列集合的概念、特性及其应用场景,如事件日志记录、任务调度和数据处理。通过保持插入顺序和高效的遍历方法,序列集合为开发者提供了更直观和易用的API。
|
24天前
|
Java 开发者
在Java集合世界中,Set以其独特的特性脱颖而出,专门应对重复元素
在Java集合世界中,Set以其独特的特性脱颖而出,专门应对重复元素。通过哈希表和红黑树两种模式,Set能够高效地识别并拒绝重复元素的入侵,确保集合的纯净。无论是HashSet还是TreeSet,都能在不同的场景下发挥出色的表现,成为开发者手中的利器。
26 2
|
25天前
|
存储 数据库 索引
如何提高索引的效率和实用性
【10月更文挑战第15天】如何提高索引的效率和实用性
|
26天前
|
存储 Java 数据处理
在Java集合框架中,Set接口以其独特的“不重复”特性脱颖而出
【10月更文挑战第14天】在Java集合框架中,Set接口以其独特的“不重复”特性脱颖而出。本文通过两个案例展示了Set的实用性和高效性:快速去重和高效查找。通过将列表转换为HashSet,可以轻松实现去重;而Set的contains方法则提供了快速的元素查找功能。这些特性使Set成为处理大量数据时的利器。
16 4
|
27天前
|
Java 开发者
在Java的集合世界里,Set以其独特的特性脱颖而出,它通过“哈希魔法”和“红黑树防御”两大绝技
【10月更文挑战第13天】在Java的集合世界里,Set以其独特的特性脱颖而出。它通过“哈希魔法”和“红黑树防御”两大绝技,有效抵御重复元素的侵扰,确保集合的纯洁性和有序性。无论是“人海战术”还是“偷梁换柱”,Set都能从容应对,成为开发者手中不可或缺的利器。
30 6
|
27天前
|
缓存
在数据驱动方式中处理复杂的数据结构
【10月更文挑战第13天】 在数据驱动的开发模式中,处理复杂数据结构是一项重要任务。本文从理解特性、数据分解、选择模型、数据绑定、转换预处理、处理嵌套、性能优化、错误处理、数据验证及实际案例等方面,详细阐述了应对这一挑战的方法和策略,强调了持续学习和改进的重要性。
|
3月前
|
存储 算法
【数据结构】复杂度(长期维护)
【数据结构】复杂度(长期维护)
|
5月前
|
存储 SQL 算法
链表:一种灵活的数据存储方式
链表:一种灵活的数据存储方式
|
6月前
|
算法 程序员 编译器
【数据结构】算法效率的度量方法
【数据结构】算法效率的度量方法
71 0