目录
一、容器的概念和容器API
容器：java API所提供的一系列的实例，用于在程序中存放对象
JDK所提供的容器API位于java.util包内
容器API的类图结构如下图所示：
左边的容器都是一个个往里装，右边的容器也就是map这一边的是一对一对往里装
Collection接口定义了存取一组对象的方法，他代表了一个集合，他下面分了两个子接口set和list。
装东西的时候set是没有顺序并且不可以重复，list是有顺序可以重复，所谓的重复是指两个对象equals
Map接口定义了存储“键(key) –值(value)” 映射对的方法
二、Collection接口
- Collection接口中所定义的方法：
int size();
boolean isEmpty();
void clear();
boolean contains(Object element);//查看是否包含某一个对象
bllean add(Object element);
boolean remove(Object element);
Iterator iterator();
boolean containsAll(collection c);
bllean addAll(Collection c);
boolean removeAll(Collection c);
boolean retainAll(Collection c);//交集
object[] toArray();
看一个例子：
public class Test{
public static void main(String[] args) {
Collection c = new ArrayList();//父类引用指向子类对象
//可以放入不同类型的对象
c.add("hello");
c.add(new Name("f1","l1"));
c.add(new Integer(100));
System.out.println(c.size());
System.out.println(c);
}
}
//输出结果：
//3
//[hello, f1 l1, 100]
public class Test{
public static void main(String[] args) {
Collection c = new ArrayList();
c.add("hello");
c.add(new Name("f1","l1"));
c.add(new Integer(100));
c.remove("hello");
c.remove(new Integer(100));
System.out.println(c.remove(new Name("f1","l1")));
System.out.println(c);
}
}
//输出结果：
//false
//[f1 l1]
//因为两个Name("f1","l1")指向的不是同一个对象，所以equals方法返回false
容器类对象在调用remove、contains等方法时需要比较对象是否相等，这回涉及到对象类型的equals方法和hashCode方法；对于自定义的类 型，需要重写equals和hashCode方法以实现自定义的对象相等规则
注意：相等的对象应该具有相等的hashCode
增加Name类的equals和hashCode方法如下：
public boolean equals(Object obj) {
if (obj instanceof Name) {
Name name = (Name) obj;
return (firstName.equals(name.firstName))&&(lastName.equals(name.lastName));
}
return super.equals(obj);
}
public int hashCode() {
return firstName.hashCode();
}
这样那个例子代码结果就会变为true 和[]了
三、Iterator接口
- 所有实现了collection接口的容器类都由一个interator方法用以返回一个实现了Interator接口的对象
- Interator对象称作迭代器，用以方便的实现对容器内元素的遍历操作
- Iterator接口定义了如下方法：
boolean hasNext();//判断游标右边是否有元素 Object next();//返回游标右边的元素并将游标移动到下一个位置 void remove();//删除游标左面的元素，在执行完next之后
看一个例子：
public class Test{
public static void main(String[] args) {
Collection c = new HashSet();
c.add(new Name("f1","l1"));
c.add(new Name("f2","l2"));
c.add(new Name("f3","l3"));
//遍历
Iterator i = c.iterator();
while(i.hasNext()) {
//由于next()的返回值为Object类型，需要转换为相应类型
Name n = (Name)i.next();
System.out.print(n.getFirstName()+" ");
}
}
}
//输出结果
//f1 f2 f3
- Iterator对象的remove方法是在迭代过程中删除元素的唯一的安全方法
public class Test{
public static void main(String[] args) {
Collection c = new HashSet();
c.add(new Name("ffff1","lllll1"));
c.add(new Name("f2","l2"));
c.add(new Name("fff3","llll3"));
for (Iterator i = c.iterator(); i.hasNext();) {
Name name = (Name)i.next();
if (name.getFirstName().length()<3) {
i.remove();
//如果换成c.remove(name);会产生例外
}
}
System.out.println(c);
}
}
//输出结果：[fff3 llll3, ffff1 lllll1]
四、增强的for循环
增强的for循环对于遍历array或Collection的时候非常简便
看一个例子先：
public class Test{
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
for(int i : arr) {
System.out.print(i + " ");//遍历输出
}
System.out.println();
Collection c = new ArrayList();
c.add(new String("aaa"));
c.add(new String("bbb"));
c.add(new String("vvv"));
for (Object o : c) {
System.out.print(o + " ");//遍历输出
}
}
}
缺陷：
- 对于数组来说不能方便的访问下标值
- 对于集合来说，与使用Iterator来说，不能方便的删除集合中的内容（在for循环内部也调用Itertor）
所以，除了简单遍历并读出其中的内容外，不建议使用增强for
五、Set接口
Set接口是Collection的子接口，Set接口没有提供额外的方法，但实现Set接口的容器类中的元素是没有有顺序的，而且不可以重复
Set容器可以与数学中的集合的概念相对应
J2SDK 的API中所提供的Set容器类有HashSwt，TreeSet等
看一个例子：
public class Test{
public static void main(String[] args) {
Set s = new HashSet();
s.add("hello");
s.add("world");
s.add(new Name("f1", "l1"));
s.add(new Integer(100));
s.add(new Name("f1", "l1"));//相同元素不会被加入
s.add("hello");//相同元素不会被加入
System.out.print(s + " ");
}
}
//输出结果：[world, 100, hello, f1 l1]
再看一个例子：
public class Test{
public static void main(String[] args) {
Set s1 = new HashSet();
Set s2 = new HashSet();
s1.add("a");
s1.add("b");
s1.add("c");
s2.add("a");
s2.add("b");
s2.add("d");
Set sn = new HashSet(s1);
sn.retainAll(s2);//交集
Set su = new HashSet(s1);
su.addAll(s2);
System.out.println("su = "+ su);
System.out.println("sn = "+ sn);
}
}
//输出结果：
//su = [a, b, c, d]
//sn = [a, b]
六、List接口和Comparable接口
1.List接口
List接口是Collection的子接口，实现List接口的俄容器类中的元素是有顺序的，而且可以重复
List的容器重点额元素都对应一个整数型的序号级再其在容器中的位置，可以根据序号存取容器中的元素
J2SDK所提供的List容器类有ArrayList，LinkedList等
Object get(int index);
Object set(int index,Object lement);
void add(int index,Object element);
Object remove(int index);
int indexOf(Object o);
int lastIndexOf(Object o);
看一个例子：
public class Test{
public static void main(String[] args) {
LinkedList l1 = new LinkedList();
for (int i=0; i<=5; i++) {
l1.add("a" + i);
}
System.out.println(l1);//[a0, a1, a2, a3, a4, a5]
l1.add(3,"a100");
System.out.println(l1);//[a0, a1, a2, a100, a3, a4, a5]
l1.set(6, "a200");
System.out.println(l1);//[a0, a1, a2, a100, a3, a4, a200]
System.out.println((String)l1.get(2)+ " ");//a2
System.out.println(l1.indexOf("a3"));//
l1.remove(1);
System.out.println(l1);//[a0, a2, a100, a3, a4, a200]
}
}
List常用算法
void sort(List) //对list容器内的元素排序
void shuffle(List) //对list容器内的对象进行随机排列
void reverse(List) //岁list容器内的对象进行逆序排列
void fill(List,Object) //用一个特定的对象重写整个List容器
void copy(List dest,list src) //将srcList容器内容拷贝到destList容器
void binarySearch(List,Object) //对于顺序的list容器，采用着办查找的方法查找特定对象
看一个例子：
public class Test{
public static void main(String[] args) {
LinkedList l1 = new LinkedList();
for(int i=0; i<=9; i++) {
l1.add("a" + i);
}
System.out.println(l1);//[a0, a1, a2, a3, a4, a5, a6, a7, a8, a9]
Collections.shuffle(l1);//随机排列
System.out.println(l1);//[a9, a2, a7, a4, a1, a5, a3, a6, a8, a0]
Collections.reverse(l1);//逆序
System.out.println(l1);//[a0, a8, a6, a3, a5, a1, a4, a7, a2, a9]
Collections.sort(l1);//排序
System.out.println(l1);//[a0, a1, a2, a3, a4, a5, a6, a7, a8, a9]
System.out.println(Collections.binarySearch(l1, "a5"));//折半查找,结果为5
}
}
2.Comparable接口
所有可以”排序”的类都实现了java.lang.Comparable接口，Comparable接口中只有一个方法：
public int compareTo(Object obj);
该方法：
- 返回0表示this == obj
- 返回正数表示this>obj
- 返回负数表示this <obj
实现了Comparable接口的类通过实现compataTo方法从而确定该类对象的排序方式
八、Map接口
实现Map接口的类用来存储键-值对
Map接口的实现类有HashMap和TreeMap等
Map类中存储的键-值对通过键来标识，所以键值不能重复
Object put(Object key,Object value);
Object get(Object key);
Object remove(Object key);
boolean containsKey(Object key);
boolean containsValue(Object value);
int size();
boolean isEmpty();
void putAll(Map t);
void clear();
看一个例子：
public class Test{
public static void main(String[] args) {
Map m1 = new HashMap();
Map m2 = new TreeMap();
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());//
System.out.println(m1.containsKey("one"));//true
System.out.println(m2.containsValue(new Integer(1)));//true
if (m1.containsKey("two")) {
int i = ((Integer)m1.get("two")).intValue();
System.out.println(i);//
}
Map m3 = new HashMap(m1);
m3.putAll(m2);
System.out.println(m3);//{A=1, B=2, two=2, three=3, one=1}
}
}
九、自动打包/解包
在合适的时机自动打包、解包（JDK1.5之后的版本支持）
- 自动将基础类型转换为对象（打包）
- 自动将对象转换为基础类型（解包）
如此，上面的例子可以这么写：
public class Test{
public static void main(String[] args) {
Map m1 = new HashMap();
Map m2 = new TreeMap();
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"));//true
System.out.println(m2.containsValue(1));//true
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);//{A=1, B=2, two=2, three=3, one=1}
}
}
看一个练习例子：
/*
* 注释掉的代码是使用了自动打包和解包进行的代码简化
*/
public class Test{ private static final Integer ONE = new Integer(1);
//private static final int ONE = 1; public static void main(String[] args) { Map m = new HashMap(); for(int i=0; i<args.length; i++) {
Integer freq = (Integer)m.get(args[i]);
//int freq = (Integer)m.get(args[i]);
m.put(args[i], (freq == null ? ONE : new Integer(freq.intValue() +1)));
//m.put(args[i], freq==0 ? ONE : freq + 1);
} System.out.println(m.size() + " distinct words detected: ");
System.out.println(m); }
}
这是一个统计传外部参次数的例子
十、泛型（JDK1.5以后新增）
起因：
JDK1.4以前类型不明确：
- 装入集合的类型都被当作Object对待，从而时区自己的实际类型
- 从集合中取出时往往需要转型，效率低，容易产生错误
解决办法：
- 在定义集合的时候同事定义集合中对象的类型
- 可以在定义Collection的时候指定
- 也可以在循环时用Iterator指定
好处：
- 增强程序的可读性和稳定性
看一个例子：
public class Test{
public static void main(String[] args) {
List<String> c = new ArrayList<String>();
c.add("aaa");
c.add("bbb");
c.add("ccc");
for(int i=0; i<c.size(); i++) {
String s = c.get(i);
System.out.println(s);
}
Collection<String> c2 = new HashSet<String>();
c2.add("aaa");
c2.add("bbb");
c2.add("ccc");
for(Iterator<String> it = c2.iterator(); it.hasNext();) {
String s = it.next();
System.out.println(s);
}
}
}
在看一个例子：
public class Test{
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);
System.out.println(m1.size());
System.out.println(m1.containsKey("one"));
if(m1.containsKey("two")) {
int i = m1.get("two");
System.out.println(i);
}
}
}