超高效率的处理 两个集合

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

超高效率的处理 两个集合

一种是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++;
            }
        });
    }
}
目录
相关文章
|
1月前
|
Java 数据处理 API
JDK 21中的序列集合:有序数据处理的新篇章
JDK 21引入了序列集合(Sequenced Collections),这是一种维护元素插入顺序的新型集合。本文介绍了序列集合的概念、特性及其应用场景,如事件日志记录、任务调度和数据处理。通过保持插入顺序和高效的遍历方法,序列集合为开发者提供了更直观和易用的API。
|
2月前
|
存储 数据库 索引
如何提高索引的效率和实用性
【10月更文挑战第15天】如何提高索引的效率和实用性
|
2月前
|
存储 Java 数据处理
在Java集合框架中,Set接口以其独特的“不重复”特性脱颖而出
【10月更文挑战第14天】在Java集合框架中,Set接口以其独特的“不重复”特性脱颖而出。本文通过两个案例展示了Set的实用性和高效性:快速去重和高效查找。通过将列表转换为HashSet,可以轻松实现去重;而Set的contains方法则提供了快速的元素查找功能。这些特性使Set成为处理大量数据时的利器。
21 4
|
2月前
|
Java 开发者
在Java集合世界中,Set以其独特的特性脱颖而出,专门应对重复元素
在Java集合世界中,Set以其独特的特性脱颖而出,专门应对重复元素。通过哈希表和红黑树两种模式,Set能够高效地识别并拒绝重复元素的入侵,确保集合的纯净。无论是HashSet还是TreeSet,都能在不同的场景下发挥出色的表现,成为开发者手中的利器。
28 2
|
4月前
|
存储 算法
【数据结构】复杂度(长期维护)
【数据结构】复杂度(长期维护)
|
7月前
|
存储 安全 Java
集合技术文章
集合技术文章
|
7月前
|
算法 程序员 编译器
【数据结构】算法效率的度量方法
【数据结构】算法效率的度量方法
89 0
|
7月前
|
存储 安全 算法
|
存储 运维 监控
转:算法与数据结构在监控软件中的优势与应用场景
算法和数据结构在监控软件中可以提高数据处理和查询的效率,实现准确的目标检测和跟踪,优化资源利用和提供实时的数据分析和决策支持。这些有助于提升监控软件的性能、准确性和实用性。
102 0
|
机器学习/深度学习 存储 监控
转:排列组合算法在监控软件中的优势、复杂性与应用场景
排列组合算法在监控软件中可能用于处理一些组合与排列问题,例如处理多个元素的组合方式或排列顺序。它在一些特定场景下具有一定的优势和适用性,但也要注意其复杂性。
105 0