07 - JavaSE之容器
本章宗旨：1136 -- 1个图 1个类 3个知识点 6个接口 容器 J2SDK 所提供的容器 API 位于 java.util 包内。 容器 API 的类图如下： Collection 接口的子接口分为：Set接口（包含 HashSet类） + List接口（包含LinkedList 类和 ArrayLis t类） Map接口：包含HashMap类 Set接口和List接口定义了不同的数据存储方式： Set 中的数据对象没有顺序并且不可以重复。 List 中的数据对象有顺序并且可以重复。 Map接口定义了存储“键(key)——值(value)映射”的方法。 Collection接口 Collection接口中所定义的方法： int size() boolean isEmpty() void clear() boolean contains(Object element) boolean add(Object element) boolean remove(Object element) Iterator iterator() boolean containsALL(Collection c) boolean addALL(Collection c) boolean removeALL(Collection c) boolean retainALL(Collection c) Object[] toArray() 举例1： import java.util.*; public class Test { public static void main(String[] args) { Collection c = new ArrayList(); // 可以放入不同类型的对象 c.add("Hello"); c.add(new String("World")); c.add(new Integer(100)); System.out.println(c.size()); System.out.println(c); } } // 3 // [Hello, World, 100] 举例2： import java.util.*; public class Test { public static void main(String[] args) { Collection c = new HashSet(); c.add("Hello"); c.add(new String("World")); c.add(new Integer(100)); // 可以删除因为HashSet重写了equals方法。 c.remove("Hello"); c.remove(new Integer(100)); System.out.println(c.size()); System.out.println(c); } } // 1 // [100] 容器类对象在调用 remove，contains 等方法时需要比较对象是否相等，这会涉及到对象类型的 equals 方法和 hashcode 方法；对于自定义的类型，需要重写 equals 和 hashCode 方法以实现自定义的对象相等规则。 相等的对象应该具有相同的 hash codes，但是 hashCode 只在这个对象作为索引、键值的时候使用此方法，其他时候虽然不用，但是还是要重写此方法，至于重写此方法的具体实现可以随便写（比如我直接返回0也是可以的）。 Iterator 接口 所有实现了 Collection 接口的容器类都有一个 iterator 方法，这个方法返回一个实现了 Iterator 接口的对象。 这个 Iterator 对象称为迭代器，用以方便的实现对容器内的元素的遍历操作。 Iterator 接口定义了如下方法： boolean hasNext(); // 判断游标右边是否有元素 Object next(); // 返回游标右边的元素并移动游标到下一个位置 void remove(); // 删除游标左边的元素，在执行完next之后，该操作只能执行一次 举例1： import java.util.*; public class Test { public static void main(String[] args) { Collection c = new ArrayList(); c.add("Hello"); c.add(new String("World")); c.add(new Integer(100)); Iterator i = c.iterator(); while(i.hasNext()) { System.out.println(i.next()); } } } Iterator 对象的 remove 方法是在迭代过程中删除元素的唯一的安全方法。（不能使用 Collection 对象的 remove 方法，因为管家Iterator 对象在迭代过程中会将元素上锁，外人无法访问。） import java.util.*; public class Test { public static void main(String[] args) { Collection c = new ArrayList(); c.add("Hello"); c.add(new String("World")); c.add(new Integer(100)); Iterator i = c.iterator(); for(Iterator i = c.iterator(); i.hasNext(); ) { if(i.next().equals(100)) { i.remove(); } } System.out.println(c); // [Hello, World] } } 补充：JDK1.5 增强的 for 循环 增强的 for 循环对于遍历 array 或者 Collection 的时候相当简便。 import java.util.*; public class EnhancedFor { public static void main(String[] args) { int[] arr = {1, 2, 3, 4, 5}; for(int i : arr) { System.out.println(i); } Collection c = new ArrayList(); c.add(new String("aaa")); c.add(new String("bbb")); c.add(new String("ccc")); for(Object o : c) { System.out.println(o); } } } 增强型 for 循环的缺陷：（除了简单遍历外，不建议使用增强 for 循环） 对于数组：不能方便的访问下标值。 对于 Iterator ，不能方便的删除集合中特定的元素。 Set 接口 Set接口是 Collection 的子接口，Set 接口没有提供额外的方法，实现Set接口的容器类中的元素是没有顺序的，而且不可以重复。 Set容器可以与数学中的“集合”概念相对应。 JDK API中所提供的Set容器类有HashSet，TreeSet等。 举例1： public static void main(String[] args) { Set s = new HashSet(); s.add("hello"); s.add("world"); s.add("world"); // 相同的元素不会被加入，类似数学的集合概念 System.out.println(s); // [hello, world] } 举例2： 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("d");s2.add("a");s2.add("b"); Set sn = new HashSet(s1); Set su = new HashSet(s1); sn.retainAll(s2); su.addAll(s2); System.out.println(sn); // [a, b] System.out.println(su); // [d, a, c, b] } List 接口 List接口是 Collection的 子接口，实现List接口的容器类中的元素是有顺序的，而且可以重复。 List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。 JAVA SDK提供的List容器类有 ArrayList，LinkedList等。 Object get(int index) // 返回index位置的元素 // 返回值为Object，表示set替换掉的元素，返回出来 Object set(int index, Object element) void add(int index, Object element) Object remove(Object o) int indexOf(Object o) int lastIndexOf(Object o) 举例： List l1 = new LinkedList(); for(int i=0; i<6; i++) { li.add("a" + i); } // [a0, a1, a2, a3, a4, a5, a6] System.out.print((String)l1.get(2) + " "); // a2 System.out.println(li.indexOf("a3")); // 3 li.remove(1); System.out.println(l1); // [a0, a2, a3, a4, a5, a6] List 常用算法（Collections类） Collections类提供了一些静态方法实现了基于List容器的常用算法。 void sort(List) // 对List容器内的元素排序 void shuffle(List) // 对List容器内的元素进行随机排列 void reverse(List) // 对List容器内的元素进行逆序排列 void fill(List, Object) // 用特定的List元素列表填充整个List容器 void copy(List dest, List src) void binarySearch(List, Object) // 对于顺序的List容器，采用二分法查找指定对象 Comparable 接口 问题：上面的算法根据什么确定容器中对象的“大小”顺序？ 其实，所有可以排序的类都实现了 java.lang.Comparable 接口，Comparable河口中只有一个方法： public int compareTo(Object obj); 该方法： 返回0表示： this == obj 返回正数表示：this > obj 返回负数表示：this < obj 实现 Comparable接口的类通过实现 compareTo 方法从而确定该类对象的排序方法。 PS：我们可以看到 compareTo 方法的参数类型是 Object 类型的，意味着如果我只想比较两只猫的话，我扔一只狗也是可以的，这就没意义了，所以在之后的 JDK 里面，将 Object 类型统一改为 泛型，这样在传入的时候就统一了比较的对象。 改写 Name 类，让其实现 Comparable 接口： class Name implements comparable { //... public int compareTo(Object o) { Name n = new (Name)o; int lastCmp = lastName.compareTo(n.lastName); // 先比较姓氏大小 return (lastCmp != 0 ? lastCmp : firstName.compareTo(n.firstName)); // 再比较名字大小 } } 改写了 compareTo 方法，相当于改写了Collections类的排序算法，至于如何排序，由你决定！ 如何选择数据结构？ 衡量标准：读的效率和写的效率（如字符串逆序操作） Array 读快写慢（写的慢，需要另开辟数组） Linked 写快读慢（写的快，还需要改变指针指向） Hash 介于两者之间 Map接口 实现Map接口的类用来存储 “键值对” Map接口的实现类有 HashMap 和 TreeMap Map类中存储的键值对通过键来标识，所以键的值不能重复 Object put(Object key, Object value) // 返回值为 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 m) void clear() 举例1： import java.util.*; public class Test { 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()); System.out.println(m1.containsKey("one")); System.out.println(m2.containsValue(new Integer(2))); 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); } } 举例2： import java.util.*; public class Test { private static final Integer ONE = new Integer(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]); m.put(args[i], freq == null ? ONE : new Integer(freq.intValue() + 1)); } System.out.println(m); } } // java Test 77 88 99 99 99 // {77=1, 88=1, 99=3} Auto-boxing/unboxing 在合适的时机自动打包/解包 自动将基础类型转换成对象 自动将对象转换成基础类型 import java.util.*; public class Test { private static final int ONE = 1; public static void main(String[] args) { Map m = new HashMap(); for(int i=0; i<args.length; i++) { int freq = ((Integer) m.get(args[i]) == null ? 0 : (Integer) m.get(args[i])); m.put(args[i], freq == 0 ? ONE : freq + 1); } System.out.println(m); } } 泛型 起因 JDK1.4之前类型不明确，装入集合的类型都被当做 Object 对待，从而失去了其本身的实际类型。 从集合中取出元素时需要转型，效率低，容易产生错误。 解决办法 在定义集合的时候定义集合中对象的类型 import java.util.*; public class Test { public static void main(String[] args) { Collection<String> c = new HashSet<String>(); c.add("aaa"); c.add("bbb"); c.add("ccc"); for(Iterator<String> i = c.iterator(); i.hasNext(); ) { System.out.println(i.next()); } } } // aaa ccc bbb 总结 1136：一个图，一个类，三个知识点，六个接口
