java hashset 效率_java常用集合效率测试

测试了下jave常见集合添加与删除效率，包括ArrayList、LinkedList、HashMap、TreeSet、LinkedHashMap

java具体集合有以下：

集合类型 描述

ArrayList 一种可以动态增长和缩减的索引序列

LinkedList 一种可以在任何位置进行高效的插入和删除操作的有序序列

ArrayDeque 一种用循环数组实现的双端队列

HashSet 一种没有重复元素的无序集合

TreeSet 一种有序集

EnumSet 一种包含枚举类型值的集

LinkedHashSet 一种可以记住元素插入次序的集

PriorityQueue 一种允许高效删除最小元素的集

HashMap 一种存储键/值关联的数据结构

TreeMap 一种键值有序排列的映射表

EnumMaP 一种键值属于枚举类型的映射表

LinkedHashMap 一种可以记住键/值添加次序的映射表

WeakHashMap 一种其值无用武之地后可以被垃圾回收器回收的映射表

IdentityHashMap 一种用 == 而不是用equals比较键值的映射表

1.添加效率测试：

测试代码如下：

int num = 1000000;

ArrayList als = new ArrayList<>();

long l1 = System.currentTimeMillis();

for (int i = 0; i < num; i++) {

StudyRecordBean s1 = new StudyRecordBean();

als.add(s1);

}

long l2 = System.currentTimeMillis();

System.out.println("ArrayList:"+(l2 - l1) + "");

LinkedList lls = new LinkedList<>();

long l3 = System.currentTimeMillis();

for (int i = 0; i < num; i++) {

StudyRecordBean s1 = new StudyRecordBean();

lls.add(s1);

}

long l4 = System.currentTimeMillis();

System.out.println("LinkedList:"+(l4 - l3) + "");

long l5 = System.currentTimeMillis();

HashMap hsm = new HashMap<>();

for (int i = 0; i < num; i++) {

hsm.put(i, new StudyRecordBean());

}

long l6 = System.currentTimeMillis();

System.out.println("HashMap:"+(l6 - l5) + "");

TreeSet trs = new TreeSet<>();

long l7 = System.currentTimeMillis();

for (int i = 0; i < num; i++) {

trs.add(new StudyRecordBean());

}

long l8 = System.currentTimeMillis();

System.out.println("TreeSet:"+(l8 - l7) + "");

TreeMap trm = new TreeMap<>();

long l9 = System.currentTimeMillis();

for (int i = 0; i < num; i++) {

trm.put(i, new StudyRecordBean());

}

long l10 = System.currentTimeMillis();

System.out.println("TreeMap:"+(l10 - l9) + "");

LinkedHashMap lhsm = new LinkedHashMap();

long l11 = System.currentTimeMillis();

for (int i = 0; i < num; i++) {

lhsm.put(i, new StudyRecordBean());

}

long l12= System.currentTimeMillis();

System.out.println("LinkedHashMap:"+(l12 - l11) + "");

num=一万时，输出如下：

ArrayList:4

LinkedList:3

HashMap:8

TreeSet:6

TreeMap:18

LinkedHashMap:6

num=十万时，输出如下：

ArrayList:19

LinkedList:6

HashMap:28

TreeSet:17

TreeMap:90

LinkedHashMap:28

num=一百万时，输出如下：

ArrayList:59

LinkedList:64

HashMap:331

TreeSet:111

TreeMap:356

LinkedHashMap:153

num=一千万时，输出如下：

ArrayList:4770

LinkedList:2761

HashMap:6334

TreeSet:1435

TreeMap:6888

LinkedHashMap:12199

对于超多数据时，TreeSet添加效率最高，其次：LinkedList>ArrayList>其他。

对于LinkedList、ArrayList，如果每次添加数据是从中间插入的话：

int num = 100000;

ArrayList als = new ArrayList<>();

long l1 = System.currentTimeMillis();

for (int i = 0; i < num; i++) {

StudyRecordBean s1 = new StudyRecordBean();

als.add(als.size()/2,s1);

}

long l2 = System.currentTimeMillis();

System.out.println("ArrayList:"+(l2 - l1) + "");

LinkedList lls = new LinkedList<>();

long l3 = System.currentTimeMillis();

for (int i = 0; i < num; i++) {

StudyRecordBean s1 = new StudyRecordBean();

lls.add(lls.size()/2,s1);

}

