JavaSE集合框架（JavaSE大全）

上一章节：JavaSE字符串（JavaSE大全）
集合框架介绍
集合框架是JAVA中一系列关于集合的实现类和接口。
集合可以看做是一种容器，用来存储对象（集合只能存对象），与数组相类似，但特性不一样。集合的功能更强大，集合类的空间容量时可以调整的。集合类都在java.util包下。
集合和数组的区别：
（1）集合专门用来存放对象，不能直接存储基本数据类型，但可以存储包装类型。数组可以存放基本数据类型等数据。
（2）集合中的数据可以是不同类，数组中只能存放同类型数据
（3）数组一旦被定义，不可以被修改，集合中的数据可以被修改
集合框架结构
Java的集合框架从整体上可以分为两大接口。
Collection接口：该接口下的所有实现类均存储的是单一对象。
Map接口：该接口下的所有实现类均存储的是key-value（键值对）形式的数据。
结构图：


还有三个分支，均为上面两大接口服务。
（1）Iterator接口（迭代器），主要用于遍历Collection接口的及其子类而设计。
（2）Comprator接口（比较器），在集合中存储对象的时候，用于对象之间的比较。
（3）Collections工具类，提供很多静态方法，来对Collection集合进行操作
常用实现类：
List接口：ArrayList，LinkedList
Set接口：HashSet，TreeSet
Map接口：HashMap，HashTable
List集合
List接口：
是Collection接口的子接口，存放的元素有序且允许重复。
List集合类常用的有：
ArrayList（重点） LinkedList Vector（了解即可）
创建ArrayList对象
ArrayList list=new ArrayList()；
创建对象后，我们可以使用Collection接口中的方法对ArrayList的各种操作。
这些方法是定义在Collection接口中的方法，所以Collection接口中其他集合类都可以通用，包括List中的几个实现类。
Collection接口中定义的方法：
（1）boolean add(E element); 向collection中添加元素。
（2）boolean remove(Object element); 在collection中移除指定的元素。
（3）int size(); 返回此collection中的元素数。
（4）boolean isEmpty(); 判断此collection中是否为空。
（5）boolean contains(Object obj); 判断此collection是否包含指定的元素。
（6）boolean contains(Collection<?> c); 判断此collection是否包含指定collection中的所有元素。
（7）boolean addAll(Collection<? extends E> c);将指定collection中的所有元素添加到此collection中
（8）boolean removeAll(Collection<?> c); 移除此collection中那些也包含在指定collection中的所有
元素。
（9）void clear(); 移除些collection中所有的元素。
（10）boolean retainAll(Collection<?> c); 仅保留此collection中那些也包含在指定collection的元素。
（11）Iterator iterator(); 返回在此collection的元素上迚行迭代的迭代器。
（12）T[] toArray(T[] arr); 把此collection转成数组。
Demo，创建一个Stu实体类

public class Stu {
	String name;
	int age;
	
	
	public Stu(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
		
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}

ArrayList l1=new ArrayList();
		
		Stu stu1=new Stu("张三",18);
		Stu stu2=new Stu("李四", 20);
		Stu stu3=new Stu("王五", 19);
		Stu stu4=new Stu("赵六", 19);
		//在集合中添加对象
		l1.add(stu1);
		l1.add(stu2);
		l1.add(stu3);
		l1.add(stu4);
		//打印个数
		System.out.println(l1.size());
		//删除个数
		l1.remove(stu4);
		System.out.println(l1.size());
	}

另一个demo

public static void main(String[] args) {
		ArrayList l1=new ArrayList();
		ArrayList l2=new ArrayList();
		
		Stu stu1=new Stu("张三",18);
		Stu stu2=new Stu("李四", 20);
		Stu stu3=new Stu("王五", 19);
		Stu stu4=new Stu("赵六", 19);
		Stu stu5=new Stu("傻橙", 19);
		Stu stu6=new Stu("E总", 19);
		Stu stu7=new Stu("Build", 19);
		//在集合中添加对象
		l1.add(stu1);
		l1.add(stu2);
		l1.add(stu3);
		l1.add(stu4);
		l2.add(stu5);
		l2.add(stu6);
		l2.add(stu7);
		//判断集合是否为空
		System.out.println(l1.isEmpty());
		System.out.println(l2.isEmpty());
		//判断集合中是否包含指定元素
		System.out.println(l1.contains(stu7));
		System.out.println(l1.contains(stu2));
		//将一个集合中所有元素添加到另一个集合中
		l1.addAll(l2);
		System.out.println(l1.size());
		//清空集合中所有元素
		l2.clear();
		System.out.println(l2.size());
		//将Collection转数组
		Stu[] sArray=(Stu[])l1.toArray();
		
		
		
	}

