Tinking in java 琐碎知识点之集合(容器)

1、Iterator必须依附于Collection接口的对象，Iterator本身不提供盛装对象的能力。Collectionname.iterator()方法获得Iterator接口实现类的对象

2、除了使用Iterator遍历Collection集合里的元素，也可以使用foreach循环(注意类型转换)

3、Set接口不允许包含重复元素(根据equals方法判断)，而Collection没有此限制。Set接口的两个实现类HashSet是使用的哈希算法决定元素的存储位置，而treeSet使用的是红黑树算法。

4、Object类中定义了hashCode和equals方法，equals方法按照内存地址比较两个对象是否相等，hashCode方法返回值是根据内存地址计算出来的，所以同一个对象hashCode一样。HashSet是通过equas方法和hashCode方法判断两个元素是否相等的，将一个对象放入HashSet中时，HashSet会调用对象的的hashCode方法获得哈希码，再根据这个哈希码计算出对象在集合中存放的位置。因此如果重写了对应类的equals方法则也应该重写hashCode方法，保证如果2个对象通过equals比较相等那这两个对象的hashCode也应该一样，否则HashSet无法正常工作。

  (即使两个对象equals方法返回true而hashCode不同也可以添加成功，使HashSet无法正常工作)

5、TreeSet集合是SortSet接口的唯一实现，TreeSet集合里的元素处于排序状态。试图把一个对象添加进TreeSet时，则该对象的类必须实现comparable接口，因为TreeSet会调用集合的元素的compareTo(Object obj)方法来比较元素之间的大小关系。

TreeSet自然排序是根据元素的大小以升序排序，也可以使用定制排序，即不用将类实现Comparable接口了，直接在创建TreeSet集合对象时提供一个Comparator对象作为TreeSet构造器参数，由该Comparator对象实现集合元素的排序逻辑。

6、compareTo(Object obj)方法返回一个整数值，如果obj1.compareTo(obj2)返回0，则表明这两个对象相等。返回一个正整数则表明obj1>obj2,如果返回一个负整数,则obj1<obj2

7、集合里的元素总是引用，但习惯上把被引用的对象称为集合元素

8、在实际应用中TreeSet集合里的对象属性被改变了不会重新排序，也就是说排序只是在元素加进集合时。所以最适合用treeSet排序的是不可变类。

9、为了保持Set规则的一致性，即Set集合中的元素总是不重复的，我们应该尽量保证两个对象通过equals方法和compareTo方法比较的结果一致(还要重写hashCode方法)。

10、关于Set的小结

    HashSet性能比TreeSet好(特别是添加、查询操作)，只有当要一个保持排序的Set时才应该使用TreeSet

    EnumSet性能虽好，但是它只能保存同一个枚举类的枚举值作为集合参数

11、List接口

    ArrayList和Vector都是List的实现类(Vector老了，虽然它是线程安全的都是也不推荐使用)，ArrayList不是线程安全的，得手动控制，

    Vector有个Stack子类，可以模拟栈这种数据结构。LinkedList也是一个List的实现类，它是基于链表实现的List

12、LinkedList和ArrayList、Vector的实现机制完全不同，ArrayList、Vector内部以数组的形式来保存集合中的元素，因此随机访问集合元素有较好的性能，而LinkedList内部以链表的形式来保存集合元素，随机访问性能差，但是插入删除元素时性能出色。

13、HashMap和Hashtable都是Map接口的实现类，他们的关系类似于ArrayList和Vector，Hashtable老了，用起来也不方便。另外Hashtable是线程安全的，HashMap是线程不安全的。(即使要使用线程安全的实现类也不必使用HashTable和Vector,有Collections工具)

14、为了在HashMap和Hashtable中存储、获取对象，用作key的对象必须实现hashCode和equals方法。HashMap和Hashtable判断两个key相等的标准是：两个key 通过equals方法返回true，通过hashCode方法返回值相等。而它们判断两个value是否相等则只要通过equals对象返回true即可。

