HashMap和HashSet的使用,区别。集合,Array、Collection(List/Set/Queue)、Map

HashMap和HashSet的区别
HashMap和HashSet的区别是Java面试中最常被问到的问题。如果没有涉及到Collection框架以及多线程的面试，可以说是不完整。而Collection框架的问题不涉及到HashSet和HashMap，也可以说是不完整。HashMap和HashSet都是collection框架的一部分，它们让我们能够使用对象的集合。collection框架有自己的接口和实现，主要分为Set接口，List接口和Queue接口。它们有各自的特点，Set的集合里不允许对象有重复的值，List允许有重复，它对集合中的对象进行索引，Queue的工作原理是FCFS算法(First Come, First Serve)。

首先让我们来看看什么是HashMap和HashSet，然后再来比较它们之间的分别。

什么是HashSet

HashSet实现了Set接口，它不允许集合中有重复的值，当我们提到HashSet时，第一件事情就是在将对象存储在HashSet之前，要先确保对象重写equals()和hashCode()方法，这样才能比较对象的值是否相等，以确保set中没有储存相等的对象。如果我们没有重写这两个方法，将会使用这个方法的默认实现。

public boolean add(Object o)方法用来在Set中添加元素，当元素值重复时则会立即返回false，如果成功添加的话会返回true。

什么是HashMap

HashMap实现了Map接口，Map接口对键值对进行映射。Map中不允许重复的键。Map接口有两个基本的实现，HashMap和TreeMap。TreeMap保存了对象的排列次序，而HashMap则不能。HashMap允许键和值为null。HashMap是非synchronized的，但collection框架提供方法能保证HashMap synchronized，这样多个线程同时访问HashMap时，能保证只有一个线程更改Map。

public Object put(Object Key,Object value)方法用来将元素添加到map中。

你可以阅读这篇文章看看HashMap的工作原理，以及这篇文章看看HashMap和HashTable的区别。

HashSet和HashMap的区别

*HashMap* *HashSet*
HashMap实现了Map接口 HashSet实现了Set接口
HashMap储存键值对 HashSet仅仅存储对象
使用put()方法将元素放入map中 使用add()方法将元素放入set中
HashMap中使用键对象来计算hashcode值 HashSet使用成员对象来计算hashcode值，对于两个对象来说hashcode可能相同，所以equals()方法用来判断对象的相等性，如果两个对象不同的话，那么返回false
HashMap比较快，因为是使用唯一的键来获取对象 HashSet较HashMap来说比较慢

java集合使用——HashSet

第一：HashSet的构造和增加元素

集合中存放的是对象的引用。集合中元素的存储空间是自动开辟的，不像数组需要预先开辟内存。

HashSet hashSet = new HashSet();
hashSet.add(new Integer(1)); //向集合中添加一个整数
hashSet.add("a"); //向集合中添加一个字符串
int x[] = {1,2,3,4,5};
hashSet.add(x); //向集合中添加一个数组
Person p = new Person("张三", 23, "男", "研究生");
hashSet.add(p); //向集合中添加一个自定义类的对象

第二：HashSet的遍历

所谓遍历就是按照某种顺序，对于集合中的每个元素访问一次并且仅一次，不重复也不遗漏。

Iterator it = hashSet.iterator();
while(it.hasNext()){
Object obj = it.next();
if(obj instanceof Integer){
System.out.println("integer:"+obj);
}
if(obj instanceof String){
System.out.println("String:"+obj);
}
if(obj instanceof int[]){
System.out.println("integer:"+x[4]);
}
if(obj instanceof Person){
System.out.println("Person:"+p.getName()+p.getAge()+p.getSex()+p.getEducation());

}
}

输出结果是：

integer:1
integer:5
String:a
Person:张三23男研究生

注意：（1）因为集合是无序的，所以输出结果也是无序的。

（2）判断对象是否是数组 obj.getClass().isArray()。

（3）判断对象是否是所属地类obj.getClass().getName()。

第三：删除HashSet中的元素

删除一个元素：hashSet.remove(Object);

删除所有元素：hashSet.clear();

第四：判断是否包含某个元素

if(hashSet.contains(new String("a"))){
System.out.println("String");
}

Java：集合，Array、Collection(List/Set/Queue)、Map的遍历，比如：ArrayList,LinkedList,HashSet,HashMap

1. 概述
1.1 Set接口
存入Set的每个元素都必须是唯一的，Set接口不保证维护元素的次序；
HashSet类： 为快速查找设计的Set，存入HashSet的对象必须定义hashCode()，它不保证集合的迭代顺序；
LinkedHashSet类： 具有HashSet的查询速度，且内部使用链表维护元素的顺序(插入的次序)。
1.2 List接口
List按对象进入的顺序保存对象，不做排序等操作；
ArrayList类：由数组实现的List，允许对元素进行快速随机访问，但是向List中间插入与移除元素的速度很慢；
LinkedList类： 对顺序访问进行了优化，向List中间插入与删除的开销并不大，随机访问则相对较慢。
1.3 Queue接口
Queue用于模拟队列这种数据结构，实现“FIFO”等数据结构。通常，队列不允许随机访问队列中的元素。
ArrayDeque类：为Queue子接口Deque的实现类，数组方式实现。
LinkedList类：是List接口的实现类，同时它也实现了Deque接口（Queue子接口）。因此它也可以当做一个双端队列来用，也可以当作“栈”来使用。
1.4 Map接口
添加、删除操作put/remove/putAll/clear
查询操作get/containsKey/containsValue/size/isEmpty
视图操作keySet/values/entrySet
Map.Entry接口(Map的entrySet()方法返回一个实现Map.Entry接口的对象集合) getKey/getValue/setValue
下面是一段代码用来遍历各种数组、集合、映射的。更多内容请参考：

