集合框架的总结

1 集合派系的顶层接口:Collection


  1.1 Collection接口中的方法


      1)Collection 集合存储对象，存储对象的方法


(1)add(E e) 将元素存储到集合的方法  add(Object e)参数，任何对象都可以传递的
(2)addAll(Collection c)将一个集合添加到另一个集合中


      2)Collection集合中，移除对象的方法


(1)boolean remove(Object o)传递一个对象，移除这个对象,移除成功返回true
(2)boolean removeAll(Collection c)移除，两个集合的共性元素,移除成功返回true


      3)Collection集合中的其他方法


        (1)void clear()移除集合中的所有元素
      (2)int size()返回集合中存储的元素的个数
(3)boolean contains(Object o)判断参数，在不在集合中，如果在返回true
(4)boolean containsAll(Collection c)判断一个集合是否包含另一个集合，包含返回true
(5)boolean retainAll(Collection c)获取两个集合的交集


2 List 接口派系


  2.1 List接口派系的特点：


      1)有序的:存储的时候，和取出的时候顺序一致
    2)List派系是一个有索引的，具有下标
    3)允许存储重复元素


  2.2 List接口中的特有方法

      1)add(int index, Object obj)在指定的索引上，插入元素
     2)Object get(int index)指定下标，获取这个下标上的元素
     3)Object remove(int index)指定下标，移除这个下标上的元素，返回删除之前的
     4)Object set(int index ,Object obj)执行下标，修改这个下标上的元素，返回修改之前的
     5)List subList(int start,int end)获取集合中的一部分，包含头，不包含尾


  2.3 List接口派系的特有迭代器ListIterator


           List接口中定义了一个方法listIterator,所有的子类都具备的，返回一个接口的实现类的对象，
      接口是就ListIterator，List的特有迭代器使用List特有迭代器，可以实现在迭代的过程中，对集合
      中的元素，进行添加，修改，和删除。


      1)ListIterator接口方法


(1)add(Object obj)使用迭代器,遍历集合的过程中，添加
(2)set( Object obj)使用迭代器，遍历集合的过程中，修改
(3)boolean hasPrevious()  看成是hasNext()
(4)Object previous() 看成是next()


3 ArrayList类


      属于List派系中的一个子类，具备List派系的所有特点：有序，下标，重复


      1)ArrayList自己的特点：

(1)ArrayList底层实现的数据结构是数组结构
(2)ArrayList实现是不同步，线程不安全，但是运行效率高
(3)ArrayList底层是一个可变数组，导致了，这个集合查询快，增删慢
(4)ArrayList 数组大小默认10个位置，每次增长50%


      2)去掉ArrayList中的重复元素


        List本身，允许重复的，必须完成去掉重复的工作，但是List没有这个功能，
我们自己写出来这样的功能.集合中存储自定义的对象，并去掉重复.
Person对象，如果姓名和年龄，同样，看做是同一对象。contains方法原理，
凭什么判断对象是否包含在集合中。contains方法的实现原理，在于对象中
的equals方法，自动调用对象中的equals方法，来进行判断


代码实现：

/*
 * 去掉ArrayList中的重复元素
 */
import java.util.*;
public class ArrayListDemo_my {
	public static void main(String[] args) {
		ArrayList<Person> array = new ArrayList<Person>();//创建一个集合
		//在集合array中加入Person的信息
		array.add(new Person("lisi1",181));
		array.add(new Person("lisi2",182));
		array.add(new Person("lisi2",182));
		array.add(new Person("lisi3",183));
		array.add(new Person("lisi3",183));
		array.add(new Person("lisi4",184));
		System.out.println("调用method之前"+array);
		array = method(array);//调用method()方法除去array中重复的元素
		System.out.println("调用method之后"+array);
	}
	/*
	 * 定义一个方法，完成去掉ArrayList的重复元素
	 * 方法中，返回一个新的集合，让main中的老集合，替换一下
	 */
	private static ArrayList<Person> method(ArrayList<Person> array){
		//定义新的集合，最终存储的是去掉重复后的元素
		ArrayList<Person> newArray = new ArrayList<Person>();
		//迭代老集合
		Iterator<Person> it = array.iterator();
		while(it.hasNext()){
			//获取老集合中的元素，获取一个到新集合中判断，是否存在
			Object obj = it.next();
			//新的集合，调用contains方法，判断，obj是否存在
			if(!newArray.contains(obj))
				newArray.add((Person) obj);
		}
		return newArray;
	}
}

      3)ArrayList存储自定义对象，并取出,代码实例如下：

