Java编程思想读书笔记——第十一章：持有对象

第十一章 持有对象

Java类库提供了一套相当完整的容器来解决这个问题，基本类型是List、Set、Queue、Map

11.1 泛型和类型安全的容器

我们常用的ArrayList，一般使用泛型指定类型，如果不指定，那么就都是Object类，直接上练习

练习1：创建一个新类Gerbil(沙鼠)，包含int gerbilNumber，在构造器中初始化它。添加一个方法hop()，用以打印沙鼠的号码以及它正在跳跃的信息。创建一个ArrayList，并向其中添加一串Gerbil对象。使用get()遍历List，并且对每个Gerbil调用hop()。这个练习太简单了，都不想贴上来了。

public class Gerbil {
	
	private int gerbilNumber;
	
	public Gerbil(int number) {
		gerbilNumber = number;
	}
	
	public void hop() {
		System.out.println(gerbilNumber + "跳起来啦");
	}
	
	public static class Inner {
		public static void main(String[] args) {
			ArrayList<Gerbil> list = new ArrayList<Gerbil>();
			for (int i = 0; i < 10; i++) {
				list.add(new Gerbil(i));
			}
			for (int i = 0; i < list.size(); i++) {
				list.get(i).hop();
			}
		}
	}
	
}

输出
0跳起来啦
1跳起来啦
2跳起来啦
3跳起来啦
4跳起来啦
5跳起来啦
6跳起来啦
7跳起来啦
8跳起来啦
9跳起来啦

11.2 基本概念

1、Collection。一个独立的元素序列，必须按照插入的顺序保存元素，Set不能有重复元素，Queue按照排队规则来确定顺序

2、Map。一组成对的"键值对"对象，ArrayList允许通过数字查值，某种意义上来说，它也将数字和值关联在了一起。通过一个对象去查找另一个对象，我们通俗的可以称"关联数组"，或者"字典"，Map是很强大的编程工具。

练习2：略

练习3：略

11.3 添加一组元素

java.util包下Arrays和Collections类中有很多实用方法，比如Arrays.asList()，Collection.addAll()，它们都接受一个数组或者用逗号分割的列表。

Collection.addAll()运行起来要快的多，首选这种方式

Arrays.asList()的要点：

1. 底层是数组，长度不可变
2. 返回的ArrayList不是真的java.util包下的ArrayList，而是Arrays的内部类，不支持添加和删除元素
3. 这个方法将数组和列表连接了起来，同生共死的关系
4. 对基本类型的数组支持不友好，有时候识别不出来基本类型，要想用，还必须使用封装类，比如int型的得用Integer

其实想要避免这些问题可以考虑这种骚操作：

// ArrayList的构造方法并不高效
List<String> list = new ArrayList<String>(Arrays.asList(arr));
// 还是像上面说的，首先建议使用Collection.addAll()这种方法更高效
List<String> list = new ArrayList<String>();
Collections.addAll(list, arr);

11.4 容器的打印

在每个槽中只保留一个元素，此类容器包括：

1. List，它以特定的顺序保存一组元素（ArrayList，LinkedList）
2. Set，元素不能重复（HashSet，TreeSet，LinkedHashSet）
3. Queue，只允许在容易的一端插入对象，并在另外一端移除对象

在每个槽中保留了两个对象

1. Map，键和与之相关联的值(HashMap，TreeMap，LinkedHashMap)

练习4：创建一个生成器类，它可以在每次调用其next方法时，产生你由你最喜欢的电影的字符构成的名字（作为String对象）。在字符列表中的电影名用完之后，循环到这个字符列表的开始处。使用这个生成器来填充数组、ArrayList、LinkedList、HashSet、LinkedHashSet和TreeSet、然后打印每一个容器。

public class Player {
	
	String[] player = {"哈登", "库里", "保罗", "科比", "艾弗森", "麦迪"};
	
	int next;
	
	public String next() {
		String s = player[next];
		next = (next + 1) % player.length;
		return s;
	}
	
	
	public static class Main {
		
		private static final Player PLAYERS = new Player();
		
		static String[] fill(String[] array) {
			for (int i = 0; i < array.length; i++) {
				array[i] = PLAYERS.next();
			}
			return array;
		}
		
		static Collection<String> fill(Collection<String> collection) {
			for (int i = 0; i < 5; i++) {
				collection.add(PLAYERS.next());
			}
			return collection;
		}
		
		public static void main(String[] args) {
			System.out.println(Arrays.toString(fill(new String[5])));
			System.out.println(fill(new ArrayList<String>()));
			System.out.println(fill(new LinkedList<String>()));
			System.out.println(fill(new HashSet<String>()));
			System.out.println(fill(new LinkedHashSet<String>()));
			System.out.println(fill(new TreeSet<String>()));
			
		}
	}
}

输出：
[哈登, 库里, 保罗, 科比, 艾弗森]
[麦迪, 哈登, 库里, 保罗, 科比]
[艾弗森, 麦迪, 哈登, 库里, 保罗]
[艾弗森, 库里, 麦迪, 哈登, 科比]
[保罗, 科比, 艾弗森, 麦迪, 哈登]
[保罗, 库里, 科比, 艾弗森, 麦迪]

