Java类集框架

所谓类集，就是一个动态的对象数组，是对一些实现好的数据结构进行了包装，这样在使用时就会非常方便，而且最重要的是，类集不会受到对象数组的长度限制。

类集框架主要接口：

Collection：存放一组单值的最大的接口，所谓单值，就是每个元素都是一个对象。一般很少使用此接口进行操作

List：是Collection的子接口，内容允许重复

Set：是Collection的子接口，内容不允许重复

Map：存放一对值的最大接口，以key-value的形式保存

Iterator：集合的输出接口，只能从前往后单向输出

ListIterator：是Iterator的子接口，可以进行双向输出

Enumeration：是最早的输出接口，用于输出指定集合中的内容

SortedSet：单值的排序接口，里面的内容是可以排序的，使用比较器排序

SortedMap：存放一对值的排序接口，里面的内容按照key排序，使用比较器排序

Queue：队列接口，此接口的子类可以实现队列操作

Map.Entry：每个Map.Entry对象都保存着一对key-value的内容，每个Map接口中都保存多个Map.Entry接口实例。

接口的继承关系

父类：Collection

子类：List、Set、Queue、SortedSet

父类：Map

子类:SortedMap

1）：Collection接口

public interface Collection<E> extends Iterable<E>

子接口的定义

List接口：可以存放重复的内容，

Set接口：不能存放重复的内容，所有的内容都是靠hashCode()和equals()两个方法区分的

Queue接口：队列接口。

SortedSet接口：可以对集合中的数据进行排序。‘

2）：List接口

public interface List<E> extends Collection<E>

List接口常用的子类：

ArrayList、Vector、LinkedList----3 个类

新的子类ArrayList类：

public classArrayList<E> extends AbstractList<E> 
implements List<E> ,Randomaccess,Cloneable,Serializable

挽救的子类Vector

从整个Java的集合发展历史来看，Vector是一个元老级的类，

public Vector<E> extends AbstractList<E> 
implements List<E> ,Randomaccess,Cloneable,Serializable

子类ArrayList与Vector的差

子类ArrayList与Vector的差

序号	比较点	ArrayList	Vector
1	推出时间	JDK1.2之后退出，属于新的	JDK1.0推出，属于旧的操作类
2	性能	采用异步处理方式，性能更高	同步处理方式，性能低
3	线程安全	非程序安全	线程安全
4	输出	只能使用Iterator、foreach输出	可以使用Iterator、foreach、Enumeration输出

LinkedList子类与Queue接口

LinkedList表示的是一个链表的操作类，

public class LinkedList<E> extends AbstractSequentialList<E>
implements List<E> ,Queue<E>,Cloneable,Serializable

从此类的定义可以看处，此类虽然实现了List接口，也同时实现了Queue接口，Queue接口表示的是队列操作的接口，采用的是FIFO（First Input First Output 先进先出）的操作方式，就好像一堆人排队那样，队列中有队头和队尾。

Queue接口是Collection的子接口，定义如下

public interface Queue<E> extends Collection<E>

 

3）：Set接口

public interface Set<E> extends Collection<E>

属于Collection的子类，最大的特点就是不允许重复

Set类的常用子类：

散列的存放：HashSet（特点，不能存放重复元素，采用散列的存储方式，所以没有顺序。）

有序的存放：TreeSet（数据的有序排列）

public class TreeSet<E> extends AbstractSet<E>
implements SortedSet<E>,Cloneable,Serializable

4）：SortedSet接口

从TreeSet接口中可以看出，TreeSet实现了SortedSet接口，此接口主要适用于排序操作的，即实现此接口的子类都属于排序的子类。

public interafce SortedSet<E> extends Set<E>

5）：集合的输出

Iterator：迭代输出，是使用最多的。

public interface Iterator<E>

ListIterator：双向迭代输出，是Iterator的接口，专门用于输出List中的内容。

Runmeration：是一个旧的接口，功能与Iterator类似。（废弃的接口）

foreach：JDK1.5之后提供的新功能，可以输出数组或集合。

for(类 对象：集合){
    //集合操作
}

6）：Map接口

public interface Map<K,V>

Map.Entry接口简介

Map.Entry是Map内部定义的一个接口，专门用来保存key-value的内容，定义如下

public static interface Map.Entry<K,V>

