CoreJava学习笔记8

[align=center][size=medium] [size=medium] [color=red]开发时经常使用到的集合API[/color][/size][/size][/align]
集合类
集合（集合类的对象）是管理其他若干对象的，类似于C++标准模板库中的容器，不过JAVA的集合类的对象中可以存放多种类型的对象。

接口和类共同构成了一个集合框架，集合的概念，一个对象可以装载多个对象，就是集合对象。

集合框架
1，集合接口

Collection 存储并管理多个对象的对象，集合中的每个元素都是对象。

Map，Map中没有对象，而是键值对，由Key，value组成的键值对，Key是不可重复的。value是可以相同的,Key和value是一一对应的。

集合中用到的类，接口在java.util包中，使用时注意将其引入import。

Collection 接口（以下介绍其子接口）

[color=red]1)List[/color] ，一个List的实现类的对象在管理多个对象时会按顺序组织对象（即按照将对象放入的顺序存储），List实现类的对象是有顺序的，List实现类对象中的内容是是可重复的。（注意，顺序和排序的区别）

[color=red]2)Set [/color]，一个Set的实现类表示一个数学概念上的集合，Set的实现类的对象中的元素是无顺序的，也就是不会按照输入顺序来存放，Set的实现类对象中的元素是不重复的。

3)SortedSet，他是Set的子接口，他的实现类会对集合中的元素进行排序。但是要指定排序规则，他会按排序规则进行排序。

[color=red]Map 接口[/color]（以下介绍其子接口）


SortedMap，这个接口的实现类同样可以实现，不过是对键值对中的Key进行排序，这个接口的实现类也是要指定排序规则的。

JDK1.4中的集合是不安全的对象，JDK5.0中解决了这个问题。

2，接口的实现类

List接口的实现类

[color=red]1） ArrayList[/color]是接近于数组功能的集合类，ArryList的实质就是一个会自动增长的数组，ArrayList是用封装的数组来实现的List接口的。

Collection的实现类对象的遍历方式是用迭代来实现的。
在使用迭代器时先要活得一个迭代器的对象，Iterator（迭代器接口）这是一个接口，迭代器是在集合类中实现的，也就是说，他是一个内部类（匿名内部类）实现的。
Iterator接口中定义的常用方法方法hasNext()，next()。
hasNext(),这个方法会使用一个游标，并通过判断游标指向的位置是否存放有对象。
next()方法也是Iterator接口中定义好的方法，这个方法会使游标指向下一个元素的位置，游标会跳过第一个元素，并返回其中的内容。

Collections（注意，这个不是Collection接口） 这是一个工具类，也是java.util包中的，这个类中的sort(list接口的实现类的对象)方法，其参数是一个集合类的对象，这个方法使用来对集合类的对象进行排序的。以后，我将以集合这个名字来称呼集合类的对象。，对于字符串对象内容的集合来说会按字典顺序排序（升序），对于数字内容的集合排序也会按照升序排序。

集合排序

排序可一份为两部分内容，一个是排序的规则，也就是按照什么来进行排序，并且排成什么样的顺序。第二个就是排序的算法，他决定了排序的效率。

在对自定义的集合内容类型排序时，需要先定义那个类型的排序规则。
Comparable接口，这个接口中只定义了一个compareTo(Object o)，方法的返回至类型是整型，如果当前对象大于参数对象就返回正数，当前对象等于参数对象是就返回0，当前对象小于参数对象时就返回负值，这样写就是升序排列，反之则是进行降序排列，在实现这个接口中的方法时，返回值定义方式，只有这两种。

根据指定类型的排序规则实现了Comparable接口，那么就可以对存有这个类型的集合进行整体排序。Comparable接口，也叫做可比较接口。这个接口在java.lang包下。只要实现了这个接口，就是可排序的。

