【咸鱼期末】Java知识点（4）

一.泛型

1.泛型的定义

（1）泛型方法
所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前。

public <E> void printArray (E[] inputArray) {
  //输出数组元素
  for (E element : inputArray)
	  System.out.printf("%s ", element);
  }
}

（2）泛型类
参数声明部分在类名之后

public class Bag<T>{
	private T content;
	
	public Bag(T content){
		this.content = content;
	}
	public T get(){
		return this.content;
	}
	public void set(T content){
		this.content = content;
	}
	
	public static void main(String[] args){
		Bag<String> bag = new String("mybook");
		Integer content1 = (Integer)bag.get();
		String content2 = (String)bag.get();
	}
}

（3）泛型接口
类型参数声明部分在接口名之后

public interface List<E>{
	void add(E x);
	Iterator<E> iterator();
}

public interfaceIterator<E>{
	E next();
	boolean hasNext();
}

（4）通配符
Collection<?>

二.集合框架

1.定义

集合框架的组成部分

Java不提供直接实现 Collection 的类，只提供实现其子接口 （如 List 和 set) 的类。

2.接口

（1）Set
用于存放无重复的元素，类似数学意义上的集合，不保证存放顺序。
拥有HashSet和TreeSet

public class FindDups{
	public static void main(String[] args){
		Set<String> s = new HashSet<String>;
		for (String a :args)
			s.add(a);
		System.out.printlns.size () + "distinct words: " + s);
	}		
}

Set中保存的是对象的引用，size大小也是对象引用的数目。因此，有可能出现添加了多个对象，但size是1的情况。

（2）List
List是一个有序的 Collection,为一个长度可变的数组，即动态数组可包含重复元素，增加了按位置访问、查找和遍历功能
拥有ArrayList和LinkedList

（3）Queue
Queue是一个特殊的 Collection，元素的存取满足FIFO (first in first out)，可以限定长度。
拥有LinkedList

public class Countdown {
	public static void main(String[] args) throws InterruptedException
		int time = Integer.parseInt(args[0]);
		Queue<Integer> queue = new LinkedList<Integer>;
		for ( int i = time; i >= 0; i++)
		 	queue.add(i);
		while (queue.isEmpty ()){
			System.out.println(queue.remove());
			Thread.sleep(1000);
		}
	}
}

（4）Deque ----Double Ended Queue
双向队列Deque是Queue的子接口，可以从队列的两端加入和删除元素。
拥有LinkedList和ArrayDeque。

（5）Map
映射Map 是把键对象和值对象进行映射的集合，按照无重复的 键对象去检索值对象，Map.Entry对象代表 Map 中的一对键与值。

3.集合的实现

（1）遍历
Set, List, Queue

Map

(2)Hash集合的元素存取
Hash集合要求两个对象用 equals() 方法比较的结果为 true 时， 它们的哈希码也相等 。
Hash集合有很好的存取和查找功能。向集合中加入对象时，会调用hashCode 方法获得哈希码，进而计算出对象在集合中的存放位置（那么存放的内存地址也会相等）。

Set<Customer> set = new HashSet <Customer>;
Customer c1 = new Customer(“Tom”,15);
Customer c2 = new Customer(“Tom”,15);
set.add(c1);
set.add(c2);
System.out.println(set.size());	//1----Hash集合对象之间满足equals，就能满足==

（3）List 性能比较
ArrayList是顺序访问的首选，LinkedList可作为栈 Stack 、队列 Queue 和双向队列 Deque 的实现类、

（4）有序集合
TreeSet和 TreeMap 分别实现了 SortedSet 和 SortedMap 接口，能够对集合中的元素排序

（5）排序
自然排序（实现 Comparable 的基础类）：如 Integer Double 和 String 等
自定义排序（实现 Comparable 或 Comparator 的自定义类）

Comparable由需要被排序的类实现，需要实现compareTo 方法

public class Customer implements Comparable{
	private String name;
	private int age;
	
	public int compareTo (Object o){
		Customer other = (Customer)o;
		if(this.name.compareTo other.getName ())>0) return -1;
		if(this.name.compareTo other.getName ())<0) return 1;
		return 0;
	}
}

Comparator由排序器实现,需要实现compare(T x, T y) 方法

public class CustomerComparator implements Comparator<Customer>{
	public int compare(Customer c1, Customer c2){
		if(c1.getName().compareTo (c2.getName())>0) return -1;
		if(c1.getName().compareTo (c2.getName())<0) return 1;
   		return 0;
	}
}

Set<Customer> set = new TreeSet<Customer>(new CustomerComparator());
set.add(new Customer(“Tom”,15);
set.add(new Customer(“Mike”,20);
for(Customer c: set)
	System.out.println(c.getName());

4.枚举

JDK 5提供了抽象的 java.lang.Enum 枚举类，用户自定义的枚举类只需继承Enum 类

public class Gender extends Enum{
	public static final Gender FEMALE;
	public static final Gender MALE;
	…
}

//遍历 Gender 类的所有常量
for(Gender g:Gender.values())
System.out.println(g.ordinal()+""+g.name());
//根据 g 的值选择
Gender g = Gender.FEMALE;
switch(g){
case FEMALE:
	System.out.println("girl");
	break;
case MALE:
	System.out.println("boy");
	break;
default:
	System.out.println(“unknown");
}

5. 使用建议