第二章 使用数组实现袋子

第二章 使用数组实现袋子

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的时候，数组不会满。

数组实现袋子的优缺点

优点：

1. 向袋子中增加一个物品的过程是很快的， 在数组末尾删除和添加物品非常简单快速，因为我们知道数组末尾的索引。
2. 删除非特定物品也很快。
3. 删除数组中间的特点物品，未了避免在数组中产生缺口，采取数组中最后一个物品替换被删除物品的策略。
4. 允许直接访问元素，只要知道索引即可。
5. 固定大小的数组限制袋子容量。
6. 可变大小的数组，需要复制物品到新的数组中，复制的都是数组物品的引用，并没有占据太多空间，也没有花费太多时间在移动上。

缺点：

1. 删除一个特点物品需要时间来定位该物品
2. 增加数组的大小需要时间来复制它的物品（的引用）。

转载于:https://www.cnblogs.com/junlin7/p/8318991.html