Java中List和Map的特性对两组大批量数据进行匹配

在项目中遇到一个问题：要将通过http方式发送过来的大批量数据（这个数据保守估计每次请求在10万条左右），要和数据库中的另一批数据（数据库中的记录1万条左右）进行匹配（匹配：指两组数据中的某几个字段值相等），匹配上的数据保存在数据库中，匹配不上的直接扔掉。或者说：有一个List<String> strList，List<Person> personList，strNoList.size是1万，personList.size是10万， 然后要从personList中把person的id属性在strList中的person取出来，personList中的person的id可能会相同，两个记录的结构不同。

要实现这个功能，首先想到的就是使用for循环逐条进行比较，那么这样就有10W*1W，即10亿次循环。但是，系统对数据的实时性要求比较高，这样做显然性能上是有问题的。于是乎就要找另一种方式，减少循环次数来提高匹配的处理速度，由于之前也没做个这样的事情，于是就想各种办法，同时在OSC社区发帖求助

List可以放重复数据，而Map为不能放重复数据的key-value结构。那么就可以把接收到的id相同的person实体数据放入一个list中，然后用该id作为key，list做作为value放入map中。那么现在处理10w条数据则需要10W次for循环。然后查出数据库中的1W条记录，遍历map，使用map.get("key")取出相同id的list，然后将这些list的元素全部添加到一个resultList中，遍历这1W条记录需要1W次for循环。这样，就将一个10W*1W次的for循环减小到10W+1W次。下边是关于for循环次数的耗时测试，结果表明减少循环次数能大幅度提高处理速度

所以我们一般写代码，双循环匹配是N*M，数据量不大可以，数据量大了那就。。。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 * For循环测试
 * @author 47Gamer
 *
 */
public class ForTest {
 public static void main(String[] args) {
  ForTest test = new ForTest();
  System.out.println("============开始=============");
   //一亿次for循环
   test.test1Yi();
   //十一万次for循环
   test.test11W();
   //嵌套for循环匹配：10W*1W次for循环
   test.testForAndFor();
   //Map和List整理匹配：10W+1W次for循环
   test.testMapAndList();
  System.out.println("============结束=============");
 }
 /**
  * 一亿次for循环
  */
 private void test1Yi(){
  long start = System.currentTimeMillis();
  for (Integer i = 0; i < 100000000;i++) {
   System.out.println(i);
  }
  long end = System.currentTimeMillis();
  System.out.println("1亿次循环耗时："+ (end - start) + "毫秒");
  System.out.println("----------------------------");
 }

 /**
  * 11万次for循环
  */
 private void test11W(){
  long start = System.currentTimeMillis();
  for (Integer i = 0; i < 110000;i++) {
   System.out.println(i);
  }
  long end = System.currentTimeMillis();
  System.out.println("11W次循环耗时："+ (end - start) + "毫秒");
  System.out.println("----------------------------");
 }

 /**
  * 嵌套for循环进行比较匹配
  */
 private void  testForAndFor(){
  //构造一个10万个Person对象的list
  List<Person> personList = new ArrayList<Person>();
  for (int i = 0; i < 100000; i++) {
   int j =10000;
   personList.add(new Person((i%j) +"", "张三"+i));
  }
  //构造一个1万个String对象的list
  List<String> strList = new ArrayList<String>();
  for (int i = 0; i < 10000; i++) {
   strList.add(i +"");
  }

  //嵌套for循环：10W*1W
  long start = System.currentTimeMillis();
  //保存匹配结果
        List<Person> resultList = new ArrayList<Person>();
        //遍历10W person的List
        for (Person person : personList) {
         //遍历1W str的List
            for (String str : strList) {
                if(person.getId().equals(str)){
                    resultList.add(person);
                }
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("reslutList.size:"+ resultList.size());
        System.out.println("10W*1W次循环耗时："+ (end - start) + "毫秒");
        System.out.println("----------------------------");
 }

 /**
  * 使用Map和List的特性进行匹配:
  * Map为key-value结构，不能放重复数据
  * List可以放重复数据
  * 使用String型id做key,List<Person>做value
  * 遍历List<String>, map.get(String)则取出id == str 的List
  */
 private void  testMapAndList(){
  //构造一个10万个Person对象的list
  List<Person> personList = new ArrayList<Person>();

  for (int i = 0; i < 100000; i++) {
   int j =10000;
   personList.add(new Person((i%j) +"", "张三"+i));
  }
  //构造一个1万个String对象的list
  List<String> strList = new ArrayList<String>();
  for (int i = 0; i < 10000; i++) {
   strList.add(i +"");
  }

  long start = System.currentTimeMillis();
  //利用Map和List的特性整理数据
        Map<String, List<Person>> map = new HashMap<String, List<Person>>();
        //将10W条数据根据id放入map
        for(int i=0;i<personList.size();i++){
         Person person = personList.get(i);
             String id = person.getId();
              if(map.containsKey(id)){
                  map.get(id).add(person);
              }else{
                   List<Person> pList = new ArrayList<Person>();
                   pList.add(person);
                   //id为key,相同id的person的List为value
                   map.put(id,pList);
             }
        }
      //保存匹配结果
        List<Person> resultList = new ArrayList<Person>();
        //根据1W条str,map.get(str)取匹配上的数据
        for (String str : strList) {
            List<Person> pList = map.get(str);
            if (pList != null) {
                resultList.addAll(pList);
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("map.size:" +map.size());
        System.out.println("reslutList.size:"+ resultList.size());
        System.out.println("10W+1W次循环耗时："+ (end - start) + "毫秒");
  System.out.println("----------------------------");
 }
}
/**
 * Person实体类
 */
class Person{
 private String id;
 private String name;
 public Person() {}

 public Person(String id, String name) {
  this.id = id;
  this.name = name;
 }
 @Override
 public String toString() {
  return this.id +"::>"+ this.name;
 }

 public String getId() {
  return id;
 }
 public void setId(String id) {
  this.id = id;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
}

测试结果：

============开始=============
1亿次循环耗时：1262985毫秒
----------------------------
11W次循环耗时：1016毫秒
----------------------------
reslutList.size:100000
10W*1W次循环耗时：21219毫秒
----------------------------
map.size:10000
reslutList.size:100000
10W+1W次循环耗时：31毫秒
============结束=============

•1亿次system.out.println(i)的循环耗时1262985毫秒，即21分钟，那么10亿次210分钟，显然不可接受。当然这里设计I/O操作，比较耗时，实际应用中没有这么吓人。
•11万次system.out.println(i)循环耗时1016毫秒，即1秒种，很明显，减少循环次数能够提高处理速度。
•使用嵌套for循环完成10W*1W次循环耗时21219毫秒，使用第二种方法完成10W+1W次循环耗时31毫秒，处理速度提高了600多陪，达到了预想的目的。