第二章 使用数组实现袋子
1.使用固定大小的数组实现ADT袋子
一组核心方法
核心方法：对实现类的意图是极为重要的，且允许合理的测试，也成为核心组。
- 构造函数
- public boolean add(T anEntity)
- public T[] toArray()
- public boolean isFull()
核心方法的实现
数据域：定义任何方法前，要考虑类的数据域。
private final T[] bag;//袋子用来容纳对象的数组
private static final int DEFAULT_CAPACITY=25;//默认数组大小
private int numberOfEntries;//跟踪袋子中物品当前物品的数量
将数据域加入到UML中
第一个改成：-bag:T []
构造函数：
public ArrayBag() {
this(DEFAULT_CAPACITY);
}
public ArrayBag(int capacity) {
numberOfEntires = 0;
T[] tempBag = (T[]) new Object[capacity];
bag = tempBag;
}
方法add
public boolean add(T newEntity) {
boolean result = true;
if (isFull()) {
result = false;
} else {
bag[numberOfEntires] = newEntity;
numberOfEntires++;
}
return result;
}
方法isFull
public boolean isFull() {
return numberOfEntires == bag.length;
}
方法toArray
方法toArray不能返回bag本身，返回bag本身，就给了客户直接访问私有数据的权利。类不应该返回私有的数组数据域的引用。
public T[] toArray() {
T[] result = (T[]) new Object[numberOfEntires];
for (int index = 0; index < numberOfEntires; index++) {
result[index] = bag[index];
}
return result;
}
更多方法的实现
（1）方法isEmpty和getCurrentSize
public boolean isEmpty() {
return numberOfEntires==0;
}
public Integer getCurrentSize() {
return numberOfEntires;
}
（2）方法getFrequencyOf public Integer getFrequencyOf(T anEntity) { int counter = 0; for (int i = 0; i < numberOfEntires; i++) { if (bag[i].equals(anEntity)) { counter++; } } return counter; }
（2）方法Contains
public boolean contains(T anEntity) {
boolean flag = false;
for (int i = 0; i < numberOfEntires; i++) {
if (bag[i].equals(anEntity)) {
flag = true;
break;
}
}
return flag;
}
删除物品的方法
（1）方法clear
public void clear() {
// 调用remove方法，不断删除，知道为空
while (!isEmpty()) {
remove();
}
}
（2）删除一个未特别指定的物品
首先，保证删除前袋子不为空；其次，从后往前删除比较简单； 步骤：访问该物品，以便返回它 设置该物品的数组元素为null； numberOfEntires值减一。
public T remove() {
T result = null;
if (numberOfEntires > 0) {
result = bag[numberOfEntires - 1];
bag[numberOfEntires - 1] = null;
numberOfEntires--;
}
return result;
}
（3）删除一个给定的物品
当该物品出现多次，只删除第一次出现。只需bag[inex]=null;但是，这样会在数组中产生缺口，袋子内容不再位于连续的数组位置上面，可以通过把后面的元素都往前移动一位来解决，但是耗时。我们不用维护袋子中物品在数组中的位置，所以可以用数组最后一个物品来替换将要移除的物品，然后把数组中最后一个物品删除。
public boolean remove(T anEntity) {
boolean flag = false;// 未删除
for (int i = 0; i < numberOfEntires; i++) {
if (anEntity.equals(bag[i])) {
bag[i] = bag[numberOfEntires - 1];
bag[numberOfEntires - 1] = null;
numberOfEntires--;
flag = true;
break;
}
}
return flag;
}
（4）避免重复劳动
私有方法，供两个remove方法调用
private T remove(int givenIndex) {
T result = null;
if (!isEmpty() && givenIndex >= 0) {
result = bag[givenIndex];
numberOfEntires--;
bag[givenIndex] = bag[numberOfEntires];
bag[numberOfEntires] = null;
}
return result;
}
私有方法，getIndexOf
private int getIndexOf(T anEntity) {
int where = -1;
boolean found = false;
for (int i = 0; !found && i < numberOfEntires; i++) {
if (anEntity.equals(bag[i])) {
found = true;
where = i;
}
}
return where;
}
修改后remove
public T remove() {
T result = remove(numberOfEntires - 1);
return result;
}
修改后remove(T anEntity)
public boolean remove(T anEntity) {
int index = getIndexOf(anEntity);
T result = remove(index);
return anEntity.equals(result);
}
2.使用可变大小的数组实现ADT袋子
固定大小的数组实现ADT袋子，会限制袋子大小。当数组满了的时候，isFull返回true，add方法返回false。一些应用可以使用这样容量有限的袋子或者集合，而另一些应用，集合的大小需要无限增长。
详细过程
假定有一个myArray引用的数组，首先定义oldArray，oldArray引用myArray，创建比myArray大一倍的新数组，让myArray引用此新数组，然后把oldArray内容复制到myArray中，然后oldArray=null。
代码 可以用myArray=Arrays.copyOf(myArray,2*myArray.length)
袋子的一种新的实现
确保add的时候，数组不会满。
数组实现袋子的优缺点
优点：
- 向袋子中增加一个物品的过程是很快的， 在数组末尾删除和添加物品非常简单快速，因为我们知道数组末尾的索引。
- 删除非特定物品也很快。
- 删除数组中间的特点物品，未了避免在数组中产生缺口，采取数组中最后一个物品替换被删除物品的策略。
- 允许直接访问元素，只要知道索引即可。
- 固定大小的数组限制袋子容量。
- 可变大小的数组，需要复制物品到新的数组中，复制的都是数组物品的引用，并没有占据太多空间，也没有花费太多时间在移动上。
缺点：
- 删除一个特点物品需要时间来定位该物品
- 增加数组的大小需要时间来复制它的物品（的引用）。