JAVA面向对象基础-容器

一、泛型

      我们可以在类的声明处增加泛型列表，如：<T,E,V>。

      此处，字符可以是任何标识符，一般采用这3个字母。

【示例9-1】泛型类的声明

1 2 3 4 5 6 7 8 9 10

class MyCollection<E> {// E:表示泛型;     Object[] objs = new Object[5];     public E get(int index) {// E:表示泛型;         return (E) objs[index];     }     public void set(E e, int index) {// E:表示泛型;         objs[index] = e;     } }

      泛型E像一个占位符一样表示“未知的某个数据类型”，我们在真正调用的时候传入这个“数据类型”。

【示例9-2】泛型类的应用

1 2 3 4 5 6 7 8 9 10

public class TestGenerics {     public static void main(String[] args) {         // 这里的”String”就是实际传入的数据类型；         MyCollection<String> mc = new MyCollection<String>();         mc.set("aaa", 0);         mc.set("bbb", 1);         String str = mc.get(1); //加了泛型，直接返回String类型，不用强制转换;         System.out.println(str);     } }

二、Collection接口

  Collection 表示一组对象，它是集中、收集的意思。Collection接口的两个子接口是List、Set接口。

表9-1 Collection接口中定义的方法

      由于List、Set是Collection的子接口，意味着所有List、Set的实现类都有上面的方法。我们下一节中，通过ArrayList实现类来测试上面的方法。

三、List特点和常用方法

List是有序、可重复的容器。

      有序：List中每个元素都有索引标记。可以根据元素的索引标记(在List中的位置)访问元素，从而精确控制这些元素。

      可重复：List允许加入重复的元素。更确切地讲，List通常允许满足 e1.equals(e2) 的元素重复加入容器。

      除了Collection接口中的方法，List多了一些跟顺序(索引)有关的方法，参见下表：

表9-2List接口中定义的方法

      List接口常用的实现类有3个：ArrayList、LinkedList和Vector。

【示例9-4】List的常用方法

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

public class TestList {     /**      * 测试add/remove/size/isEmpty/contains/clear/toArrays等方法      */     public static void test01() {         List<String> list = new ArrayList<String>();         System.out.println(list.isEmpty()); // true,容器里面没有元素         list.add("高淇");         System.out.println(list.isEmpty()); // false,容器里面有元素         list.add("高小七");         list.add("高小八");         System.out.println(list);         System.out.println("list的大小：" + list.size());         System.out.println("是否包含指定元素：" + list.contains("高小七"));         list.remove("高淇");         System.out.println(list);         Object[] objs = list.toArray();         System.out.println("转化成Object数组：" + Arrays.toString(objs));         list.clear();         System.out.println("清空所有元素：" + list);     }     public static void main(String[] args) {         test01();     } }

      执行结果如图9-3所示：

【示例9-5】两个List之间的元素处理

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

public class TestList {     public static void main(String[] args) {         test02();     }     /**      * 测试两个容器之间元素处理      */     public static void test02() {         List<String> list = new ArrayList<String>();         list.add("高淇");         list.add("高小七");         list.add("高小八");         List<String> list2 = new ArrayList<String>();         list2.add("高淇");         list2.add("张三");         list2.add("李四");         System.out.println(list.containsAll(list2)); //false list是否包含list2中所有元素         System.out.println(list);         list.addAll(list2); //将list2中所有元素都添加到list中         System.out.println(list);         list.removeAll(list2); //从list中删除同时在list和list2中存在的元素         System.out.println(list);         list.retainAll(list2); //取list和list2的交集         System.out.println(list);     } }

      执行结果如图9-4所示：

图9-4 示例9-5运行效果图

【示例9-6】List中操作索引的常用方法

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

public class TestList {     public static void main(String[] args) {         test03();     }     /**      * 测试List中关于索引操作的方法      */     public static void test03() {         List<String> list = new ArrayList<String>();         list.add("A");         list.add("B");         list.add("C");         list.add("D");         System.out.println(list); // [A, B, C, D]         list.add(2, "高");         System.out.println(list); // [A, B, 高, C, D]         list.remove(2);         System.out.println(list); // [A, B, C, D]         list.set(2, "c");         System.out.println(list); // [A, B, c, D]         System.out.println(list.get(1)); // 返回：B         list.add("B");         System.out.println(list); // [A, B, c, D, B]         System.out.println(list.indexOf("B")); // 1 从头到尾找到第一个"B"         System.out.println(list.lastIndexOf("B")); // 4 从尾到头找到第一个"B"     } }

