超高效率的处理 两个集合

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

超高效率的处理 两个集合

一种是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++;
            }
        });
    }
}
目录
相关文章
|
3月前
|
存储 安全 Java
深度解析ArrayList:灵活高效的动态数组实现
在 Java 集合框架中,ArrayList 是一个常用而强大的类,它提供了动态数组的实现,允许在运行时动态调整数组的大小。 ArrayList 是 List 接口的实现类,基于动态数组的数据结构。它可以存储任意类型的对象,并提供了丰富的方法,包括添加、删除、遍历等,使其在各种场景下都能发挥重要作用。
112 1
深度解析ArrayList:灵活高效的动态数组实现
|
3月前
|
测试技术
7、软件产品交付过程——所有表集合
7、软件产品交付过程——所有表集合
93 0
|
5天前
|
存储 算法
【数据结构】复杂度(长期维护)
【数据结构】复杂度(长期维护)
|
2月前
|
存储 Python
列表和字典在处理大型数据集时优势和局限性
列表和字典在处理大型数据集时优势和局限性
|
3月前
|
存储 安全 Java
集合技术文章
集合技术文章
|
3月前
|
存储 安全 算法
|
3月前
|
测试技术 API 数据格式
5、软件产品集成过程——所有表集合
5、软件产品集成过程——所有表集合
47 0
|
存储 运维 监控
转:算法与数据结构在监控软件中的优势与应用场景
算法和数据结构在监控软件中可以提高数据处理和查询的效率,实现准确的目标检测和跟踪,优化资源利用和提供实时的数据分析和决策支持。这些有助于提升监控软件的性能、准确性和实用性。
92 0
|
存储 Java 测试技术
4.3 Java数组性能优化策略:数组与集合性能对比分析
4.3 Java数组性能优化策略:数组与集合性能对比分析
133 0
|
机器学习/深度学习 存储 监控
转:排列组合算法在监控软件中的优势、复杂性与应用场景
排列组合算法在监控软件中可能用于处理一些组合与排列问题,例如处理多个元素的组合方式或排列顺序。它在一些特定场景下具有一定的优势和适用性,但也要注意其复杂性。
81 0