程序总是根据运行时才知道的某些条件去创建新对象。需要在任意时刻和任意位置创建任意数量的对象。
如果你想保存一组基本数据类型数据，建议使用数组，但是数组有固定的尺寸。
一般情况下，你在写程序时并不知道将需要多少个对象，或者是否需要更复杂的方式来存储对象。
Java实用类库提供了一套完整的容器类来解决这个问题，其中基本的类型是List、Set、Queue和Map。这些对象类型也称为集合类。容器提供了完善的方法来保存对象。
下面是完整的容器分类图：
1.基本概念
Java容器类类库的用途是“保存对象”，并将其划分为两个不同的概念：
- Collection。一个独立元素的序列。
List必须按照插入的顺序保存元素，而Set不能有重复元素。Queue按照排队规则来确定对象产生的顺序。 - Map。一组成对的“键值对”对象，允许你使用键来查找值。
//在创建的时候指定所使用的精确类型。
List<Apple> apples = new ArrayList<Apple>();
//注意：ArrayList已经被向上转型为List。使用接口的目的在于如果你决定去修改你的实现，你所需要的只是在创建出修改它。
//List<Apple> apples = new LinkedList<Apple>();
import java.util.*;
public class SimpleCollection {
//用Integer对象填充了一个Collection，然后打印所产生的容器中的所有元素。
public static void main(String[] args) {
Collection<Integer> c = new ArrayList<Integer>();
for(int i = 0; i < 10; i++){
c.add(i); // Autoboxing
}
for(Integer i : c){
System.out.print(i + ", ");
}
}
}
/* Output:
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
*/
添加一组元素
import java.util.*;
public class AddingGroups {
public static void main(String[] args) {
Collection<Integer> collection = new ArrayList<Integer>(Arrays.asList(1, 2, 3, 4, 5));
Integer[] moreInts = { 6, 7, 8, 9, 10 };
collection.addAll(Arrays.asList(moreInts));
// Runs significantly faster, but you can't
// construct a Collection this way:
Collections.addAll(collection, 11, 12, 13, 14, 15);
Collections.addAll(collection, moreInts);
// Produces a list "backed by" an array:
List<Integer> list = Arrays.asList(16, 17, 18, 19, 20);
list.set(1, 99); // OK -- modify an element, list的值为 [16, 99, 18, 19, 20]
// list.add(21); // Runtime error because the underlying array cannot be resized.
}
}
//在java.util包中的Arrays和Collections类中都有很多实用方法，可以在一个Collection中添加一组元素。
//Arrays.asLisst()方法接受一个数组或是一个用逗号分隔的元素列表(实用可变参数)，并将其转换为一个List对象。
2.容器的打印
你必须使用Arrays.toString()来产生数组的可打印表示，但是打印容器无需任何帮助。
import java.util.*;
@SuppressWarnings("rawtypes")
public class PrintingContainers {
static Collection fill(Collection<String> collection) {
collection.add("rat");
collection.add("cat");
collection.add("dog");
collection.add("dog");
return collection;
}
static Map fill(Map<String,String> map) {
map.put("rat", "Fuzzy");
map.put("cat", "Rags");
map.put("dog", "Bosco");
map.put("dog", "Spot");
return map;
}
public static void main(String[] args) {
System.out.println(fill(new ArrayList<String>()));
System.out.println(fill(new LinkedList<String>()));
System.out.println(fill(new HashSet<String>()));
System.out.println(fill(new TreeSet<String>()));
System.out.println(fill(new LinkedHashSet<String>()));
System.out.println(fill(new HashMap<String,String>()));
System.out.println(fill(new TreeMap<String,String>()));
System.out.println(fill(new LinkedHashMap<String,String>()));
}
}
/* Output:
[rat, cat, dog, dog]
[rat, cat, dog, dog]
[rat, cat, dog]
[cat, dog, rat]
[rat, cat, dog]
{rat=Fuzzy, cat=Rags, dog=Spot}
{cat=Rags, dog=Spot, rat=Fuzzy}
{rat=Fuzzy, cat=Rags, dog=Spot}
*/
3.List
有两种类型的List：
- 基本的ArrayList，它长于随机访问元素，但是在List的中间插入和移除元素时较慢。
- LinkedList，它通过代价较低的在List中间进行的插入和删除操作，提供了优化的顺序访问。
List的功能方法
4.Set
Set不保存重复的元素。
import java.util.*;
public class SetOfInteger {
public static void main(String[] args) {
Random rand = new Random(47);
Set<Integer> intset = new HashSet<Integer>();
for(int i = 0; i < 10000; i++)
intset.add(rand.nextInt(30));
System.out.println(intset);
}
}
5.Map
import java.util.*;
public class Statistics {
public static void main(String[] args) {
Random rand = new Random(47);
Map<Integer,Integer> m = new HashMap<Integer,Integer>();
for(int i = 0; i < 10000; i++) {
// Produce a number between 0 and 20:
int r = rand.nextInt(20);
Integer freq = m.get(r);
//自动包装机制将随机生成的int转换为HashMap可以使用的Integer引用。
m.put(r, freq == null ? 1 : freq + 1);
}
System.out.println(m);
}
}
/* Output:
{0=481, 1=502, 2=489, 3=508, 4=481, 5=503, 6=519, 7=471, 8=468, 9=549, 10=513, 11=531, 12=521, 13=506, 14=477, 15=497, 16=533, 17=509, 18=478, 19=464}
*/
//键是由Random产生的数字，而值是该数字出现的次数。
6.Collection和Iterator
Collection是描述所有序列容器的共性的根接口。
java.util.AbstractCollection类提供了Collection的默认实现。
使用接口描述的一个理由是它可以使我们能够创建更通用的代码。
Collection的功能方法：
迭代器
import typeinfo.pets.*;
import java.util.*;
public class SimpleIteration {
public static void main(String[] args) {
List<Pet> pets = Pets.arrayList(12);
//实现Collection就意味着需要提供iterator()方法。
Iterator<Pet> it = pets.iterator();
while(it.hasNext()) {
Pet p = it.next();
System.out.print(p.id() + ":" + p + " ");
}
System.out.println();
//foreach语法主要用于数组，但是它也可以应用于任何Collection对象。
// A simpler approach, when possible:
for(Pet p : pets){
System.out.print(p.id() + ":" + p + " ");
}
System.out.println();
// An Iterator can also remove elements:
it = pets.iterator();
for(int i = 0; i < 6; i++) {
it.next();
it.remove();
}
System.out.println(pets);
}
}
/* Output:
0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 8:Cymric 9:Rat 10:EgyptianMau 11:Hamster
0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 8:Cymric 9:Rat 10:EgyptianMau 11:Hamster
[Pug, Manx, Cymric, Rat, EgyptianMau, Hamster]
*/
Java SE5引入了新的被称为Iterable的接口，该接口包含一个能够产生Iterator的iterator()方法，并且Iterable接口被foreach用来在序列中移动。
因此，如果你创建任何实现Iterable的类，都可以将它用于foreach语句中。
import java.util.*;
public class IterableClass implements Iterable<String> {
protected String[] words = ("And that is how we know the Earth to be banana-shaped.").split(" ");
public Iterator<String> iterator() {
return new Iterator<String>() {
private int index = 0;
public boolean hasNext() {
return index < words.length;
}
public String next() { return words[index++]; }
public void remove() { // Not implemented
throw new UnsupportedOperationException();
}
};
}
public static void main(String[] args) {
for(String s : new IterableClass())
System.out.print(s + " ");
}
}
/* Output:
And that is how we know the Earth to be banana-shaped.
*/
在Java SE5中，大量的类都是Iterable类型，主要包括所有的Collection类（但是不包括各种Map）。
7.散列与散列码
Object的hashCode()方法默认是使用对象的地址计算散列码，equals()方法默认是比较对象的地址。
如果要使用自己的类作为HashMap的键，必须同时重载hashCode()和equals()。
相关阅读：到底什么是hash?