集合框架：

Java中的集合框架大类可分为Collection和Map；两者的区别：

1、Collection是单列集合；Map是双列集合

2、Collection中只有Set系列要求元素唯一；Map中键需要唯一，值可以重复

3、Collection的数据结构是针对元素的；Map的数据结构是针对键的。

泛型：

在说两大集合体系之前先说说泛型，因为在后面的集合中都会用到；

所谓的泛型就是：类型的参数化

泛型是类型的一部分，类名+泛型是一个整体

如果有泛型，不使用时，参数的类型会自动提升成Object类型，如果再取出来的话就需要向下强转，就可能发生类型转化异常(ClassCaseException)；不加泛型就不能在编译期限定向集合中添加元素的类型，导致后期的处理麻烦。

下面就来对比加了泛型和不加泛型的区别：

  1. package com.xiaoshit_zongjie;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.Iterator;
  5. import java.util.List;
  6.  
  7. public class Test {
  8.  
  9.     public static void main(String[] args) {
  10.         // 不加泛型，添加和遍历
  11.         List list = new ArrayList<>();
  12.         list.add(1);
  13.         list.add("123");
  14.         list.add("hello");
  15.  
  16.         Iterator it = list.iterator();
  17.         while(it.hasNext()){
  18.             // 没有添加泛型，这里只能使用Object接收
  19.             Object obj = it.next();
  20.             System.out.println(obj);
  21.         }
  22.     }
  23.  
  24. }
  25. package com.xiaoshit_zongjie;
  26.  
  27. import java.util.ArrayList;
  28. import java.util.Iterator;
  29. import java.util.List;
  30.  
  31. public class Test {
  32.  
  33.     public static void main(String[] args) {
  34.         // 加泛型，添加和遍历
  35.         List<String> list = new ArrayList<String>();
  36.         list.add("123");
  37.         list.add("hello");
  38.  
  39.         Iterator<String> it = list.iterator();
  40.         while(it.hasNext()){
  41.             // 因为添加了泛型，就说明集合中装的全部都是String类型的数据
  42.             // 所以这里用String类型接收，就不会发生异常，并且可以使用String的方法
  43.             String str = it.next();
  44.             System.out.println(str.length());
  45.         }
  46.     }
  47.  
  48. }

自定义带泛型的类:

  1. package com.xiaoshit_zongjie;
  2.  
  3. public class Test {
  4.     // 自定义一个带有一个参数的泛型类,可以向传入什么类型就传入什么类型
  5.     public static void main(String[] args) {
  6.         // 进行测试, 传入一个String对象
  7.         Person<String> perStr = new Person<String>();
  8.         perStr.setT("我是字符串");
  9.         String str = perStr.getT();
  10.         System.out.println(str);
  11.  
  12.         // 进行测试，传入一个Integer对象
  13.         Person<Integer> perInt = new Person<Integer>();
  14.         perInt.setT(100);
  15.         Integer intVal = perInt.getT();
  16.         System.out.println(intVal);
  17.  
  18.     }
  19.  
  20. }
  21. //自定义一个带有一个参数的泛型类
  22. class Person<T>{
  23.     private T t;
  24.  
  25.     void setT(T t){
  26.         this.t = t;
  27.     }
  28.  
  29.     T getT(){
  30.         return t;
  31.     }
  32. }

实现带有泛型的接口类型：

实现接口的同时, 指定了接口中的泛型类型. (定义类时确定)；

public class GenericImpl1 implements GenericInter<String> {}

实现接口时, 没有指定接口中的泛型类型.此时, 需要将该接口的实现类定义为泛型类.接口的类型需要在创建实现类对象时才能真正确定其类型. (始终不确定类型, 直到创建对象时确定类型);

public class GenericImpl2<T> implements GenericInter<T> {}

泛型的通配符(?)：

上限限定：比如定义方法的时候出现，public void getFunc(List<? extends Animal> an)，

那么表示这里的参数可以传入Animal，或者 Animal的子类

下限限定: 比如定义方法的时候出现，public void getFunc(Set<? super Animal> an ),

那么表示这里的参数可以传入Animal，或者Animal的父类

使用泛型的注意点:

1、泛型不支持基本数据类型

2、泛型不支持继承，必须保持前后一致（比如这样是错误的：List<Object> list = new ArrayList<String>();

Collection体系：

ollection包括两大体系，List和Set

List的特点：

存取有序，有索引，可以根据索引来进行取值，元素可以重复

Set的特点：

存取无序，元素不可以重复

List:

下面有ArrayList，LinkedList，Vector(已过时)

集合的的最大目的就是为了存取；List集合的特点就是存取有序，可以存储重复的元素，可以用下标进行元素的操作