ArrayList，LinkedList和Vector的区别：
ArrayList：
（1）底层是封装数组实现，分配的是一块连续内存空间
（2）读取快，增删慢
（3）线程不安全
（4）初始大小是10，扩充是扩充50%
LinkedList：
（1）底层封装链表实现，分配的是不连续的内存空间。
（2）增删快，读取慢
（3）线程不安全
（4）没有扩容的机制，使用首尾添加的操作 addFirst()和addList()
Vector
（1）底层封装数组实现
（2）增删插速度都慢
（3）线程安全
（4）初始大小10，扩充时扩充一倍
注：其他操作中，都是使用Collection接口中的方法。

ArrayList l1=new ArrayList();
		l1.add("傻橙");
		l1.add("E总");
		l1.add("缶字");
		//索引从0开始，顺序由添加顺序决定
		System.out.println(l1.get(1));
		
		for (int i=0;i<l1.size(); i++) {
			System.out.println(l1.get(i));
		}
		

Set集合
Set接口：
是Collection接口的子接口，存取的元素无序且不允许重复。
Set接口没有提供Collection接口额外的方法，也就是仍然使用Collection接口已经定义好的方法，与List接口相似，没有get()方法
Set接口常用的实现类有：
HashSet：散列存放，无序
TreeSet：有序存放，自然排序（不是按照存入顺序）
Set接口存，取，删对象都有很高的效率。

**HashSet原理：**根据每个对象的哈希码值（调用hashCode()获得）用固定的算法算出它的存储索引，把对象存放在hash表中的相应位置中；
存对象时，首先获得该对象的hashCode值，与hash表中的值进行比较，如果不存在，则直接把该对象存入集合中，并把该hashCode值存入hash表中，此次add操作结束，如果存在，则进行下面的计算。通过“==”操作符判断已经存入的对象与要存入的对象是否为同一对象。如果true则集合认为添加相同对象，add失败。如果false（不是同一对象），则调用要添加的对象的equals()方法，如果返回值为true，则集合认为添加相同对象add失败，否则添加成功。

public static void main(String[] args) {
		Stu stu1=new Stu("张三",18);
		Stu stu2=new Stu("李四", 20);
		Stu stu3=new Stu("王五", 19);
		Stu stu4=new Stu("赵六", 19);
		
		//泛型
		HashSet<Stu> h1=new HashSet<Stu>();
		h1.add(stu1);
		h1.add(stu2);
		h1.add(stu3);
		h1.add(stu4);
		h1.add(stu4);
		//不能存放相同对象
		System.out.println(h1.size());
		
		for (Stu stu : h1) {
			System.out.println(stu.getName());
		}
	}

TreeSet存储原理：存放时会调用集合集合元素的CompareTo()方法，根据该方法的返回值来比较元素之间的大小，然后进行“升序”排列，这种排序方式我们称之为自然排列。（升序排列）
注：如果想采用自然排序，则要存储的对象所属类必须实现Comparable接口。该接口只有一个方法 public int compareTo(Object obj)，必须实现该方法。

TreeSet<Integer> ts=new TreeSet<Integer>();
		//int类型会自动装箱。
		ts.add(1);
		ts.add(44);
		ts.add(33);
		ts.add(0);

		for (Integer integer : ts) {
			System.out.println(integer);
		}
	}

Iterator迭代器
迭代器是一种设计模式，他是一个对象，可以遍历序列中的对象。
for循环—有索引
For-each循环—类型统一
Java中迭代器的实现步骤：
（1）使用方法iterator()要求容器（集合就是一种容器）返回一个Iterator。第一次调用Iterator的next()方法时，返回序列的第一个元素。
（2）使用next()获得序列中的下一个元素
（3）使用hasNext()检查序列中是否还有元素
（4）使用remove()将迭代器新返回的元素删除
注：iterator()方法是将java.lang.Iterable接口，被Collection继承。