在Map的操作中，所有的内容都是通过key-value的形式保存数据的，那木对于集合来讲，实际上是将key-value的数据保存在了Map.Entry的实例之后，再再Map集合中插入的一个Map.Entry的实例化对象。

Map接口常用的子类

HashMap：无序存放，是新的擦欧总类，key不允许重复

Hashtable：无序存放，是旧的操作类，key不允许重复

TreeMap：可以排序的Map集合，按集合中的key排序，key不允许重复

WeakHashMap：弱引用的Map集合，当集合中的某些内容不再使用时清除掉无用的数据，使用gc进行回收

IdentityHashMap：key可以重复的Map集合。

Map接口的使用注意事项：不能直接使用迭代输出Map中的全部内容。

7）：集合工具类Collections

public class Collections extends Object

8）：其他集合类

Java中最早出现的集合类有Vector和HashMap两个，所以在这两个类上，又派生出了Stack和Properties两个常用的子类。

Stack类：

采用的是先进后出，的数据存储方式，每一个栈都包含一个栈顶，每次出栈是将栈顶的数据取出。

Stack类是Vector的子类，定义如下

public class Stack<E> extends Vector<E>

属性类Properties类：
主要进行的是属性的操作，同时可以结合IO流，实现属性的输出与读取操作。

Properties类本身是Hashtable的子类，也是按照key-value的形式存放数据的。

public class Properties 
extends Hashtable<Objecect,Object>

9）：范例1-----一对多关系

package collection.demo;

public class Student {
	private String name;
	private int age;
	private School school;
	public Student(String name, int age) {
		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;
	}
	public School getSchool() {
		return school;
	}
	public void setSchool(School school) {
		this.school = school;
	}
	@Override
	public String toString() {
		return "学生年龄：" + age + ", 学生姓名：" + name ;
	}
	
}

package collection.demo;

import java.util.ArrayList;
import java.util.List;


public class School {
	private String name;
	private List<Student> allStudents;
	
	public School() {
		allStudents = new ArrayList<Student>();
	}
	
	public School(String name) {
		this();
		this.name = name;
	}

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public List<Student> getAllStudents() {
		return allStudents;
	}

	@Override
	public String toString() {
		return "学校名称："+this.name;
	}
	
}

package collection.demo;

import java.util.Iterator;


public class TestDemo {
	public static void main(String[] args) {
		School sch = new School("清华大学");
		Student s1 = new Student("张三", 21);
		Student s2 = new Student("李四", 22);
		Student s3 = new Student("王五", 23);
		sch.getAllStudents().add(s1);
		sch.getAllStudents().add(s2);
		sch.getAllStudents().add(s3);
		s1.setSchool(sch);
		s2.setSchool(sch);
		s3.setSchool(sch);
		System.out.println(sch);
		Iterator<Student> iter = sch.getAllStudents().iterator();
		while (iter.hasNext()) {
			System.out.println("\t|-"+iter.next());
		}
	}
}

结果：

学校名称：清华大学
	|-学生年龄：21, 学生姓名：张三
	|-学生年龄：22, 学生姓名：李四
	|-学生年龄：23, 学生姓名：王五

范例2-----多对多关系

package collection.demo1;

import java.util.ArrayList;
import java.util.List;


public class Students {
	private String name;
	private int age;
	private List<Course> allCourses;
	public Students() {
		allCourses = new ArrayList<Course>();
	}
	public Students(String name, int age) {
		this();
		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;
	}
	public List<Course> getAllCourses() {
		return allCourses;
	}
	public void setAllCourses(List<Course> allCourses) {
		this.allCourses = allCourses;
	}
	@Override
	public String toString() {
		return "学生年龄：" + age + ", 学生姓名：" + name ;
	} 
	
}

package collection.demo1;

import java.util.ArrayList;
import java.util.List;