Java：集合，Collection接口框架图

Java：集合，Map接口框架图

Java：concurrent包下面的Collection接口框架图（ CopyOnWriteArraySet, CopyOnWriteArrayList,ConcurrentLinkedQueue,BlockingQueue）

Java：concurrent包下面的Map接口框架图（ConcurrentMap接口、ConcurrentHashMap实现类）

2. 示范代码
复制代码
package com.clzhang.sample.collections;

import java.util.*;

import org.junit.Test;
import org.junit.Before;
import org.junit.After;

/**
* 测试遍历Array/Set/List/Queue/Map的类
* @author acer
*
*/
public class CollectionMapTest {
private static final int TOTAL_COUNT = 100000;

private String[] array;
private Set set;
private List list;
private Queue queue;
private Map map;

@Before
public void init() {
// 准备测试数据
array = new String[TOTAL_COUNT];
set = new HashSet();
list = new ArrayList();
queue = new LinkedList();
map = new HashMap();

for (int i = 0; i it = set.iterator();
while (it.hasNext()) {
String str = it.next();
}

// 迭代遍历的for方式；或者相对while循环而言，能够避免变量名错误
for (Iterator iter = set.iterator(); iter.hasNext();) {
String str = iter.next().toString();
}

// foreach遍历：JDK1.5之后的方法
for (String str : set) {
// 直接用了，注意它是无序的
}

System.out.println("遍历set各种方式总耗时：" + (Calendar.getInstance().getTimeInMillis() - startTime));
}

@SuppressWarnings("unused")
@Test
public void testList() {
long startTime = Calendar.getInstance().getTimeInMillis();

// 老款遍历的方法
for (int i = 0; i iterator = list.iterator();
while (iterator.hasNext()) {
String str = iterator.next();
}

// 迭代遍历的for方式；相对while循环而言，能够避免变量名错误
for (Iterator iter = list.iterator(); iter.hasNext();) {
String str = iter.next().toString();
}

// foreach遍历：JDK1.5之后的方法
for (String str : list) {
// 直接用了
}

System.out.println("遍历list各种方式总耗时：" + (Calendar.getInstance().getTimeInMillis() - startTime));
}

@SuppressWarnings("unused")
@Test
public void testQueue() {
long startTime = Calendar.getInstance().getTimeInMillis();

// 老款遍历的方法
for (int i = 0; i iterator = queue.iterator();
while (iterator.hasNext()) {
String str = iterator.next();
}

// 迭代遍历的for方式；或者相对while循环而言，能够避免变量名错误
for (Iterator iter = queue.iterator(); iter.hasNext();) {
String str = iter.next().toString();
}

// foreach遍历：JDK1.5之后的方法
for (String str : queue) {
// 直接用了
}

System.out.println("遍历queue各种方式总耗时：" + (Calendar.getInstance().getTimeInMillis() - startTime));
}

@SuppressWarnings("unused")
@Test
public void testMap() {
long startTime = 0;

// Entry方式的迭代遍历（Entry方式遍历时间短）
startTime = Calendar.getInstance().getTimeInMillis();
Iterator> iter1 = map.entrySet().iterator();
while(iter1.hasNext()) {
Map.Entry entry = (Map.Entry) iter1.next();

String key = (String)entry.getKey();
String value = (String)entry.getValue();
}
System.out.println("Map之Entry方式遍历耗时：" + (Calendar.getInstance().getTimeInMillis() - startTime));

// Entry方式的foreach遍历，简单多了是不是，速度还贼快
for (Map.Entry entry : map.entrySet()) {
String key = entry.getKey();
String value = entry.getValue();
}

// keySet方式的迭代遍历（keySet方式遍历耗时多）
startTime = Calendar.getInstance().getTimeInMillis();
Iterator iter2 = map.keySet().iterator();
while (iter2.hasNext()) {
String key = (String)iter2.next();
String value = (String)map.get(key);
}
System.out.println("Map之keySet方式遍历耗时：" + (Calendar.getInstance().getTimeInMillis() - startTime));

// keySet方式的foreach遍历，更简单，但速度慢
for(String key: map.keySet()) {
String value = (String)map.get(key);
}
}
}
复制代码
输出：

遍历set各种方式总耗时：31
遍历list各种方式总耗时：47
遍历queue各种方式总耗时：47
遍历array各种方式总耗时：0
Map之Entry方式遍历耗时：15
Map之keySet方式遍历耗时：31

3. 总结
1.遍历数组速度最快；
2.Map在Entry方式与keySet方式遍历时，耗时有着非常大的区别，原因应该是keySet方式遍历时再次调用map.get(key)方法造成的，当数据量大时，需要特别考虑。