数据结构中的包，其实是对现实中的包的一种抽象。 想像一下现实中的包，比如书包，它能做什么？有哪些功能？首先它用来装东西，里面的东西可以随便放，没有规律，没有顺序，当然，可以放多个相同的东西。其次，东西可以拿出来，拿出来也有几种情况，随便拿出一个，拿出特定的一个，比如书本，把所有的东西都拿出来。附带的功能就是，包有没有满，包是不是空的，里面有多少东西，都是什么，里面是不是有书，放了几本书之类的。想好之后，就可以定义数据结构中的包的方法了。
装东西，定义add()方法，要接受一个参数，要装的东西，没有返回值。
随便拿出一个东西，定义remove()方法， 没有参数，返回拿出的东西。
拿出一个特定的东西，定义remove(anEntry), 接收一个参数，要拿出的东西，返回值是布尔值，表示有没有成功，因为要拿出的东西，包里可能没有
拿出所有东西，定义clear()方法，没有参数，也没有返回值。
包里有多少东西，定义getCurrentSize()方法，返回包中元素的个数，没有参数。
包是不是空的，定义isEmpty()方法，没有参数，返回布尔值。
包里有没有书，定义contains()方法，它接受一个参数，要找的东西，返回布尔值。
包里有几本书，定义getFrequencyOf()方法，接受一个参数，要找的东西，返回整数。
包里都是什么，可以定义toArray()方法，返回一个数组，包含包里所有的东西，也是定义迭代方法。
/** * 一个用来描述包的操作的接口 */ public interface BagInterface<T> { /** * 获取包中元素的数量 * * @return 元素数量 */ int getCurrentSize(); /** * 包是否为空 * * @return 包为空，返回true, 否则返回false */ boolean isEmpty(); /** * 向包里添加一个元素 * * @param newEntry 要添加到包里的元素 */ void add(T newEntry); /** * 从包里删除任意一个元素 * @return 删除的元素 */ T remove(); /** * 从包里删除一个给定的元素 * @param anEntry 要删除的元素 * @return 是否删除成功 */ boolean remove(T anEntry); /** * 删除包中所有元素 */ public void clear(); /** * 计算一个给定元素的数量 * @param anEntry 给定的元素 * @return 给定元素的数量 */ public int getFrequencyOf(T anEntry); /** * 是否包含给定的元素 * @param anEntry 要查找的元素 * @return 如查包含返回true, 否则返回false */ public boolean contains(T anEntry); /** * 获取包中所有的元素， * @return 包含包中所有元素新数组。 * 注意，如果包为空，返回空数组 */ T[] toArray(); }
使用数组实现bag --- 创建ArrayBag<T>类来实现BagInterface<T>
首先考虑类的属性。既然决定用数组实现的，属性中肯定有一个数组的引用。除此之外，还要有个属性记录包中元素的个数，因为要判断包是否为空等。
private T[] bag; private int numberOfEntries; private static final int DEFAULT_CAPACITY = 25;
构造函数，初始化包。首先要创建数组对象，赋值给bag属性，因为属性中的bag只是一个数组的引用，并没有真正地创建数组。在Java中，创建数组需要指定长度。数组的长度。既也可以让使用者来决定，也可以提供一个默认容量，因此提供无参和有参两个构造函数。其次，初始化时，包中并没有元素，numberOfEntries初始化为0. 但怎么创建数组呢？假设构造函数接收一个参数capacity, bag = new T[capacity]; 不行。bag = new Object[capacity]; 还是不行。bag = (T[])new Object[capacity]; 倒是没有报错，但有warning(unchecked cast). 编译器想让你确保数组中的每一个元素从Object类强制转化成泛型T是安全的，由于数组刚刚创建，每一个元素都是null，因此转化是安全的，我们可以使用@SuppressWarnings("unchecked")告诉编译器忽略这个warning。@SuppressWarnings("unchecked")只能出现在方法定义或变量声明之前，由于bag = (T[])new Object[capacity]; 是赋值操作，不是变量声明，因为bag已经声明了，最终创建数组如下
// 强制类型转化是安全的，因为新数组中所有元素都是null @SuppressWarnings("unchecked") T[] tempBag = (T[])new Object[capacity]; // Unchecked cast bag = tempBag;
整个构造函数如下
/** * 创建一个空bag，初始空量为用户指定容量 * @param capacity 指定容量 */ public ArrayBag(int capacity) { // 强制类型转化是安全的，因为新数组中所有元素都是null @SuppressWarnings("unchecked") T[] tempBag = (T[]) new Object[capacity]; // Unchecked cast bag = tempBag; numberOfEntries = 0; } /** * 创建一个空bag，初始空量为默认容量25 */ public ArrayBag() { this(DEFAULT_CAPACITY); }
先实现add()方法，只有添加了元素，其它方法才好实现或测试。添加元素时，如果数组满了，肯定不能添加了，需要扩容(增加容量)，再添加。如果数组没有满，就可以继续添加。扩容后面再说，先看数组没有满的情况。添加元素，就是把要添加的元素直接放到数组中最后一个元素的后面，元素个数加1。刚开始时，数组为空，numberOfEntries为0，数组中没有元素，直接在0位置放置新元素，然后numberOfEntries + 1。再添加一个元素，那就要放到1的位置，numberOfEntries+1。再添加一个元素，那就要放到2的位置，numberOfEntries+1。
你会发现，新元素的放置位置就是bag[numberOfEntries]的位置，add()方法就是
public void add(T newEntry) { if(isArrayFull()){ } else { bag[numberOfEntries] = newEntry; numberOfEntries++; } }
isArrayFull()就是判断数组是不是满了，只要元素的个数等于数组的长度就是满了
private boolean isArrayFull() { return numberOfEntries == bag.length; }
添加方法实现完了，就要看看实现的对不对，添加的元素有没有添加成功。这就是ToArray() 方法了，创建一个新数组，把bag中的元素复制过去，然后把新数组返回
public T[] toArray() { @SuppressWarnings("unchecked") T[] result = (T[])new Object[numberOfEntries]; // Unchecked cast for (int index = 0; index < numberOfEntries; index++) { result[index] = bag[index]; } return result; }
添加和查看成功后，就要实现其它方法了。先从简单的开始，isEmpty()，包是否为空，直接判断numberOfEntries是否等于0就可以了。 getCurrentSize(), 包中元素的个数，直接返回numberofEntries。
public boolean isEmpty() { return numberOfEntries == 0; } public int getCurrentSize() { return numberOfEntries; }
getFrequencyOf(T anEntry)，一个元素在包中出现的次数。循环遍历数组就可以了，在遍历过程中，只要有元素和要查找的元素相等，计数器加1。遍历完成后，返回计数器。
public int getFrequencyOf(T anEntry) { int count = 0; for (int i = 0; i < numberOfEntries; i++) { if(anEntry.equals(bag[i])){ count++; } } return count; }
contains()方法，包中是否包含某个元素，还是循环遍历数组，只不过是返回true或false。可以先设一个表示找到找不到的变量found,默认是false，只有当fasle的时候，才遍历数组，在遍历过程中，如果找到了，设为true。如果遍历完，还没有找到，那还是false，直接返回found就可以了。
public boolean contains(T anEntry) { boolean found = false; int index = 0; while (!found && index < numberOfEntries){ if (anEntry.equals(bag[index])){ found = true; } index++; } return found; }
clear()方法，清空bag，简单一点的实现，就是numberOfEntries = 0;，复杂一点就是包不为空的时候，循环调用remove()方法
public void clear() { // numberOfEntries = 0; while (!isEmpty()){ remove(); } }
remove() 方法，删除任意一个元素，由于包中的元素没有顺序要求，可以随便删除，简单起见，就删除最后一个元素，当然，如果包为空的话，是不允许删除的，可以抛出错误。
public T remove() { if (isEmpty()) { throw new RuntimeException("空"); } T result = bag[numberOfEntries - 1]; bag[numberOfEntries - 1] = null; numberOfEntries--; return result; }
remove(anEntry)，删除一个给定的元素，首先要先查找这个元素，如果包中没有这个元素，也就没有办法删除，直接return false就好了。如果找到了，再想办法删除。查找，用的是循环遍历，找到了，也就是找到了这个元素所在的位置。
怎么删除呢？最先想到的是把后面的元素向前移，因为数组是连续的。
有点复杂。因为bag中的元素，并没有规定顺序，也就没有必要前移。可以让要删除的元素和最后一个元素，进行交换，直接删除最后一个元素就好了。
public boolean remove(T anEntry) { if(isEmpty()){ throw new RuntimeException("空"); } boolean found = false; int index = 0; while (!found && index < numberOfEntries){ if (anEntry.equals(bag[index])){ found = true; } else { index++; } } if(found){ bag[index] = bag[numberOfEntries - 1]; bag[numberOfEntries - 1] = null; numberOfEntries--; return true; } else { return false; } }
remove()和remove(T anEntry)代码有了重复，实现上remove() 就是remove(numberOfEntry-1), 这时可以写一个私有方法，删除给定index处的元素，它接受一个index参数，返回要删除的元素
private T removeEntry(int givenIndex){ if(isEmpty()){ throw new RuntimeException("空"); } T result = bag[givenIndex]; bag[givenIndex] = bag[numberOfEntries - 1]; bag[numberOfEntries - 1] = null; numberOfEntries--; return result; }
remove()方法简化成
public T remove() { return removeEntry(numberOfEntries - 1); }
再看remove(T anEntry), 里面查找定位元素的代码和contains()方法，也是重复的，也可以写一个私有方法getIndexOf来返回index。
private int getIndexOf(T anEntry) { int where = -1; boolean found = false; int index = 0; while (!found && (index < numberOfEntries)) { if (anEntry.equals(bag[index])) { found = true; where = index; } index++; } return where; }
contains()方法就变成了
public boolean contains(T anEntry) { return getIndexOf(anEntry) > -1; }
remove(T anEntry)变成了
public boolean remove(T anEntry) { int index = getIndexOf(anEntry); if(index > -1){ removeEntry(index); return true; } else { return false; } }
数组扩容的基本原理：假设有一个数组myArray，先让它赋值一个临时变量oldArray, 再创建一个新数组赋值给myArray， 最后把oldArray中的每一个元素都复制到myArray中。
扩容要注意是新生成的数组的大小。如果太小，就要经常扩容，也就是经常把元素从一个数组复制到另一个数组，浪费性能。通常来说，新的数组长度是旧的数组的2倍。比如有50个元素，添加51个元素的时候，扩容到100，剩下的49个元素添加，就不用扩容，抵消掉这个扩容的成本。expanding the array by m elements spreads the copying cost over m additions instead of just one. Doubling the size of an array each time it becomes full is a typical approach. When increasing the size of an array, you copy its entries to a larger array. You should expand the array sufficiently to reduce the impact of the cost of copying. A common practice is to double the size of the array.
private void resize(int newLength) { @SuppressWarnings("unchecked") T[] newArray = (T[]) new Object[newLength]; // Unchecked cast for (int index = 0; index < numberOfEntries; index++) { newArray[index] = bag[index]; } bag = newArray; }
add()方法变成了
public void add(T newEntry) { if (isArrayFull()) { resize(2 * bag.length); } bag[numberOfEntries] = newEntry; numberOfEntries++; }
remove方法需要缩容(减少容量)，如果把所有元素都删除了，剩下那么大空间也不合适。缩容和扩容的原理相似，只不过是创建的新数组比原数组要小。缩容的时机是，当删除的元素时，数组元素的个数是数组长度的1/4时，缩小一半的容量。removeEntry() 方法改成
private T removeEntry(int givenIndex){ if(isEmpty()){ throw new RuntimeException("空"); } T result = bag[givenIndex]; bag[givenIndex] = bag[numberOfEntries - 1]; bag[numberOfEntries - 1] = null; numberOfEntries--; if(numberOfEntries > 0 && numberOfEntries == bag.length / 4){ resize(bag.length / 2); } return result; }
使用链表实现bag --- 创建LinkedListBag<T>类来实现BagInterface<T>
还是先考虑类的属性。链表是由节点组成，节点中的数据域可以存放包中的元素
需要创建一个私有内部类Node
private class Node { T data; Node next; Node(T dataPortion) { data = dataPortion; next = null; } }
操作链表需要头指针，它指向链表中的第一个节点，还需要一个变量来记录包中元素的个数。
private Node firstNode; private int numberOfEntries;
add(T newEntry) 方法，既然包中的元素没有顺序，而在链表的头部插入节点，又比较简单，那add(T newEntry) 就定义为从头部插入节点。刚开始，链表为空，插入节点，就是创建新节点，并赋值给头指针
Node newNode = new Node(newEntry); firstNode = newNode;
当链表不为空时，头部插入节点，就是，创建新节点，新节点的next指向链表中的第一个节点(firstNode)，再让新节点成为链表中的第一个节点(新节点赋值给firstNode)
Node newNode = new Node(newEntry); newNode.next = firstNode; firstNode = newNode; // New node is at beginning of chain
实际上，向一个空链表中插入节点，和向一个非空链表头部插入节点是一样的。向空链表中插入节点时，如果加入newNode.next = firstNode，也没有问题，因为此时firstNode为null，而newNode的next本来也是null。所以add()方法的完整实现
public void add(T newEntry) { Node newNode = new Node(newEntry); newNode.next = firstNode; firstNode = newNode; numberOfEntries++; }
toArray()方法，需要遍历链表，把链表中的每一个节点中的数据放到数组中。怎么遍历呢？firstNode指向链表中的第一个节点，第一个节点又包含第二个节点的引用，第二个节点又包含第三个节点的引用，因此需要一个变量来顺序地引用每一节点，到达每一个节点时， .data就可以获取节点中的数据。刚开始的时候，变量引用第一个节点，把firstNode赋值给这个变量，假设变量是currrentNode, 那么currentNode = firstNode. currentNode.data就可以获取到数据。currentNode= currentNode.next, currentNode指向第二个节点，currentNode.data获取数据。currentNode = currentNode.next，第三个节点，一直到最后一个节点currentNode为null。
public T[] toArray() { @SuppressWarnings("unchecked") T[] array = (T[]) new Object[numberOfEntries]; Node current = firstNode; int index = 0; while (current != null){ array[index] = current.data; index++; current = current.next; } return array; }
getFrequencyOf(), 像toArray()一样，遍历链表，只不过获取到数据后，要做的是判断是否相等。
public int getFrequencyOf(T anEntry) { int frequency = 0; Node currentNode = firstNode; while (currentNode != null) { if (anEntry.equals(currentNode.data)) frequency++; currentNode = currentNode.next; } return frequency; }
contains() 还是遍历链表
public boolean contains(T anEntry){ boolean found = false; Node currentNode = firstNode; while (!found && (currentNode != null)) { if (anEntry.equals(currentNode.data)) found = true; else currentNode = currentNode.next; } return found; }
remove(), 因为包中的元素顺序没有要求，所以删除第一个元素就好了，简单
public T remove() { T result = null; if (firstNode != null) { result = firstNode.data; firstNode = firstNode.next; numberOfEntries--; } return result; }
remove(T anEntry), 遍历链表，找到元素，然后和第一个节点进行交换，删除第一个节点
private Node getReferenceTo(T anEntry) { boolean found = false; Node currentNode = firstNode; while (!found && (currentNode != null)) { if (anEntry.equals(currentNode.data)) found = true; else currentNode = currentNode.next; } return currentNode; } public boolean remove(T anEntry) { boolean result = false; Node nodeN = getReferenceTo(anEntry); if (nodeN != null) { nodeN.data = firstNode.data; firstNode = firstNode.next; numberOfEntries--; result = true; } return result; }
clear()方法，直接让firstNode = null就好了
public void clear() { firstNode = null; }
迭代方法，就要实现Iterable<T>接口，实现Iterable<T>接口，就要提供一个iterator方法，这个方法要返回Iterator<T>接口类型的对象，有对象就要创建一个类来这个Iterator<T>接口，它有两个方法，一个是hasNext()，表示，还有迭代对象中还没有元素，next()方法，返回每一次迭代的元素。
import java.util.Iterator; public class LinkedListBag<T> implements BagInterface<T>, Iterable<T> { public Iterator<T> iterator() { return new ListIterator(); } private class ListIterator implements Iterator<T> { private Node current = firstNode; public boolean hasNext() { return current != null; } public T next() { T item = current.data; current = current.next; return item; } } }