1.概念
Java API 所提供的一系列类的实例，用于在程序中存放对象。J2SDK所提供的容器API位于java.util包内。
容器API的类图结构如下图所示：
- Collection 接口：定义了存取一组对象的方法其子接口Set和List分别定义了存储方式。
Set中的数据对象没有顺序且不可以重复
List中的数据对象有顺序且可以重复
- Map 接口定义了存储"键（key）——值（value）"映射对的方法。
2.Collection接口：
2.1.Collection接口中所定义的方法：
int size();//集合的元素个数
void clear();//清空所有集合元素
boolean isEmpty();//判断指定集合的元素size是否为0
boolean contains(Object element);//判断指定集合是否包含对象element
boolean add(Object element);//向集合添加元素element，若指定集合元素改变了则返回true
boolean remove(Object element);//删除集合中的元素对象element,若集合有多个element元素，则只会删除第一个元素
Iterator iterator();//获取遍历容器的迭代器
boolean containsAll(Collection c);//判断指定集合是否包含集合c的所有元素
boolean addAll(Collection c);//把集合c中的元素全部添加到集合中，若指定集合元素改变返回true
boolean removeAll(Collection c);//删除指定集合包含集合c的元素
boolean retainAll(Collection c);//从指定集合中保留包含集合c的元素,其他元素则删除
Object[] toArry();//将集合转换为T类型的数组
实例1：
import java.util.Collection;
import java.util.HashSet;
public class aaa {
public static void main(String args[]) {
Collection c = new HashSet();
c.add("Hello");//添加字符串"Hello"
c.add(new Integer(124));//添加Integer对象
c.add(new Name1("f3","l3"));//添加Name1对象
//remove()方法会返回一个boolean值，如果能除去则返回true,否则返回flase
System.out.println(c.remove(new Name1("f3","l3")));
System.out.println(c);
}
}
class Name1 {
String firstName,lastName;
public Name1 (String firstName,String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
public String getLastName() { return lastName; }
public String getFirstName() { return firstName;}
//重写toString方法
public String toString() {
return firstName + " " + lastName;
}
//重写equals方法，因为Object类中equals的方法是比较两个对象的引用。
//而我们需要的是比较他的FirstName和lastName是否相同。
public boolean equals(Object obj) {
//判断传入的对象是不是Name1类
if(obj instanceof Name1) {
return (firstName.equals(((Name1) obj).firstName)
&&lastName.equals(((Name1) obj).lastName));
}
//如果传入的对象不是Name1类，则交给Object类实现equals方法
return super.equals(obj);
//重写equals方法一定要同时重写hashCode方法
//即：如果这个类的对象可能作为键值时，一定要重写hashCode方法
public int hashCode() {
return firstName.hashCode();
}
}
//output:
true
[Hello, 124]
Process finished with exit code 0
2.2.Iterator接口
- 所有实现了Collection接口·的容器类都有一个iterator方法用以返回一个实现了Iterator接口的对象。
- Iterator对象称作迭代器，用以方便实现容器内元素的遍历操作。
Iterator接口定义了如下方法：
boolean hasNext();//判断游标右边是否有元素
Object next();//返回游标右边的元素并将游标移动到下一个位置
void remove();//删除游标左边的元素。在执行完Next后该操作只能执行一次
实例：
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
public class TestA {
public static void main(String args[]) {
Collection c = new HashSet();
c.add(new Name("ffff1","l1"));
c.add(new Name("f2","lllll2"));
c.add(new Name("ff3","l3"));
for(Iterator i = c.iterator() ; i.hasNext() ; ) {
Name name = (Name)i.next();
if(name.getFirstName().length()<=2) {
i.remove();
//如果换成 c.remove(name) 会产生例外
//因为Iterator在遍历时执了 锁定 ，即：Iterator 所遍历的对象 只有 它自己能看、改动等操作.
}
}
System.out.println(c);
}
}
//output:
[ff3 l3, ffff1 l1]
Process finished with exit code 0
增强的for循环：
优点：
语法简单
缺点：
对于数组：不能方便地访问下标值
对于集合：与使用Iterator相比，不能方便地删除集合中的内容：
其内部实现也是调用Iterator（所以在遍历时会有锁定）
所以，除了用于简单遍历并读出其中的内容外，不建议使用增强的for循环。
实例1：
public class Test02 {
public static void main(String args[]) {
int i = 0;
int a[] = new int[10];
//要遍历什么类型，r就定义为什么类型
for(int r : a) {
r = i++;
}
for(int m : a) {
System.out.print(m + " ");
}
}
}
//output:
0 0 0 0 0 0 0 0 0 0
Process finished with exit code 0
/**
*原因：
*遍历时数组被锁定，所以 r = i++；这行代码是无效的，所以数组中的每个元素的值任然为0。
*/
IDEA会有如下提示：
实例2：
import java.util.Collection;
import java.util.HashSet;
public class Test02 {
public static void main(String args[]) {
Collection c = new HashSet();
c.add("Hello");
c.add(new Integer(100));
c.add(new Name("f1","l1"));
for(Object r : c) {
System.out.println(r);
}
}
}
//output:
Hello
100
f1 l1
Process finished with exit code 0
2.3.Set接口
- Set接口时Collection的子接口，Set接口没有提供额外的方法，但实现Set接口的容器类中的元素是没有顺序的，而且不可以重复。
- Set容器可以与数学中“集合”的概念相对应。
- J2SDK API中所提供的Set容器类有 HashSet ， TreeSet。
实例1：
import java.util.Collection;
import java.util.HashSet;
public class Test02 {
public static void main(String args[]) {
Collection c1 = new HashSet();
Collection c2 = new HashSet();
c1.add("a"); c1.add("b"); c1.add("c");
c2.add("b"); c2.add("c"); c2.add("d");
//把 c1 中的元素复制到 s 中
Collection s = new HashSet(c1);
c1.retainAll(c2);//求c1与c2的交集
c2.addAll(s);//求c2与s（即c1）的并集
System.out.println(c1);
System.out.println(c2);
}
}
实例2：
import java.util.Collection;
import java.util.HashSet;
public class Test02 {
public static void main(String args[]) {
Collection c1 = new HashSet();
c1.add("Hello");
c1.add("Hello");//元素重复，添加失败
c1.add(new Name("f1","l1"));
c1.add(new Name("f1","l1"));//元素重复，添加失败
System.out.println(c1);
}
}
//output:
[Hello, f1 l1]
2.4.List接口
- List接口是Collection的子接口，实现List接口的容器的类中的元素是有顺序的，而且可以重复。
- List容器中的元素都对应一个整数类型的序号记载在容器中的位置，可以根据序号存取容器中的元素。
- J2SDK所提供的List容器有 ArrayList (数组) , LinkedList (链表) 等。
常用方法：
Object get(int index);
Object set(int index,Object e);//把index位置除的元素设为 e ，返回值是这个位置的旧对象。
void add(int index,Object e);//添加一个新元素
Object remove(int index);
int indexOf(Object o);
int lastIndexOf(Object o);
实例1：
import java.util.LinkedList;
import java.util.List;
public class Test02 {
public static void main(String args[]) {
List l1 = new LinkedList();
for(int i = 0; i <= 5l ;i++) {
l1.add("a"+i);
}
System.out.println(l1);
l1.add(3,"a100");//在下标为3的位置添加字符串 “a100” .把原来位置的元素及其后面的元素向后挤一个位置
System.out.println(l1);
Object m = l1.set(6,"a200");//把下标为6的元素设为“a100”,返回原来位置的元素
System.out.println(l1);
System.out.println(m);
System.out.println((String) l1.get(2)+" ");//得到下标为2的元素
System.out.println(l1.indexOf("a3"));//得到元素为“a3”的下标
l1.remove(1);//删除下标为1的元素
System.out.println(l1);
}
}
//output:
[a0, a1, a2, a3, a4, a5]
[a0, a1, a2, a100, a3, a4, a5]
[a0, a1, a2, a100, a3, a4, a200]
a5
a2
4
[a0, a2, a100, a3, a4, a200]
Process finished with exit code 0
List的常用算法：
void sort(List);//对List容器内的元素排序
void shuffle(List);//对List容器内的对象进行随机排序
void reverse(List);//对List容器内的对象进行逆序排序
void fill(List,Object);//用一个特定的对象重写整个List容器
void copy(List dest,List src);//将 src List容器内容拷贝到 dest List容器
int binarySearch(List,Object);//对于顺序的List容器，采用二分查找的方法查找特定对象
实例2：
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
public class Test02 {
public static void main(String args[]) {
List l1 = new LinkedList();
for(int i = 0;i<=9;i++) {
l1.add("a"+i);
}
System.out.println(l1);
Collections.shuffle(l1);//随机排序
System.out.println(l1);
Collections.reverse(l1);//逆序排序
System.out.println(l1);
Collections.sort(l1);//排序
System.out.println(l1);
System.out.println(Collections.binarySearch(l1,"a5"));//二分查找，找到l1中"a5"的下标
}
}
//output:
[a0, a1, a2, a3, a4, a5, a6, a7, a8, a9]
[a5, a7, a1, a3, a2, a4, a8, a9, a6, a0]
[a0, a6, a9, a8, a4, a2, a3, a1, a7, a5]
[a0, a1, a2, a3, a4, a5, a6, a7, a8, a9]
5
Process finished with exit code 0
那么上面的算法根据什么来确定容器中的对象的大小顺序？
下面来介绍Comparable接口。
2.5.Comparable接口
所以可以排序的类都实现了java.lang.Comparable接口，Comparable接口中只有一个方法：
public int compareTo(Object obj);
该方法：
返回 0 表示this = obj
返回正数表示 this > obj
返回负数表示 this < obj
实现了Comparable接口的类通过实现compareTo方法从而确定该类对象的排序方式.
实例1：
import java.util.*;
public class aaa {
public static void main(String args[]) {
List l1 = new LinkedList();
l1.add(new Name1("Karl","M"));
l1.add(new Name1("Steven","Lee"));
l1.add(new Name1("John","O"));
l1.add(new Name1("Tom","M"));
System.out.println(l1);
Collections.sort(l1);
System.out.println(l1);
}
}
//Name1类实现了Comparable接口
class Name1 implements Comparable{
String firstName,lastName;
public Name1 (String firstName,String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
public String getLastName() { return lastName; }
public String getFirstName() { return firstName;}
public String toString() {
return firstName + " " + lastName;
}
public boolean equals(Object obj) {
if(obj instanceof Name1) {
return (firstName.equals(((Name1) obj).firstName)
&&lastName.equals(((Name1) obj).lastName));
}
return super.equals(obj);
}
public int hashCode() {
return firstName.hashCode();
}
public int compareTo(Object o) {
Name1 n = (Name1)o;
int lastCmp =
lastName.compareTo(n.getLastName());
return
(lastCmp != 0 ? lastCmp :
firstName.compareTo(n.getFirstName()));
}
}
//output:
[Karl M, Steven Lee, John O, Tom M]
[Steven Lee, Karl M, Tom M, John O]
Process finished with exit code 0
3.Map接口
实现 Map 接口的类用来存储 键——值 对。
Map 接口的实现类有 HashMap 和 TreeMap 等。
Map 类中存储的 键——值 对通过键来标识，所以键值不能重复。
常用方法：
Object put(Object key,Object value)//把key对应的值替换为value,返回值为key对应的旧值
Object get(Object key)//得到key所对应的值
Object remove(Object key)//除去key所对应的值，同时key也被除去
boolean containsKey(Object key)//是否包含key
boolean containsValue(Object value)//是否包含value
int size()//返回键值对的数量
boolean isEmpty()//是否为空
void putAll(Map t)//把 t 中的元素都加进去
void clear()//清除
实例：
import java.util.HashMap;
import java.util.Map;
public class Test05 {
public static void main(String args[]) {
Map m1 = new HashMap();
Map m2 = new HashMap();
m1.put("one",new Integer(1));
m1.put("two",new Integer(2));
m1.put("three",new Integer(3));
m2.put("A",new Integer(1));
m2.put("B",new Integer(2));
System.out.println(m1.size());//输出 m1 中键值对的数量
System.out.println(m1.containsKey("one"));//输出 m1 中是否有键"one"
System.out.println
(m2.containsValue(new Integer(1)));//输出 m2 中是否有值 new Integer(1)
if(m1.containsKey("two")) {
int i = ((Integer)m1.get("two")).intValue();//因为get方法返回的是Object 类型，所以需要强转
System.out.println(i);//输出 m1 中键 "two" 对应的值
}
Map m3 = new HashMap(m1);//把 m1 中的元素都复制到 m3 中
m3.putAll(m2);//把 m2 中的元素都添加到 m3 中
System.out.println(m3);
}
}
//output:
3
true
true
2
{A=1, B=2, two=2, three=3, one=1}
Process finished with exit code 0
有了自动打包和解包（Auto-boxing/unboxing），会让我们更方便地使用Map。
boxing（自动打包）：自动将基础类型转换为对象
unboxing（自动解包）：自动将对象转换为基础类型
如上述例子可以写为：
import java.util.HashMap;
import java.util.Map;
public class Test05 {
public static void main(String args[]) {
Map m1 = new HashMap();
Map m2 = new HashMap();
//自动打包
m1.put("one",1);
m1.put("two",2);
m1.put("three",3);
m2.put("A",1);
m2.put("B",2);
System.out.println(m1.size());
System.out.println(m1.containsKey("one"));
System.out.println
(m2.containsValue(1));//自动打包
if(m1.containsKey("two")) {
int i = (Integer) m1.get("two");//自动解包
System.out.println(i);
}
Map m3 = new HashMap(m1);
m3.putAll(m2);
System.out.println(m3);
}
}
4.如何选择数据结构？
衡量的标准：
Array : 读快改慢
Linked : 改快读慢
Hash : 两者之间
5.Generic (泛型)
使用泛型的原因：JDK1.4 以前的类型不明确
装入集合的类型都被当作 Object 对待，从而失去了自己的实际类型
从集合中取出时往往需要转型，效率低，容易产生错误
解决方法：
在定义集合的时候同时定义集合中对象的类型，在运行时由程序自己来判断类型是否正确
可以在定义Collection时指定
可以在循环时用Iterator指定
泛型的优点：
增强程序的可读性和稳定性。
实例1：
实例2：
import java.util.HashMap;
import java.util.Map;
public class Test07 {
public static void main(String[] args) {
//使用泛型
Map<String,Integer> m1 = new HashMap<String,Integer>();
m1.put("one",1);
m1.put("two",2);
m1.put("three",3);
if(m1.containsKey("two")) {
//因为使用了泛型，返回的对象一定的是 Integer 类型，所以在调用get方法时无需强转，
int i = m1.get("two");
System.out.println(i);
}
}
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