(当重写了一个类的equals方法后，最好也重写一下hashCode方法，以保证一致性)

public class MapTest {
	public static void main(String[] args) {
		HashMap<PerId,Person> hm=new HashMap<PerId,Person>();
		hm.put(new PerId(0001), new Person("周鹏程1",25));
		hm.put(new PerId(0002), new Person("周鹏程2",25));
		hm.put(new PerId(0003), new Person("周鹏程3",26));
		hm.put(new PerId(0004), new Person("周鹏程",27));
		hm.put(new PerId(0005), new Person("周鹏程",27));
		System.out.println(hm.containsKey(new PerId(0004)));
		System.out.println(hm.containsValue( new Person("周鹏程1",25)));
		System.out.println(hm.remove(new PerId(0001)));
		for(Object o:hm.keySet()){
			System.out.println(hm.get(o).name);
		}
	}

}

class Person{
	String name;
	int age;
	public Person(String name,int age){
		this.name=name;
		this.age=age;
	}
	public boolean equals(Object obj){
		if(obj==this){
			return true;
		}
		if(obj!=null&&obj.getClass()==Person.class){
			Person p=(Person)obj;
			if(p.age==this.age&&p.name==this.name){
				return true;
			}
		}
		return false;
	}
}

class PerId{
	int id;
	public PerId(int id){
		this.id=id;
	}
	public boolean equals(Object obj){
		if(obj==this){
			return true;
		}
		if(obj!=null&&obj.getClass()==PerId.class){
			PerId p=(PerId)obj;
			if(p.id==this.id){
				return true;
			}
		}
		return false;	
	}
	//假如没有重写hashCode方法将会出现问题
	public int hashCode(){
		return id;
	}
}

15、遍历Map中全部key-value对：调用Map对象的keySet方法返回全部key组成的Set对象，再通过遍历Set的元素(get方法获得key对应的    value)就可以遍历Map中所有的key-value对。

16、HashMap、Hashtable保存key的方式和HashSet保存集合元素的方式一至，所以HashMap、Hashtable对key的要求与HashSet对集合元素的要求相同。如果重写了该类的equals方法则应该也重写hashCode方法。

17、与HashSet类似的是，尽量不要使用可变对象作为HashMap、Hashtable的key,如果使用了可变对象，则尽量不要在程序中修改作为key的可变对象。

18、Hashtable有一个实用的子类Properties类，在处理属性文件时特别方便。Properties类可以把Map对象和属性文件关联起来，从而可以把Map对象中的key-value写入属性文件，也可以把属性文件中的属性名、属性值加载到Map对象中。

例程：

import java.io.*;
import java.util.*;
public class TestProperties  {
public static void main(String[] args)throws Exception {
Properties props=new Properties();
props.setProperty("username", "zpc");
props.setProperty("password", "123456");
//将Properties中的属性保存到a.ini对象中
props.store(new FileOutputStream("a.ini"), "comment line(属性文件)");
Properties props2=new Properties();
props2.setProperty("gender", "male");
props2.load(new FileInputStream("a.ini"));
System.out.println(props2);
}
}
 //输出：{password=123456, gender=male, username=zpc}

19、正如Set接口派生出SortedSet子接口，SortedSet接口有一个TreeSet实现类，Map接口有一个SortedMap子接口，SortedMap也有一个TreeMap实现类。与TreeSet类似，TreeMap也是基于红黑树对TreeMap中的所有key进行排序，从而保证TreeMap中所有key-value对处于有序状态。TreeMap也有自然排序(key所在的类实现Comparable接口、所有key应该是同一个类的对象)和客户化(创建TreeMap时传入一个Comparator对象，该对象负责实现排序逻辑)排序两种方式。

20、IdentityHashMap与HashMap基本相似，只是在处理两个key是否相等时不一样：只有当两个key严格相等(key1==key2)时才会认为两个key相等

