集合框架

1.集合：

   面向对象的语言对事物的体现都是以对象的形式，所以了为了对对象的操作，对对象进行存储，那么集合就是对对象操作最常用的一种方式。
2.数组和集合类的区别：
   数组和集合类都是容器，但是数组的长度是不可以变得，而集合类的长度是可变的。数组就只可以存储基本类型数据，而集合类可以存储对象。
3.集合类的特点：
  集合只用于存储对象，集合的长度是可变，可以存储不同类型的对象。
4.Collection
     ----List
          ----ArrayList
          -----LinedList
          -----Vector
     ------Set
         -----HashSet
         -----TreeSet
5.为什么会出现那么多的容器呢？
   因为集合类对数据的存储方式不一样，故出现多个容器。
6.集合存放的都是对象的引用
7.Collection接口的共性方法
1.boolean add(Object obj):添加元素。参数是Ojbect类型，因为参数类型不确定，这样方便接收任何数据类型。
2.int size()：获取集合的大小
3.boolean remove():移除元素
4.void  clear():清空集合中元素。
5.boolean isEmpty():判断集合中元素是否为空
6.boolean contains(Object obj):判断元素是否在集合中

7.boolean retainAll():取二个集合的交集，将相同的交集赋值到前者
8.remove() :取交集，在前者移除相同的交集部分。
9.Iterator iterator():迭代器，遍历元素。

案例：Collection的共性方法

package org.collection.demo;

import java.util.ArrayList;
import java.util.Iterator;

@SuppressWarnings("rawtypes")
public class ArrayListDemo {
public static void main(String[] args) {
	method_1();
	method_2();
}
@SuppressWarnings("unchecked")
public static  void method_1(){
	//创建一个容器，使用Collection的子类ArrayList类。
		ArrayList al=new ArrayList();
		//集合的大小
		int len=al.size();
		System.out.println("添加之前集合的大小:"+len);
		//往容器里添加元素
		al.add("java01");
		al.add("java02");
		al.add("java03");
		sop("添加之后集合的大小:"+al.size());
		//将集合中的元素循环遍历出来
		for (int i = 0; i < al.size(); i++) {
			sop(al.get(i));
		}
		//根据索引移除元素
		al.remove(0);
		//根据元素的内容移除元素
		al.remove("java02");
		sop("移除之后集合的大小:"+al.size());
		//清空集合的元素
		al.clear();
		
		//判断元素是否为空
		boolean b=al.isEmpty();
		sop(b);
		//判断元素是否存在集合中
		boolean b1=al.contains("javao4");
		sop("java04是否存在:"+b1);	
}
public static void method_2(){
	ArrayList  al1=new ArrayList();
	al1.add("java01");
	al1.add("java02");
	al1.add("java03");
	ArrayList al2=new ArrayList();
	al2.add("java02");
	al2.add("java03");
	al2.add("java08");
	//取交集，得到al1与al2的相同部分，将交集部分存储到al1中去。
	//al1.retainAll(al2);
	//取交集，然后移除al1中交集的那部分元素。
	//al1.removeAll(al2);
	sop(al1);
	
	//第一种方式：
	Iterator it=al1.iterator();//获取迭代器，遍历打印
	while(it.hasNext()){
		sop(it.next());
	}
	//第二种方式：
	for(Iterator it1=al1.iterator();it.hasNext();){
		sop(it1.next());
	}
	//第三种方式；
	for (int i = 0; i < al2.size(); i++) {
		sop(al2.get(i));
	}
}
public static void sop(Object  obj){
	System.out.println(obj);
}
}

8.List：存放的数据是有序可重复，因为有索引。
ArrayList:底层的数据结构是数组结构，查询起来速度比较快，但是增加和删除元素比较慢。线程不同步
LinkList:底层的数据结构是链表结构。增删速度比较快，但是查询速度稍慢。
Vector:底层的数据结构是数组结构。线程是同步的，已经被ArrayList所替代。
  Set：存放的数据是无序不可重复。
 List集合特有的方法：凡是可以操作下标的方法都是List体系特有的方法
 增：add(index,element)
     addAll(index,Collection);
删除：remove(index)
改：set(index ,element)
查：get(index)
subList(from,to)
listItreator()
List集合特有的迭代器：ListIterator是Iterator的子接口。
在使用Iterator迭代器时，只可以对元素进行获取和移除，如果要使用其他的操作，那么会发生异常。所以可以使用ListIterator迭代器。集合.listIterator()方法就可以获取到ListIterator迭代器。
hasPervious():判断光标前面是否有元素
Pervious():读取前一个元素。

案例：List集合的共性方法

package org.list.demo;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

