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 跨域問題最佳解決方案
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