接下来介绍另外一种对自定义类型对象的集合整体排序的方法，也就是实现比较器接口（Comparator），这个接口中定义了一个compare(Object o1，Object o2)方法来比较两个对象，这个方法的返回值定义和上面介绍的那个方法是一样。

注意：在API，帮助文档中以上两个方法的参数类型是T，这代表的模板类型，也就是集合中存放的内容的类型，在JDK1.4中其参数就是Object类型，模板类型的详细内容会在最后的JDK5.0新特性中讲到。

Comparator接口可以在匿名内部类中实现，Collections 中的sort(集合了的对象，比较器)方法，可以对自定义类型内容的集合进行整体排序。

集合排序的实例：

public class Employee implements Comparable{
	private String name;
	private int age;
	private double salary;
	public Employee(String name, int age, double salary) {
		super();
		// TODO Auto-generated constructor stub
		this.name = name;
		this.age = age;
		this.salary = salary;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getSalary() {
		return salary;
	}
	public void setSalary(double salary) {
		this.salary = salary;
	}
	public String toString() {
		return name+" "+age+" "+salary;
	}
	public int compareTo(Object o){//默认是升序排列，也可以使用降序
		Employee e=(Employee)o;
		if (this.age<e.getAge()) return 1;
		else if (this.age()>e.getAge()) return -1;
		else if (this.salary()<e.getSalary()) return 1;
		else if (this.salary>e.getSalary()) return -1;
		else return this.name.compareTo(e.getName());
	}
}

import java.util.*;
public class TestEmployee {
	public static void main(String[] args){
		List l=new ArrayList();
		l.add(new Employee("Liucy",40,2000));
		l.add(new Employee("Hiloo",40,8000));
		l.add(new Employee("Chenzq",18,300));
		l.add(new Employee("George",45,10000));
		l.add(new Employee("BaoJie",18,300));
		Collections.sort(l);
		print(l);
	}
	static void print(Collection c){
		Iterator it=c.iterator();
		while(it.hasNext()){
			Employee e=(Employee)(it.next());
			System.out.println(e);
		}
	}
}

2） LinkedList，它是List接口的实现类，其底层是用双向循环链表来实现的。

注意：ArrayList的查询效率比较高，增删动作的效率比较差，适用于查询比较频繁，增删动作较少的元素管理的集合。
LinkedList的查询效率低，但是增删效率很高。适用于增删动作的比较频繁，查询次数较少的元素管理集合。

ArrayList，LinkedList都是线程不安全的。

[color=orange]实现堆栈
1，数组（ArrayList，增删效率比较低，不适合）
2，LinkedList（实现堆栈的好方法）
3，java.util.Stack类，Stack是Vector的子类，Vector类是一个线程安全的（是一个重量级的类），并继承了Vector的方法，Verctor类（这个类也是List接口的实现类）和ArrayList的功能近乎相同。（不推荐使用Stack类来实现堆栈）。
[/color]
Set接口的实现类

[color=red]1）HashSet[/color]

Set的实现类的集合对象中不能够有重复元素，HashSet也一样他是使用了一种标识来确定元素的不重复，HashSet用一种算法来保证HashSet中的元素是不重复的，HashSet的底层实现还是数组。

Object类中的hashCode()的方法是所有子类都会继承这个方法，这个方法会用Hash算法算出一个Hash（哈希）码值返回，HashSet会用Hash码值去和数组长度取模，模（这个模就是对象要存放在数组中的位置）相同时才会判断数组中的元素和要加入的对象的内容是否相同，如果不同才会添加进去。如果数组中的元素和要加入的对象的hashCode()返回了相同的Hash值（相同对象）,才会用equals()方法来判断两个对象的内容是否相同。

Hash算法是一种散列算法。

注意：所以要存入HashSet的集合对象中的自定义类必须覆盖hashCode(),equals()两个方法，才能保证集合中元素容不重复。在覆盖和hashCode()方法时，要使相同对象的hashCode()方法返回相同值，覆盖equals()方法再判断其内容。为了保证效率，所以在覆盖hashCode()方法时，也要尽量使不同对象尽量返回不同的Hash码值。


例：
[color=red]要向HashSet中的添加自定义类型的对象并保证对象在HashSet中的唯一性的话，就要覆盖hashCode()方法和equals（）方法。[/color]

import java.util.*;
public class TestSet {
	public static void main(String[] args) {
		Set s=new HashSet();
		TarenaStudent s1=new TarenaStudent("Liucy",30);
		TarenaStudent s2=new TarenaStudent("Hiloo",29);
		TarenaStudent s3=new TarenaStudent("Chenzq",33);
		TarenaStudent s4=new TarenaStudent("Liucy",30);
		s.add(s1);
		s.add(s2);
		s.add(s3);
		s.add(s4);
		System.out.println();
		print(s);
	}
	static void print(Collection c){
		Iterator it=c.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
	}
}

class TarenaStudent{
	String name;
	int age;
	public TarenaStudent(String name, int age) {
		super();
		// TODO Auto-generated constructor stub
		this.name = name;
		this.age = age;
	}
	public String toString(){
		return "Student: "+name+" age="+age;
	}
	public boolean equals(Object o){
		System.out.println(this+" equals "+o);
		if (o==null) return false;
		if (this==o) return true;
		if (o.getClass()!=this.getClass()) return false;
		TarenaStudent t=(TarenaStudent)o;
		if ((this.name.equals(t.name)) && this.age==t.age) return true;
		else return false;
	}
	public int hashCode(){
		return this.name.hashCode()+this.age;
	}
}

LinkedSet是Set接口的实现类，他的底层是用链表实现的，他的增删效率很高，常用于过滤重复对象。
SortedSet接口是Set的子接口。

TreeSet是SortedSet接口的实现类，他可以对集合中的元素进行排序。
要存放在TreeSet中自定义类的对象，这个类要么是已经实现了Comparable接口，要么是能给出Comparator比较器，TreeSet可以自动过滤掉重复元素所以不用重载hashCode()方法，TreeSet会根据比较规则判断元素内容是否相同，TreeSet会在元素存入世就进行了排序。（在TreeSet给出排序规则时，一定要注意对象内容相等的条件，一定要注意在主观的认为两个对象内容相同时，才可以使用比较少的条件来进行判断）

在要排序时才使用TreeSet类（存储效率比较低），HashSet的存储效率比较高，在需要为HashSet的对象排序时，就可以把HashSet中的元素放入TreeSet。


Map接口的实现类

Map中只可以存放键值对（Key，value），其中Key是不可以重复的。Key和value是一一对应的。

[color=red]HashMap[/color]，是Map接口的实现类，Key时无序存放的，其中Key是不可以重复的，它也是通过Hash码值来保证Key不重复的，Key和value是一一对应的。如果要加入的键值对和HashMap中键值对的Key是相同的就会将这个集合中的Key所队应的value值进行覆盖，在使用自定义类型作为Key时，那就是要覆盖hashCode(),equals()方法，也就是和HashSet中要放入自定义类型是的处理方法相同。这个类的对象是线程不安全的。

在遍历Map时，要使用其keySet()方法获得Key的一个Set集合，可以通过遍历这个Set，用get()方法来获得Key所对应的value，也就遍历了Map。

Hashtable，也是Map接口的实现类，他和HashMap比较相似，只不过这个类对象是重量级的，是线程安全的。他不允许Key和value为null。

Properties，这个类是Hashtable的子类，他的Key和value只能是字符串String类型。

SortedMap是Map的子接口

TreeMap，是SortedMap的实现类，他会按照Key进行排序。和TreeSet类一样，在使用自定义类作Key时，要用自定义类实现Comparable接口。

注意：其实HashSet底层就是一个HashMap，只不过其中的value值都是null值，而HashMap的底层是用数组实现的。

完整的集合框架