Java 获取两个List的交集和差集，以及应用场景

最新推荐文章于 2024-06-08 15:43:39 发布
最新推荐文章于 2024-06-08 15:43:39 发布
阅读量6.8k 收藏 2
点赞数 1
分类专栏： java
本文探讨了在一对多关系的数据库中，如何通过找出两个List对象的交集和差集来实现数据的同步更新。具体包括数据的插入、删除和修改操作，利用LinkedHashMap的特性来高效处理数据对比。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

背景介绍
在实际项目中，特别是一些管理后台类的项目，会遇到底层数据是按照一对多关系的数据表存储的管理界面。列表页是一对多关系中一对应的数据列表，二级的详情页中是一对多关系中多对应的多条数据展示。通常二级页面是能够增、删、改数据的编辑页面，在点击保存提交数据后，服务器端需要插入新增的数据，删除要删除的数据，更新改变的数据。

交集：指的是两个List对象中都有的元素。 
差集：指的是一个List对象中有，而另一个List对象中没有的元素。

转化为一般问题

页面保存数据详情按钮后,请求会传送一组数据到服务端，服务端把这组数据保存到一个List对象中。如果客户端传送的数据有的省份行情数据，数据库中也有该省的行情数据，则这些数据是要更新的数据。如果数据库中有的省份数据，而客户端传送的数据中没有该省份数据，则这些数据是要删除的。
经过上述分析，不难发现就是找出两个List对象的交集和差集。例如，a为客户端传送的数据List对象，b为从数据库中获取的List对象。 a中有的元素，而b中没有的元素就是要插入数据库中的数据，即a与b的差集。a和b共有的元素就是要更新的数据，即a与b的交集。b中有的元素，a中没有的就是要删除的数据，即b与a的差集。

程序代码
程序的大致思路是：利用LinkedHashMap key值的唯一性和顺序存储的特性，把detailFlow作为key值，先用一个map添加一个List元素，然后再去比较另一个List对象中的元素，找出detailFlow相同的对象和只有b中才有的对象。map中去除相同的key值的对象，剩余的就是a中独有的元素。

实体类 略…

求两个List 交集 差集

private int sameAndDifferentOperation(String projectFlow, List<SkillPdDetail> pdDetailListOld, List<SkillPdDetail> pdDetailListNew) {
		LinkedHashMap<String, SkillPdDetail> map = new LinkedHashMap<>();
		LinkedHashMap<String, SkillPdDetail> sameMap = new LinkedHashMap<>();
		LinkedHashMap<String, SkillPdDetail> onlyBMap = new LinkedHashMap<>();
		LinkedList<SkillPdDetail> sameItems = new LinkedList<>();
		LinkedList<SkillPdDetail> onlyAItems = new LinkedList<>();
		LinkedList<SkillPdDetail> onlyBItems = new LinkedList<>();
		//把oldList.detailFlow 做为key存到map中
		for (SkillPdDetail item : pdDetailListOld) {
			map.put(item.getDetailFlow(), item);
		}
		for (SkillPdDetail item : pdDetailListNew) {
		    //遍历newList,key值相同时,则添加到sameMap中,不同时则添加到onlyBMap中
			if (map.containsKey(item.getDetailFlow())) {
				SkillPdDetail pdDetail = map.get(item.getDetailFlow());
				sameMap.put(item.getDetailFlow(), pdDetail);
			} else {
			    //考虑多个key值为null时,数据覆盖,及时添加到list中
				onlyBMap.put(item.getDetailFlow(), item);
				onlyBItems.addAll(onlyBMap.values());
			}
		}
		sameItems.addAll(sameMap.values());
		for (SkillPdDetail item : sameItems) {
			map.remove(item.getDetailFlow());
		}
		onlyAItems.addAll(map.values());
		try {
		    //只有数据库中存在的数据删除 
			if (onlyAItems.size() > 0 && onlyAItems != null) {
				for (SkillPdDetail onlyAItem : onlyAItems) {
					onlyAItem.setRecordStatus(GlobalConstant.RECORD_STATUS_N);
					this.addProjectDetail(onlyAItem);
				}
			}
			//新增加的数据插入数据库
			if (onlyBItems.size() > 0 && onlyBItems != null) {
				for (SkillPdDetail onlyBItem : onlyBItems) {
					onlyBItem.setProjectFlow(projectFlow);
					this.addProjectDetail(onlyBItem);
				}
			}
			//相同的数据则更新
			if (sameItems.size() > 0 && sameItems != null) {
				for (SkillPdDetail sameItem : sameItems) {
					this.addProjectDetail(sameItem);
				}
			}
		} catch (Exception e) {
			return 0;
		}
		return 1;
	}

