1.集合:

存储多个引用数据类型对象的容器,它的长度可变.
(动态数组,可以存多个数据,而且长度可变)

2.集合中常用概念:

有序:按照添加顺序来排列就叫有序.
可排序:按照数字由小到大或由大到小或按字典顺序由前到后或由后到前来排列叫可排序.
唯一性:不可重复.

3.集合家族:

3.1:Collection:集合接口,存储无序,可重复的单一对象.
	3.1.1:List:集合接口,存储有序,可重复的单一对象.
		3.1.1.1:ArrayList:存储有序,可重复的单一对象,底层采用Object[]存值.
		3.1.1.2:LinkedList:存储有序,可重复的单一对象,底层采用双向链表存值.
	3.1.2:Set:集合接口,存储无序,唯一的单一对象.
		3.1.2.1:HashSet:存储无序,唯一的单一对象,底层采用HashMap.
		3.1.2.2:TreeSet:存储无序可排序,唯一的单一对象,底层采用TreeMap.
3.2:Map:集合接口,按Key-Value方式存值.
	3.2.1:HashMap:按Key-Value方式存值,Key无序,唯一的单一对象,底层采用数组+链表结构存值.
	3.2.2:TreeMap:按Key-Value方式存值,Key无序可排序,唯一的单一对象,底层采用红黑二叉树结构存值.

4.ArrayList

存储有序,可重复的单一对象.底层采用Object[]存值.一般情况下按1.5倍扩容.
	优点:遍历集合和修改指定位置元素的效率高,按顺序添加元素效率高.
	缺点:按指定索引位置添加元素,删除元素效率低.	
	eg:public static void main(String[] args) {
		//创建集合对象
		ArrayList alist=new ArrayList();
		//向集合中添加元素
		alist.add(22);
		alist.add(11);
		alist.add(55);
		alist.add(11);
		
		//向集合中指定索引位置添加元素,前提:索引范围0~集合.size()
		alist.add(0, 66);
		
		//遍历集合
		for (int i = 0; i <alist.size(); i++) {
			//获得集合中每个元素输出
			System.out.println(alist.get(i));
		}
		
		System.out.println("-----------------------------------");
		//修改集合中指定索引处元素,前提:索引范围0~集合.size()-1
		alist.set(1, 88);
		
		//遍历集合
		for (Object a : alist) {
			System.out.println(a);
		}
		
		System.out.println("***********************************");
		//删除集合中指定索引处的元素
		alist.remove(0);
		
		//删除集合中元素对象,如果有多个相同对象,按索引顺序删除是第一个
		alist.remove((Object)11);
		
		//遍历集合
		for (Object a : alist) {
			System.out.println(a);
		}
		
		System.out.println("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&");
		//清空集合中元素
		alist.clear();
		System.out.println("清空集合后,集合中元素个数为:"+alist.size());
	}

5.过滤器

将不需要的数据过滤出去,将需要的数据留下.
	eg:/**
 * 自定义过滤器
 * @author sx
 * @version 2020年1月10日
 */
public class MyFilter implements Predicate{

	/**
	 * 过滤方法
	 * @param t 当前每个要过滤
	 */
	@Override
	public boolean test(Object t) {
		if (String.valueOf(t).endsWith("2")) {
			return true;
		}
		return false;
	}
}

	public static void main(String[] args) {
		//创建集合对象
		ArrayList alist=new ArrayList();
		//向集合中添加元素
		alist.add(12);
		alist.add(11);
		alist.add(15);
		alist.add(22);
		
		//遍历集合
		for (int i = 0; i <alist.size(); i++) {
			//获得集合中每个元素输出
			System.out.println(alist.get(i));
		}
		
		System.out.println("-----------------------------------");
		//按过滤器删除集合中元素
		alist.removeIf(new MyFilter());
		
		//遍历集合
		for (Object a : alist) {
			System.out.println(a);
		}
	}

6.LinkedList

存储有序,可重复的单一对象.底层采用双向链表结构存值.
	优点:按指定索引添加和删除元素效率高.
	缺点:遍历元素效率较ArrayList低,修改元素效率较ArrayList低.
	 
	源码分析:变量追踪法.
	eg:public static void main(String[] args) {
		//创建集合对象
		LinkedList alist=new LinkedList();
		//向集合中添加元素
		alist.add(22);
		alist.add(11);
		alist.add(55);
		alist.add(11);
		
		//向集合中指定索引位置添加元素,前提:索引范围0~集合.size()
		alist.add(0, 66);
		
		//向集合中添加第一个元素
		alist.addFirst(77);
		
		//向集合中添加最后一个元素
		alist.addLast(99);
		
		//遍历集合
		for (int i = 0; i <alist.size(); i++) {
			//获得集合中每个元素输出
			System.out.println(alist.get(i));
		}
		
		System.out.println("-----------------------------------");
		//修改集合中指定索引处元素,前提:索引范围0~集合.size()-1
		alist.set(1, 88);
		
		//遍历集合
		for (Object a : alist) {
			System.out.println(a);
		}
		
		System.out.println("***********************************");
		//删除集合中指定索引处的元素,前提:索引范围0~集合.size()-1
		alist.remove(0);
		
		//删除集合中元素对象,如果有多个相同对象,按索引顺序删除是第一个
		alist.remove((Object)11);
		
		//删除集合中第一个元素
		alist.removeFirst();
		
		//删除集合中最后一个元素
		alist.removeLast();
		
		//遍历集合
		for (Object a : alist) {
			System.out.println(a);
		}
		
		System.out.println("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&");
		//清空集合中元素
		alist.clear();
		System.out.println("清空集合后,集合中元素个数为:"+alist.size());
	}

