List数据对比筛选，如何才能达到最佳效率？
在实际的开发中，常常会晕倒这样的问题，有两个List的数据，须要对这两个List的数据进行对比，而后筛选出须要的对象。 java
例如：财务中的对帐,数据源一个是银行日记帐（aList），一个是银行对账单（bList），业务操做就是把两个List里面金额相同的记录筛选掉，剩下金额不相等的。 编程
在实际开发中我目前知道有两个方式（假设两个List各有1000条数据）：
一、最简单的就是用双重循环进行比较，虽然简单，可是若是两个List的数据量都很大，那么运行时间将成数量级增加。循环次数为1000*1000 性能
方法1：遍历两个集合：spa
package com.czp.test;import java.util.ArrayList;import java.util.List;public class TestList { public static void main(String[] args) {
List<String> list1 = new ArrayList<String>();
List<String> list2 = new ArrayList<String>(); for (int i = 0; i < 10000; i++) {
list1.add("test"+i);
list2.add("test"+i*2);
}
getDiffrent(list1,list2); //输出：total times 2566454675 } /**
* 获取两个List的不一样元素
* @param list1
* @param list2
* @return
*/
private static List<String> getDiffrent(List<String> list1, List<String> list2) { long st = System.nanoTime();
List<String> diff = new ArrayList<String>(); for(String str:list1)
{ if(!list2.contains(str))
{
diff.add(str);
}
}
System.out.println("total times "+(System.nanoTime()-st)); return diff;
}
}
千万不要采用这种方法，总共要循环的次数是两个List的size相乘的积，从输出看耗时也是比较长的，那么咱们有没有其余的方法呢？固然有.code
方法2：采用List提供的retainAll（）方法：orm
package com.czp.test;import java.util.ArrayList;import java.util.List;public class TestList { public static void main(String[] args) {
List<String> list1 = new ArrayList<String>();
List<String> list2 = new ArrayList<String>(); for (int i = 0; i < 10000; i++) {
list1.add("test"+i);
list2.add("test"+i*2);
}
getDiffrent(list1,list2); //输出：total times 2566454675 getDiffrent2(list1,list2); //输出：getDiffrent2 total times 2787800964 }
/**
* 获取连个List的不一样元素
* @param list1
* @param list2
* @return
*/
private static List<String> getDiffrent2(List<String> list1, List<String> list2) { long st = System.nanoTime();
list1.retainAll(list2);
System.out.println("getDiffrent2 total times "+(System.nanoTime()-st)); return list1;
} /**
* 获取两个List的不一样元素
* @param list1
* @param list2
* @return
*/
private static List<String> getDiffrent(List<String> list1, List<String> list2) { long st = System.nanoTime();
List<String> diff = new ArrayList<String>(); for(String str:list1)
{ if(!list2.contains(str))
{
diff.add(str);
}
}
System.out.println("getDiffrent total times "+(System.nanoTime()-st)); return diff;
}
}
很遗憾，这种方式虽然只要几行代码就搞定，可是这个却更耗时，查看retainAll（）的源码:对象
public boolean retainAll(Collection<?> c) { boolean modified = false;
Iterator<E> e = iterator(); while (e.hasNext()) { if (!c.contains(e.next())) {
e.remove();
modified = true;
}
} return modified;
}
无需解释这个耗时是必然的，那么咱们还有没有更好的办法呢？仔细分析以上两个方法中我都作了mXn次循环，其实彻底没有必要循环这么屡次，咱们的需求是找出两个List中的不一样元素,那么我能够这样考虑：用一个map存放lsit的全部元素，其中的key为lsit1的各个元素，value为该元素出现的次数,接着把list2的全部元素也放到map里，若是已经存在则value加1，最后咱们只要取出map里value为1的元素便可，这样咱们只需循环m+n次，大大减小了循环的次数。ci
package com.czp.test;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;public class TestList { public static void main(String[] args) {
List<String> list1 = new ArrayList<String>();
List<String> list2 = new ArrayList<String>(); for (int i = 0; i < 10000; i++) {
list1.add("test"+i);
list2.add("test"+i*2);
}
getDiffrent(list1,list2); //输出：total times 2566454675 getDiffrent2(list1,list2); //输出：getDiffrent2 total times 2787800964 getDiffrent3(list1,list2); //输出：getDiffrent3 total times 61763995 } /**
* 获取两个List的不一样元素
* @param list1
* @param list2
* @return
*/
private static List<String> getDiffrent3(List<String> list1, List<String> list2) { long st = System.nanoTime();
Map<String,Integer> map = new HashMap<String,Integer>(list1.size()+list2.size());
List<String> diff = new ArrayList<String>(); for (String string : list1) {
map.put(string, 1);
} for (String string : list2) {
Integer cc = map.get(string); if(cc!=null)
{
map.put(string, ++cc); continue;
}
map.put(string, 1);
} for(Map.Entry<String, Integer> entry:map.entrySet())
{ if(entry.getValue()==1)
{
diff.add(entry.getKey());
}
}
System.out.println("getDiffrent3 total times "+(System.nanoTime()-st)); return list1;
} /**
* 获取两个List的不一样元素
* @param list1
* @param list2
* @return
*/
private static List<String> getDiffrent2(List<String> list1, List<String> list2) { long st = System.nanoTime();
list1.retainAll(list2);
System.out.println("getDiffrent2 total times "+(System.nanoTime()-st)); return list1;
} /**
* 获取两个List的不一样元素
* @param list1
* @param list2
* @return
*/
private static List<String> getDiffrent(List<String> list1, List<String> list2) { long st = System.nanoTime();
List<String> diff = new ArrayList<String>(); for(String str:list1)
{ if(!list2.contains(str))
{
diff.add(str);
}
}
System.out.println("getDiffrent total times "+(System.nanoTime()-st)); return diff;
}
}
package com.czp.test;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;public class TestList { public static void main(String[] args) {
List<String> list1 = new ArrayList<String>();
List<String> list2 = new ArrayList<String>(); for (int i = 0; i < 10000; i++) {
list1.add("test"+i);
list2.add("test"+i*2);
}
getDiffrent(list1,list2);
getDiffrent2(list1,list2);
getDiffrent3(list1,list2);
getDiffrent4(list1,list2);// getDiffrent total times 2789492240// getDiffrent2 total times 3324502695// getDiffrent3 total times 24710682// getDiffrent4 total times 15627685 } /**
* 获取两个List的不一样元素
* @param list1
* @param list2
* @return
*/
private static List<String> getDiffrent4(List<String> list1, List<String> list2) { long st = System.nanoTime();
Map<String,Integer> map = new HashMap<String,Integer>(list1.size()+list2.size());
List<String> diff = new ArrayList<String>();
List<String> maxList = list1;
List<String> minList = list2; if(list2.size()>list1.size())
{
maxList = list2;
minList = list1;
} for (String string : maxList) {
map.put(string, 1);
} for (String string : minList) {
Integer cc = map.get(string); if(cc!=null)
{
map.put(string, ++cc); continue;
}
map.put(string, 1);
} for(Map.Entry<String, Integer> entry:map.entrySet())
{ if(entry.getValue()==1)
{
diff.add(entry.getKey());
}
}
System.out.println("getDiffrent4 total times "+(System.nanoTime()-st)); return diff;
} /**
* 获取两个List的不一样元素
* @param list1
* @param list2
* @return
*/
private static List<String> getDiffrent3(List<String> list1, List<String> list2) { long st = System.nanoTime();
Map<String,Integer> map = new HashMap<String,Integer>(list1.size()+list2.size());
List<String> diff = new ArrayList<String>(); for (String string : list1) {
map.put(string, 1);
} for (String string : list2) {
Integer cc = map.get(string); if(cc!=null)
{
map.put(string, ++cc); continue;
}
map.put(string, 1);
} for(Map.Entry<String, Integer> entry:map.entrySet())
{ if(entry.getValue()==1)
{
diff.add(entry.getKey());
}
}
System.out.println("getDiffrent3 total times "+(System.nanoTime()-st)); return diff;
} /**
* 获取连个List的不一样元素
* @param list1
* @param list2
* @return
*/
private static List<String> getDiffrent2(List<String> list1, List<String> list2) { long st = System.nanoTime();
list1.retainAll(list2);
System.out.println("getDiffrent2 total times "+(System.nanoTime()-st)); return list1;
} /**
* 获取两个List的不一样元素
* @param list1
* @param list2
* @return
*/
private static List<String> getDiffrent(List<String> list1, List<String> list2) { long st = System.nanoTime();
List<String> diff = new ArrayList<String>(); for(String str:list1)
{ if(!list2.contains(str))
{
diff.add(str);
}
}
System.out.println("getDiffrent total times "+(System.nanoTime()-st)); return diff;
}
}
这里对连个list的大小进行了判断，小的在最后添加，这样会减小循环里的判断，性能又有了必定的提高，正如一位朋友所说，编程是无止境的，只要你认真去思考了，总会找到更好的方法！开发
针对List有重复元素的问题，作如下修正，首先明确一点，两个List无论有多少个重复，只要重复的元素在两个List都能找到，则不该该包含在返回值里面，因此在作第二次循环时，这样判断：若是当前元素在map中找不到，则确定须要添加到返回值中，若是能找到则value++，遍历完以后diff里面已经包含了只在list2里而没在list2里的元素，剩下的工做就是找到list1里有list2里没有的元素，遍历map取value为1的便可：rem
package com.czp.test;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;public class TestList { public static void main(String[] args) {
List<String> list1 = new ArrayList<String>();
List<String> list2 = new ArrayList<String>(); for (int i = 0; i < 10000; i++) {
list1.add("test"+i);
list2.add("test"+i*2);
}
getDiffrent(list1,list2);
getDiffrent3(list1,list2);
getDiffrent5(list1,list2);
getDiffrent4(list1,list2);
getDiffrent2(list1,list2);// getDiffrent3 total times 32271699// getDiffrent5 total times 12239545// getDiffrent4 total times 16786491// getDiffrent2 total times 2438731459
} /**
* 获取两个List的不一样元素
* @param list1
* @param list2
* @return */
private static List<String> getDiffrent5(List<String> list1, List<String> list2) { long st = System.nanoTime();
List<String> diff = new ArrayList<String>();
List<String> maxList = list1;
List<String> minList = list2; if(list2.size()>list1.size())
{
maxList = list2;
minList = list1;
}
Map<String,Integer> map = new HashMap<String,Integer>(maxList.size()); for (String string : maxList) {
map.put(string, 1);
} for (String string : minList) { if(map.get(string)!=null)
{
map.put(string, 2); continue;
}
diff.add(string);
} for(Map.Entry<String, Integer> entry:map.entrySet())
{ if(entry.getValue()==1)
{
diff.add(entry.getKey());
}
}
System.out.println("getDiffrent5 total times "+(System.nanoTime()-st)); return diff;
} /**
* 获取两个List的不一样元素
* @param list1
* @param list2
* @return */
private static List<String> getDiffrent4(List<String> list1, List<String> list2) { long st = System.nanoTime();
Map<String,Integer> map = new HashMap<String,Integer>(list1.size()+list2.size());
List<String> diff = new ArrayList<String>();
List<String> maxList = list1;
List<String> minList = list2; if(list2.size()>list1.size())
{
maxList = list2;
minList = list1;
} for (String string : maxList) {
map.put(string, 1);
} for (String string : minList) {
Integer cc = map.get(string); if(cc!=null)
{
map.put(string, ++cc); continue;
}
map.put(string, 1);
} for(Map.Entry<String, Integer> entry:map.entrySet())
{ if(entry.getValue()==1)
{
diff.add(entry.getKey());
}
}
System.out.println("getDiffrent4 total times "+(System.nanoTime()-st)); return diff;
} /**
* 获取两个List的不一样元素
* @param list1
* @param list2
* @return */
private static List<String> getDiffrent3(List<String> list1, List<String> list2) { long st = System.nanoTime();
Map<String,Integer> map = new HashMap<String,Integer>(list1.size()+list2.size());
List<String> diff = new ArrayList<String>(); for (String string : list1) {
map.put(string, 1);
} for (String string : list2) {
Integer cc = map.get(string); if(cc!=null)
{
map.put(string, ++cc); continue;
}
map.put(string, 1);
} for(Map.Entry<String, Integer> entry:map.entrySet())
{ if(entry.getValue()==1)
{
diff.add(entry.getKey());
}
}
System.out.println("getDiffrent3 total times "+(System.nanoTime()-st)); return diff;
} /**
* 获取连个List的不一样元素
* @param list1
* @param list2
* @return */
private static List<String> getDiffrent2(List<String> list1, List<String> list2) { long st = System.nanoTime();
list1.retainAll(list2);
System.out.println("getDiffrent2 total times "+(System.nanoTime()-st)); return list1;
} /**
* 获取两个List的不一样元素
* @param list1
* @param list2
* @return */
private static List<String> getDiffrent(List<String> list1, List<String> list2) { long st = System.nanoTime();
List<String> diff = new ArrayList<String>(); for(String str:list1)
{ if(!list2.contains(str))
{
diff.add(str);
}
}
System.out.println("getDiffrent total times "+(System.nanoTime()-st)); return diff;
}
}
补充一下，其实能够先将list转换为set，这样就达到去重的目的，而后把set中的数据再转存到map中。也就免除了list1或list2中自己就有重复数据的状况。
相关文章
- 1. 两个List对比筛选
- 2. array.array 和 list 效率对比
- 3. 博客怎么推广才能达到最佳优化效果
- 4. Tableau如何多数据源共用筛选器筛选数据
- 5. 如何才能更加有效率(转)
- 6. 教你如何筛选到最值得学习的数据技能？
- 7. 大数据量下DataTable To List效率对比
- 8. SQL SERVER 2000 如何提升大数据筛选GROUP BY 的效率
- 9. 如何使用JS筛选JSON数据
- 10. 如何才能选到好导师？
- 更多相关文章...
- • XSD 如何使用? - XML Schema 教程
- • 如何干扰TCP数据传输？ - TCP/IP教程
- • Flink 数据传输及反压详解
- • PHP Ajax 跨域问题最佳解决方案
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. 升级Gradle后报错Gradle‘s dependency cache may be corrupt (this sometimes occurs
- 2. Smarter, Not Harder
- 3. mac-2019-react-native 本地环境搭建(xcode-11.1和android studio3.5.2中Genymotion2.12.1 和VirtualBox-5.2.34 )
- 4. 查看文件中关键字前后几行的内容
- 5. XXE萌新进阶全攻略
- 6. Installation failed due to: ‘Connection refused: connect‘安卓studio端口占用
- 7. zabbix5.0通过agent监控winserve12
- 8. IT行业UI前景、潜力如何？
- 9. Mac Swig 3.0.12 安装
- 10. Windows上FreeRDP-WebConnect是一个开源HTML5代理，它提供对使用RDP的任何Windows服务器和工作站的Web访问
欢迎关注本站公众号,获取更多信息
