JAVA获取两个数据量较大的ArrayList的交集、差集以及并集

测试说明:获取firstArrayList和secondArrayList的交集、差集以及并集。实际测试中firstArrayList数据量190000,secondArrayList数据量170000.效率比较高。此处只列出少量数据。测试代码如下:

import java.util.Set;
import java.util.List;
import java.util.HashSet;
import java.util.TreeSet;
import java.util.Iterator;
import java.util.ArrayList;
import java.util.LinkedList;

public class getSet {

    public static void main(String args[]) {
        getList();
    }

    // 获取两个ArrayList的差集、交集、去重并集(数据量大小不限制)
    private static void getList() {
        List<String> firstArrayList = new ArrayList<String>();
        List<String> secondArrayList = new ArrayList<String>();
        List<String> defectList = new ArrayList<String>();//差集List
        List<String> collectionList = new ArrayList<String>();//交集List
        List<String> unionList = new ArrayList<String>();//去重并集List
        try {
            firstArrayList.add("aaa");
            firstArrayList.add("bbb");
            firstArrayList.add("ccc");
            firstArrayList.add("ddd");

            secondArrayList.add("bbb");
            secondArrayList.add("ccc");
            secondArrayList.add("eee");
            // 获取差集
            defectList = receiveDefectList(firstArrayList, secondArrayList);
            Iterator<String> defectIterator = defectList.iterator();
            System.out.println("===================差集===================");
            while(defectIterator.hasNext()) {
                System.out.println(defectIterator.next());
            }
            // 获取交集
            collectionList = receiveCollectionList(firstArrayList, secondArrayList);
            Iterator<String> collectionIterator = collectionList.iterator();
            System.out.println("===================交集===================");
            while(collectionIterator.hasNext()) {
                System.out.println(collectionIterator.next());
            }
            // 获取去重并集
            unionList = receiveUnionList(firstArrayList, secondArrayList);
            Iterator<String> unionIterator = unionList.iterator();
            System.out.println("===================去重并集===================");
            while(unionIterator.hasNext()) {
                System.out.println(unionIterator.next());
            }
        }catch(Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * @方法描述:获取两个ArrayList的差集
     * @param firstArrayList 第一个ArrayList
     * @param secondArrayList 第二个ArrayList
     * @return resultList 差集ArrayList
     */
    public static List<String> receiveDefectList(List<String> firstArrayList, List<String> secondArrayList) {
        List<String> resultList = new ArrayList<String>();
        LinkedList<String> result = new LinkedList<String>(firstArrayList);// 大集合用linkedlist
        HashSet<String> othHash = new HashSet<String>(secondArrayList);// 小集合用hashset
        Iterator<String> iter = result.iterator();// 采用Iterator迭代器进行数据的操作
        while(iter.hasNext()){
            if(othHash.contains(iter.next())){
                iter.remove();
            }
        }
        resultList = new ArrayList<String>(result);
        return resultList;
    }

    /**
     * @方法描述:获取两个ArrayList的交集
     * @param firstArrayList 第一个ArrayList
     * @param secondArrayList 第二个ArrayList
     * @return resultList 交集ArrayList
     */
    public static List<String> receiveCollectionList(List<String> firstArrayList, List<String> secondArrayList) {
        List<String> resultList = new ArrayList<String>();
        LinkedList<String> result = new LinkedList<String>(firstArrayList);// 大集合用linkedlist
        HashSet<String> othHash = new HashSet<String>(secondArrayList);// 小集合用hashset
        Iterator<String> iter = result.iterator();// 采用Iterator迭代器进行数据的操作
        while(iter.hasNext()) {
            if(!othHash.contains(iter.next())) {
                iter.remove();
            }
        }
        resultList = new ArrayList<String>(result);
        return resultList;
    }

    /**
     * @方法描述:获取两个ArrayList的去重并集
     * @param firstArrayList 第一个ArrayList
     * @param secondArrayList 第二个ArrayList
     * @return resultList 去重并集ArrayList
     */
    public static List<String> receiveUnionList(List<String> firstArrayList, List<String> secondArrayList) {
        List<String> resultList = new ArrayList<String>();
        Set<String> firstSet = new TreeSet<String>(firstArrayList);
        for(String id : secondArrayList) {
            // 当添加不成功的时候 说明firstSet中已经存在该对象
            firstSet.add(id);
        }
        resultList = new ArrayList<String>(dawjidSet);
        return resultList;
    }
}

打印结果:

===================差集===================
aaa
ddd
===================交集===================
bbb
ccc
=================去重并集==================
aaa
bbb
ccc
ddd
eee

说明,取差集指的是取firstArrayList中存在但secondArrayList中不存在的数据集

时间: 2024-10-24 11:24:22

JAVA获取两个数据量较大的ArrayList的交集、差集以及并集的相关文章

Java模拟数据量过大时批量处理数据实现

代码: import java.util.ArrayList; import java.util.List; /** * 模拟批量处理数据 * 当数据量过大过多导致超时等问题可以将数据进行分批处理 * @author [] * */ public class BatchUtil { public static void listBatchUtil(List<Integer> lists) { System.out.println(lists); // 定义批处理的数据数量(即批处理条件) in

es 在数据量很大的情况下(数十亿级别)如何提高查询效率啊?

面试题es 在数据量很大的情况下(数十亿级别)如何提高查询效率啊?面试官心理分析这个问题是肯定要问的,说白了,就是看你有没有实际干过 es,因为啥?其实 es 性能并没有你想象中那么好的.很多时候数据量大了,特别是有几亿条数据的时候,可能你会懵逼的发现,跑个搜索怎么一下 5~10s,坑爹了.第一次搜索的时候,是 5~10s,后面反而就快了,可能就几百毫秒.你就很懵,每个用户第一次访问都会比较慢,比较卡么?所以你要是没玩儿过 es,或者就是自己玩玩儿 demo,被问到这个问题容易懵逼,显示出你对

MongoDB数据量较大时如何构建索引--减少业务最少影响

在数据量较大或请求量较大,直接建立索引对性能有显著影响时,可以利用复制集(数据量较大时一般为线上环境,使用复制集为必然选择或者使用分片.)中部分机器宕机不影响复制集工作的特性,继而建立索引. 备注:添加索引的表使用WT引擎,数据量有1.5亿左右. 1. 副本集配置参数 节点1: $ more shard1.conf dbpath=/data/users/mgousr01/mongodb/dbdata/shard1_1 logpath=/data/users/mgousr01/mongodb/lo

针对数据量较大的表,需要进行跨库复制,采用navcat 实现sqlite数据库跨数据库的数据表迁移 [转载]

2014年12月13日 14:36 新浪博客 (转自http://www.cnblogs.com/nmj1986/archive/2012/09/17/2688827.html) 需求: 有两个不同的SQLite数据库 A.B,需要将B数据库中的表复制到A数据库中去,数据量较小的时候,可以在数据库可视化工具Navicat中直接将表导成.sql文件,然后将sql文件在另一个数据库运行即可.但是当数据量较大时,这样操作会丢失一部分数据.因此针对这种情况可采用下述方法: 解决办法: (1)使用软件:S

关于android中gridview数据量很大的时候,在加载gridview时会出现卡顿的现象

好的解决办法就是先加载一定数量的数据,然后在最下方提示正在加载! 动态加载就是把放入adapter中的数据分好几次加载.在用户拖动gridview时再加载一定的数据,和sina微博的客户端类似. 给gridview添加OnScrollListener监听事件默认会覆盖下面两个方法: 下面列举个列子: <com.ui.widget.LazyGridView xmlns:android="http://schemas.android.com/apk/res/android" andr

WCF入门(一)--Request Entity Too large 传输的数据量过大

通过WCF进行数据的查询或者添加的时候,如果数据量过大,一般会报出如下的错误: 1.已超过传入消息(65536)的最大消息大小配额.若要增加配额,请使用相应绑定元素上的MaxReceivedMessageSize 属性. 2.远程服务器返回了意外反应(413)Request Entity too large. 3.远程服务器返回了意外反应(400)Bad Request. 具体的解决方案: 服务端返回数据给客户端报错 在客户端的配置文件中,主要修改maxReceivedMessageSize <

关于数据量很大的题目

这段时间写多校,碰到很多数据量很大的题目,有的有规律,有的需要一定的预处理以及一些好玩的算法.那么怎么区分呢?首先看下题目给的限时,如果比较多,那么就需要一定预处理啦:再就是看下rank,如果一道题目突然很多人短时间写出来,一定是规律题,而且是巧妙的规律题.在说一下关于贡献这个东西,有些题目需要枚举,我们在枚举的时候,通常题目表面信息给的枚举是满足不了时间复杂度的,所以我们需要选取合适的枚举对象..这个也很重要.

第9条:用生成器表达式来改写数据量较大的列表推导式

核心知识点: (1)当输入的数据量较大时,列表推导可能会因为占用太多内存而出问题. (2)由生成器表达式所返回的迭代器,可以逐次产生输出值,从而避免内存用量问题. (3)把某个生成器表达式所返回的迭代器,放在另一个生成器表达式的for子表达式中,即可将二者结合起来. (4)串在一起的生成器表达式执行速度很快. 列表推导式的缺点是:在推导过程中,对于输入序列中的每个值来说,可能都要创建仅含一项元素的全新列表. 当输入的数据比较少时,不会出任何问题,但如果输入的数据非常多,那么可能会消耗大量内存,并

斯坦福大学公开课机器学习:machine learning system design | data for machine learning(数据量很大时,学习算法表现比较好的原理)

下图为四种不同算法应用在不同大小数据量时的表现,可以看出,随着数据量的增大,算法的表现趋于接近.即不管多么糟糕的算法,数据量非常大的时候,算法表现也可以很好. 数据量很大时,学习算法表现比较好的原理: 使用比较大的训练集(意味着不可能过拟合),此时方差会比较低:此时,如果在逻辑回归或者线性回归模型中加入很多参数以及层数的话,则偏差会很低.综合起来,这会是一个很好的高性能的学习算法. 原文地址:https://www.cnblogs.com/chenwenyan/p/8326027.html