Vì vậy, tôi gặp khó khăn trong việc hình thành câu trả lời cho câu hỏi sau đây. Tôi không tìm kiếm câu trả lời mà thay vào đó là những bước hữu ích mà tôi có thể thực hiện để cho phép tôi tự tìm ra câu trả lời. Lưu ý: Để trả lời những câu hỏi này, tôi đã lấy lớp tham chiếu và trình điều khiển. Câu hỏi như sau:

Q.1 Triển khai phương thức thay thế gói ADT bằng một đối tượng nhất định.

Q.2.Viết phương thức xóa để xóa từng phiên bản của một phần tử trong ArrayBag.

Câu hỏi 3. Cho ít nhất hai ví dụ về trường hợp gói cố định và hai ví dụ về trường hợp gói có thể thay đổi kích thước.

Đoạn mã sau là những gì tôi đã bắt đầu, nhưng không chắc liệu tôi có đi đúng hướng hay không:

a.1 công khai T thay thế(T theItem) {
    Trình tạo ngẫu nhiên = Random mới();
    int RandomPosition = Generator.nextInt(numberOfEntries);

    Kết quả T = null;

    if (!isEmpty() && (randomPosition >= 0)) {
        result = bag[randomPosition]; // Mục nhập cần xóa
        bag[randomPosition] = theItem; // Thay thế mục cần xóa bằng
                                // mục nhập cuối cùng

    }
    return result;
 a.2 public void clear(T theItem) {
    trong khi (!this.isEmpty(ArrayBag))
        this.remove();

 a.3 không chắc nó có liên quan đến các ví dụ mã hóa hay cái gì khác không.

Ngoài ra, lớp ArrayBag như sau để tham khảo:

import java.util.Arrays;
nhập java.util.Random;

lớp cuối cùng công khai ArrayBag triển khai BagInterface {
túi T[] cuối cùng riêng tư;
số int riêngOfEntries;
boolean riêng được khởi tạo = false;
int tĩnh cuối cùng DEFAULT_CAPACITY = 25;
int tĩnh cuối cùng MAX_CAPACITY = 10000;

/** Tạo một túi trống có sức chứa ban đầu là 25. */
công khai ArrayBag() {
    cái này(DEFAULT_CAPACITY);
} // kết thúc hàm tạo mặc định

/**
 * Tạo một túi rỗng có sức chứa nhất định.
 * 
 * @param mong muốn Năng lực
 * Dung lượng số nguyên mong muốn.
 */
công khai ArrayBag(int mong muốnCapacity) {
    if (desiredCapacity <= MAX_CAPACITY) {
        // Việc truyền diễn viên an toàn vì mảng mới chứa các mục rỗng
        @SuppressWarnings("không được chọn")
        T[] tempBag = (T[]) new Object[desiredCapacity]; // Bỏ chọn cast
        túi = tempBag;
        numberOfEntries = 0;
        khởi tạo = đúng;
    } else
        ném IllegalStateException mới ("Cố gắng tạo túi"
                + “có dung lượng vượt quá” + “tối đa cho phép.”);
  } // hàm tạo kết thúc

  /**
   * Thêm một mục mới vào túi này.
   * 
   * @param newEntry
  * Đối tượng được thêm vào dưới dạng mục mới.
  * @return Đúng nếu phép cộng thành công hoặc sai nếu không.
 */
  bổ sung boolean công khai (T newEntry) {
    checkInitialization();
    kết quả boolean = đúng;
    nếu (isArrayFull()) {
        kết quả = sai;
    } else { // Khẳng định: kết quả ở đây là đúng
        túi[numberOfEntries] = newEntry;
        numberOfEntries++;
    } // kết thúc nếu

    return result;
  } // kết thúc thêm

 /**
 * Truy xuất tất cả các mục có trong túi này.
 * 
 * @return Một mảng mới được phân bổ của tất cả các mục trong túi này.
 */
công khai T[] toArray() {
    checkInitialization();

    // Việc truyền diễn viên an toàn vì mảng mới chứa các mục rỗng.
    @SuppressWarnings("không được chọn")
    T[] result = (T[]) new Object[numberOfEntries]; // Bỏ chọn cast

    for (int chỉ mục = 0; chỉ số < numberOfEntries; chỉ mục++) {
        kết quả[chỉ mục] = túi[chỉ mục];
    } // kết thúc cho

    return result;
    // Lưu ý: Phần thân của phương thức này có thể bao gồm một câu lệnh return,
    // nếu bạn gọi Arrays.copyOf
} // kết thúc mảng

/**
 * Xem túi này có trống không.
 * 
 * @return Đúng nếu túi này trống hoặc sai nếu không.
 */
boolean công khai isEmpty() {
    trả về sốOfEntries == 0;
} // kết thúc làEmpty

/**
 * Lấy số mục hiện tại trong túi này.
 * 
 * @return Số nguyên các mục hiện có trong túi này.
 */
int công khai getCurrentSize() {
    trả về sốOfEntries;
} // kết thúc getCurrentSize

/**
 * Đếm số lần một mục nhất định xuất hiện trong túi này.
 * 
 * @param anEntry
 * Mục nhập được tính.
 * @return Số lần anEntry xuất hiện trong ba này.
 */
public int getFrequencyOf(T anEntry) {
    checkInitialization();
    bộ đếm int = 0;

    for (int chỉ mục = 0; chỉ số < numberOfEntries; chỉ mục++) {
        if (anEntry.equals(bag[index])) {
            bộ đếm++;
        } // kết thúc nếu
    } // kết thúc cho

    bộ đếm trở lại;
} // kết thúc getFrequencyOf

/**
 * Kiểm tra xem túi này có chứa một mục nhất định hay không.
 * 
 * @param anEntry
 * Mục để xác định vị trí.
 * @return Đúng nếu túi này chứa một Mục nhập, hoặc sai nếu ngược lại.
 */
boolean công khai chứa(T anEntry) {
    checkInitialization();
    trả về getIndexOf(anEntry) > -1; // hoặc >= 0
} // cuối chứa

/** Xóa tất cả mục từ túi này */
khoảng trống công khai rõ ràng () {
    trong khi (!this.isEmpty())
        this.remove();
} // kết thúc rõ ràng

/**
 * Loại bỏ một mục không xác định khỏi túi này, nếu có thể.
 * 
 * @return Hoặc là mục đã bị xóa, nếu việc xóa thành công hoặc không có giá trị.
 */
công khai T xóa() {
    checkInitialization();
    Kết quả T = RemoveEntry(numberOfEntries - 1);
    return result;
} // kết thúc xóa

/**
 * Loại bỏ một lần xuất hiện của một mục nhất định khỏi túi này.
 * 
 * @param anEntry
 * Mục cần xóa.
 * @return Đúng nếu xóa thành công hoặc sai nếu không.
 */
loại bỏ boolean công khai(T anEntry) {
    checkInitialization();
    int chỉ mục = getIndexOf(anEntry);
    Kết quả T = RemoveEntry(index);
    trả về anEntry.equals(kết quả);
} // kết thúc xóa

boolean công khai RemoveRandom() {
    Trình tạo ngẫu nhiên = Random mới();
    int RandomPosition = Generator.nextInt(numberOfEntries);
    Kết quả T = RemoveEntry(randomPosition);
    nếu (kết quả == null) {
        trả về sai;
    } khác {
        trả về đúng sự thật;
    }

}

@Ghi đè
boolean công khai bằng(Object obj) {
    if (obj instanceof ArrayBag) {
        ArrayBag otherArrayBag = (ArrayBag) obj;

        if (numberOfEntries == otherArrayBag.numberOfEntries) {

            // Tôi tạo các mảng mới để có thể thao tác với chúng
            // và nó sẽ không thay đổi this.bag hoặc otherArrayBag.bag
            T[] currentBagTempArray = toArray();
            T[] otherBagTempArray = otherArrayBag.toArray();

            Arrays.sort(currentBagTempArray);
            Arrays.sort(otherBagTempArray);

            for (int i = 0; i < numberOfEntries; i++) {
                if (!currentBagTempArray[i].equals(otherBagTempArray[i])) {
                    trả về sai;
                }
            }
            trả về đúng sự thật;
        } khác {
            trả về sai;
        }

    } khác {
        trả về sai;
    }
}

công khai ResizableArrayBag createResizableArray() {
    T[] currentBagContents = toArray();
    ResizableArrayBag newBag = new ResizableArrayBag(currentBagContents);
    trả lại Túi mới;
}

// Trả về true nếu túi mảng đầy hoặc sai nếu không.
boolean riêng tư isArrayFull() {
    return numberOfEntries >= bag.length;
} // kết thúc isArrayFull

// Xác định vị trí một mục nhất định trong túi mảng.
// Trả về chỉ mục của mục nhập, nếu được tìm thấy,
// hoặc -1 nếu không.
// Điều kiện tiên quyết: checkInitialization đã được gọi.
int riêng tư getIndexOf(T anEntry) {
    int trong đó = -1;
    tìm thấy boolean = sai;
    chỉ số int = 0;

    while (!found && (index < numberOfEntries)) {
        if (anEntry.equals(bag[index])) {
            tìm thấy = đúng;
            ở đâu = chỉ mục;
        } // kết thúc nếu
        chỉ mục++;
    } // kết thúc trong khi

    // Khẳng định: Nếu ở đâu > -1, một Entry nằm trong túi mảng và nó
    // bằng bag[where]; nếu không thì anEntry không có trong mảng.

    trở về đâu;
} // kết thúc getIndexOf

// Loại bỏ và trả về mục nhập tại một chỉ mục nhất định trong mảng.
// Nếu không có mục nào như vậy tồn tại, trả về null.
// Điều kiện tiên quyết: 0 <= GivenIndex < numberOfEntries.
// Điều kiện tiên quyết: checkInitialization đã được gọi.
riêng tư T RemoveEntry(int GivenIndex) {
    Kết quả T = null;

    if (!isEmpty() && (givenIndex >= 0)) {
        result = bag[givenIndex]; // Mục nhập cần xóa
        int LastIndex = numberOfEntries - 1;
        bag[givenIndex] = bag[lastIndex] // Thay thế mục cần xóa bằng
                                            // mục nhập cuối cùng
        bag[lastIndex] = null // Xóa tham chiếu đến mục cuối cùng
        numberOfEntries--;
    } // kết thúc nếu

    return result;
} // kết thúc RemoveEntry

// Ném ra một ngoại lệ nếu đối tượng này không được khởi tạo.
kiểm tra khoảng trống riêng tưInitialization() {
    nếu (!khởi tạo)
        ném ngoại lệ bảo mật mới (
                "Đối tượng ArrayBag không được khởi tạo đúng cách.");
} // kết thúc kiểm tra Khởi tạo

}//Kết thúc ArrayBag

câu trả lời hay nhất

Những người khác đang ở đó Triển khai lớp túi trong Java/Sử dụng mảng Túi được triển khai bằng cách sử dụng một mảng ở đây. Tôi chỉ xem mã, vì vậy nó có thể là một túi hỗn hợp.

Tôi giả sử rằng Túi giống như Bộ, ngoại trừ việc có thể lưu trữ cùng một đối tượng nhiều lần. Bạn có thể muốn triển khai một số loại bộ sưu tập riêng tư (có thể là một mảng như trên). chúng tôi gọi nó túi của tôi. Vì bạn đang sử dụng loại chung T,Túi của bạn sẽ chỉ chứa loại T sự vật.

Đối với Q1, phương thức thay thế() của bạn có thể cần lấy hai tham số: đối tượng được thay thế (ví dụ: tìm tôi) và đối tượng bạn muốn thay thế (ví dụ: thay thế). Nếu Túi của bạn có thể chứa các bản sao, bạn có thể muốn thay thế đối tượng phù hợp đầu tiên. Thay vì sử dụng Random(), bạn có thể muốn duyệt qua từng phần tử myBag và thay thế phần tử tìm thấy bằng phần tử bạn muốn thay thế. nếu không tìm thấy tìm tôi, bạn có thể muốn đưa ra một lỗi. Vì vậy, việc khai báo phương thức có thể trông như thế này:

thay thế boolean công khai(T findMe, T thay thế)

nếu tìm thấy tìm tôi Nó trả về true, ngược lại nó trả về false.

Đối với Q2, bạn có thể tạo vòng lặp while để xóa phần tử đầu tiên trong myBag khi kích thước của myBag > 0.

Đối với Q3, không có mã hóa nào liên quan. Đây là một câu hỏi để suy nghĩ. Nhìn chung, một chiếc túi có kích thước cố định sẽ rất hữu ích nếu bạn biết ngay từ đầu rằng kích thước đó sẽ không thay đổi.

Các gói có thể thay đổi kích thước sẽ có ý nghĩa hơn trong nhiều trường hợp khi bạn không biết kích thước ngay từ đầu và rất có thể nó sẽ thu nhỏ hoặc tăng lên, chẳng hạn như danh sách chờ cho một lớp học.

Về java - loại bỏ và thay thế phương thức java, chúng tôi tìm thấy một câu hỏi tương tự trên Stack Overflow: https://stackoverflow.com/questions/28353351/