/*
* ArrayList存储自定义对象并取出
*/
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListDemo{
public static void main(String[] args){
	method();
}
/*
 * 定义方法，实现将Person对象存储到ArrayList，并迭代器和for取出两种方法取出
*/
private static void method(){
	ArrayList<Person> array = new ArrayList<Person>();
	array.add(new Person("张三",15));
	array.add(new Person("李四",25));
	array.add(new Person("王武",18));
	array.add(new Person("小强",35));
	array.add(new Person("旺财",45));


	//获取迭代器对象，用集合的iterator方法
	Iterator<Person> it = array.iterator();


	//循环判断，调用迭代器的hasNext()
	while(it.hasNext()){


	   //调用迭代器的next方法输出存储的对象
	   //定义Person变量，接收it.next返回值
	   Person p = (Person)it.next();
	   System.out.println(p.getName()+"==="+p.getAge());
	}




	//第二种方法：for循环，传统的，用下标获取
	for(int i = 0 ; i < array.size() ; i++){
	     Person p = (Person)array.get(i);
	     System.out.println(p.getName()+"*****"+p.getAge());
	}
    }
}

4)案例；
 (1)用户通过键盘输入，输入姓名和成绩，姓名成绩封装成学生对象
    学生对象存到ArrayList中如果用户输入了over,结束键盘输入，迭代
    集合，迭代出已经存储的学生对象，姓名和成绩，不使用toString()
    解：代码实现如下：

/*分析：键盘录入姓名和成绩存储到ArrayList集合
Scanner类，nextLine实现键盘的输入
String 切割字符串split 姓名和成绩的分割
将姓名成绩，存到ArrayList
*/
import java.util.*;
public class ArrayListTest_my {
	public static void main(String[] args) {
		method();
	}


	private static void method() {
		//创建一个集合，创建一个键盘输入的Scanner
		ArrayList<Student> array = new ArrayList<Student>();
		//接受键盘的输入
		Scanner sc = new Scanner(System.in);
		while(true){
			String str = sc.nextLine().trim();
			if("over".equals(str))
				break;
			String[] s = str.split(" +");
			//将姓名和成绩存储到ArrayList集合，成绩转成int
			array.add(new Student(s[0],Integer.parseInt(s[1])));
		}
		//创建迭代器，获取集合中的元素
		Iterator<Student> it = array.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}	
	}
}
	  (2)制作一个6位不同字符的验证码输出到控制台，用户输入，判断对还
	     是错(6位不同的，数字，字母，汉字）


	     代码实现如下：
/*
 *  六位随机验证码
 *  利用字符数组，获取验证码
 *  随机数，随机产生下标，通过下标到数组中获取一个字符
 *  装在字符串的缓冲区中，如果缓冲区长度到达6个，直接退出循环
 */
import java.util.*;
public class GetCodeTest {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);//键盘输入
		//定义字符数组，保存一些字符
		char[] ch = {'a','v','1','3','6','p','m','0','啊','你','我','黑','去','抛','为'};
		while(true){
			StringBuilder builder = new StringBuilder();//创建StringBuilder
		while(true){
			//得到随机数
			int num = new Random().nextInt(ch.length);
			//利用随机数，当作下标，去数组中，获取字符
			char c = ch[num];
			//判断这个字符，是否已经存在于缓冲区了，将缓冲区变成字符串，
			//利用Strin的方法contains
			if(builder.toString().contains(c+""))
			//如果if成立返回的真，继续随机
				continue;
			//如果if不成立，将字符追加到缓冲区
			builder.append(c);
			//判断缓冲区的长度
				if(builder.length()==6)
					break;
		}
		System.out.println(builder);
		String code = sc.nextLine();
		if(builder.toString().equalsIgnoreCase(code)){
			System.out.println("正确");break;
		}
		else{
			System.out.println("错了");
			continue ;
		}
		}
	}
}