ArrayList: 底层是使用数组实现，所以查询速度快，增删速度慢

  1. package com.xiaoshit_zongjie;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.Iterator;
  5. import java.util.List;
  6.  
  7. public class Test {
  8.     // 使用ArrayList进行添加和遍历
  9.     public static void main(String[] args) {
  10.         List<String> list = new ArrayList<String>();
  11.  
  12.         list.add("接口1");
  13.         list.add("接口2");
  14.         list.add("接口3");
  15.  
  16.         // 第一种遍历方式,使用迭代器
  17.         Iterator<String> it = list.iterator();
  18.         while(it.hasNext()){
  19.             String next = it.next();
  20.             System.out.println(next);
  21.         }
  22.         System.out.println("-------------------");
  23.         // 第二种遍历方式，使用foreach
  24.         for (String str : list){
  25.             System.err.println(str);
  26.         }
  27.     }
  28.  
  29. }

LinkedList:是基于链表结构实现的，所以查询速度慢，增删速度快，提供了特殊的方法，对头尾的元素操作（进行增删查）。

使用LinkedList来实现栈和队列；栈是先进后出，而队列是先进先出

  1. package com.xiaoshitou.classtest;
  2.  
  3. import java.util.LinkedList;
  4.  
  5. /**
  6.  * 利用LinkedList来模拟栈
  7.  * 栈的特点：先进后出
  8.  * @author Beck
  9.  *
  10.  */
  11. public class MyStack {
  12.     private LinkedList<String> linkList = new LinkedList<String>();
  13.  
  14.     // 压栈
  15.     public void push(String str){
  16.         linkList.addFirst(str);
  17.     }
  18.  
  19.     // 出栈
  20.     public String pop(){
  21.         return linkList.removeFirst();
  22.     }
  23.  
  24.     // 查看
  25.     public String peek(){
  26.         return linkList.peek();
  27.     }
  28.  
  29.     // 判断是否为空
  30.     public boolean isEmpty(){
  31.         return linkList.isEmpty();
  32.     }
  33. }
  34.  
  35. package com.xiaoshit_zongjie;
  36.  
  37. public class Test {
  38.     public static void main(String[] args) {
  39.         // 测试栈
  40.         StackTest stack = new StackTest();
  41.         stack.push("我是第1个进去的");
  42.         stack.push("我是第2个进去的");
  43.         stack.push("我是第3个进去的");
  44.         stack.push("我是第4个进去的");
  45.         stack.push("我是第5个进去的");
  46.         // 取出
  47.         while (!stack.isEmpty()){
  48.             String pop = stack.pop();
  49.             System.out.println(pop);
  50.         }
  51.         // 打印结果
  52.         /*我是第5个进去的
  53.         我是第4个进去的
  54.         我是第3个进去的
  55.         我是第2个进去的
  56.         我是第1个进去的*/
  57.     }
  58.  
  59. }

LinkedList实现Queue:

  1. package com.xiaoshit_zongjie;
  2.  
  3. import java.util.LinkedList;
  4.  
  5. /**
  6.  * 利用linkedList来实现队列
  7.  * 队列: 先进先出
  8.  * @author Beck
  9.  *
  10.  */
  11. public class QueueTest {
  12.     private LinkedList<String> link = new LinkedList<String>();
  13.  
  14.     // 放入
  15.     public void put(String str){
  16.         link.addFirst(str);
  17.     }
  18.  
  19.     // 获取
  20.     public String get(){
  21.         return link.removeLast();
  22.     }
  23.  
  24.     // 判断是否为空
  25.     public boolean isEmpty(){
  26.         return link.isEmpty();
  27.     }
  28. }
  29. package com.xiaoshit_zongjie;
  30.  
  31. public class Test {
  32.     public static void main(String[] args) {
  33.         // 测试队列
  34.         QueueTest queue = new QueueTest();
  35.  
  36.         queue.put("我是第1个进入队列的");
  37.         queue.put("我是第2个进入队列的");
  38.         queue.put("我是第3个进入队列的");
  39.         queue.put("我是第4个进入队列的");
  40.  
  41.         // 遍历队列
  42.         while (!queue.isEmpty()){
  43.             String str = queue.get();
  44.             System.out.println(str);
  45.         }
  46.         // 打印结果
  47.         /*我是第1个进入队列的
  48.         我是第2个进入队列的
  49.         我是第3个进入队列的
  50.         我是第4个进入队列的*/
  51.  
  52.     }
  53.  
  54. }