新手上路,请多指教
感谢原文转载：https://blog.youkuaiyun.com/u010657094/article/details/78906641

Java 求两个 List 集合的交集和差集
C_V_Better的博客
03-29 1118
求两个 List 集合的交集和差集是 Java 开发中的常见需求。：代码简洁，适合现代项目。传统迭代方法：兼容性好，适合低版本 Java。：功能强大，适合需要更多集合操作的场景。希望本文的示例和讲解对您有所帮助，如果您在处理 List 集合交集和差集时有任何疑问，欢迎随时交流探讨！
java8获取两个list的交集和差集_java8 stream两个集体交集、差集、并集操作
weixin_39528525的博客
12-18 2864
业务场景：页面左右两个datagrid，双击左边datagrid行，移动到右边datagrid，右边datagrid行双击，移动到左边datagrid点击保存，提交修改的数据到后台后台要把查询到的数据，和这次提交的数据对比，不变的不动，有新添加的，要增加，有去掉的要执行删除操作注：不能统一删除，再全新增，原来已经存在的信息可以做了一些配置，全删除，再全插入，原来的配置会丢了。那就要后台对两个集合进...
求两个list的交集和差集
michellechouu的专栏
05-25 799
方法一，用set类 b1=[1,2,3] b2=[2,3,4] b1 = set(b1) b2 = set(b2) difference = set.difference(b1,b2) inetersection = set.intersection(b1, b2) print(difference, inetersection) 方法二：
JAVA获取两个数据量较大的ArrayList的交集、差集以及并集
baidu_35975930的博客
11-07 4194
转载:https://www.cnblogs.com/o0shine0o-zp/p/6902392.html 测试说明：获取firstArrayList和secondArrayList的交集、差集以及并集。实际测试中firstArrayList数据量190000，secondArrayList数据量170000.效率比较高。此处只列出少量数据。测试代码如下： import java.util...
两个List集合取交集、并集、差集
极客神殿
09-29 1682
业务场景：根据用户查询权限，入参：UserCode，lastQueryTime（上次查询时间），出参：权限变化的列表。 oldList（上次查询到的权限列表），currList（当前查询到的权限列表），比对两个list找出：移除和增加的权限加以标识（1–增加，-1–删除）返回。 原逻辑处理方法：循环currList，如果oldList中不包含即为增加的权限列表，反之，循环oldList，如果currList中不包含即为移除的权限列表，代码如下(简略写没运行，比较笨拙)： //之前写的已经删了手动打下（add
求两个List的交集和并集
学无止境
03-20 1964
最近遇到的面试题， 假设有两个list分别为list1和list2 交集：list1.retainAll(list2); list1的数据就变成list1和list2的交集，list2不变。 public class ListTest { public static void main(String[] args) { List list1 = new Array...
Java中两个自定义对象List列表取交集(intersection())和差集(removeAll())
丸啊~
02-24 3935
可以直接使用第三方库 org.apache.commons.collections4.ListUtils 首先针对结合中的对象需要重写hashcode()和equals()方法。这是因为intersection()和removeAll()会去利用对象的这两个方法来比较对象是否是同一个对象。 假设我们现在有两个集合list1和list2 要得到在list1中不包含在list2中的集合 // 差集 List<Integer> result = ListUtils.removeAll(list1,
集合 求交集 求差集 高效 算法 性能对比 与 分析 JAVA
Ximerr的博客
07-28 4890
问题： 两个集合，分别含有一定数量的元素，如何快速得到两个集合的交集和差集？ 举例： 给定两个集合List<String> list1和List<String> list2，假定两个集合分别具有m和n个元素，要求取出两个集合中不同的元素，A比B多的元素和B比A多的元素。 说明： 1.以String作为集合中元素的类型，如果是自定义的数据结构，需要重写equals方法 2.输入参数：第一个集合list1，第二个集合list2 3.方法：实现求两个集合交集的方法 &
【精】【Java8】===两个List集合取交集、并集、差集
热门推荐
weixin_38256991的博客
08-14 13万+
业务场景：根据用户查询权限，入参：UserCode，lastQueryTime（上次查询时间），出参：权限变化的列表。 oldList（上次查询到的权限列表），currList（当前查询到的权限列表），比对两个list找出：移除和增加的权限加以标识（1--增加，-1--删除）返回。 原逻辑处理方法：循环currList，如果oldList中不包含即为增加的权限列表，反之，循环oldList，如...
List求交集、并集、差集
dj1955的博客
06-08 212
【代码】List求交集、并集、差集。
list的交集,差集,并集
诚的博客
02-02 818
需求 list的方法 说明 备注 交集 listA.retainAll(listB) listA内容变为listA和listB都存在的对象 listB不变 差集 listA.removeAll(listB) listA中存在的listB的内容去重 listB不变 并集 listA.removeAll(listB) listA.addAll(listB) 为了去重，listA先取差集，然后追加全部的listB li...
java两个List的交集，并集，差异集
进阶的小橙子
10-18 9740
public static void main(String[] args) { List list1 =new ArrayList(); list1.add("1111"); list1.add("2222"); list1.add("3333"); list1.add("4444"); list1.add("5555"); List ...
一种复杂度为O(1)获取两个List差集的算法(JAVA)
liujie379908的博客
10-15 2245
一种复杂度为O(1)获取两个List差集的算法(JAVA)
【Java用法】java 8两个List集合取交集、并集、差集、去重并集
费马程序猿的博客
12-21 2595
【Java用法】java 8两个List集合取交集、并集、差集、去重并集_No8g攻城狮的博客-优快云博客_java两个list对象取交集
java list 交集_java两个List的交集，并集
weixin_34207865的博客
02-12 457
文章来源:https://www.cnblogs.com/qdhxhz/p/10787130.html非对象集合交、并、差处理方法一:使用apache的CollectionUtils工具类(推荐)public static voidmain(String[] args) {String[] arrayA= new String[] { "1", "2", "3", "4"};String[] ar...
Java 使用stream()获取两个实体类列表的交集
程序员雅痞的博客
11-02 1087
使用stream()获取两个实体类列表的交集。使用几种不同的方式实现，并对比每种方式的效率。
JDK1.8 两个List对象 求交集
sdewendong的专栏
05-21 3064
两个List求交集，一个是 alist<ObjectA> 一个是bList<ObjectB>. 不管list内置的对象相同与否，都要把他们的属性值取出来做对比，对象是无法对比的。说到底还是字符串的对比。 下面的例子是：两个对象各自取出 三个要对比的属性值 拼接成 ‘attr1|attr2|attr3’ 这样的字符串做对比。 List<ObjectA> resList = aList.stream().filter(item -> bList.stream...
Java中两个List之间的比较(差集，交集，并集)
guoqiaosen的博客
09-30 4227
实现比较两个List之间的差异，包括获取两List的差集，交集，并集(不去重&去重)的API解法和优化解法的解决方案。
获取List实体交集差集
weixin_44491391的博客
08-31 372
List inlist=(List)map.get(“entity”); List updlist=(List)map.get(“entity”); List jiaoList = deptlist.stream() .filter(item ->//!差集，不加就是求交集 inlist.stream().map(SysDept::getOrgcd) .collect(Collectors.toList()) .contains(item.getOrgcd()) ).collect(Collector
Java两个list求差集
最新发布
06-05
<think>首先，用户的问题是：“我想查找如何在Java中计算两个List的差集”。他们提供了一个查询："Javacalculatedifferencebetweentwolists"。系统指令要求我使用中文回答，所以我的整个回应必须用中文。回顾系统级指令：-所有行内数学表达式使用$...$。-独立公式使用$$...$$并单独成段。-LaTeX语法正确。-使用中文回答。-生成相关问题。-在引用的段落末尾添加引用标识。用户提供了三个引用：-引用[1]:Java代码，读取输入并输出字符串长度。-引用[2]:Java中List的四种实现：ArrayList,LinkedList,Vector,Stack。-引用[3]:LeetCode题解博客。但用户说这些引用仅供参考，不是真正需求，我应该参考用户上一次的问题和我的回答。用户上一次的问题是什么？在对话历史中，用户提到了“参考站内引用”，但这些引用是通用的，我需要专注于当前查询。用户的问题是计算两个List的差集在Java中。差集意味着从一个列表中移除另一个列表中出现的所有元素。常见方法是使用Java的集合操作，如使用List或Set。用户指定“List”，所以这可能涉及Java中的List接口。Java中，List允许重复元素，而Set不允许。差集操作可能因是否考虑顺序和重复而不同。常见的差集定义：-List差集：对于列表A和B，A-B是A中有但B中没有的元素。-如果列表有重复元素，需要指定如何处理。例如，差集可能保留A中每个元素在B中未出现的次数。-或者，使用集合操作转换为Set，移除重复项。在Java中，计算两个List的差集的通用方法是：1.使用JavaCollectionsFramework中的List.removeAll(Collection<?>c)方法。它移除列表中所有在指定集合中出现的元素。但要注意：这个方法会修改原始列表。2.为了避免修改原列表，可以创建副本，然后使用removeAll。3.使用Set：将两个列表转换为Set（如HashSet），然后使用Set.removeAll()。但Set自动去重，所以如果列表有重复元素，结果可能不同。4.对于有序列表或有重复元素，可以用循环手动实现。现在，用户提到“尽可能多的参考用户上一次的问题和你的回答”。在上一个用户消息中，用户说：“参考站内引用:...”，但那些引用不直接相关。真正的用户需求是计算List的差集。在引用[2]中提到了List的实现：ArrayList,LinkedList等。这与问题相关，因为我讨论List的操作。我的回答结构应该：-清晰、帮助用户逐步解决问题。-使用中文。-在需要时添加引用标识。-生成相关问题。步骤：1.**介绍概念**：解释什么是差集（两个列表的差异）。2.**推荐方法**：-使用List的removeAll方法。-说明如何避免修改原列表。-考虑元素是否重复。-举例Java代码。3.**考虑性能**：根据列表大小，选择合适的数据结构（如ArrayListvs.LinkedList）。4.**添加代码示例**：提供Java代码计算差集。5.**引用标识**：如果我从参考中汲取灵感，添加引用。但引用[2]提到List类型，我可以提一下选择列表类型的影响。添加引用标识，如[^2]。6.**生成相关问题**：在回答结束后，添加相关问题。回答大纲：-**开头**：直接回答用户问题。-**方法1:使用List.removeAll**-解释方法。-代码示例。-**方法2:使用Set（如果想去重）**-解释差异。-**方法3:手动实现（如果需要处理重复）**-**注意事项**：如修改列表、异常处理。-**代码示例**：完整Java类。-**引用**：如果提到List类型，可以引用[^2]。-**结尾**：总结。生成相关问题：1.如何在Java中合并两个列表？2.计算列表交集的方法？3.在大型列表中提高差集计算效率的方法？确保LaTeX正确：由于这是关于代码，可能不需要数学公式，除非我解释算法。但指令说变量等用行内LaTeX。例如，$A-B$或类似的东西。但我可以用中文文字描述。在回答中，引用的段落末尾添加引用标识。例如，如果我说“在List类型的选择会影响性能时，...[^2]”。现在，构建回应：-用中文。-使用代码块显示Java代码。-确保真实可靠：我是AI，应该基于标准知识。最终响应结构：1.解释差集概念。2.提供方法。3.给出代码。4.注意事项。5.添加相关问题。</think> 为了在Java中计算两个列表（List）的差集，我将基于您的查询"Java calculate difference between two lists"进行详细解释。差集操作指的是从一个列表中移除另一个列表中的所有元素（包括重复元素的移除），即得到List A中独有的元素，而不是List B中的任何元素。Java提供了多种实现方式，但需要注意列表是否允许重复元素、是否有序以及性能考虑。具体方法包括使用Java Collections Framework的内置方法（如`List.removeAll()`）或手动实现来处理特定需求。 我将逐步引导您理解概念、推荐方法、提供代码示例，并解释注意事项。回答中，我会参考您提供的引用信息（如List类型的选择对性能的影响）[^2]，并确保回答真实可靠（基于标准Java库文档和最佳实践）。 ### 1. **概念解释** 在集合论中，差集通常表示为 $A - B$，即列表 $A$ 中有但列表 $B$ 中无的所有元素组成的集合。在Java中，由于List允许重复元素和有序，差集操作需考虑元素多次出现的情况： - 如果列表有重复元素，差集保留$A$中每个元素在$B$中未出现的次数。例如，$A = [1,2,2,3]$，$B = [2]$，则$A - B = [1,3]$（移除所有$B$中的元素）。 - 相反，如果想去重，可以先转换为Set（集合），再进行差集操作，但这样会丢失顺序和重复。 ### 2. **推荐方法** 以下是三种常用方法，各有适用场景。选择依据： - **List.removeAll()方法**：最简单高效，但会修改原列表；适合小列表或可接受修改的情况[^2]。 - **Set-based方法**：如果想去重或处理大型列表（时间复杂度更低），但会丢失顺序。 - **手动实现**：当需要完全控制（如处理重复计数或自定义顺序时）使用。 #### **方法1: 使用List.removeAll()方法**（推荐通用） 这是最直接的方法，使用Java的`List.removeAll(Collection<?> c)`方法。它会修改原始列表 $A$，移除所有在列表 $B$ 中出现的元素。但为了避免修改原列表，先创建副本。 - **优点**：代码简洁、时间复杂度为 $O(n \times m)$（n和m是列表大小），适用于中小列表[^2]。 - **缺点**：修改原列表；如果列表有大量元素，性能较差，特别是使用`LinkedList`时（基于链接节点实现）[^2]。 - **代码示例**： ```java import java.util.ArrayList; import java.util.List; public class ListDifference { public static void main(String[] args) { List<Integer> listA = new ArrayList<>(); // ArrayList支持快速随机访问 List<Integer> listB = new ArrayList<>(); // 添加示例元素 listA.add(1); listA.add(2); listA.add(2); listA.add(3); // A = [1,2,2,3] listB.add(2); listB.add(4); // B = [2,4] // 计算差集: 创建副本以避免修改原列表 List<Integer> difference = new ArrayList<>(listA); // 深拷贝，保留A的副本 difference.removeAll(listB); // 移除所有在B中的元素 System.out.println("差集结果: " + difference); // 输出: [1,3] } } ``` - **输出解释**：`difference`将是listA的差集部分（移除所有listB中出现的元素）。在此示例中，listA中'2'被完全移除，因为listB包含'2'。 - **注意**：如果使用`LinkedList`（基于链接节点，适合频繁插入删除），性能略好于`ArrayList`（基于动态数组）在移除操作时[^2]。但如果列表很大，推荐使用`ArrayList`避免内存问题。 #### **方法2: 使用Set实现（如HashSet），适合去重** 如果列表中元素无重复，或您想去重和优化性能，可以将列表转换为HashSet（基于哈希表），然后使用 `Set.removeAll()`。这能降低时间复杂度到 $O(n + m)$（average case）。 - **优点**：时间复杂度低，适合大型列表；能确保结果唯一。 - **缺点**：结果无序（HashSet不保证顺序）；丢失重复元素。 - **代码示例**： ```java import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Set; public class ListDifferenceSet { public static void main(String[] args) { List<Integer> listA = new ArrayList<>(); List<Integer> listB = new ArrayList<>(); listA.add(1); listA.add(2); listA.add(2); listA.add(3); listB.add(2); listB.add(4); // 转换为Set并计算差集 Set<Integer> setA = new HashSet<>(listA); // 去重和转换 Set<Integer> setB = new HashSet<>(listB); setA.removeAll(setB); // Set差集操作 // 输出结果（可能无序） System.out.println("差集结果 (去重): " + setA); // 输出: [1,3] 或 [3,1] } } ``` #### **方法3: 手动实现处理重复或顺序** 当需要控制元素出现次数（如保留每个元素在差集中的出现次数）或列表是有序时（如使用`Vector`或`Stack`，它们基于动态数组且线程安全，但较慢），可手动遍历实现。 - **优点**：灵活处理顺序和重复；不修改原列表。 - **缺点**：代码稍复杂，时间复杂度 $O(n \times m)$。 - **代码示例**： ```java import java.util.ArrayList; import java.util.List; public class ManualDifference { public static void main(String[] args) { List<Integer> listA = new ArrayList<>(); List<Integer> listB = new ArrayList<>(); listA.add(1); listA.add(2); listA.add(2); listA.add(3); listB.add(2); listB.add(4); List<Integer> difference = new ArrayList<>(); // 遍历listA，只添加不在listB中的元素（考虑重复） for (Integer element : listA) { if (!listB.contains(element)) { difference.add(element); } } System.out.println("差集结果 (手动): " + difference); // 输出: [1,3] } } ``` ### 3. **注意事项** - **性能优化**：对于大型列表（如超过10,000元素），优先使用Set方法（$O(n + m)$时间复杂度），或选择高效的List实现： - 如果列表需要快速查询，用`ArrayList`（随机访问快）[^2]。 - 如果频繁修改，用`LinkedList`（插入删除快）。 - **元素比较**：所有方法依赖于元素的`equals()`和`hashCode()`方法。如果列表中包含自定义对象（如用户类），请重写这些方法。 - **线程安全**：如果涉及多线程，使用线程安全的`Vector`或`Collections.synchronizedList()`包装列表[^2]。 - **异常处理**：在代码中添加null检查或try-catch块，例如`if(listA == null || listB == null)` 避免NullPointerException。 - **内存消耗**：`List.removeAll()`可能需要较大内存空间创建副本；在Android或低资源环境中谨慎使用。 ### 4. **生成相关问题** 如果您已理解上述方法，接下来可探索更多相关主题： 1. 如何在Java中合并两个列表并去重？ 2. 计算两个列表交集的方法有哪些（例如，使用`List.retainAll()`）？ 3. 在大型数据集中提高差集计算效率的策略（如使用并行流或外部数据库）？ 4. Java集合框架中的`Set`和`List`在性能差异上如何进行基准测试？ 如果您的需求涉及特定场景（如列表中有自定义对象或需要详细基准），请提供更多细节以便更精确回答！[^1] [^2] [^3]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值