public static void main(String[] args) {
		IdentityHashMap ihm=new IdentityHashMap();
		ihm.put(new String("语文"),89);
		ihm.put(new String("语文"),78);
		ihm.put("java",89);
		ihm.put("java",89);
		System.out.println(ihm);
	}//“java”字符串是字符串直接量，放在缓存，而new的两个对象用==比较不等

21、操作集合工具类Collections提供了一些方法对集合元素进行排序、查询和修改操作，还提供了将集合对象设置成不可变、对集合对象实现同步控制等方法。

//showHand游戏
import java.util.*;
class ArrayUtils {
	/**
	 * 定义一个工具方法，工具方法从字符串数组中找到对应的字符串元素的位置
	 * 
	 * @param array
	 *            搜索的数组
	 * @param target
	 *            搜索的字符串
	 * @return 目标字符串出现的位置,-1表明找不到
	 */
	public static int search(String[] array, String target) {
		for (int i = 0; i < array.length; i++) {
			if (array[i] != null && array[i].equals(target)) {
				return i;
			}
		}
		return -1;
	}
}

public class ShowHand {
	private final int PLAY_NUM = 4;// 限定玩家数量
	private String[] types = { "\4 ", "\5", "\3", "\6" };//特殊字符,会在控制台打印出方块、草花、红心和黑桃
	private String[] values = { "2", "3", "4", "5", "6", "7", "8", "9", "10",
			"J", "Q", "K", "A" };
	// cards存放牌
	private List<String> cards = new LinkedList<String>();
	// 用一个数组存放玩家
	private String[] players = new String[PLAY_NUM];
	// 每一个玩家都用一个List存放其获得的牌
	private List<String>[] playersCards = new List[PLAY_NUM];


	// 初始化，放入扑克牌
	public void initCards() {
		for (int i = 0; i < types.length; i++) {
			for (int j = 0; j < values.length; j++) {
				cards.add(types[i] + values[j]);
			}
		}
		// 调用集合工具类的方法随机排列
		Collections.shuffle(cards);
	}

	// 初始化玩家,为每个玩家分配用户名
	public void initPlayer(String... names) {
		if (names.length < 2 || names.length > PLAY_NUM) {
			System.out.println("输入玩家数量不对！");
			return;
		} else {
			// 初始化用户
			for (int i = 0; i < names.length; i++) {
				players[i] = names[i];
			}
		}
	}

	// 初始化保存玩家牌的List
	public void initPlayerCards() {
		for (int i = 0; i < players.length; i++) {
			if (players[i] != null && !players.equals("")) {
				playersCards[i] = new LinkedList<String>();
			}
		}
	}

	// 写一个输出全部扑克牌的方法
	public void showAllCards() {
		for (String card : cards) {
			System.out.println(card);
		}
	}

	// 给玩家派牌的方法(指定一个最先派牌的玩家)
	public void deliverCard(String first) {
		int firstPos = ArrayUtils.search(players, first);
		//依次给位于指定玩家之后、之前的每个玩家派牌
		for(int i=firstPos;i<players.length;i++){
			if(players[i]!=null){
				playersCards[i].add(cards.get(0));
				cards.remove(0);
			}
		}
		//为之前的每个玩家派牌
		for(int i=0;i<firstPos;i++){
			if(players[i]!=null){
				playersCards[i].add(cards.get(0));
				cards.remove(0);
			}
		}
	}	
	//输出玩家手中的牌
	public void showPlayerCards(){
		System.out.print("当前牌况：");
		for(int i=0;i<players.length;i++){
			if(players[i]!=null){
				System.out.println("\n"+players[i]+":");
				for(String card:playersCards[i]){
					System.out.print (card+"\t");
				}
			}
			
		}
		System.out.print("\n");
	}