public static void main(String[] args) {
		HashSet hs=new HashSet();
		hs.add("张三");
		hs.add("李四");
		hs.add("王五");
		hs.add(555);
		
		Iterator it=hs.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
		
	}

Map集合
Map集合通过键值对(key-value)的形式来存储数据。
Map中，key可以为任意类型，但建议使用String，value也可以是任意类型；
Map集合通过键获取值，查询速度非常快。

Map的实现类：
HashMap（使用频率最高（无序））
TreeMap（自然升序）
HashTab）无序
三个实现类使用步骤是相似的。
使用步骤：
根据键获取值：get（Object key）
根据key删除指定数据：remove（Object key）
注：Map里面key是不可以重复的，当key重复时，后存入的数据会覆盖前面的数据，Map中的值可以重复。

public static void main(String[] args) {
		HashMap hm=new HashMap();
		hm.put("1","zhangsan");
		hm.put("2", "lisi");
		hm.put("3","wangwu");
		hm.put("2","zhaoliu");
		System.out.println(hm.get("1"));
		hm.remove("3");
		System.out.println(hm.size());
	}

Map接口中的常用方法：
（1）Boolean containsKey（Object key）：//判断是否包含指定的key。
（2）boolean containsValue(Object value); //判断是否包含指定值的“键-值”对。
（3）Object get(Object key); //返回指定键所映射的值
（4）boolean isEmpty(); //判断此Map中是否有元素。
（5）Set keySet(); //返回此Map中包含的键的Set集。
（6）Collection values(); //返回此Map中包含的值的Collection集。
（7）Object put(Object key, Object value); //将指定的“键-值”对存入Map中
（8）put All(Map m):把一个Map集合存入指定的Map中
（9）Object remove(Object key); //根据指定的键把此“键-值”对从Map中移除。
（10）int size(); //获得些Map中“键-值”对的数量。
（11）void clear(); //清空Map中的所有“键-值”对。
（12）Set<Map.Entry<K,V>> entrySet();

public static void main(String[] args) {
		HashMap hm=new HashMap();
		hm.put("1","zhangsan");
		hm.put("2", "lisi");
		hm.put("3","wangwu");
		hm.put("4","zhaoliu");
		
		//System.out.println(hm.containsKey("2"));
		//System.out.println(hm.isEmpty());
		//System.out.println(hm.remove("6"));
		//System.out.println(hm.size());
		Set set =hm.keySet();
		Iterator it=set.iterator();
		while (it.hasNext()) {
			System.out.println(hm.get(it.next()));
			
		}
	}

HashMap Hashtable treeMap区别：
（1）HashMap线程不安全，无序，允许Key值出现一次null，Value值允许Null；
（2）Hashtable线程安全，无序，不仅实现了Map接口，也实现了Dictionary接口，Key值与Value值不允许为null；
（3）treeMap线程不安全，默认按照键的自然顺序进行升序排序，Key不允许null，Value值允许Null；
泛型
通过泛型替代定义不明确的参数类型。
泛型的本质是参数化类型，是将类的类型参数化，具体调用的时候再给具体的类型，这种参数类型可以用在类，接口和方法的创建中，分别称为泛型类，泛型接口，泛型方法。
泛型类：public class 类名{}
泛型接口：public interface 接口名{}
泛型方法:public 返回值类型 方法名（）｛｝

public class FanXing {
	public static <T> void fun(T t) {
		System.out.println("传入的参数类型是"+t.getClass());
	}
	public static void main(String[] args) {
		Generics<String> gs=new Generics<String>();
		gs.add("hello");
		gs.add("world");
		
		gs.show();
		
		fun("assd");
		
	}
}

public interface GenDao<T> {
	public void add(T t);
}

public class Generics<T> {
	//保存任意类型的集合
	ArrayList<T> al=new ArrayList<T>();
	
	public void add(T t) {
		al.add(t);
	}
	
	public void show() {
		for (T t : al) {
			System.out.println(t);
		}
	}
}

下一章节：JavaSE多线程（JavaSE大全）