Vector:因为已经过时，被ArrayList取代了；它还有一种迭代器通过vector.elements()获取，判断是否有元素和取元素的方法为：hasMoreElements()，nextElement()。

  1. package com.xiaoshit_zongjie;
  2.  
  3. import java.util.Enumeration;
  4. import java.util.Vector;
  5.  
  6. public class Test {
  7.     public static void main(String[] args) {
  8.         Vector<String> vector = new Vector<String>();
  9.  
  10.         vector.add("搜索");
  11.         vector.add("vector");
  12.         vector.add("list");
  13.  
  14.         Enumeration<String> elements = vector.elements();
  15.         while (elements.hasMoreElements()){
  16.             String nextElement = elements.nextElement();
  17.             System.out.println(nextElement);
  18.         }
  19.     }
  20.  
  21. }

List集合总结：

Set:

Set集合的特点：元素不重复，存取无序，无下标
Set集合下面有：HashSet，LinkedHashSet，TreeSet

HashSet存储字符串:

  1. package com.xiaoshit_zongjie;
  2.  
  3. import java.util.HashSet;
  4. import java.util.Iterator;
  5. import java.util.Set;
  6.  
  7. public class Test {
  8.     public static void main(String[] args) {
  9.         // 利用HashSet来存取
  10.         Set<String> set = new HashSet<String>();
  11.  
  12.         set.add("我的天");
  13.         set.add("我是重复的");
  14.         set.add("我是重复的");
  15.         set.add("welcome");
  16.  
  17.         // 遍历 第一种方式 迭代器
  18.         Iterator<String> it = set.iterator();
  19.         while(it.hasNext()){
  20.             String str = it.next();
  21.             System.out.println(str);
  22.         }
  23.  
  24.         System.out.println("--------------");
  25.         for (String str : set){
  26.             System.out.println(str);
  27.         }
  28.         // 打印结果，重复的已经去掉了
  29.         /*我的天
  30.         welcome
  31.         我是重复的
  32.         --------------
  33.         我的天
  34.         welcome
  35.         我是重复的*/
  36.     }
  37.

那哈希表是怎么来保证元素的唯一性的呢，哈希表是通过hashCode和equals方法来共同保证的。

哈希表的存储数据过程（哈希表底层也维护了一个数组）：

根据存储的元素计算出hashCode值，然后根据计算得出的hashCode值和数组的长度进行计算出存储的下标；如果下标的位置无元素，那么直接存储；如果有元素，那么使用要存入的元素和该元素进行equals方法，如果结果为真，则已经有相同的元素了，所以直接不存；如果结果假，那么进行存储，以链表的形式存储。

演示HashSet来存储自定义对象：

  1. package com.xiaoshit_zongjie;
  2.  
  3. public class Person {
  4.     // 属性
  5.     private String name;
  6.     private int age;
  7.  
  8.     // 构造方法
  9.     public Person() {
  10.         super();
  11.  
  12.     }
  13.     public Person(String name, int age) {
  14.         super();
  15.         this.name = name;
  16.         this.age = age;
  17.     }
  18.  
  19.     // 要让哈希表存储不重复的元素，就必须重写hasCode和equals方法
  20.     @Override
  21.     public int hashCode() {
  22.         final int prime = 31;
  23.         int result = 1;
  24.         result = prime * result + age;
  25.         result = prime * result + ((name == null) ? 0 : name.hashCode());
  26.         return result;
  27.     }
  28.     @Override
  29.     public boolean equals(Object obj) {
  30.         if (this == obj)
  31.             return true;
  32.         if (obj == null)
  33.             return false;
  34.         if (getClass() != obj.getClass())
  35.             return false;
  36.         Person other = (Person) obj;
  37.         if (age != other.age)
  38.             return false;
  39.         if (name == null) {
  40.             if (other.name != null)
  41.                 return false;
  42.         } else if (!name.equals(other.name))
  43.             return false;
  44.         return true;
  45.     }
  46.  
  47.     @Override
  48.     public String toString() {
  49.         return "Person [name=" + name + ", age=" + age + "]";
  50.     }
  51.     // getter & setter
  52.     public String getName() {
  53.         return name;
  54.     }
  55.     public void setName(String name) {
  56.         this.name = name;
  57.     }
  58.     public int getAge() {
  59.         return age;
  60.     }
  61.     public void setAge(int age) {
  62.         this.age = age;
  63.     }
  64.  
  65. }
  66.  
  67. package com.xiaoshit_zongjie;
  68.  
  69. import java.util.HashSet;
  70. import java.util.Set;
  71.  
  72. public class Test {
  73.     public static void main(String[] args) {
  74.         // 利用HashSet来存取自定义对象 Person
  75.         Set<Person> set = new HashSet<Person>();
  76.  
  77.         set.add(new Person("张三", 12));
  78.         set.add(new Person("李四", 13));
  79.         set.add(new Person("王五", 22));
  80.         set.add(new Person("张三", 12));
  81.  
  82.         // 遍历
  83.         for (Person p : set){
  84.             System.out.println(p);
  85.         }
  86.         // 结果：向集合中存储两个张三对象，但是集合中就成功存储了一个
  87.         /*Person [name=王五, age=22]
  88.         Person [name=李四, age=13]
  89.         Person [name=张三, age=12]*/
  90.     }
  91.  
  92. }

所以在向HashSet集合中存储自定义对象时，为了保证set集合的唯一性，那么必须重写hashCode和equals方法。

LinkedHashSet:

是基于链表和哈希表共同实现的，所以具有存取有序，元素唯一

  1. package com.xiaoshit_zongjie;
  2.  
  3. import java.util.LinkedHashSet;
  4.  
  5. public class Test {
  6.     public static void main(String[] args) {
  7.         // 利用LinkedHashSet来存取自定义对象 Person
  8.         LinkedHashSet<Person> set = new LinkedHashSet<Person>();
  9.  
  10.         set.add(new Person("张三", 12));
  11.         set.add(new Person("李四", 13));
  12.         set.add(new Person("王五", 22));
  13.         set.add(new Person("张三", 12));
  14.  
  15.         // 遍历
  16.         for (Person p : set){
  17.             System.out.println(p);
  18.         }
  19.         // 结果：向集合中存储两个张三对象，但是集合中就成功存储了一个,
  20.         // 并且存进的顺序，和取出来的顺序是一致的
  21.         /*Person [name=张三, age=12]
  22.         Person [name=李四, age=13]
  23.         Person [name=王五, age=22]*/
  24.     }
  25.  
  26. }

TreeSet：

特点：存取无序，元素唯一，可以进行排序（排序是在添加的时候进行排序）。

TreeSet是基于二叉树的数据结构，二叉树的：一个节点下不能多余两个节点。

二叉树的存储过程：

如果是第一个元素，那么直接存入，作为根节点，下一个元素进来是会跟节点比较，如果大于节点放右边的，小于节点放左边；等于节点就不存储。后面的元素进来会依次比较，直到有位置存储为止

TreeSet集合存储String对象

  1. package com.xiaoshit_zongjie;
  2.  
  3. import java.util.TreeSet;
  4.  
  5. public class Test {
  6.     public static void main(String[] args) {
  7.         TreeSet<String> treeSet = new TreeSet<String>();
  8.         treeSet.add("abc");
  9.         treeSet.add("zbc");
  10.         treeSet.add("cbc");
  11.         treeSet.add("xbc");
  12.  
  13.         for (String str : treeSet){
  14.             System.out.println(str);
  15.         }
  16.         // 结果：取出来的结果是经过排序的
  17.         /*
  18.         abc
  19.         cbc
  20.         xbc
  21.         zbc*/
  22.     }
  23.  
  24. }

TreeSet保证元素的唯一性是有两种方式：

1、自定义对象实现Comparable接口，重写comparaTo方法，该方法返回0表示相等，小于0表示准备存入的元素比被比较的元素小，否则大于0；

2、在创建TreeSet的时候向构造器中传入比较器Comparator接口实现类对象，实现Comparator接口重写compara方法。

如果向TreeSet存入自定义对象时，自定义类没有实现Comparable接口，或者没有传入Comparator比较器时，会出现ClassCastException异常

下面就是演示用两种方式来存储自定义对象

  1. package com.xiaoshit_zongjie;
  2. public class Person implements Comparable<Person>{
  3.     // 属性
  4.     private String name;
  5.     private int age;
  6.  
  7.     // 构造方法
  8.     public Person() {
  9.         super();
  10.  
  11.     }
  12.     public Person(String name, int age) {
  13.         super();
  14.         this.name = name;
  15.         this.age = age;
  16.     }
  17.  
  18.     // 要让哈希表存储不重复的元素，就必须重写hasCode和equals方法
  19.     @Override
  20.     public int hashCode() {
  21.         final int prime = 31;
  22.         int result = 1;
  23.         result = prime * result + age;
  24.         result = prime * result + ((name == null) ? 0 : name.hashCode());
  25.         return result;
  26.     }
  27.     @Override
  28.     public boolean equals(Object obj) {
  29.         if (this == obj)
  30.             return true;
  31.         if (obj == null)
  32.             return false;
  33.         if (getClass() != obj.getClass())
  34.             return false;
  35.         Person other = (Person) obj;
  36.         if (age != other.age)
  37.             return false;
  38.         if (name == null) {
  39.             if (other.name != null)
  40.                 return false;
  41.         } else if (!name.equals(other.name))
  42.             return false;
  43.         return true;
  44.     }
  45.  
  46.     @Override
  47.     public String toString() {
  48.         return "Person [name=" + name + ", age=" + age + "]";
  49.     }
  50.     // getter & setter
  51.     public String getName() {
  52.         return name;
  53.     }
  54.     public void setName(String name) {
  55.         this.name = name;
  56.     }
  57.     public int getAge() {
  58.         return age;
  59.     }
  60.     public void setAge(int age) {
  61.         this.age = age;
  62.     }
  63.  
  64.     @Override
  65.     public int compareTo(Person o) {
  66.         int result = this.age - o.age;
  67.         if (result == 0){
  68.             return this.name.compareTo(o.name);
  69.         }
  70.         return result;
  71.     }
  72.  
  73. }
  74.  
  75. package com.xiaoshit_zongjie;
  76.  
  77. import java.util.TreeSet;
  78.  
  79. public class Test {
  80.     public static void main(String[] args) {
  81.         // 利用TreeSet来存储自定义类Person对象
  82.         TreeSet<Person> treeSet = new TreeSet<Person>();
  83.         // Person类实现了Comparable接口，并且重写comparaTo方法
  84.         // 比较规则是先按照 年龄排序，年龄相等的情况按照年龄排序
  85.         treeSet.add(new Person("张山1", 20));
  86.         treeSet.add(new Person("张山2", 16));
  87.         treeSet.add(new Person("张山3", 13));
  88.         treeSet.add(new Person("张山4", 17));
  89.         treeSet.add(new Person("张山5", 20));
  90.  
  91.         for (Person p : treeSet){
  92.             System.out.println(p);
  93.         }
  94.         // 结果：按照comparaTo方法内的逻辑来排序的
  95.         /*
  96.         Person [name=张山3, age=13]
  97.         Person [name=张山2, age=16]
  98.         Person [name=张山4, age=17]
  99.         Person [name=张山1, age=20]
  100.         Person [name=张山5, age=20]
  101.          */
  102.  
  103.     }
  104.  
  105. }

另一种方式：使用比较器Comparator

  1. package com.xiaoshit_zongjie;
  2.  
  3. public class Person{
  4.     // 属性
  5.     private String name;
  6.     private int age;
  7.  
  8.     // 构造方法
  9.     public Person() {
  10.         super();
  11.  
  12.     }
  13.     public Person(String name, int age) {
  14.         super();
  15.         this.name = name;
  16.         this.age = age;
  17.     }
  18.  
  19.     // 要让哈希表存储不重复的元素，就必须重写hasCode和equals方法
  20.     @Override
  21.     public int hashCode() {
  22.         final int prime = 31;
  23.         int result = 1;
  24.         result = prime * result + age;
  25.         result = prime * result + ((name == null) ? 0 : name.hashCode());
  26.         return result;
  27.     }
  28.     @Override
  29.     public boolean equals(Object obj) {
  30.         if (this == obj)
  31.             return true;
  32.         if (obj == null)
  33.             return false;
  34.         if (getClass() != obj.getClass())
  35.             return false;
  36.         Person other = (Person) obj;
  37.         if (age != other.age)
  38.             return false;
  39.         if (name == null) {
  40.             if (other.name != null)
  41.                 return false;
  42.         } else if (!name.equals(other.name))
  43.             return false;
  44.         return true;
  45.     }
  46.  
  47.     @Override
  48.     public String toString() {
  49.         return "Person [name=" + name + ", age=" + age + "]";
  50.     }
  51.     // getter & setter
  52.     public String getName() {
  53.         return name;
  54.     }
  55.     public void setName(String name) {
  56.         this.name = name;
  57.     }
  58.     public int getAge() {
  59.         return age;
  60.     }
  61.     public void setAge(int age) {
  62.         this.age = age;
  63.     }
  64.  
  65. }
  66.  
  67. package com.xiaoshit_zongjie;
  68.  
  69. import java.util.Comparator;
  70. import java.util.TreeSet;
  71.  
  72. public class Test {
  73.     public static void main(String[] args) {
  74.         // 利用TreeSet来存储自定义类Person对象
  75.         // 创建TreeSet对象的时候传入Comparator比较器，使用匿名内部类的方式
  76.         // 比较规则是先按照 年龄排序，年龄相等的情况按照年龄排序
  77.         TreeSet<Person> treeSet = new TreeSet<Person>(new Comparator<Person>() {
  78.             @Override
  79.             public int compare(Person o1, Person o2) {
  80.                 if (o1 == o2){
  81.                     return 0;
  82.                 }
  83.                 int result = o1.getAge() - o2.getAge();
  84.                 if (result == 0){
  85.                     return o1.getName().compareTo(o2.getName());
  86.                 }
  87.                 return result;
  88.             }
  89.  
  90.         });
  91.  
  92.         treeSet.add(new Person("张山1", 20));
  93.         treeSet.add(new Person("张山2", 16));
  94.         treeSet.add(new Person("张山3", 13));
  95.         treeSet.add(new Person("张山4", 17));
  96.         treeSet.add(new Person("张山5", 20));
  97.  
  98.         for (Person p : treeSet){
  99.             System.out.println(p);
  100.         }
  101.         // 结果：按照compara方法内的逻辑来排序的
  102.         /*
  103.         Person [name=张山3, age=13]
  104.         Person [name=张山2, age=16]
  105.         Person [name=张山4, age=17]
  106.         Person [name=张山1, age=20]
  107.         Person [name=张山5, age=20]
  108.          */
  109.  
  110.     }
  111.  
  112. }

比较器总结：

Collection体系总结：

List   : "特点 :" 存取有序,元素有索引,元素可以重复.

ArrayList : 数组结构,查询快,增删慢,线程不安全,因此效率高.

Vector : 数组结构,查询快,增删慢,线程安全,因此效率低.

LinkedList : 链表结构,查询慢,增删快,线程不安全,因此效率高.

addFirst()    removeFirst()    getFirst()

Set   :"特点 :" 存取无序,元素无索引,元素不可以重复.

HashSet : 存储无序,元素无索引,元素不可以重复.底层是哈希表.

请问 : 哈希表如何保证元素唯一呢 ? 底层是依赖 hashCode 和 equals 方法.

当存储元素的时候,先根据 hashCode + 数组长度 计算出一个索引,判断索引位置是否有元素.

如果没有元素,直接存储,如果有元素,先判断 equals 方法,比较两个元素是否相同,不同则存储,相同则舍弃.

我们自定义对象存储的元素一定要实现 hashCode 和 equals.

LinkedHashSet : 存储有序,元素不可以重复.

TreeSet : 存取无序, 但是可以排序 (自然排序), 元素不可以重复.

有两种排序方式 :

自然排序 :

我们的元素必须实现 Comparable 接口.可比较的.实现     CompareTo 方法.

比较器排序 :

我们需要自定义类,实现Comparetor接口,这个类就是比较器实现 compare 方法.

然后在创建 TreeSet 的时候,把比较器对象作为参数传递给 TreeSet.

"总结 : 如何选择用哪个集合呢?"

"问题1 : 元素是否可以重复呢?"

可以 : List 系列.

"问题2 : 查询多还是增删多?"

查询多 : ArrayList

增删多 : LinkedList

不可以 : Set 系列.

"问题3 : 是否需要排序呢?"

排序 : TreeSet

不排序 : HashSet

如果要唯一,又要存取有序. LinkedHashSet.

Map:

Map是一个双列集合，其中保存的是键值对，键要求保持唯一性，值可以重复

键值是一一对应的，一个键只能对应一个值

Map的特点：是存取无序，键不可重复

Map在存储的时候，将键值传入Entry，然后存储Entry对象

其中下面有HashMap，LinkedHashMap和TreeMap

HashMap：

是基于哈希表结构实现的，所以存储自定义对象作为键时，必须重写hasCode和equals方法。存取无序的

下面演示HashMap以自定义对象作为键：

  1. package com.xiaoshit_zongjie;
  2.  
  3. import java.util.HashMap;
  4. import java.util.Iterator;
  5. import java.util.Map.Entry;
  6. import java.util.Set;
  7.  
  8. public class Test {
  9.     public static void main(String[] args) {
  10.         // 利用HashMap存储，自定义对象Person作为键
  11.         // 为了保证键的唯一性，必须重写hashCode和equals方法
  12.         HashMap<Person,String> map = new HashMap<Person,String>();
  13.  
  14.         map.put(new Person("张三", 12), "JAVA");
  15.         map.put(new Person("李四", 13), "IOS");
  16.         map.put(new Person("小花", 22), "JS");
  17.         map.put(new Person("小黑", 32), "PHP");
  18.         map.put(new Person("张三", 12), "C++");
  19.  
  20.         Set<Entry<Person, String>> entrySet = map.entrySet();
  21.         Iterator<Entry<Person, String>> it = entrySet.iterator();
  22.         while (it.hasNext()){
  23.             Entry<Person, String> entry = it.next();
  24.             System.out.println(entry.getKey() + "---" + entry.getValue());
  25.         }
  26.         // 结果：存入的时候添加了两个张三，如果Map中键相同的时候，当后面的值会覆盖掉前面的值
  27.         /*
  28.         Person [name=李四, age=13]---IOS
  29.         Person [name=张三, age=12]---C++
  30.         Person [name=小黑, age=32]---PHP
  31.         Person [name=小花, age=22]---JS
  32.         */
  33.  
  34.     }
  35.  
  36. }

LinkedHashMap:

用法跟HashMap基本一致，它是基于链表和哈希表结构的所以具有存取有序，键不重复的特性

下面演示利用LinkedHashMap存储，注意存的顺序和遍历出来的顺序是一致的:

  1. package com.xiaoshit_zongjie;
  2.  
  3. import java.util.LinkedHashMap;
  4. import java.util.Map.Entry;
  5.  
  6. public class Test {
  7.     public static void main(String[] args) {
  8.         // 利用LinkedHashMap存储，自定义对象Person作为键
  9.         // 为了保证键的唯一性，必须重写hashCode和equals方法
  10.         LinkedHashMap<Person,String> map = new LinkedHashMap<Person,String>();
  11.  
  12.         map.put(new Person("张三", 12), "JAVA");
  13.         map.put(new Person("李四", 13), "IOS");
  14.         map.put(new Person("小花", 22), "JS");
  15.         map.put(new Person("小黑", 32), "PHP");
  16.         map.put(new Person("张三", 12), "C++");
  17.  
  18.         // foreach遍历
  19.         for (Entry<Person,String> entry : map.entrySet()){
  20.             System.out.println(entry.getKey()+"==="+entry.getValue());
  21.         }
  22.         // 结果：存入的时候添加了两个张三，如果Map中键相同的时候，当后面的值会覆盖掉前面的值
  23.         // 注意：LinkedHashMap的特点就是存取有序，取出来的顺序就是和存入的顺序保持一致
  24.         /*
  25.         Person [name=张三, age=12]===C++
  26.         Person [name=李四, age=13]===IOS
  27.         Person [name=小花, age=22]===JS
  28.         Person [name=小黑, age=32]===PHP
  29.         */
  30.     }
  31. }

TreeMap:

给TreeMap集合中保存自定义对象，自定义对象作为TreeMap集合的key值。由于TreeMap底层使用的二叉树，其中存放进去的所有数据都需要排序，要排序，就要求对象具备比较功能。对象所属的类需要实现Comparable接口。或者给TreeMap集合传递一个Comparator接口对象。

利用TreeMap存入自定义对象作为键：

  1. package com.xiaoshit_zongjie;
  2.  
  3. import java.util.Comparator;
  4. import java.util.Map.Entry;
  5. import java.util.TreeMap;
  6.  
  7. public class Test {
  8.     public static void main(String[] args) {
  9.         // 利用TreeMap存储，自定义对象Person作为键
  10.         // 自定义对象实现Comparable接口或者传入Comparator比较器
  11.         TreeMap<Person,String> map = new TreeMap<Person,String>(new Comparator<Person>() {
  12.             @Override
  13.             public int compare(Person o1, Person o2) {
  14.                 if (o1 == o2){
  15.                     return 0;
  16.                 }
  17.                 int result = o1.getAge() - o2.getAge();
  18.                 if (result == 0){
  19.                     return o1.getName().compareTo(o2.getName());
  20.                 }
  21.                 return result;
  22.             }
  23.         });
  24.  
  25.         map.put(new Person("张三", 12), "JAVA");
  26.         map.put(new Person("李四", 50), "IOS");
  27.         map.put(new Person("小花", 32), "JS");
  28.         map.put(new Person("小黑", 32), "PHP");
  29.         map.put(new Person("张三", 12), "C++");
  30.  
  31.         // foreach遍历
  32.         for (Entry<Person,String> entry : map.entrySet()){
  33.             System.out.println(entry.getKey()+"==="+entry.getValue());
  34.         }
  35.         // 结果：存入的时候添加了两个张三，如果Map中键相同的时候，当后面的值会覆盖掉前面的值
  36.         // 注意：TreeMap 取出来的顺序是经过排序的，是根据compara方法排序的
  37.         /*
  38.         Person [name=张三, age=12]===C++
  39.         Person [name=小花, age=32]===JS
  40.         Person [name=小黑, age=32]===PHP
  41.         Person [name=李四, age=50]===IOS
  42.         */
  43.     }
  44. }

Map总结：

Java-集合框架总结的更多相关文章

  1. Java集合框架List，Map，Set等全面介绍

    Java集合框架的基本接口/类层次结构: java.util.Collection [I]+--java.util.List [I]   +--java.util.ArrayList [C]   +- ...

  2. Java集合框架练习-计算表达式的值

    最近在看<算法>这本书,正好看到一个计算表达式的问题,于是就打算写一下,也正好熟悉一下Java集合框架的使用,大致测试了一下,没啥问题. import java.util.*; /* * ...

  3. 【集合框架】Java集合框架综述

    一.前言 现笔者打算做关于Java集合框架的教程,具体是打算分析Java源码,因为平时在写程序的过程中用Java集合特别频繁,但是对于里面一些具体的原理还没有进行很好的梳理,所以拟从源码的角度去熟悉梳 ...

  4. Java 集合框架

    Java集合框架大致可以分为五个部分:List列表,Set集合.Map映射.迭代器.工具类 List 接口通常表示一个列表(数组.队列.链表 栈),其中的元素 可以重复 的是:ArrayList 和L ...

  5. Java集合框架之map

    Java集合框架之map. Map的主要实现类有HashMap,LinkedHashMap,TreeMap,等等.具体可参阅API文档. 其中HashMap是无序排序. LinkedHashMap是自 ...

  6. 22章、Java集合框架习题

    1.描述Java集合框架.列出接口.便利抽象类和具体类. Java集合框架支持2种容器:(1) 集合(Collection),存储元素集合 (2)图(Map),存储键值对.

  7. Java集合框架实现自定义排序

    Java集合框架针对不同的数据结构提供了多种排序的方法,虽然很多时候我们可以自己实现排序,比如数组等,但是灵活的使用JDK提供的排序方法,可以提高开发效率,而且通常JDK的实现要比自己造的轮子性能更优 ...

  8. （转）Java集合框架：HashMap

    来源:朱小厮 链接:http://blog.csdn.net/u013256816/article/details/50912762 Java集合框架概述 Java集合框架无论是在工作.学习.面试中都 ...

  9. Java集合框架

    集合框架体系如图所示 Java 集合框架提供了一套性能优良,使用方便的接口和类,java集合框架位于java.util包中, 所以当使用集合框架的时候需要进行导包. Map接口的常用方法 Map接口提 ...

  10. Java集合框架（常用类） JCF

    Java集合框架(常用类) JCF 为了实现某一目的或功能而预先设计好一系列封装好的具有继承关系或实现关系类的接口: 集合的由来: 特点:元素类型可以不同,集合长度可变,空间不固定: 管理集合类和接口 ...

随机推荐

  1. 【转】JDBC学习笔记(2)——Statement和ResultSet

    转自:http://www.cnblogs.com/ysw-go/ Statement执行更新操作 Statement:Statement 是 Java 执行数据库操作的一个重要方法,用于在已经建立数 ...

  2. ASP.NET MVC4 微信公众号开发之网页授权（一）：搭建基础环境

    首先你得注册并认证一个个人或企业的微信公众号===服务号从而确保获得以下接口权限: 然后打开公众号设置里的功能设置里找到业务域名和网页授权域名分别填上你的域名(注:已备案的域名),如下图所示: 到这里 ...

  3. Lambda表达式效率问题

    原文 http://www.importnew.com/17262.html 有许许多多关于 Java 8 中流效率的讨论,但根据 Alex Zhitnitsky 的测试结果显示:坚持使用传统的 Ja ...

  4. angularjs中常用的ng指令介绍【转载】

    原文:http://www.cnblogs.com/lvdabao/p/3379659.html 一.模板中可使用的东西及表达式 模板中可以使用的东西包括以下四种: 指令(directive).ng提 ...

  5. Laravel 中使用 Redis 数据库

    一.前言 Redis 是一个开源高效的键值对存储系统,它通常用作为一个数据结构服务器来存储键值对,它可以支持字符串.散列.列表.集合.有序集合. 1. 安装 predis/predis 在 Larav ...

  6. 深入解析MySQL视图view

    阅读目录---深入解析MySQL视图view 创建视图 查看视图 视图的更改 create or replace view alter DML drop 使用with check option约束 嵌 ...

  7. 「七天自制PHP框架」第二天：模型与数据库

    往期回顾:「七天自制PHP框架」第一天:路由与控制器,点击此处 什么是模型? 我们的WEB系统一定会和各种数据打交道,实际开发过程中,往往一个类对应了关系数据库的一张或多张数据表,这里就会出现两个问题 ...

  8. SpringMVC中使用bean来接收form表单提交的参数时的注意点

    这是前辈们对于SpringMVC接收表单数据记录下来的总结经验: SpringMVC接收页面表单参数 springmvc请求参数获取的几种方法 下面是我自己在使用时发现的,前辈们没有记录的细节和注意点 ...

  9. iOS APP打包分发给远程的手机测试

    APP要打包给远程的朋友或客户测试,但又不是企业账号的情况下,我们只能根据手机的udid进行描述证书的配置,再打包分发给提供了udid的手机进行安装 一.如何得到udid? 手机连接到mac电脑,打开 ...

  10. python安装pillow模块错误

    安装的一些简单步骤就不介绍了,可以去搜索一下,主要就记录下我在安装pillow这一模块遇到的问题 1:安装好pillow后,安装过程没有出错 2:但是在python的IDLE输入from PIL im ...