      执行结果如图9-5所示：

三、Map接口-HashMap和HashTable

Map就是用来存储“键(key)-值(value) 对”的

Map类中存储的“键值对”通过键来标识，所以“键对象”不能重复(根据equals方法)，否则新的会覆盖旧的

Map 接口的实现类有HashMap、TreeMap、HashTable、Properties等

HashMap底层实现采用了哈希表，这是一种非常重要的数据结构。希表的本质就是“数组+链表”

Entry[] table 就是HashMap的核心数组结构，我们也称之为“位桶数组”。一个Entry对象存储了：

• key：键对象，value：值对象
• next:下一个节点
• hash: 键对象的hash值

Entry[]数组的结构：

存储数据过程put(key,value)

  当添加一个元素(key-value)时，首先计算key的hash值，以此确定插入数组中的位置，但是可能存在同一hash值的元素已经被放在数组同一位置了，这时就添加到同一hash值的元素的后面，他们在数组的同一位置，就形成了链表，同一个链表上的Hash值是相同的，所以说数组存放的是链表。

HashMap

 HashMap采用哈希算法实现，是Map接口最常用的实现类。 由于底层采用了哈希表存储数据，我们要求键不能重复，如果发生重复，新的键值对会替换旧的键值对。 HashMap在查找、删除、修改方面都有非常高的效率。

【示例9-7】Map接口中的常用方法

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

public class TestMap {     public static void main(String[] args) {         Map<Integer, String> m1 = new HashMap<Integer, String>();         Map<Integer, String> m2 = new HashMap<Integer, String>();         m1.put(1, "one");         m1.put(2, "two");         m1.put(3, "three");         m2.put(1, "一");         m2.put(2, "二");         System.out.println(m1.size());         System.out.println(m1.containsKey(1));         System.out.println(m2.containsValue("two"));         m1.put(3, "third"); //键重复了，则会替换旧的键值对         Map<Integer, String> m3 = new HashMap<Integer, String>();         m3.putAll(m1);         m3.putAll(m2);         System.out.println("m1:" + m1);         System.out.println("m2:" + m2);         System.out.println("m3:" + m3);     } }

      执行结果如图9-11所示：

HashTable

      HashTable类和HashMap用法几乎一样，底层实现几乎一样，只不过HashTable的方法添加了synchronized关键字确保线程同步检查，效率较低。

HashMap与HashTable的区别

      1. HashMap: 线程不安全，效率高。允许key或value为null。

      2. HashTable: 线程安全，效率低。不允许key或value为null。

四、Set接口-HashSet基本使用

大家在做下面练习时，重点体会“Set是无序、不可重复”的核心要点。

【示例9-9】HashSet的使用

1 2 3 4 5 6 7 8 9 10 11 12 13 14

public class Test {     public static void main(String[] args) {         Set<String> s = new HashSet<String>();         s.add("hello");         s.add("world");         System.out.println(s);         s.add("hello"); //相同的元素不会被加入         System.out.println(s);         s.add(null);         System.out.println(s);         s.add(null);         System.out.println(s);     } }

      执行结果如图9-24所示：

五、Collections工具类

类 java.util.Collections 提供了对Set、List、Map进行排序、填充、查找元素的辅助方法。

      1. void sort(List) //对List容器内的元素排序，排序的规则是按照升序进行排序。

      2. void shuffle(List) //对List容器内的元素进行随机排列。

      3. void reverse(List) //对List容器内的元素进行逆续排列 。

      4. void fill(List, Object) //用一个特定的对象重写整个List容器。

      5. int binarySearch(List, Object)//对于顺序的List容器，采用折半查找的方法查找特定对象。

【示例9-23】Collections工具类的常用方法

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

public class Test {     public static void main(String[] args) {         List<String> aList = new ArrayList<String>();         for (int i = 0; i < 5; i++){             aList.add("a" + i);         }         System.out.println(aList);         Collections.shuffle(aList); // 随机排列         System.out.println(aList);         Collections.reverse(aList); // 逆续         System.out.println(aList);         Collections.sort(aList); // 排序         System.out.println(aList);         System.out.println(Collections.binarySearch(aList, "a2"));          Collections.fill(aList, "hello");         System.out.println(aList);     } }

      执行结果如图9-31所示：