HashSet

<1> 此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。它不保证集合的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用 null 元素。

<2> HashSet不是同步的，需要用以下语句来进行S同步转换

Set s = Collections.synchronizedSet(new HashSet(...));

<3> 是如何保证元素的唯一性？

是通过元素的两个方法，hashCode和equals来完成，如果元素的HashCode值相同，才会判断equals来完成

如果元素的HashCode值不同，不会调用equals

<4> 对于判断元素是否还在，以及删除等操作，依赖的方法是元素的hashCode和equals方法

往HashSet集合中存入自定义对象

public class ListDemoClass {  public static void main(String[] args) {  //新建集合  HashSet hs = new HashSet();  //向集合中添加元素  hs.add("java2");  hs.add("java3");  hs.add("java1");  hs.add("java4");  hs.add("java5");  //注：add方法的返回值为boolean true代表添加元素成功  //使用迭代器的方法将集合中的元素数据取出  //获取迭代器  Iterator iterator = hs.iterator();  //取出数据  while(iterator.hasNext()){  Object next = iterator.next();  System.out.println("hs中的数据为  ："+next+"");  }  }  } 

往HashSet集合中存入自定义对象

定义要进行存储的对象类

public class PersonInfo {  // 姓名和年龄相同为同一个人，重复元素  private String name;  private int age;  PersonInfo(String name, int age) {  this.name = name;  this.age = age;  }  public int hashCode() {  return name.hashCode();  }  public String getName() {  return name;  }  public int getAge() {  return age;  }  //进行比较的方法  public boolean equals(Object obj) {  if (!(obj instanceof PersonInfo))  return false;  PersonInfo pe = (PersonInfo) obj;  return this.name.equals(pe.name) && this.age == pe.age;  }  }

编写储存数据的测试类

public class ListDemoClass {  public static void main(String[] args) {  // 往hAashSet集合中存入自定义对象  // 姓名和年龄相同为同一个人，重复元素  HashSet hs = new HashSet();  //向集合中添加元素  hs.add(new PersonInfo("lishi", 22));  hs.add(new PersonInfo("lishi1", 23));  hs.add(new PersonInfo("lishi2", 24));  hs.add(new PersonInfo("lishi3", 25));  hs.add(new PersonInfo("lishi3", 25));  hs.add(new PersonInfo("lishi3", 25));  Iterator it = hs.iterator();  while (it.hasNext()) {  //取出集合中的元素  PersonInfo pe = (PersonInfo) it.next();  System.out.println( "person name is " + pe.getName()+"and age is "+pe.getAge());  }  } 

编译运行调试

可以看到，我们向其中添加了六条数据，但实际上集合中只添加了四条数据，因为其中有两条数据是相同的，也就是说那两条数据与我们集合中现有的数据name 各age 是一致的

TreeSet

<1> 可以对集合中的元素进行排序

<2> 里面存储的元素必须具有可比性

<3> TreeSet排序的第一种方式为  让元素自身具有比较性，元素需要实现compareable接口，覆盖compareTo方法，这种方式也是元素的自然顺序，或者叫默认顺序

向TreeSet中储存String类型的数据

public class ListDemoClass {  public static void main(String[] args) {  // 新建集合  TreeSet ts = new TreeSet();  //向集合中添加元素  ts.add("aaa");  ts.add("aoa");  ts.add("ara");  ts.add("aea");  //获取取迭代器  Iterator it = ts.iterator();  //循环取出集合中的元素，并将取出的元素输出在控制台上面  while (it.hasNext()) {  System.out.println(it.next());  }  }

可以看到，集合中储存的数据以按照其自然顺序进行了排序

//创建集合TreeSet<String> treeSet = new TreeSet<String>();//添加元素treeSet.add("adsf");treeSet.add("uytf");treeSet.add("hjk");treeSet.add("wedcv");treeSet.add("kngfsf");treeSet.add("wqqs");//输出储存的数据System.out.println(treeSet.toString());//[adsf, hjk, kngfsf, uytf, wedcv, wqqs]

按照自定义的比较规则进行集合中元素排序

这里是按字符串的长度来进行排序

//创建集合TreeSet<String> treeSet = new TreeSet<String>();//添加元素treeSet.add("adsf");treeSet.add("uytf");treeSet.add("hjk");treeSet.add("wedcv");treeSet.add("kngfsf");treeSet.add("wqqs");//输出储存的数据System.out.println(treeSet.toString());//[adsf, hjk, kngfsf, uytf, wedcv, wqqs]

//将集合中的String类型的数据进行降序排序 //创建集合TreeSet<String> treeSet = new TreeSet<String>(Collections.reverseOrder());//添加元素treeSet.add("adsf");treeSet.add("uytf");treeSet.add("hjk");treeSet.add("wedcv");treeSet.add("kngfsf");treeSet.add("wqqs");//输出储存的数据System.out.println(treeSet.toString());//[wqqs, wedcv, uytf, kngfsf, hjk, adsf]

//将集合中的String类型的数据按照自定义的比较方法按长度由大到小进行排序 //创建集合TreeSet<String> treeSet = new TreeSet<String>(Collections.reverseOrder(new StringSortComparator()));//添加元素treeSet.add("adsf");treeSet.add("uytf");treeSet.add("hjk");treeSet.add("wedcv");treeSet.add("kngfsf");treeSet.add("wqqs");//输出储存的数据System.out.println(treeSet.toString());//[kngfsf, wedcv, wqqs, uytf, adsf, hjk]//自定义比较器，按照字符串的长度进行比较原则
class StringSortComparator implements Comparator<String>{@Overridepublic int compare(String arg0, String arg1) {//比较两个字符串的长度int number = arg0.length()-arg1.length();//==0说明两个字符串的长度一样，再进行内容比较if(number==0){return arg0.compareTo(arg1);}return number;}
}

向TreeSet中储存自定义对象

在其中存储自定义对象的时候，必须使自定义对象具有可比性，那么可以实现 Comparable接口，然后复写compareTo方法，在其中定义比较对象顺序的方法发生

public class PersonBean implements Comparable {  private String name;  private int age;  PersonBean(String name, int age) {  this.name = name;  this.age = age;  }  public String getName() {  return name;  }  public int getAge() {  return age;  }  @Override  public int compareTo(Object obj) {  if (!(obj instanceof PersonBean))  throw new RuntimeException();  /** * 在这里定义比较对象大小的方法 * 先进行年龄的比较，年龄不相等再进行姓名的比较 * 如果年龄与姓名都相等，那么就代表同一个对象 */  PersonBean pe = (PersonBean) obj;  if (this.age > pe.age)  return 1;  if (this.age == pe.age) {  return this.name.compareTo(pe.name);  }  return -1;  }
} 

建立测试类

public class ListDemoClass {  public static void main(String[] args) {  // 向这个集合中存储自定义对象  TreeSet ts = new TreeSet();  ts.add(new PersonBean("lishi", 22));  ts.add(new PersonBean("lishi1", 23));  ts.add(new PersonBean("lishi3", 25));  ts.add(new PersonBean("lishi4", 25));  //获取迭代器，取出其中的元素  Iterator it = ts.iterator();  while (it.hasNext()) {  PersonBean pe = (PersonBean) it.next();  System.out.println(pe.getAge() + "  " + pe.getName());  }  }

可以看到输出的结果 ，先按照年龄进行排序储存，如果年龄相同，再按照姓名进行排序储存，如果姓名也相同，则代表是同一对象 ，则不进行储存

向TreeSet中传入比较器进行排序

这时需要让容器自身具备比较性，

那么需要定义比较器 ，将比较器对象作为参数传递给TreeSet 集合的构造函数

当两种排序都存在时，以比较器为主

那么可以定义一个类，实现Comparator接口，覆盖compare方法

新建储存对象，并实现Comparator接口，在compare方法中宝比较规则

public class PersonBean implements Comparable {  private String name;  private int age;  PersonBean(String name, int age) {  this.name = name;  this.age = age;  }  public String getName() {  return name;  }  public int getAge() {  return age;  }  @Override  public int compareTo(Object obj) {  if (!(obj instanceof PersonBean))  throw new RuntimeException();  /** * 在这里定义比较对象大小的方法 * 先进行年龄的比较，年龄不相等再进行姓名的比较 * 如果年龄与姓名都相等，那么就代表同一个对象 */  PersonBean pe = (PersonBean) obj;  if (this.age > pe.age)  return 1;  if (this.age == pe.age) {  return this.name.compareTo(pe.name);  }  return -1;  }
} 

自定义一个比较器

import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.TreeSet;  class CustomCompare implements Comparator {  public int compare(Object obj1, Object obj2) {  //获取将要进行比较的两个对象  PersonBean p1 = (PersonBean) obj1;  PersonBean p2 = (PersonBean) obj2;  //先进行比较两个对象中的name是否相等，如果相等，那么将返回0  int num = p1.getName().compareTo(p2.getName());  //如果name相等，那么再比较age的大小   if (num == 0) {  if (p1.getAge() > p2.getAge())  return 1;  if (p1.getAge() == p2.getAge())  return 0;  return -1;  }  return num;  }
} 

新建测试类：

public class ListDemoClass {  public static void main(String[] args) {  // 向这个集合中存储自定义对象  TreeSet ts = new TreeSet(new CustomCompare());  ts.add(new PersonBean("lishi", 22));  ts.add(new PersonBean("lishi1", 23));  ts.add(new PersonBean("lishi3", 25));  ts.add(new PersonBean("lishi3", 26));  ts.add(new PersonBean("lishi3", 24));  ts.add(new PersonBean("lishi4", 25));  // 取出集合中的元素数据，并将相关信息输出在控制台上  Iterator it = ts.iterator();  while (it.hasNext()) {  PersonBean pe = (PersonBean) it.next();  System.out.println(pe.getAge() + "  " + pe.getName());  }  } 

以字符串的长度为排序规则进对TreeSet集合中的String类型的数据进行排序

首先自定义一个比较器

class StringLengthCompare implements Comparator {  public int compare(Object obj1, Object obj2) {  //获取将要进行比较的字符串  String s = (String) obj1;  String s1 = (String) obj2;  int num = new Integer(s.length()).compareTo(new Integer(s1.length()));  if (num == 0) {  return s.compareTo(s1);  }  return num;  }
} 

新建测试类：

    public class ListDemoClass {  public static void main(String[] args) {  // 按照字符长度排序  // 字符串具有比较性，但是不是所需要的  // 向这个集合中存储自定义对象  //新建TreeSet集合并将自定义比较 器传给集合  TreeSet ts = new TreeSet(new StringLengthCompare());  //向集合中添加不同长度的String字符串  ts.add("ggg");  ts.add("aaa");  ts.add("swed");  ts.add("asdfv");  ts.add("tyrfg");  //获取迭代器，循环取出集合中的数据并输出在控制台上  Iterator it = ts.iterator();  while (it.hasNext()) {  String s = (String) it.next();  System.out.println(s);  }  }  

Map

Map没有继承Collection接口。也就是说Map和Collection是2种不同的集合。Collection可以看作是（value）的集合，而Map可以看作是（key，value）的集合。

Map接口由Map的内容提供3种类型的集合视图，一组key集合，一组value集合，或者一组key-value映射关系的集合。

常见子类及特点
HashTable 底层是哈希表，是同步的，null不可以做键值进行储存
HashMap 底层是哈希不结表结构，不同步，null可以做键值进行储存
TreeMap 底层是二叉树结构，是不同步的，

Hashtable

Hashtable继承Map接口，实现一个key-value映射的哈希表。任何非空（non-null）的对象都可作为key或者value。
由于作为key的对象将通过计算其散列函数来确定与之对应的value的位置，因此任何作为key的对象都必须实现hashCode和equals方 法。

特别说明

hashCode和equals方法继承自根类Object，如果你用自定义的类当作key的话，要相当小心，按照散列函数的定义，如果两个对象相 同，即obj1.equals(obj2)=true，则它们的hashCode必须相同，但如果两个对象不同，则它们的hashCode不一定不同，如 果两个不同对象的hashCode相同，这种现象称为冲突，冲突会导致操作哈希表的时间开销增大，所以尽量定义好的hashCode()方法，能加快哈希 表的操作。

  
    如果相同的对象有不同的hashCode，对哈希表的操作会出现意想不到的结果（期待的get方法返回null），要避免这种问题，只需要牢记一条：要同时复写equals方法和hashCode方法，而不要只写其中一个。

    Hashtable是同步的。

HashMap

HashMap和Hashtable类似，不同之处在于HashMap是非同步的，并且允许null，即null value和null ke

// 新建一个集合Map<Integer, String> map = new HashMap<Integer, String>();// 向map中添加10条数据for (int i = 0; i < 10; i++) {map.put(i, "java" + i);}System.out.println(map);// {0=java0, 1=java1, 2=java2, 3=java3, ...}//删除指定位置的元素map.remove(0);System.out.println(map);//{1=java1, 2=java2, 3=java3,...}//判断指定位置的元素是否在在boolean containsKey = map.containsKey(0);System.out.println(containsKey);//false

取出map集合中的数据 方式一

//取出方式一 //获取集合中的元素//先获取所有的key，然后再去获取所的valueSet<Integer> keySet = map.keySet();Iterator<Integer> iterator = keySet.iterator();while (iterator.hasNext()) {//获取对应的keyInteger next = iterator.next();//根据key值获取对应的值 String string = map.get(next);}

取出map集合中的数据 方式二

// 取出方式二//将map中的键值的映射关系 作为对象储存到set集合中去Set<Entry<Integer,String>> entrySet = map.entrySet();//获取迭代器Iterator<Entry<Integer, String>> iterator2 = entrySet.iterator();while(iterator2.hasNext()){Entry<Integer, String> entry = iterator2.next();//获取keyInteger key = entry.getKey();//获取对应的valueString value = entry.getValue();}

取出map集合中的数据 方式三

//取出方式三Collection<String> values = map.values();Iterator<String> iterator3 = values.iterator();while(iterator3.hasNext()){String valueString = iterator3.next();}

TreeMap

创建一个类对象，作为key储存在TreeMap集合中

class Person {//定义对象的两个私有属性private String name = "张三";private String age = "22";private Person person;public Person() {super();}public Person(String name, String age) {super();this.name = name;this.age = age;}public String getName() {return name;}public String getAge() {return age;}

//创建一个集合TreeMap<Person,String> treeMap = new TreeMap<Person,String>();//向TreeMap中添加数据 treeMap.put(new Person("张三", "10"), "山西");treeMap.put(new Person("李四", "15"), "上海");treeMap.put(new Person("王五", "9"), "山西");treeMap.put(new Person("小六", "13"), "北京");//输出元素信息System.out.println(treeMap);

编译运行;出现错误

Exception in thread "main" java.lang.ClassCastException: Person cannot be cast to java.lang.Comparableat java.util.TreeMap.compare(Unknown Source)at java.util.TreeMap.put(Unknown Source)at MapDemoTest.main(MapDemoTest.java:15)

走到这里，我们可以看到在进行元素储存的过程的时候就已经出现错误了

解决方案 （一）

使我们的对象本身具有比较性，实现Comparable接口，在compareTo方法定义比较规则为根据姓名来排序

class Person implements Comparable<Person>{//定义对象的两个私有属性private String name = "张三";private String age = "22";private Person person;public Person() {super();}public Person(String name, String age) {super();this.name = name;this.age = age;}public String getName() {return name;}public String getAge() {return age;}@Overridepublic int compareTo(Person arg0) {return this.name.compareTo(arg0.name);}

这样后，我们再进行编译运行就要吧发现可以进行了

解决方案（二）
定义一个比较器，然后将比较器传给集合

// 自定义一个比较器，在compare中定义比较规则
// 这里定义的比较规则是Person中的姓名进行比较
class MapSortCompar implements Comparator<Person> {@Overridepublic int compare(Person o1, Person o2) {return o1.getName().compareTo(o2.getName());}}

然后将比较器传递给集合

// 创建一个集合TreeMap<Person, String> treeMap = new TreeMap<Person, String>(new MapSortCompar());// 向TreeMap中添加数据treeMap.put(new Person("张三", "10"), "山西");treeMap.put(new Person("李四", "15"), "上海");treeMap.put(new Person("王五", "9"), "山西");treeMap.put(new Person("小六", "13"), "北京");// 输出元素信息Set<Person> keySet = treeMap.keySet();Iterator<Person> iterator = keySet.iterator();while(iterator.hasNext()){Person key = iterator.next();String values = treeMap.get(key);System.out.println("key is "+key.getName()+"value is "+values);}

编译运行：控制台会输出

key is 小六value is 北京
key is 张三value is 山西
key is 李四value is 上海
key is 王五value is 山西