一、集合入门总结

集合框架：

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

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

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

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

泛型：

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

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

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

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

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

package 好好学java;import java.util.ArrayList;import java.util.Iterator;import java.util.List;public class Test { public static void main(String[] args) { // 不加泛型，添加和遍历 List list = new ArrayList<>(); list.add(1); list.add("123"); list.add("hello");  Iterator it = list.iterator(); while(it.hasNext()){ // 没有添加泛型，这里只能使用Object接收 Object obj = it.next(); System.out.println(obj); } }}package 好好学java;import java.util.ArrayList;import java.util.Iterator;import java.util.List;public class Test { public static void main(String[] args) { // 加泛型，添加和遍历 List list = new ArrayList(); list.add("123"); list.add("hello");  Iterator it = list.iterator(); while(it.hasNext()){ // 因为添加了泛型，就说明集合中装的全部都是String类型的数据 // 所以这里用String类型接收，就不会发生异常，并且可以使用String的方法 String str = it.next(); System.out.println(str.length()); } }}

自定义带泛型的类:

package 好好学java;public class Test { // 自定义一个带有一个参数的泛型类,可以向传入什么类型就传入什么类型 public static void main(String[] args) { // 进行测试, 传入一个String对象 Person perStr = new Person(); perStr.setT("我是字符串"); String str = perStr.getT(); System.out.println(str);  // 进行测试，传入一个Integer对象 Person perInt = new Person(); perInt.setT(100); Integer intVal = perInt.getT(); System.out.println(intVal);  }}//自定义一个带有一个参数的泛型类class Person{ private T t;  void setT(T t){ this.t = t; }  T getT(){ return t; }}

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

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

public class GenericImpl1 implements GenericInter {}

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

public class GenericImpl2 implements GenericInter {}

泛型的通配符(?)：

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

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

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

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

使用泛型的注意点:

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

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

Collection体系：

ollection包括两大体系，List和Set

List的特点：

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

Set的特点：

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

List:

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

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

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

package 好好学java;import java.util.ArrayList;import java.util.Iterator;import java.util.List;public class Test { // 使用ArrayList进行添加和遍历 public static void main(String[] args) { List list = new ArrayList();  list.add("接口1"); list.add("接口2"); list.add("接口3");  // 第一种遍历方式,使用迭代器 Iterator it = list.iterator(); while(it.hasNext()){ String next = it.next(); System.out.println(next); } System.out.println("-------------------"); // 第二种遍历方式，使用foreach for (String str : list){ System.err.println(str); } }}

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

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

package com.xiaoshitou.classtest;import java.util.LinkedList;/** * 利用LinkedList来模拟栈 * 栈的特点：先进后出 * @author Beck * */public class MyStack { private LinkedList linkList = new LinkedList();  // 压栈 public void push(String str){ linkList.addFirst(str); }  // 出栈 public String pop(){ return linkList.removeFirst(); }  // 查看 public String peek(){ return linkList.peek(); }  // 判断是否为空 public boolean isEmpty(){ return linkList.isEmpty(); }}package 好好学java;public class Test { public static void main(String[] args) { // 测试栈 StackTest stack = new StackTest(); stack.push("我是第1个进去的"); stack.push("我是第2个进去的"); stack.push("我是第3个进去的"); stack.push("我是第4个进去的"); stack.push("我是第5个进去的"); // 取出 while (!stack.isEmpty()){ String pop = stack.pop(); System.out.println(pop); } // 打印结果 /*我是第5个进去的 我是第4个进去的 我是第3个进去的 我是第2个进去的 我是第1个进去的*/ } }

LinkedList实现Queue:

package 好好学java;import java.util.LinkedList;/** * 利用linkedList来实现队列 * 队列: 先进先出 * @author Beck * */public class QueueTest { private LinkedList link = new LinkedList();  // 放入 public void put(String str){ link.addFirst(str); }  // 获取 public String get(){ return link.removeLast(); }  // 判断是否为空 public boolean isEmpty(){ return link.isEmpty(); }}package 好好学java;public class Test { public static void main(String[] args) { // 测试队列 QueueTest queue = new QueueTest();  queue.put("我是第1个进入队列的"); queue.put("我是第2个进入队列的"); queue.put("我是第3个进入队列的"); queue.put("我是第4个进入队列的");  // 遍历队列 while (!queue.isEmpty()){ String str = queue.get(); System.out.println(str); } // 打印结果 /*我是第1个进入队列的 我是第2个进入队列的 我是第3个进入队列的 我是第4个进入队列的*/ } }

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

package 好好学java;import java.util.Enumeration;import java.util.Vector;public class Test { public static void main(String[] args) { Vector vector = new Vector();  vector.add("搜索"); vector.add("vector"); vector.add("list");  Enumeration elements = vector.elements(); while (elements.hasMoreElements()){ String nextElement = elements.nextElement(); System.out.println(nextElement); } } }

Set:

Set集合的特点：元素不重复，存取无序，无下标

Set集合下面有：HashSet，LinkedHashSet，TreeSet

HashSet存储字符串:

package 好好学java;import java.util.HashSet;import java.util.Iterator;import java.util.Set;public class Test { public static void main(String[] args) { // 利用HashSet来存取 Set set = new HashSet();  set.add("我的天"); set.add("我是重复的"); set.add("我是重复的"); set.add("welcome");  // 遍历 第一种方式 迭代器 Iterator it = set.iterator(); while(it.hasNext()){ String str = it.next(); System.out.println(str); }  System.out.println("--------------"); for (String str : set){ System.out.println(str); } // 打印结果，重复的已经去掉了 /*我的天 welcome 我是重复的 -------------- 我的天 welcome 我是重复的*/ } 

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

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

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

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

package 好好学java;public class Person { // 属性 private String name; private int age;  // 构造方法 public Person() { super();  } public Person(String name, int age) { super(); this.name = name; this.age = age; }  // 要让哈希表存储不重复的元素，就必须重写hasCode和equals方法 @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; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Person other = (Person) 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; }   @Override public String toString() { return "Person [name=" + name +