long l4 = System.currentTimeMillis();

System.out.println("LinkedList:"+(l4 - l3) + "");

插入1万条数据，每次都是从中间插入，输出：

ArrayList:10

LinkedList:82

HashMap:10

TreeSet:0

TreeMap:11

LinkedHashMap:3

插入三万条数据，每次都是从中间插入，输出：

ArrayList:35

LinkedList:671

HashMap:12

TreeSet:43

TreeMap:17

LinkedHashMap:7

插入十万条数据，每次都是从中间插入，输出：

ArrayList:332

LinkedList:16666

HashMap:27

TreeSet:5

TreeMap:56

LinkedHashMap:27

对于从中间某位置插入，ArrayList效率远高于LinkedList

添加数据小结：

对于有序列表：

如果添加到尾部，LinkedList效率比较高；如果插入都中间某位置ArrayList效率会比较高。

对于无序集合：

TreeSet>HashMap>LinkedHashMap

2读取效率测试

测试包括：ArrayList、LinkedList、HashMap、LinkedHashMap

测试代码如下：

public static int num = 10000000;

public static ArrayList als;

public static LinkedList lls;

public static HashMap hsm;

public static TreeSet trs;

public static TreeMap trm;

public static LinkedHashMap lhsm;

public static void main(String[] args) {

Add();

testRead();

}

private static void testRead() {

long l1 = System.currentTimeMillis();

for (int i = 0; i < num; i++) {

als.get(i);

}

long l2 = System.currentTimeMillis();

System.out.println("ArrayList:" + (l2 - l1) + "");

long l3 = System.currentTimeMillis();

for (int i = 0; i < num; i++) {

lls.get(i);

}

long l4 = System.currentTimeMillis();

System.out.println("LinkedList:" + (l4 - l3) + "");

long l5 = System.currentTimeMillis();

for (int i = 0; i < num; i++) {

hsm.get(i);

}

long l6 = System.currentTimeMillis();

System.out.println("HashMap:" + (l6 - l5) + "");

long l9 = System.currentTimeMillis();

for (int i = 0; i < num; i++) {

trm.get(i);

}

long l10 = System.currentTimeMillis();

System.out.println("TreeMap:" + (l10 - l9) + "");

long l11 = System.currentTimeMillis();

for (int i = 0; i < num; i++) {

lhsm.get(i);

}

long l12 = System.currentTimeMillis();

System.out.println("LinkedHashMap:" + (l12 - l11) + "");

}

private static void Add() {

als = new ArrayList<>();

for (int i = 0; i < num; i++) {

StudyRecordBean s1 = new StudyRecordBean();

als.add(als.size(), s1);

}

lls = new LinkedList<>();

for (int i = 0; i < num; i++) {

StudyRecordBean s1 = new StudyRecordBean();

lls.add(lls.size(), s1);

}

hsm = new HashMap<>();

for (int i = 0; i < num; i++) {

hsm.put(i, new StudyRecordBean());

}

trs = new TreeSet<>();

for (int i = 0; i < num; i++) {

trs.add(new StudyRecordBean());

}

trm = new TreeMap<>();

for (int i = 0; i < num; i++) {

trm.put(i, new StudyRecordBean());

}

lhsm = new LinkedHashMap();

for (int i = 0; i < num; i++) {

lhsm.put(i, new StudyRecordBean());

}

}

num=10000时，输出：

ArrayList:1

LinkedList:58

HashMap:3

TreeMap:7

LinkedHashMap:1

num=50000,输出：

ArrayList:3

LinkedList:1089

HashMap:3

TreeMap:20

LinkedHashMap:1

num=10 0000,输出：

ArrayList:21

LinkedList:5135

HashMap:26

TreeMap:7

LinkedHashMap:25

num=5000000,输出：

ArrayList:14

LinkedList:*

HashMap:71

TreeMap:8717

LinkedHashMap:71

结论：

对于数据较多时读取来说，ArrayList>LinkedHashMap>HashMap>TreeMap>LinkedList

总结

添加数据效率：

对于有序列表：

如果添加数据到尾部，LinkedList效率比较高；如果插入都中间某位置ArrayList效率会比较高。

对于无序集合：

TreeSet>HashMap>LinkedHashMap

读取数据

对于数据较多时读取，ArrayList>LinkedHashMap>HashMap>TreeMap>LinkedList