public class Course {
	private String name;
	private int credit;
	private List<Students> allStudents;
	public Course() {
		allStudents = new ArrayList<Students>();
	}
	public Course(String name, int credit) {
		this();
		this.name = name;
		this.credit = credit;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getCredit() {
		return credit;
	}
	public void setCredit(int credit) {
		this.credit = credit;
	}
	public List<Students> getAllStudents() {
		return allStudents;
	}
	public void setAllStudents(List<Students> allStudents) {
		this.allStudents = allStudents;
	}
	@Override
	public String toString() {
		return "课程学分：" + credit + ", 课程名称：" + name;
	}
	
}

package collection.demo1;

import java.util.Iterator;

import javax.swing.CellEditor;

import collection.demo.Student;


public class TestMore {
	public static void main(String[] args) {
		Course c1 = new Course("英语",3);
		Course c2 = new Course("计算机",5);
		Students s1 = new Students("张三", 21);
		Students s2 = new Students("李四", 22);
		Students s3 = new Students("王五", 23);
		Students s4 = new Students("赵六", 24);
		Students s5 = new Students("孙七", 25);
		Students s6 = new Students("钱八", 26);
		c1.getAllStudents().add(s1);
		c1.getAllStudents().add(s2);
		c1.getAllStudents().add(s6);
		s1.getAllCourses().add(c1);
		s2.getAllCourses().add(c1);
		s3.getAllCourses().add(c1);
		
		c2.getAllStudents().add(s1);
		c2.getAllStudents().add(s2);
		c2.getAllStudents().add(s3);
		c2.getAllStudents().add(s4);
		c2.getAllStudents().add(s5);
		c2.getAllStudents().add(s6);
		s1.getAllCourses().add(c2);
		s2.getAllCourses().add(c2);
		s3.getAllCourses().add(c2);
		s4.getAllCourses().add(c2);
		s5.getAllCourses().add(c2);
		s6.getAllCourses().add(c2);
		
		System.out.println(c1);
		Iterator<Students> iter1 = c1.getAllStudents().iterator();
		while (iter1.hasNext()) {
			Students s = (Students) iter1.next();
			System.out.println("\t|-"+s);
		}
		
		System.out.println(c2);
		Iterator<Students> iter2 = c2.getAllStudents().iterator();
		while (iter2.hasNext()) {
			Students s = (Students) iter2.next();
			System.out.println("\t|-"+s);
		}
	}
}

课程学分：3, 课程名称：英语
	|-学生年龄：21, 学生姓名：张三
	|-学生年龄：22, 学生姓名：李四
	|-学生年龄：26, 学生姓名：钱八
课程学分：5, 课程名称：计算机
	|-学生年龄：21, 学生姓名：张三
	|-学生年龄：22, 学生姓名：李四
	|-学生年龄：23, 学生姓名：王五
	|-学生年龄：24, 学生姓名：赵六
	|-学生年龄：25, 学生姓名：孙七
	|-学生年龄：26, 学生姓名：钱八

总结：

1. 类集的目的是用来创建动态的对象数组操作
2. Collection接口是类集中的最大的单值操作的父类接口，一般开发中都使用其子类List类和Set类
3. List接口扩展了Collection接口，里面的内容是允许重复的
4. List接口的常用子类是ArrayList和Vector，在开发中ArrayList性能较高，属于异步处理，而Vector性能较低，属于同步处理
5. Set接口与Collection接口的定义一致，里面的内容是不允许重复的，依靠Object类中的equals()和hashCode()方法来区分是否是同一个对象
6. Set接口的常用字类是HashSet和TreeSet类，前者是散列存放，没有顺序，后者是顺序存放，使用Comparable进行排序操作
7. 集合的输出要使用Iterator接口完成，Iterator属于迭代输出接口
8. 在JDK1.5之后集合也可以使用foreach的方式输出
9. Enumeration属于最早的迭代输出接口，现在基本上很少使用，在类集中Vector类可以使用Enumeration接口进行内容的输出
10. List集合的操作可以使用ListIterator接口进行双向的输出操作
11. Map接口可以存放key-value的形式保存的一对内容，每一对key-value都是一个Map.Entry对象的实例
12. Map中的常用子类是HashMap、TreeMap、Hashtable。HashMap属于异步处理，性能较高，TreeMap属于排序类，按照Comparable指定的顺序进行key的排序；Hashtable属于同步处理，性能较低
13. 类集中提供了Collections工具类，完成类集的相关操作
14. Stack类可以完成先进后出的操作
15. Properties类属于属性操作类，使用属性操作类可以直接操作属性文件，属性文件可以按普通文件，或者XML的文件格式进行保存。
16. 使用类集可以方便的表示出一对及多对多的关系。