Java基础之ArrayList与LinkedList、Vector，以及HashMap与HashTable的区别

最新推荐文章于 2023-08-08 14:14:05 发布

itchenlin

最新推荐文章于 2023-08-08 14:14:05 发布

阅读量1.3k

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/itchenlin/article/details/45872875

版权

java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

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有两种遍历方法：

<div style="text-align: left;">		// 第一种:</div><div style="text-align: left;">		Map<Object, Object> map = new HashMap<Object, Object>();</div>		for (int i = 0; i < 10000; i++) {
			map.put(it, i);
		}
<div style="text-align: left;">		Iterator<Entry<Object, Object>> iter = map.entrySet().iterator();</div>		long time=System.currentTimeMillis();
		while (iter.hasNext()) {
			Entry<Object, Object> entry = iter.next();
<div style="text-align: left;">		Iterator<Object> iter2 = map.keySet().iterator();</div>			Object key = entry.getKey();
			Object val = entry.getValue();
		}
		long time2=System.currentTimeMillis();
		// 第二种:
<div style="text-align: left;">		System.out.println("(time3-time2)>(time2-time)："+((time3-time2)>(time2-time)));</div>		while (iter2.hasNext()) {
			Object key = iter2.next();
			Object val = map.get(key);
		}
<div style="text-align: left;">		long time3=System.currentTimeMillis();</div>

运行结果：

[html]view plaincopyprint? 
    
 (time3-time2)>(time2-time)：false  

很显然，第二种方法要比第一种方法快，是一种轻量级的处理方式。

Hashset：不允许有重复元素，不同步，线程安全，可自动排序，与List用法相似。

有关HashSet：

[html]view plaincopyprint? 
    
 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());  
 }  

执行结果：

[html]view plaincopyprint? 
    
 1  
 2  
 4  

说明两个问题，第一、HashSet是不允许重复数据的，第二、HashSet是自动排序的

ArrayList：查找数据快，由其数组结构决定，是动态数组而非链表，有下标。底层由数组支持。

LinkedList：增加、删除数据快，而查找数据慢，前一个元素带有后一个元素的索引。底层由双向链表实现。

最有争议的是修改这一块，关于修改，它其实是删除+增加，理论上说是LinkedList要快一点。

[html]view plaincopyprint? 
    
 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)));  

运行结果：

[html]view plaincopyprint? 
    
 (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<Student> list = new ArrayList<Student>();
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<Student> {
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;
}

//如果需要从小到大的排序，需要用本对象与传过来的对象进行比较

@Override
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<String> v = new Vector<String>();
// 把对象加入Vector
v.add("ab");
v.add("ef");
v.add("cd");
v.add("ij");
v.add("gh");
// 排序
Collections.sort(v);// Collections.sort给集合排序，根据元素的自然顺序对指定列表按升序进行排序。
// 输出
Iterator<String> it = v.iterator();// 返回以正确顺序在此列表的元素上进行迭代的迭代器。
while (it.hasNext()) {// 遍历iterator
String t = (String) it.next();// 向下读取一个iterator
System.out.println(t);
}
}
}