非独立思考
    常规思路：

    1. 由于互为字母异位词的两个字符串包含的字母相同，因此对两个字符串分别进行排序之后得到的字符串一定是相同的，故可以将排序之后的字符串作为哈希表的键。
    2. 由于互为字母异位词的两个字符串包含的字母相同，因此两个字符串中的相同字母出现的次数一定是相同的，故可以将每个字母出现的次数使用字符串表示，作为哈希表的键。

    3. getOrDefault() 方法获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值。

      1. class Solution {
      2.      public static List<List<String>> groupAnagrams(String[] strs) {
      3.      // 因为既有存值，也有查询。所以用Map会好一些
      4.      // 很多题目可能会有溢出一些问题，在对数据本身没有要求时可以尝试使用高精度型
      5.      Map<Double, ArrayList<String>> resMap = new HashMap<>(16);
      6.      Map<Character, Integer> chaMap = new HashMap<>(16);
      7.      List<Integer> list = has26Prime();
      8.      char ch = 'a';
      9.      for (Integer val : list) {
      10.          // 存入26个字母对应的值
      11.          chaMap.put(ch, val);
      12.          ch++;
      13.      }
      14.      for (String str : strs) {
      15.          // 针对每个str,我们再循环去获取他们的乘积
      16.          // 先获取乘积，再比较map
      17.          double sum = 1;
      18.          for (int i = 0; i < str.length(); i++) {
      19.              sum *= chaMap.get(str.charAt(i));
      20.          }
      21.          // 比较，但是不管有没有，都是需要添加进去，只不过没有的时候需要新建
      22.          if (!resMap.containsKey(sum)) {
      23.              resMap.put(sum, new ArrayList());
      24.          }
      25.          resMap.get(sum).add(str);
      26.      }
      27.      return new ArrayList<>(resMap.values());
      28.  }
      30.  public static List<Integer> has26Prime() {
      31.      ArrayList<Integer> list = new ArrayList<>();
      32.      for (int i = 2; i <= 200; i++) {
      33.          if (isPrime(i)) {
      34.              list.add(i);
      35.          }
      36.          if (list.size() == 26) {
      37.              return list;
      38.          }
      39.      }
      40.      return list;
      41.  }
      43.  public static boolean isPrime(int n) {
      44.      for (int i = 2; i <= n / 2; i++) {
      45.          if (n % i == 0) {
      46.              return false;
      47.          }
      48.      }
      49.      return true;
      50.  }
      51. }
      1. class Solution {
      2.  public List<List<String>> groupAnagrams(String[] strs) {
      3.      HashMap<String, List<String>> map = new HashMap<>(16);
      4.      for (String str : strs) {
      5.          char[] chars = str.toCharArray();
      6.          Arrays.sort(chars);
      7.          // 这里的key,要么Arrays工具类，要么new String();
      8.          // char[]的toString默认调用的是Object的toString
      9.          // return getClass().getName() + "@" + Integer.toHexString(hashCode());
      10.          String key = Arrays.toString(chars);
      11.          List<String> list = map.getOrDefault(key, new ArrayList<>());
      12.          list.add(str);
      13.          map.put(key, list);
      14.      }
      15.      return new ArrayList<List<String>>(map.values());
      16.  }
      17. }