	public static void main(String[] args) {
		ShowHand sh = new ShowHand();
		sh.initCards();
		sh.initPlayer("鸟鹏", "鸟朱");
		sh.initPlayerCards();
		sh.showAllCards();
		System.out.println("*****************");
		//第一次从玩家鸟鹏开始派牌
		sh.deliverCard("鸟鹏");
		sh.showPlayerCards();
		//第二次从玩家鸟朱开始派牌
		sh.deliverCard("鸟朱");
		sh.showPlayerCards();
	}
}

22、泛型：JDK1.5支持的泛型很大程度上是为了让集合能记住其元素的类型，这样会带来许多好处(Java泛型可以保证如果程序在编译的时候没有警告，运行时就不会产生ClassCastException异常，集合中默认存放的都是object对象，取出来还得强制转型，使用泛型就不要了)。

//一个泛型的案例
public class Apple<T> {
	private T info;
	public Apple() {
	}
	public Apple(T info){
		this.info=info;
	}
	public T getInfo(){
		return info;
	}
	public static void main(String[] args){
		//因为传给T形参的是String实际类型，所以构造器的参数只能是String
		Apple<String> apple1=new Apple<String>("苹果");
		System.out.println(apple1.getInfo());
		System.out.println(apple1.getClass());
		Apple<Double> apple2=new Apple<Double>(12.9);
		System.out.println(apple2.getInfo());
		System.out.println(apple2.getClass());
	}
}
//输出
//苹果
//12.9

泛型数组(Java允许创建无上限的通配符泛型数组)：

List<?>[] lsa= new ArrayList<?>[10];
Object[] oa=(Object[])lsa;
List<Integer> li=new ArrayList<Integer>();
li.add(new Integer(7));
oa[1]=li;
System.out.println("lsa.getClass():"+lsa.getClass());
System.out.println("lsa[1].get(0).getClass():"+lsa[1].get(0).getClass());
//String s=(String)lsa[1].get(0);//List的get方法
Object target=lsa[1].get(0);
if(target instanceof String){
String s=(String)target;
}

23、注意：在使用带了泛型声明的接口、父类之后，在使用这些接口或父类时不能再包含类型形参(方法中的形参只有当定义方法时才使用数据形参，当调用(使用)方法时必须传入实际的数据;与此类似的是：类、接口中的类型参数只有在定义类、接口时才可以使用类型参数，当使用类、接口时应该为类型参数传入实际的类型)。
如上例继承Apple类时可以有两种写法
public class A extends Apple<String>{}
或者直接不写<T>即：public class A extends Apple{}
数组和泛型有所不同，假设Son是Father的一个子类型(子类或者子接口)，那么Son[]依然是Father[]的一个子类型，但是C<Son>并不是C<Father>的一个子类型。

24、使用类型通配符

(设定类型通配符的上限)比如List<? extends Shape>表示所有Shape泛型List的父类,List集合的元素要么是Shape类型的要么是Shape的子类型都行
(设定类型形参的上限)也可以在定义类时设定类型上限：public class Apple<T extends Number>。
也可以使用泛型方法：
修饰符 <T,S> 返回值类型 方法名(形参列表)
{
  //方法体
}

例程：
abstract class Shape{
	public abstract void draw(Canvas c);
 } 

class Circle extends Shape{
	@Override
	public void draw(Canvas c) {
		System.out.println("在画布"+c+"画一个圆");
	}
}

class Rectangule extends Shape{
	@Override
	public void draw(Canvas c) {
		System.out.println("在画布"+c+"画一个矩形");
	}
}

public class Canvas {
	//同时在画布上绘制多个形状
	//使用被限制的泛型通配符
	public void drawAll(List<? extends Shape> shapes){
		for(Shape s:shapes){
			s.draw(this);
		}
	}
	
	public static void main(String[] args) {
		List<Circle> circleList=new ArrayList<Circle>();
		List<Rectangule> rectangule=new ArrayList<Rectangule>();
		circleList.add(new Circle());
		rectangule.add(new Rectangule());
		Canvas c=new Canvas();
		c.drawAll(circleList);
		c.drawAll(rectangule);
	}
}