public class ArrayListDemo {
public static void main(String[] args) {
	method_1();
}
public static void method_1(){
	ArrayList al=new ArrayList();
	al.add("java01");
	al.add("java02");
	al.add("java03");
	sop("原集合:"+al);
	//在指定位置添加元素
	al.add(1,"java04");
	sop("新集合:"+al);
	//根据索引删除元素
	al.remove(1);
	//修改元素
	al.set(0, "java09");
	//根据索引获取元素
	sop("元素："+al.get(1));
	//获取所有元素
	//第一种方式:
	for(int i=0;i<al.size();i++){
		sop(al.get(i));
	}
	//第二种方式
	/*iterator():获取迭代器
	 * hasNext():读取下一行是否有数据,如果有返回True.否则返回flase.
	 * next():将下一行的数据读取出来.
	 */
	Iterator it=al.iterator();
	while(it.hasNext()){
		sop(it.next());
	}
	
	for(Iterator it1=al.iterator();it1.hasNext();){
		sop(it1.next());
	}
	//通过indexOf(Object obj)方法获取元素的位置
	sop("index="+al.indexOf("java03"));
	//通过subList(form,to)方法获取子集合
	sop("subList="+al.subList(1,3));
	
}
public static void method_2(){
	ArrayList al=new ArrayList();
	al.add("java01");
	al.add("java02");
	al.add("java03");
	//iterator()方法:使用Iterator迭代器，只可以对元素进行查询和获取
		Iterator it2=al.iterator();
		while(it2.hasNext()){
			Object obj=it2.next();
			if("java02".equals(obj)){
				al.remove(obj);
			}
			sop("obj="+obj);
		}
		//ListIteartor迭代器：listIterator(),可以对元素进行增删改查的操作.
		ListIterator li=al.listIterator();//正向遍历
		while(li.hasNext()){
			Object obj=li.next();
			if("java03".equals(obj)){
				li.set("java06");
			}
		}
		//逆向遍历，读取光标的前一个元素
		ListIterator li2=al.listIterator();
		while(li2.hasPrevious()){
			sop("前一个元素是:"+li2.previous());
		}
}
public static void sop(Object obj){
	System.out.println(obj);
}
}

9.Vector特有的方法：
  枚举是Vector特有的方式，枚举和迭代器相似。因为枚举的方法名过长，所以是被ArrayList取代。所以Vector最后郁郁而终。
elments()： 获取一个枚举对象Enumertion.
hasMoreElments()：类似于hasNext()
nextElments()：类似于next().
10.LinkedList的特有方法
   addFirst(Object obj):将元素添加到集合中第一个元素的位置
   addLast(Object obj):将元素添加到集合中最后一个元素的位置。
 getFirst():获取集合中第一个元素，但是不会移除元素。但是如果集合中没有元素，则会 报异常。
   getLast():获取集合中的最后一个元素，但是不会移除元素。但是如果集合中没有元素， 则会报异常。
   removeFirst():获取集合中的第一个元素，同时会移除元素。但是如果集中没有元素，则 会报异常。
   removeLast():获取集合中的最后一个元素，同时会移除元素，但是如果集合中没有元素， 则会异常。
在JDK1.6版本中，已经替代了。
offerFirst();
offerLast():
peekFirst():
peekLast():
poolFirst():
poolLast():
如果集合中没有元素，会返回null。不会出现异常。
 ArrayList自定义存储对象时，先要把重复元素去除，再去重写equals方法。
11.List集合判断元素是否相同，依据的是equals().
12.Set集合：无序不可以重复.无序是指存入和取出的顺序不一定一致.
   Set集合的功能和Collection功能的是一致.
  HashSet:底层的数据结构是哈希结构,线程是不同步的。
  hashset是如何保证元素的唯一性的？
  是通过元素的二个方法，hashCode()和equals().
  如果hashCode值相同，才会去判断equals是否为true.
  如果hashCode值不相同，那么不会调用equals方法.
  注意的是：删除和判断都要调用equals方法和hashcode方法
  TreeSet:可以对Set集合的元素进行排序。底层数据结构是二叉树。
   TreeSet集合自定义存储对象时：
先将对象实现Comparable接口，并且重写compareTo()方法。
TreeSet集合的排序的第一种方式：
让元素具备比较性，实现Comparable接口，覆盖compareTo()方法。
这种方式被称之为自然顺序。
TreeSet集合的排序的第二种方式：
如果元素不具备比较性，或者元素的比较性不是所需要的，那么这时就需要让集合自身  
具备比较性。在集合初始化时，就有了比较性。
定义一个比较器，将比较器对象作为参数传递给集合的构造函数。
当二种排序都存在时，以比较器为主。
定义一个类，实现Comparator接口，覆盖 compare方法。 

13.Map集合：
       该集合的存储方式是键值对，一对一对的存入，而且保证键的唯一性。
        1.添加
put(key,value):
2.删除
 clear():
remove():
3.判断
 isEmpty()
containsKey(Object value);
containsValue(Object value)
4.获取
  get();
  size();
  values():
  entrySet()
  keySet();

案例：Map集合的共性方法

package com.map.demo;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

public class MapDemo {
public static void main(String[] args) {
	Map<String,String> m=new HashMap<String,String>();
	//添加元素
	//添加元素时，如果集合中已有键，那么新的值会覆盖之前的值，并且会返回之前键对应的值
	m.put("01","java01");
	m.put("02", "java02");
	m.put("03","java03");
	System.out.println("大小："+m.size());
	sop("判断集合中是否有某个键:"+m.containsKey("01"));
	sop("移除某个键值对"+m.remove("01"));
	
	System.out.println("判断集合是否为空："+m.isEmpty());
	//使用get()可以判断是否存在某个键，如果不存在就将会返回null.
	System.out.println("获取值:"+m.get("02"));
	
	//获取map中所有的值
	Collection<String> c=m.values();
	sop(c);
	
}
public static void sop(Object obj){
	System.out.println(obj);
}
}

  14.Map：
       ---Hastable:底层数据结构是哈希表数据结构，不可以存入null键Nullz值线程是同步的。
       ---Hashmap:底层数据结构是哈希表数据结构，可以存入null键和null值，线程是非同步的
       ---Treemap:底层是二叉树数据结构，线程是非同步的，可以给map集合的键排序。
和Set集合很像。
Map集合元素的二种取出方式：
1.keySet():将map集合所有的键存入到Set集合中，再通过get()，根据键取出值。
 Map集合取出原理：将map集合转成Set集合，再通过迭代器取出。
entrySet():将集合的映射关系存入到Set集合中，通过迭代器取出来。