11.5 List

List有两种：

• ArrayList，我们常用的用于访问随机元素，在插入和移除的时候较慢
• LinkedList，插入和移除操作较快，随机访问较慢

List允许创建后添加移除，并且调整自身的尺寸，一种可修改的序列。这些是它的重要价值所在。

常用方法：

contains()：确定某个对象是否在列表中

remove()：将对象的引用传递给此方法可以移除对象

indexOf()：发现某一个对象所在的索引

subList()：从一个list中截取一个片段，此片段就是基于截取的那个list，所以此片段的变化会通知到初始列表

retainAll()：取交集的方法，也同样依赖于equals()方法，这个不常用

removeAll()：移除所有元素

set()：作者也说了这个方法应该命名为replace更合适些，哈哈，取代的意思

addAll()：添加一个list，这个方法还是很常用的

isEmpty()和clear()：这俩方法就不用说了吧

toArray()：转换为一个数组

练习5：略

练习6：略

练习7：创建一个类，然后创建一个用你的类的对象进行初始化过的数组。通过subList()方法，创建你的List的子集，然后在你的List中移除这个子集

// 这个例子很简单，但是非要写一下，subList得到的这个list，进行何种操作都会影响到初始列表
// 想要正常使用Arrays.asList()和subList()这两个方法返回的list，我们可以创建它们的副本
public class Apple {
	
	int id;
	
	public Apple(int i) {
		id = i;
	}
	
	public static class Main{
	
		static List<Apple> list = new ArrayList<>();
		
		public static void main(String[] args) {
			for (int i = 0; i < 10; i++) {
				list.add(new Apple(i));
			}
			
			List<Apple> list2 = list.subList(0, 3);
			// 移除list2中的第二项
			list2.remove(1);
			for (int i = 0; i < list.size(); i++) {
				System.out.println(list.get(i).id);
			}
		}
	}
	
}

输出：
0
2
3
4
5
6
7
8
9

11.6 迭代器

任何容器都可以插入元素并取出元素，比如list的add()和get()方法

对于list我们肯定会涉及到遍历操作

// 一个list的三种遍历方式
List<Apple> list = new ArrayList<>();
// 1、普通方式
for (int i = 0; i < list.size(); i++) {
	System.out.print(list.get(i).id);
				
}
// 2、foreach， 写起来挺简洁，但是无法获得下标
for(Apple apple : list) {
	System.out.print(apple.id);
}
// 3、迭代器方式
Iterator<Apple> iterator = list.iterator();
while(iterator.hasNext()) {
	System.out.print(iterator.next().id);
}

通过list.iterator()方法返回迭代器，注意Iterator只能向一个方向遍历迭代器有三个方法：

• next()
• hasNext()
• remove()

挺简单的，这几个练习不写了，略了

练习8：略

练习9：略

练习10：略

练习11：略

11.6.1 ListIterator

ListIterator是一种更强大的子类型，它的优点有：

• 可以双向移动
• 可以获取当前位置的前一个和后一个的元素的索引
• set()方法替换它访问过的最后一个元素
• 可以创建一个一开始就指向列表索引为n的元素处的ListIterator

练习12：略

11.7 LinkedList

LinkedList实现了List的接口，同样也实现了使其作用于栈和队列的一些方法，这些方法只存在些许差异：

getFirst()和element()都是返回了列表的头（第一个元素），并且不移除它，List为空，抛出异常，而peek()方法list为空返回null

removeFirst()和remove()也是一样的，移除并返回列表的头，List为空，抛出异常，而poll()方法在列表为空时返回null

addFirst()与add()和addFirst()相同，都是将某个元素插入到列表的尾部

removeLast()移除并返回列表的最后一个元素

练习13：略

练习14：略

11.8 Stack

LinkedList拥有能够直接实现栈的所有的方法，因为可以直接将LinkedList作为栈使用，不过一个真正的栈更能把事情讲清楚

public class Stack<T> {
	
	private LinkedList<T> storage = new LinkedList<>();
	
	public void push(T v) {
		storage.addFirst(v);
	}
	
	public T peek() {
		return storage.getFirst();
	}
	
	public T pop() {
		return storage.removeFirst();
	}
	
	public boolean empty() {
		return storage.isEmpty();
	}
	
}

练习15：对表达式求值，“+”表示将后面的字母压进栈，而“-”表示弹出栈顶字母并打印它

// 你还别说，通过这个例子
// for循环不自增的用法确实挺骚
// 再一个就是思维的问题，如果按正常考虑肯定要一位一位的判断是+还是-，
// 然后用一个变量来记录上一位是个符号还是字母，
// 因为存在符号也算字符的问题，甚至得记录到上一位的上一位，那这样解决这个问题就太复杂了
// 通过自增来解决这个问题，那么就容易多了
public class Pratice15 {
	
	private static Stack<Character> stack = new Stack<>();

