使用Bean其实优于Map

Posted 2021-02-01 chenss15060100790

在很长的时间里，一直以为使用反射技术效率低，对比于使用反射创建对象，可能直接创建Map更快，但是这种认知是错误的，以下以创建一百万个对象为例

 

package spring;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.alibaba.fastjson.JSONObject;
import com.client.bean.Person;

public class Test {
    public static void main(String[] args) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
        {
            //在很长的时间里，一直以为map是快速的存储结构
            //但是这种认知是错误的，实际测试下，反而是最慢的
            //（但是map支持无限制地填充数据，这一点优于bean对象）
            //原因可能是过多的对象创建，因为每一个对象都需要一个entry等对象进行包装
            List<Map<String,Object>> l = new ArrayList<>();
            Map<String,Object> map;
            int cnt = 1000000;
            long start = System.nanoTime();
            while(cnt-->0){
                map= new HashMap<>();
                map.put("name", "xiaoming");
                map.put("age", cnt);
                map.put("name", "xiaoming");
                map.put("age", cnt);
                l.add(map);
            }
            long end = System.nanoTime();
            System.out.println(l.size());
            System.out.println(start);
            System.out.println(end);
            System.out.println(end-start);
        }
        {
            //阿里的JSON对象优于map，而弱于bean对象
            List<JSONObject> l = new ArrayList<>();
            JSONObject map;
            int cnt = 1000000;
            long start = System.nanoTime();
            while(cnt-->0){
                map= new JSONObject();
                map.put("name", "xiaoming");
                map.put("age", cnt);
                l.add(map);
            }
            long end = System.nanoTime();
            System.out.println(l.size());
            System.out.println(start);
            System.out.println(end);
            System.out.println(end-start);
        }
        {
            //使用bean对象
            List<Person> l = new ArrayList<>();
            Person map;
            int cnt = 1000000;
            long start = System.nanoTime();
            while(cnt-->0){
                map= new Person();
                map.setName("xiaoming");
                map.setAge(cnt);
                l.add(map);
            }
            long end = System.nanoTime();
            System.out.println(l.size());
            System.out.println(start);
            System.out.println(end);
            System.out.println(end-start);  
        }
        {   
            //对java反射进行优化，先解析一部分参数（缓存），这种方式最快
            //唯一的顾虑是在并发情况下是否有问题
            List<Person> l = new ArrayList<>();
            Person map;
            int cnt = 1000000;
            Field fn = Person.class.getDeclaredField("name");
            fn.setAccessible(true);
            Field fa = Person.class.getDeclaredField("age");
            fa.setAccessible(true);
            
            Map<String,Field> f = new HashMap<>();
            f.put("name", fn);
            f.put("age", fa);
            
            long start = System.nanoTime();
            while(cnt-->0){
                map= new Person();
                f.get("name").set(map, "xiaoming");
                f.get("age").set(map, cnt);
                l.add(map);
            }
            long end = System.nanoTime();
            System.out.println(l.size());
            System.out.println(start);
            System.out.println(end);
            System.out.println(end-start);  
        }
        {
            //所有的反射留到使用时再解析,这种方式会随着参数变多，
            //耗时也越来越多，超过某个阶段，效率低于Map
            List<Person> l = new ArrayList<>();
            Person map;
            int cnt = 1000000;
            
            long start = System.nanoTime();
            Field fa,fn;
            while(cnt-->0){
                fn = Person.class.getDeclaredField("name");
                fn.setAccessible(true);
                fa = Person.class.getDeclaredField("age");
                fa.setAccessible(true);
                map= new Person();
                fn.set(map, "xiaoming");
                fa.set(map, cnt);
                l.add(map);
            }
            long end = System.nanoTime();
            System.out.println(l.size());
            System.out.println(start);
            System.out.println(end);
            System.out.println(end-start);  
        }
    }
}