第28，29，39，40，44行相对应带上大括号会更好
第39，40，44行属于一行表示多重行为，不便于观察和理解，换行会更好
第28，31，36，42，47行的代码与前面的代码没有很好的分块，构成不了视觉上面清晰的代码块，在前面加上空行会更好
第35行命名不够清晰，修改为Map<Character, Character> charMapping = new HashMap<>();
第29行，就像前面 @背着吉他的大漠狼 同学说的，if 里面的 match 函数其实表示的意义不太明确，读者需要去看 match 函数的大致实现，如果在此之前定义一个boolean isMatched = match(word, pattern); 再将 isMatched 放到 if 里面会好很多；而且把函数直接放在 if 语句里面其实也违反了我们之前提到的单行单一行为的原则，因为运行函数返回结果和表达式条件判断在概念上本就是两个完全不同的行为

能看到的就这些了，不足之处还请老师和大神们补充

```
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

class Solution {
    /**
     * Return a list of the words in words that match the given pattern.
     *
     * A word matches the pattern if there exists a permutation of
     * letters p so that after replacing every letter x in the pattern
     * with p(x), we get the desired word.
     *
     * Example:
     * Input: words = ["abc","deq","mee","aqq","dkd","ccc"],
     * pattern = "abb"
     * Output: ["mee","aqq"]
     *
     * Explanation: "mee" matches the pattern because there is
     * a permutation {a -> m, b -> e, ...}.
     *
     * "ccc" does not match the pattern because
     * {a -> c, b -> c, ...} is not a permutation, since a
     * and b map to the same letter.
     */
    public List<String> findAndReplacePattern(String[] words, String pattern) {
        List<String> ans = new ArrayList();
        for (String word : words) {
            if (match(word, pattern)) {
                ans.add(word);
            }
        }
        return ans;
    }

    public boolean match(String word, String pattern) {
        Map<Character, Character> M = new HashMap();
        for (int i = 0; i < word.length(); ++i) {
            char w = word.charAt(i);
            char p = pattern.charAt(i);
            if (!M.containsKey(w)) {
                M.put(w, p);
            }
            if (M.get(w) != p) {
                return false;
            }
        }
        boolean[] seen = new boolean[26];
        for (char p : M.values()) {
            if (seen[p - 'a']) {
                return false;
            }
            seen[p - 'a'] = true;
        }
        return true;
    }
}
```
改成我喜欢的格式,虽然不一定准确,但是自己看上去舒服很多

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

class Solution {

    private static final char CHAR_VALUE = 'a';
    
    
    /**
     * Return a list of the words in words that match the given pattern.
     *
     * A word matches the pattern if there exists a permutation of
     * letters p so that after replacing every letter x in the pattern
     * with p(x), we get the desired word.
     *
     * Example:
     * Input: words = ["abc","deq","mee","aqq","dkd","ccc"],
     * pattern = "abb"
     * Output: ["mee","aqq"]
     *
     * Explanation: "mee" matches the pattern because there is
     * a permutation {a -> m, b -> e, ...}.
     *
     * "ccc" does not match the pattern because
     * {a -> c, b -> c, ...} is not a permutation, since a
     * and b map to the same letter.
     */
    public List<String> findAndReplacePattern(String[] words, String pattern) {
        List<String> result = new ArrayList();
        
        for (String word: words)
        {
         if (match(word, pattern))
            {
            
             result.add(word);
            }
                
        }
            
        return result;
    }

    public boolean match(String word, String pattern) {
        Map<Character, Character> map = new HashMap();
        
        for (int i = 0; i < word.length(); ++i) {
        
            char wordChar = word.charAt(i);
            char patternChar = pattern.charAt(i);
            
            if (!map.containsKey(w))
            {
             map.put(wordChar, patternChar);
            }
            if (map.get(wordChar) != patternChar)
            {
             return false;
            }
            
        }
        
        boolean[] seen = new boolean[26];
        
        for (char charPattern: map.values()) {
            
            if (seen[charPattern - CHAR_VALUE])
            {
                return false;
            }
            
            seen[charPattern - CHAR_VALUE] = true;
        }
        
        return true;
    }
}