是否有可能减少这两种方法之间的冗余？

Question

在我的代码中，我有两种方法，public LetterInventory add和public LetterInventory subtract。 add方法构造一个新的LetterInventory对象，该对象表示此字母清单和另一个给定清单的总和（每个字母的计数加在一起）。减法方法构造并返回一个新的LetterInventory对象，该对象表示从此库存中减去其他库存的结果（从该对象的计数中减去其他库存中的计数）

public class LetterInventory {
    private int size;
    private int[] elementData;

    public static final int ALPHABETS = 26;

    // post: constructs an inventory(elementData) for the letters in a given string
    //       and counts the number of times each letter occurred and then puts them
    //       in inventory and then increases the size
    //       upper case is same as lower in the inventory
    public LetterInventory(String data) {
        elementData = new int[ALPHABETS];
        data = data.toLowerCase();
        for (int i = 0; i < data.length(); i++) {
            if (Character.isLetter(data.charAt(i))) {
                size++;
                elementData[data.charAt(i) - 'a']++;
            }
        }
    }

    // pre: throws IllegalArgumentException if letters are not alphabets
    // post: returns the count stored in inventory
    public int get(char letter) {
        if (!Character.isLetter(letter)) {
            throw new IllegalArgumentException();
        }
        letter = Character.toLowerCase(letter);
        return elementData[letter - 'a'];
    }

    // pre: throws IllegalArgumentException if letters are not alphabets
    //      and positive or 0
    // post: sets the value in inventory
    public void set(char letter, int value) {
        if (!Character.isLetter(letter) || value < 0) {
            throw new IllegalArgumentException();
        }
        letter = Character.toLowerCase(letter);
        size -= elementData[letter - 'a'];
        elementData[letter - 'a'] = value;
        size += value;
    }

    // post: returns the size of inventory
    //       size -> sum of character counts
    public int size() {
        return size;
    }

    // post: returns true if inventory is Empty
    //       returns false if inventory is not Empty
    public boolean isEmpty() {
        return size == 0;
    }

    // post: returns an alphabetically organized version of the
    //       inventory with brackets
    public String toString() {
        String result = "[";
        for (int i = 0; i < ALPHABETS; i++) {
            for (int j = 0; j < elementData[i]; j++) {
                result += (char) (i + 'a');
            }
        }
        return result + "]";
    }

    // Pre:  Accepts LetterInventory 'other' as parameter
    // Post: Returns new LetterInventory object with counts of each letter
    //       equal to the sum of counts of each letter in 'other' and the
    //       counts of each letter in current LetterInventory object
    public LetterInventory add(LetterInventory other) {
        LetterInventory sum = new LetterInventory("");
        for (int i = 0; i < ALPHABETS; i++) {
            char ch = (char) ('a' + i);
            int value = elementData[i] - other.get(ch);
            sum.set(ch, value);
        }
        return sum;
    }

    // Pre:  Accepts LetterInventory 'other' as parameter
    // Post: Returns new LetterInventory object with counts of each letter
    //       equal to the difference of counts of each letter in 'other' and the
    //       counts of each letter in current LetterInventory object
    //       null if the difference is negative
    public LetterInventory subtract(LetterInventory other) {
        LetterInventory diff = new LetterInventory("");
        for (int i = 0; i < ALPHABETS; i++) {
            char ch = (char) ('a' + i);
            int value = elementData[i] - other.get(ch);
            if (value < 0) {
                return null;
            }
            diff.set(ch, value);
        }
        return diff;
    }
}

我在两种方法中都重复使用此代码块

for (int i = 0; i < ALPHABETS; i++) {
       char ch = (char) ('a' + i);
       int value = elementData[i] - other.get(ch);

并且想知道是否有可能在我的代码中解决此冗余问题。

Answer 1

是的，您可以使用Map <>而不是在那里进行的所有转换。

private Map<Character, Integer> inventory = new HashMap<>();

public int getLetterValue(char letter) {
    return inventory.get(letter) == null ? 0 : inventory.get(letter);
}

public void incrementLetterValue(char letter, int value) {
    int currentValue = getLetterValue(letter);
    inventory.put(letter, currentValue + value);
}

public void subtractLetterValue(char letter, int value) {
    if (inventory.get(letter) == null)
        return;

    int currentValue = getLetterValue(letter);
    int subtractedValue = currentValue - value;

    inventory.put(letter, Math.max(subtractedValue, 0));
}


public void addLetter(char letter) {
    int currentLetterCount = getLetterValue(letter);
    inventory.put(letter, currentLetterCount + 1);
}

public void addInventory(LetterInventory letterInventory) {
    Map<Character, Integer> additionalInventory = letterInventory.getInventory();

    additionalInventory.forEach((letter, value) -> {
        this.incrementLetterValue(letter, value);
    });
}

public void subtractInventory(LetterInventory letterInventory) {
    Map<Character, Integer> additionalInventory = letterInventory.getInventory();

    additionalInventory.forEach((letter, value) -> {
        this.subtractLetterValue(letter, value);
    });
}

public Map<Character, Integer> getInventory() {
    return this.inventory;
}
}

当然，如果需要使其不区分大小写，则可以使用Java中的Character.toLowerCase()方法。附言：这不是代码的最终版本。您可以进行一些更改以使外观更加干净。