超高效率的处理 两个集合

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

超高效率的处理 两个集合

一种是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++;
            }
        });
    }
}
目录
相关文章
|
NoSQL 数据可视化 JavaScript
漂亮又好用的Redis可视化客户端汇总
漂亮又好用的Redis可视化客户端汇总
9705 0
漂亮又好用的Redis可视化客户端汇总
|
异构计算 内存技术
FPGA - 7系列 FPGA内部结构之SelectIO -08- 高级逻辑资源之OSERDESE2(二)
FPGA - 7系列 FPGA内部结构之SelectIO -08- 高级逻辑资源之OSERDESE2
720 0
FPGA - 7系列 FPGA内部结构之SelectIO -08- 高级逻辑资源之OSERDESE2(二)
|
JavaScript Java 测试技术
基于SpringBoot+Vue+uniapp的新媒体视域下的中国古诗词展演的详细设计和实现(源码+lw+部署文档+讲解等)
基于SpringBoot+Vue+uniapp的新媒体视域下的中国古诗词展演的详细设计和实现(源码+lw+部署文档+讲解等)
136 1
|
Java
java8中使用groupingBy分组返回有序的Map
java8中使用groupingBy分组返回有序的Map
627 0
|
存储 安全 Java
SpringBoot整合SpringSecurity完整教程
SpringBoot整合SpringSecurity完整教程
SpringBoot整合SpringSecurity完整教程
|
Java 测试技术 持续交付
老司机使用CompletableFuture实现集成任务失败后自动重跑
0 老司机集成任务在Aone实验室中遇到的问题  老司机平台是一个集合了用例管理,用例执行,测试沉淀等功能的一站式集成测试平台。老司机中提供了一种名为集成任务的测试件,它一般包含一组核心的可执行用例,主要在变更发布前回归指定的接口或应用时由平台或手工触发运行。也可以在每日定时执行指定的集成任务,以实现用例与测试任务的持续集成。  集成任务用作发布前的卡点测试件时,一般是在流水线中加入Aone实验室
1576 1
老司机使用CompletableFuture实现集成任务失败后自动重跑
|
监控 安全 Java
如何查看Java进程和线程
如何查看Java进程和线程
2562 1
如何查看Java进程和线程
|
XML Java 测试技术
Mybatis-Plus字段策略FieldStrategy详解
Mybatis-Plus字段策略FieldStrategy详解
2623 0
Mybatis-Plus字段策略FieldStrategy详解
|
存储 缓存 算法
【eNSP 华为模拟器】了解一下交换机原理和基础命令
【eNSP 华为模拟器】了解一下交换机原理和基础命令
841 0
【eNSP 华为模拟器】了解一下交换机原理和基础命令