JAVA面向对象基础-容器

一、泛型

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

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

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

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】泛型类的应用

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的常用方法

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之间的元素处理

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中操作索引的常用方法

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接口中的常用方法

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的使用

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工具类的常用方法

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所示：