	public static void main(String[] args) {
		String string = "+U+n+c---+e+r+t---+a-+i-+n+t+y---+ -+r+u--+l+e+s---";
		char[] array = string.toCharArray();
		for (int i = 0; i < array.length;) {
			switch (array[i++]) {
			case '+':
				stack.push(array[i++]);
				break;
			case '-':
				System.out.print(stack.pop());
			default:
				break;
			}
		}
		
	}
}

输出：
cnUtreaiytn ursel

11.9 Set

Set不保存重复元素，比如add相同元素，是不会保存的。

HashSet输出的时候是散列的

TreeSet输出的时候是有序的

使用contain()方法来确定Set中有没有此元素

练习16：略

11.10 Map

map是很牛逼的，解决编程问题的杀手锏，哈哈哈

比如此时Random类的随机性，随机生成的数出现几次的问题。那么使用Map简直不要太爽，键（key）是生成的数字，值（value）是出现的次数

键不在容器中，get()方法返回null，否则将产生对应的关联值，containsKey()和containsValue()用来查看map中是否包含某个值

• Map可以返回它键的Set，keySet()方法
• 值的Collection，values()方法
• 或者键值对的Set，entrySet()方法

以后写练习不写题目了，代码也写主要代码了。这样能节省好多时间

练习17：

// 主要考察：
// Map的entrySet()方法返回键值对的集合
// 容器使用Iterator来遍历
Map<String, Gerbil> map = new HashMap<>();
Iterator<Entry<String, Gerbil>> iterator = map.entrySet().iterator(); 
while(iterator.hasNext()) {
    Entry<String, Gerbil> entry = iterator.next();
	System.out.println(entry.getKey() + ":");
	entry.getValue().hop();
}

练习18：

// 主要考察：
// map.ketSet()方法
// 排序
// foreach循环
String[] keys = map.keySet().toArray(new String[0]);
Arrays.sort(keys);
Map<String, String> map2 = new LinkedHashMap<String, String>();
for (String key : keys) {
	map2.put(key, map.get(key));
}

练习19：略

练习20：

// 考察：
// 使用map来解决记录次数的问题
void updateStatus(Map<Character, Integer> map, char letter) {
	Integer integer = map.get(letter);
	map.put(letter, integer == null ? 1 : integer + 1);
}

练习21：略

练习22：略

练习23：略

练习24：略

练习25：略

练习26：略

11.11 Queue

队列是先进先出的容器，常被当做是一种可靠的将对象从程序的某个区域传输到另一个区域的途径。队列在并发编程中非常重要

LinkedList实现了Queue的接口，可以用作queue的一种实现

插入队列，offer方法()：将一个元素插入队尾或者返回false

返回队头，peek()在队列为空返回null，element()在队列为空抛出异常

移除并返回队头poll()在队列为空返回null，remove()抛出异常

练习27：

// 主要考察：
// 队列的这三个方法
// offer()入队
// peek()获取队首元素
// remove()获取并移除队首元素，如果队列为空，抛出异常
Queue<String> queue = new LinkedList<>();
queue.offer("1");
if (queue.peek() != null) {
	queue.remove();
}

11.11.1 PriorityQueue

一种优先级队列，不一定是先进先出，可以通过Comparator来修改这个顺序，有它一定的优势

练习28：略

练习29：略

11.12 Collection和Iterator

使用接口描述的理由是：它可以使我们能够创建更通用的代码

Collection是所有序列容器的共性接口

继承Collection必须首先实现很多的方法，如果继承AbstractCollection只需实现iterator()方法

11.13 foreach与迭代器

foreach适用于数组和所有Collection对象

是因为在Java SE5引入了新的被称为Iterable的接口，包含一个iterator()的方法用来在序列中移动，如果我们创建了任何实现Iterable的类，都可以使用foreach语句。

foreach语句可以用于数组，但是并不意味着数组也是一个Iterable

练习31：略

11.13.1 适配器方法惯用法

挺重要的一点：

Arrays.asList()返回的List并不是ArrayList，只能访问不能修改，所以正确方法是在ArrayList的构造方法中传入Arrays.asList返回的list

练习32：略

11.14 总结

• 数组保存类型明确的对象，数组一旦生成，其容量无法改变
• Collection保存单一的对象，Map保存相关联的键值对，泛型可以指定存放的类型，Collection和Map都可以在添加元素时自动调整尺寸。不能持有基本类型，但是有自动包装机制可以双向转换。
• 要进行大量的随机访问，就使用ArrayList，如果经常要从中插入或删除元素，就使用LinkedList
• 各种Queue和栈行为，有LinkedList支持
• HashMap用来快速访问，TreeMap保持键始终处于排序状态，LinkedHashMap保持元素插入顺序
• Set不接受重复的元素，HashSet用来快速访问，TreeSet保持元素处于排序状态，LinkedHashSet以插入顺序保存元素
• 新程序中不应该使用过时的Vetor、HashTable、Stack

这个图脑子里应该大体有个印象

其实这张也就是容器类的一个简述而已，大体的功能什么的了解一下，再后面会学到更多详细的有关容器类的内容