java中的享元设计模式，目的是什么？

Question

I have the following code:

public class Sentence {

    private String [] words;
    private Map<Integer, WordToken> tokens = new HashMap<>();

    public Sentence(String plainText) {
        words = plainText.split(" ");
    }

    public WordToken getWord(int index) {
        WordToken wt = new WordToken();
        tokens.put(index, wt);
        return tokens.get(index);
    }

    @Override
    public String toString() {
        List<String> ws = new ArrayList<>();
        for (int i = 0; i < words.length; ++i) {
            String w = words[i];
            if (tokens.containsKey(i) && tokens.get(i).capitalize) {
                w = w.toUpperCase();
            }
            ws.add(w);
        }
        return String.join(" ", ws);
    }
}

and test:

@Test
public void test() {
    Sentence s = new Sentence("alpha beta gamma");
    s.getWord(1).capitalize = true;
    assertEquals("alpha BETA gamma", s.toString());
}

My question is: what is the purpose of use flyweight pattern in that way?

Answer 1

The Flyweight Pattern is a re-use pattern that reduces the memory footprint of a program by re-using identical objects. This is common with value objects , which represent simple values, such as words, since words with the same characters are identical. For example, suppose we have the following sentence (ignore capitalization for now):

the doorman held the door for the guest

This sentence has 39 characters, which means that if we created a String from this sentence, we would need to store 39 characters (ignore the length field used by the Java String implementation for now). If we look at the sentence, there are 3 instances of the , which are identical to one another. There are also 7 spaces, which are identical to one another. If we tokenized the string, we would obtain the following words:

["the", "doorman", "held", "the", "door", "for", "the", "guest"]

If we take only the unique values in this list, we obtain:

["the", "doorman", "held", "door", "for", "guest"]

Using these unique words, we could create the sentence by mapping the indexes of the word in the sentence to the unique words:

[0, 1, 2, 0, 3, 4, 0, 5]

To reconstruct the sentence, we would simple map the indices above to the list of unique words, adding a space between each of the words.

In the case of the example you provided, it appears that the algorithm is incorrect (it does not save any space, since it stores both the words and the tokens). A more correct solution (one of many) would resemble):

public class Sentence {

    private final List<Integer> wordMap = new ArrayList<>();
    private final List<String> words = new ArrayList<>();

    public Sentence(String sentence) {
        for (String word: sentence.split(" ")) {
            addIfNotExists(word);
            wordMap.add(words.indexOf(word));
        }
    }

    private void addIfNotExists(String word) {

        if (!words.contains(word)) {
            words.add(word);
        }
    }

    public List<Integer> getWordMap() {
        return wordMap;
    }

    public List<String> getWords() {
        return words;
    }

    public static void main(String[] args) {
        Sentence s = new Sentence("the doorman held the door for the guest");
        System.out.println(s.getWordMap());
        System.out.println(s.getWords());
    }
}

Running this results in the following output:

[0, 1, 2, 0, 3, 4, 0, 5]
[the, doorman, held, door, for, guest]

I left it to you to implement the toString method.