4 LinkedList类


  LinkedList底层数据结构链表实现，记录对象地址的方式存储查询慢，
  增删快，线程也是不安全的，执行效率高


  4.1 LinkedList类的特有方法


     1) addFirst(Object obj)将元素添加到链表开头
     2)addLast(Object obj)将元素添加到链表结尾
     3)Object getFirst()获取链表的开头
     4)Object getLast()获取链表的结尾
     5)Object removeFirst()移除链表的开头，返回被移除前的对象
     6)Object removeLast()移除链表的结尾, 返回被移除前的对象


  4.2 JDK1.6开始，有n个新的方法，把以前的方法取代


     1)offerFirst()-->addFist() 返回值不同add开头的没有返回值，offer开头返回boolean
     2)offerLast()-->addLast()
     3)peekFirst()-->getFirst()get开头没有元素，出异常，peek开头没有元素返回null，没异常
     4)peekLast()-->getLast()
     5)pollFirst()-->removeFirst()
     6)pollLast()-->removeLast()

   4.3 LinkedList案例

       LinkedList模拟一个数据结构，堆栈，和队列，堆栈数据先进后出，队列先进先出
       代码实现：

/*
 * 使用LinkedList模拟队列和堆栈
 * 采用OOP思想，自己写一个类，实现数据的堆栈和队列功能
 * 让用户在main方法中，调用自己写的类
 * 思想转换：
 *   自己写方法，调用JDK中的类，实现的
 *   自己写方法，自己的方法中，封装了JDK中类的功能
 *   调用者，用的是我们自己的方法
 */
import java.util.*;
//实现数据的堆栈和队列，类中封装LinkedList功能
class MyDate_my{
	private LinkedList link = null;
	MyDate_my(){link = new LinkedList();}
	//提高一个添加对象的功能，其实调用LinkedList的add方法
	public void add(Object obj){
		link.add(obj);
	}
	//返回对象，实现先进先出
	public Object get(int x){
		return link.removeFirst();
	}
	public Object get(){
		return link.removeLast();
	}
	public boolean isEmpty(){
		return !link.isEmpty();
	}
}


public class LinkedListTest_my {
	public static void main(String[] args) {
		MyDate my = new MyDate();
		my.add("abc1");
		my.add("abc2");
		my.add("abc3");
		while(my.isEmpty()){//!link.isEmpty()
		System.out.println(my.get());
		}
		
	}
}

5 Vector类

  集合框架在JDK1.2版本后出现的，Vector类出现在JDK1.0版本。
  没有集合框架以前，存储对象只能依赖Vector。
  Vector底层数据结构也是可变数组实现，线程是安全的，运行效率慢，

  每次数组扩容100%。从JDK1.2版本开始，此类被ArrayList取代。

6 Set集合派系的特点：

   1)不允许存储重复的元素
   2)没有下标
   3)无序的集合，存储和取出的顺序不一致的
  Set接口中的方法，和Collection接口中的方法一致

7 HashSet类

  7.1 HashSet类的特点

   1)底层数据结构哈希表
    2)HashSet本身没有功能，功能来自于HashMap
    3)HashSet调用的是HashMap的功能
    4)无序的
    5)允许存储null
    6)线程不安全，不同步，执行效率高
 
8 哈希值


  每一个对象，在建立的时候存储在内存堆中，JVM对每一个对象，根据底层的一个算法，
  哈希算法，计算出来一个十进制数,十进制就是哈希值。程序人员开发时候的一个参考，仅此而已
  Object类，定义了一个方法  public int hashCode()计算对象的哈希值的，所有的子类都有这个
  哈希值.出现是为了哈希表而来的，本身，没有地址意义HashSet，存储的其实是对象的哈希值
  HashSet集合的存储过程，存储对象的时候，先调用对象的hashCode方法，获取该对象的哈希值(十进制数)，
  HashSet看看这个数以前存储过没有，如果没有存储过，就将这个哈希值存储到自己的哈希表中
  实现去掉重复的元素，让姓名和年龄相同的对象，具有相同的哈希值。覆盖hashCode方法存储到
  HashSet中的对象，保证对象的唯一性，必须重写hashCode和equals方法


  8.1 hashCode和equals的问题


      如果两个对象具有相同的哈希值，两个对象进行equals比较，一定返回true吗?No
      如果两个对象进行equals比较，返回真，两个对象具有相同的哈希值吗,必须相同


