Java基础之ArrayList与LinkedList、Vector，以及HashMap与HashTable的区别
ArrayList是一个动态数组，有下标
LinkedList是一个双向链表，一个指针指向下一个
相同点：都继承自Collections类，放动态数据。
不同点：
后者有指针，增加一个数据，只用断开一个连接，分别将新数据连上
删除一个数据，区别在于如果这个数据位于数组中间，后者只用查到该数据，断开一个连接，将两边的数据连上；
而前者需要将后面所有数据移位
修改，对于后者来说，就是删除+增加；而后者需要移位。
查找，前者通过下标查找方便，后者需要一个指针指向下一个指针来寻找数据，比较慢。
Vector使用数组实现，其实跟ArrayList一样，区别仅在于实现同步，即不同线程可以共用一个数据。但它不会对遍历如iterator加锁，仅set、get、remove等常用操作加锁，在这一点上HashTable同理。
HashMap底层使用数组+链表实现，同一个键可以放多个值，但取出的是最后一个，非同步，允许放空值空键
HashTable与HashMap一样，唯一不同就是，它是线程安全的,put、get等操作都加锁。
LinkedHashMap与LinkedArrayList原理相似，可以放空值空键，非同步。
我们能否让HashMap同步？可以通过下面语句同步：
Map map=Collections.sychronizedMap(hashmap);
如果要完全的线程安全可以考虑CopyOnWriteArrayList和ConcurrentHashMap。它们使用volatile和synchronzied来保持同步。
大家好，今天我们来讲一下常用的集合类，如ArrayList、HashMap、HashSet、LinkedList
同步：即多个线程访问一个实例，如果一个线程对实例进行修改，则实例发生改变
Hashmap：是一个键值对组合，允许多个空值和一个空键的出现，可同步，不安全。
HashMap有两种遍历方法：
// 第一种: Map map = new HashMap(); for (int i = 0; i < 10000; i++) {
map.put(it, i);
}
Iterator> iter = map.entrySet().iterator(); long time=System.currentTimeMillis();
while (iter.hasNext()) {
Entry entry = iter.next();
Iterator Object key = entry.getKey();
Object val = entry.getValue();
}
long time2=System.currentTimeMillis();
// 第二种:
System.out.println("(time3-time2)>(time2-time)："+((time3-time2)>(time2-time))); while (iter2.hasNext()) {
Object key = iter2.next();
Object val = map.get(key);
}
long time3=System.currentTimeMillis();
- (time3-time2)>(time2-time)：false
Hashset：不允许有重复元素，不同步，线程安全，可自动排序，与List用法相似。
有关HashSet：
- HashSet<Integer> set = new HashSet<Integer>();
- set.add(2);
- set.add(1);
- set.add(4);
- set.add(2);
- Iterator<Integer> it = set.iterator();
- while(it.hasNext()){
- System.out.println(it.next());
- }
执行结果：
- 1
- 2
- 4
说明两个问题，第一、HashSet是不允许重复数据的，第二、HashSet是自动排序的
ArrayList：查找数据快，由其数组结构决定，是动态数组而非链表，有下标。底层由数组支持。
LinkedList：增加、删除数据快，而查找数据慢，前一个元素带有后一个元素的索引。底层由双向链表实现。
最有争议的是修改这一块，关于修改，它其实是删除+增加，理论上说是LinkedList要快一点。
- ArrayList<Integer> list = new ArrayList<Integer>();
- for (int i = 0; i < 1000000; i++) {
- list.add(i);
- }
- LinkedList<Integer> list2 = new LinkedList<Integer>();
- for (int i = 0; i < 1000000; i++) {
- list2.add(i);
- }
- long time4 = System.currentTimeMillis();
- list.remove(100);
- list.add(100, 9000);
- long time5 = System.currentTimeMillis();
- list2.remove(100);
- list2.add(100, 9000);
- long time6 = System.currentTimeMillis();
- System.out.println("(time6-time5)>(time5-time4)："
- + ((time6-time5)>(time5-time4)));
运行结果：
- (time6-time5)>(time5-time4)：false
很显然LinkedList要比ArrayList修改要快。
下面是有关List集合中对象排序的问题：
ArrayList和LinkedList是两个集合类，一般查找数据操作多需要用前者，删除插入操作多的要用后者。
方法一：
主程序：
package test.test5;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
//按姓名的长度排序
public class SortByName {
public static void main(String[] args) {// Student stu1 = new Student(23, "fred");
// Student stu2 = new Student(29, "frankie");
// Student stu3 = new Student(27, "gv");
// Student stu4 = new Student(28, "terry");
Student stu1 = new Student(23, "刘L中");
Student stu2 = new Student(29, "魏W");
Student stu3 = new Student(27, "张");
Student stu4 = new Student(28, "杨Y史泰龙");
List
list.add(stu1);
list.add(stu2);
list.add(stu3);
list.add(stu4);
Collections.sort(list);
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i).name + ":" + list.get(i).age);
}
}
}
结果：
张:27
魏W:29
刘L中:23
杨Y史泰龙:28
Bean程序：
package test.test4;
import test.test3.PinYin;
//要实现其Comparable接口
public class Student implements Comparable
public int age;
public String name;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Student(int age, String name) {
super();
this.age = age;
this.name = name;
}
//如果需要从小到大的排序，需要用本对象与传过来的对象进行比较
public int compareTo(Student o) {
// TODO Auto-generated method stub
int a = o.name.length();
int b = this.name.length();
return b - a;
}
}
方法二：
package test.test5;
import java.util.Collections;
import java.util.Iterator;
import java.util.Vector;
public class VectorTest {
public static void main(String[] args) {
Vector
// 把对象加入Vector
v.add("ab");
v.add("ef");
v.add("cd");
v.add("ij");
v.add("gh");
// 排序
Collections.sort(v);// Collections.sort给集合排序，根据元素的自然顺序 对指定列表按升序进行排序。
// 输出
Iterator
while (it.hasNext()) {// 遍历iterator
String t = (String) it.next();// 向下读取一个iterator
System.out.println(t);
}
}
}
源码：http://download.csdn.net/detail/liuxian13183/4319722
Java容器的深入研究：
ConcurrentMap接口及其实现ConcurrentHashMap均用于多线程机制。
CopyOnWriteArrayList和CopyOnWriteArraySet也是用于多线程机制的。
LinkedHashSet以插入元素的顺序保存数据，代价要比HashSet高
TreeSet按照降序保存数据，要实现Comparator接口，一般只有用于一个排好序的Set时才会用到它。
SortedSet按照Comparator来排序保存数据
LinkedList和PriorityQueue是Queue的实现类，差异在排序而非性能，前者升序后者无序
LinkedList是双向队列，可以前后分别插入和删除数据，区别于底层由数组实现的ArrayList
HashMap是通过hashCode来实现快速查询的
SortedMap使键处于始终排序的状态
LinkedHashMap为提高速度，散列化所有元素，插入时比HashMap慢一点
SlowMap是最慢的查询方式
hashCode对于同一个对象的调用都是一样的，如果程序中有多个String对象，且包含相同的字符串，则它们共用一块内存
HashSet效率要比TreeSet好，同时它是自动排序的
WeakHashMap允许垃圾回收器自动清理键和值，触发条件：不再需要此键
Stack关注pop返回首对象并删除之，peek返回首对象并不删除，push将一值插入栈顶