HashSet
1.元素顺序：元素唯一，但是无序（它不保证Set的迭代顺序，特别是它不保证该顺序永久不变）。
2.如何保证元素的唯一性：重写hashCode()和equals()两个方法。
执行流程：
首先判断哈希值是否相同：
（1）如果不同，就直接添加到集合；
（2）如果相同，继续执行equals()，看其返回值：
-如果是false，就直接添加到集合；
-如果是true，说明元素重复不添加。
使用：看到哈希结构的集合，就要考虑可能需要重写这两个方法。（自动生成就可以了：shift+alt+s）
重写的方法如下：
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
/* (non-Javadoc)
* @see java.lang.Object#equals(java.lang.Object)
*/
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}3.HashSet底层结构是哈希表。
哈希表结构：是一个元素为链表的数组结构。
TreeSet
1.元素顺序：使用元素的自然排序对元素进行排序，或者根据创建Set时提供的Comparator进行排序。
2.底层算法：二叉树。
3.二叉树存储元素的原则：
当存入第二个元素的时候，会与之前的元素做减法：
-如果为负说明比之前的元素小，往左放；
-如果为正说明比之前的元素大，往右放；
-如果为零，不存储。
需求：创建集合存储Integer类型的元素（20,18,23,22,17,24,19,18,24）。
public class TreeSetDemo {
public static void main(String[] args) {
//创建TreeSet集合
TreeSet<Integer> ts = new TreeSet<Integer>();
//给集合添加元素
ts.add(20);
ts.add(18);
ts.add(23);
ts.add(22);
ts.add(17);
ts.add(24);
ts.add(19);
ts.add(18);
ts.add(24);
//遍历集合
for (Integer it : ts) {
System.out.println(it);
}
}
}运行结果： 
需求：存储字符串并遍历（字母a-z排序）。
public class TreeSetDemo2 {
public static void main(String[] args) {
//创建TreeSet集合
TreeSet<String> ts = new TreeSet<String>();
//给集合添加元素
ts.add("hello");
ts.add("bat");
ts.add("c++");
ts.add("java");
ts.add("php");
//遍历集合
for (String str : ts) {
System.out.println(str);
}
}
}运行结果： 
4.自然比较法和比较器比较法：
（1）自然比较法：当使用无参构造创建集合时，自定义对象实现Comparable接口，并重写compareTo()方法。
//学生类中实现Comparable接口，并重写compareTo()方法如下
@Override
public int compareTo(Student s) {
//按照年龄进行排序
int num=this.age-s.age;
//如果年龄相同按照姓名排序
int num2= num==0 ? this.name.compareTo(s.name):num;
return num2;
}（2）比较器比较法：当使用有参构造创建集合时，可以使用匿名内部类的方式，传入Comparator进行排序。
//这里也是通过学生类来举例，先比较年龄，再比较姓名
TreeSet<Student> ts=new TreeSet<Student>(new Comparator<Student>(){
public int compare(Student s1, Student s2) {
int num = s1.getAge() - s2.getAge();
int num2 = num==0?s1.getName().compareTo(s2.getName()):num;
return num2;
}
});Set的遍历
1.Iterator迭代器比较法
2.增强for循环
HashSet与TreeSet的相同点与不同点
1.相同点：
单列集合，元素不可重复。
2.不同点：
（1）底层存储的数据结构不同：
HashSet底层用的是HashMap哈希表结构存储，而TreeSet底层用的是TreeMap树结构存储。
（2）存储时保证数据唯一性依据不同：
HashSet是通过重写HashCode()方法和equals()方法来保证的，而TreeSet通过Comparable接口的compareTo()方法来保证的。
3.有序性不一样：
HashSet无序，TreeSet有序。
Map
1.Map：将键映射到值得对象。一个映射不能包含重复的键，每个键最多只能映射到一个值。
2.Map接口中的部分方法：
-获取功能
Set<Map.Entry<K,V>> entrySet() //获取键值对对象的集合，遍历键值对对象，再利用getKey(),getValue()取出键和值
V get(Object key) //根据键获取值
Set<K> keySet() //获取所有的键
Collection<V> values() //获取所有的值-删除功能:
void clear() //移除集合中的所有键值对元素
V remove(Object key) //根据键移除键值对元素，并返回值-判断功能:
boolean containsKey(Object key) //判断集合中是否包含指定的键
boolean containsValue(Object value) //判断集合中是否包含指定的值
boolean isEmpty() //判断集合是否为空-添加功能
V put(K key,V value) //集合添加键值对-长度功能
int size() //键值对对数需求：存入（String,String）主要讲解遍历方式，键：丈夫 值：妻子。
public class HashMapDemo {
public static void main(String[] args) {
/**
* 2.HashMap
2.1元素顺序：元素顺序不可预测
2.2底层算法：哈希算法
2.3对键没有要求（仅仅相对于TreeMap来说）
*/
//存入（String,String）主要讲解遍历方式，键：丈夫 值：妻子
HashMap<String,String> hs = new HashMap<String,String>();
//给集合添加元素
hs.put("丈夫1","妻子1");
hs.put("丈夫2","妻子2");
hs.put("丈夫3","妻子3");
hs.put("丈夫4","妻子4");
hs.put("丈夫5","妻子5");
//遍历，通过键找值
Set<String> ks = hs.keySet();
for (String key : ks) {
System.out.println(key+" "+hs.get(key));
}
System.out.println("--------------------------");
//通过entrySet来遍历
Set<Entry<String, String>> entrySet = hs.entrySet();
for (Entry<String, String> entry : entrySet) {
System.out.println(entry.getKey()+" "+entry.getValue());
}
}
}
运行结果： 
需求：存入（String,Student）键：String(国籍) 值：Student。
public class HashMapDemo {
public static void main(String[] args) {
//存入（String,Student）键：String(国籍) 值：Student
HashMap<String,Student> hm = new HashMap<String,Student>();
//创建学生对象
Student s1 = new Student("张三",21);
Student s2 = new Student("樱桃小丸子",22);
Student s3 = new Student("金韩一",23);
Student s4 = new Student("Jackson",22);
//添加键值对到集合中
hm.put("中国",s1);
hm.put("日本",s2);
hm.put("韩国",s3);
hm.put("美国",s4);
//遍历，通过键找值
Set<String> ks = hm.keySet();
for (String key : ks) {
System.out.println(key+" "+hm.get(key));
}
}
}
运行结果： 
3.HashMap
（1）元素顺序：元素顺序不可预测
（2）底层算法：哈希算法
（3）对键没有要求（仅仅相对于TreeMap来说）
4.Treemap
（1）元素顺序：元素顺序与键的排序规则有关
（2）底层算法：Tree算法
5.遍历：
（1）获取建的集合
（2）遍历键
（3）根据键找值foreach()
1.foreach()：例如：根据丈夫找妻子（根据键找值）
2.entrySet()：例如：先找到夫妻的结婚证，再从结婚证里面找到丈夫和妻子（先找到键值对对象，再从键值对对象里面找到键和值）
6.HashMap与TreeMap的相同点与不同点：
（1）相同点：主要用于存储键(key)值(value)对，根据键得到值，因此键不允许键重复,但允许值重复。
（2）不同点：
HashMap里面存入的键值对在取出的时候是随机的,也是我们最常用的一个Map.根据键可以直接获取它的值，具有很快的访问速度。在Map 中插入、删除和定位元素，HashMap 是最好的选择。
TreeMap取出来的是排序后的键值对。但如果您要按自然顺序或自定义顺序遍历键，那么TreeMap会更好。