9 LinkedHashSet类


  特点：有序的，基于哈希表的链表，线程不安全的，执行效率高


10 TreeSet类
   10.1 特点：
       1)底层数据结构二叉树
       2)线程不安全的，执行效率高
       3)对存储到集合的对象，进行排序(对象的自然顺序 0-9 a-z)
   10.2 案例
       将自定义的对象Person存储到TreeSet集合，出现了类型转换异常
       ClassCastException :原因，Person不能被转成java.lang.Comparable
       TreeSet中，需要对Person进行排序，可是你的Person对象，不具备自然顺序。
       可以让Person具备自然顺序，实现Comparable接口.
       String类，可以按照字符串的字典顺序，比较两个字符串，原因String类实现了Comparable接口，重写了接口中的方法compareTo()String类就具备了自然顺序


       实现Person类，具备自然顺序，实现Comparable接口，重写compareTo方法
       姓名，年龄，主要比较姓名，如果姓名一样，比较年龄


       TreeSet集合两个排序方法在上篇播客中已经详细的讲述过。


11 Map集合


   映射，键映射到值的集合，Map体系的集合，存储对象的时候，一次存储两个对象，一个称作键，
   一个称作值，双列集合一个键，最多只能映射一个值不允许出现重复键。
   
   11.1 Map接口中的方法


        1)V put(K,V) 将键值对存储到集合。返回值，存储了重复的键，返回被覆盖之间的值
2)V get(K) 根据键，获取值，传递一个键，返回键映射的值，没有这个键，返回null
3)V remove(K)移除指定的键，对应的值，返回被移除前的值，没有移除成功，返回null
4)boolean containsKey(K)判断集合中，有没有这个键，有返回true
5)boolean containsValue(V)判断集合中个，有没有这个值，有返回true
6)Collection values()将集合中的所有值，保存到Collection集合
7)Set<K> keySet()键存储到Set集合
8)Set<Map.Entry<K,V>>映射关系对象保存到Set集合


   11.2 获取Map集合中键值对的方式(上篇播客中已经详细的讲述过)


12 HashMap类


   底层也是哈希表，允许存储null值，null键
   不同步，线程不安全，执行效率高
   保证：存储到HashMap集合中的键，唯一性
   自定义对象，保证唯一性，hashCode equals方法
   HashMap存储自定义对象，当作键，两种方式获取


13 LinkedHashMap


   是HashMap的子类，特点保证键的顺序，存储的键，怎么存的，怎么取出来，
   不同步执行效率高底层结构基于哈希表的链表实现


14 TreeMap集合


   底层数据结构红黑树，自然平衡二叉树
   线程不同步的，不安全，执行效率高
   存储键，对键进行自然顺序的排序，要求的作为键的对象，必须具备自然顺序
   或者自定义比较器
   TreeMap使用方式，原来的TreeSet是一致的，保证对象的自然顺序，或者自定义
   比较器就可以了，程序代码，存储的时候和TreeSet几乎一致。Set使用add,Map
   使用put


15 Hashtable


  JDK1.0出现的集合，存储键值对，底层数据结构也是哈希表，Hashtable JDK1.2
  后实现Map接口。线程安全，不允许存null值，null键。除了线程，null，和HashMap
  是一致的。已经被HashMap取代。但是Hashtable虽然不用了，但是有一个子类，至今
  活跃在开发的舞台中。Properties是Hashtable的子类


16 Properties
   存储键值对的集合，线程安全，IO流配合使用，这个集合的泛型，定好了，键值的
   泛型都是String


   Prperties类的两个自己的特性方法
   setProperty(String key,String value)将键值对存储到集合
   String getProperty(String key)根据键，获取值