7.迭代器(Iterator)

遍历Collection集合家族的工具类.
	 
	常用方法:
		hasNext();如果迭代器后面是否有元素可迭代，则返回 true 。
		next();返回迭代中的下一个元素。集合中每个元素只可迭代一次.
		eg:public static void main(String[] args) {
		//创建集合对象
		LinkedList alist=new LinkedList();
		//向集合中添加元素
		alist.add(22);
		alist.add(55);
		
		/*迭代器遍历集合*/
		//获得当前集合迭代器对象
		Iterator it1=alist.iterator();
		//判断迭代器后面是否有元素可迭代
		while (it1.hasNext()) {
			//调用迭代器对象的迭代方法,获得集合中每个元素
			Object ob=it1.next();
			System.out.println(ob);
		}
}

8.泛型

泛型就是可以表示一个广泛数据类型的类型参数（泛型只能表示引用类型）,把数据类型作为参数来传递。
	8.1:泛型集合:只能存泛型类型指定的一种数据类型集合叫泛型集合.
		8.1.1:为什么要用泛型集合:避免普通集合存数据要频繁的装箱,取数据要频繁的拆箱的问题,提高程序的效率.
		8.1.2:泛型集合优点:拥有数组的优点存值取值方便(同一个集合中可以存相同类型多个对象),同时也弥补数组的缺点,长度可变.
         8.1.3:泛型集合:集合类型<数据类型> 集合名=new 集合类型[<数据类型>]();
  注意： 1 <E>：<>表示泛型,E(Element)表示占位符代替一个数据类型 ,其他的名称T(Type) V(Value) K(Key) 
        2 可以写多个泛型参数，如果写多个中间用逗号隔开    
              
			eg:public static void main(String[] args) {
		//创建集合对象
		List<Student> alist=new ArrayList();
		//向集合中添加元素
		alist.add(new Student("张三1", 18));
		alist.add(new Student("张三2", 38));
		alist.add(new Student("张三3", 28));
		alist.add(new Student("张三4", 98));
		
		//遍历集合
		for (Student stu1 : alist) {
			System.out.println("学生姓名:"+stu1.sname);
		}
  }

	8.2:泛型迭代器:迭代器迭代每个元素都是泛型类型,叫泛型迭代器.
		注意:泛型迭代器和泛型集合是黄金搭挡(用迭代器遍历泛型集合时要用泛型迭代器,否则要频繁装箱和拆箱).
		8.2.1:泛型迭代器的作用:避免了迭代元素时频繁装箱和拆箱.
		8.2.2:泛型迭代器的语法:Iterator<数据类型> 迭代器名=集合名.iterator();
			eg:public static void main(String[] args) {
		//创建集合对象
		List<Student> alist=new ArrayList<>();
		//向集合中添加元素
		alist.add(new Student("张三1", 18));
		alist.add(new Student("张三2", 38));
		alist.add(new Student("张三3", 28));
		alist.add(new Student("张三4", 98));
		
		System.out.println("-----------------------");
		//获得集合的泛型迭代器
		Iterator<Student> it1=alist.iterator();
		//判断迭代器后面是否有元素可迭代,判断一次迭代一次
		while (it1.hasNext()) {
			//获得跌元素
			Student stu1=it1.next();
			System.out.println("学生姓名:"+stu1.sname);
		}
}
			
	8.3:泛型类(扩展):在类名后面加<数据类型>
		eg:/**
 * 泛型类
 * @author sx
 * @version 2020年1月10日
 * @param <T> 泛型类型,T数据类型占位符,在创建这个类的对象时传过来
 */
public class Student1<T> {
	public String sname;
	public T aa;
}

public static void main(String[] args) {
		//创建泛型类对象
		Student1<Integer> stu1=new Student1<>();
		stu1.sname="张三";
		stu1.aa=18;
		
		//创建泛型类对象
		Student1<Character> stu2=new Student1<>();
		stu2.sname="李四";
		stu2.aa='男';
	}

	8.4:泛型方法(扩展):在方法访问修饰符后面加<数据类型>,方法参数类型用泛型数据类型作形参类型.
		eg:/**
 * 学生类
 * @author sx
 * @version 2020年1月10日
 */
public class Student2{
	/**
	 *  泛型方法
	 * @param t1
	 */
	public <T> void show(T t1) {
		System.out.println("方法参数为:"+t1);
	}
}

public static void main(String[] args) {
		//创建对象
		Student2 stu2=new Student2();
		//用对象调用泛型方法
		stu2.show("abc");
		stu2.show(11);
	}

	8.5:<?>：表示任意类型,不受限类型.
		<? extends T>：表示T类或者T类的子类
         <? super T>：表示T类或者T类的父

9.Collections是Collection集合工具类,提供对集合操作方法.

11.ArrayList vs Vector:

11.1:相同点:
	11.1.1:都是List接口下实现类
	11.1.2:都存储的是有序的,可重复单一对象,底层都采用Object数组存值.
11.2:不同点:
	11.2.1:推出时间不同:在jdk1.2之前就推出了Vector
					在jdk1.2之后,才推出了ArrayList .
	11.2.2:安全性和效率不同:Vector是线程安全集合,效率低,在多线程中使用安全.
					ArrayList是线程不安全的集合,效率高,在单线程中用效率高.
	11.2.3:扩容倍数不同:Vector一般情况下按原来2倍扩容.
					  ArrayList一般情况下按原来1.5倍扩容.
	11.2.4:方法不同:ArrayList拥有所有方法,Vector都有,Vector还有自己独有方法.

12.Stack集合:

按压栈的方式存值,取值时后进先出.