chore: use computeIfAbsent api in java solutions

yanglbme · yanglbme · commit f44deeb6765a · 2021-09-30T11:14:13.000+08:00
diff --git a/solution/0100-0199/0126.Word Ladder II/Solution.java b/solution/0100-0199/0126.Word Ladder II/Solution.java
@@ -38,13 +38,12 @@ private void bfs(Set<String> forward, Set<String> backward, Set<String> dict, bo
                     if (!backward.contains(temp) && !dict.contains(temp)) continue;
                     String key = !swap ? str : temp;
                     String val = !swap ? temp : str;
-                    if (!hs.containsKey(key)) hs.put(key, new ArrayList<>());
                     if (backward.contains(temp)) {
-                        hs.get(key).add(val);
+                        hs.computeIfAbsent(key, k -> new ArrayList<>()).add(val);
                         isConnected = true;
                     }
                     if (!isConnected && dict.contains(temp)) {
-                        hs.get(key).add(val);
+                        hs.computeIfAbsent(key, k -> new ArrayList<>()).add(val);
                         set3.add(temp);
                     }
                 }
diff --git a/solution/0200-0299/0216.Combination Sum III/Solution.java b/solution/0200-0299/0216.Combination Sum III/Solution.java
@@ -1,20 +1,20 @@
 class Solution {
     public List<List<Integer>> combinationSum3(int k, int n) {
-        List<List<Integer>> ans = new ArrayList<>();        
-        robot(1, k, n, ans, new ArrayList<Integer>());
+        List<List<Integer>> ans = new ArrayList<>();
+        robot(1, k, n, ans, new ArrayList<>());
         return ans;
     }
-    
+
     private void robot(int start, int k, int left, List<List<Integer>> ans, List<Integer> tmp) {
-        if(k < 0 || left < 0) return;
-        
-        if(k == 0 && left == 0) {
+        if (k < 0 || left < 0) return;
+
+        if (k == 0 && left == 0) {
             ans.add(new ArrayList<>(tmp));
             return;
         }
-        
-        for(int i = start; i <= 9; i++) {
-            if(left >= i && k > 0) {
+
+        for (int i = start; i <= 9; i++) {
+            if (left >= i && k > 0) {
                 tmp.add(i);
                 robot(i + 1, k - 1, left - i, ans, tmp);
                 tmp.remove(tmp.size() - 1);
diff --git a/solution/0200-0299/0288.Unique Word Abbreviation/README.md b/solution/0200-0299/0288.Unique Word Abbreviation/README.md
@@ -115,12 +115,10 @@ class ValidWordAbbr {
         words = new HashMap<>();
         for (String word : dictionary) {
             String abbr = wordAbbr(word);
-            Set<String> vals = words.getOrDefault(abbr, new HashSet<>());
-            vals.add(word);
-            words.put(abbr, vals);
+            words.computeIfAbsent(abbr, k -> new HashSet<>()).add(word);
         }
     }
-
+    
     public boolean isUnique(String word) {
         String abbr = wordAbbr(word);
         Set<String> vals = words.get(abbr);
diff --git a/solution/0200-0299/0288.Unique Word Abbreviation/README_EN.md b/solution/0200-0299/0288.Unique Word Abbreviation/README_EN.md
@@ -103,12 +103,10 @@ class ValidWordAbbr {
         words = new HashMap<>();
         for (String word : dictionary) {
             String abbr = wordAbbr(word);
-            Set<String> vals = words.getOrDefault(abbr, new HashSet<>());
-            vals.add(word);
-            words.put(abbr, vals);
+            words.computeIfAbsent(abbr, k -> new HashSet<>()).add(word);
         }
     }
-
+    
     public boolean isUnique(String word) {
         String abbr = wordAbbr(word);
         Set<String> vals = words.get(abbr);
diff --git a/solution/0200-0299/0288.Unique Word Abbreviation/Solution.java b/solution/0200-0299/0288.Unique Word Abbreviation/Solution.java
@@ -5,9 +5,7 @@ public ValidWordAbbr(String[] dictionary) {
         words = new HashMap<>();
         for (String word : dictionary) {
             String abbr = wordAbbr(word);
-            Set<String> vals = words.getOrDefault(abbr, new HashSet<>());
-            vals.add(word);
-            words.put(abbr, vals);
+            words.computeIfAbsent(abbr, k -> new HashSet<>()).add(word);
         }
     }
     
diff --git a/solution/0300-0399/0355.Design Twitter/README.md b/solution/0300-0399/0355.Design Twitter/README.md
@@ -159,16 +159,12 @@ class Twitter {
     
     /** Follower follows a followee. If the operation is invalid, it should be a no-op. */
     public void follow(int followerId, int followeeId) {
-        Set<Integer> following = userFollowing.getOrDefault(followerId, new HashSet<>());
-        following.add(followeeId);
-        userFollowing.put(followerId, following);
+        userFollowing.computeIfAbsent(followerId, k -> new HashSet<>()).add(followeeId);
     }
     
     /** Follower unfollows a followee. If the operation is invalid, it should be a no-op. */
     public void unfollow(int followerId, int followeeId) {
-        Set<Integer> following = userFollowing.getOrDefault(followerId, new HashSet<>());
-        following.remove(followeeId);
-        userFollowing.put(followerId, following);
+        userFollowing.computeIfAbsent(followerId, k -> new HashSet<>()).remove(followeeId);
     }
 }
 
diff --git a/solution/0300-0399/0355.Design Twitter/README_EN.md b/solution/0300-0399/0355.Design Twitter/README_EN.md
@@ -154,16 +154,12 @@ class Twitter {
     
     /** Follower follows a followee. If the operation is invalid, it should be a no-op. */
     public void follow(int followerId, int followeeId) {
-        Set<Integer> following = userFollowing.getOrDefault(followerId, new HashSet<>());
-        following.add(followeeId);
-        userFollowing.put(followerId, following);
+        userFollowing.computeIfAbsent(followerId, k -> new HashSet<>()).add(followeeId);
     }
     
     /** Follower unfollows a followee. If the operation is invalid, it should be a no-op. */
     public void unfollow(int followerId, int followeeId) {
-        Set<Integer> following = userFollowing.getOrDefault(followerId, new HashSet<>());
-        following.remove(followeeId);
-        userFollowing.put(followerId, following);
+        userFollowing.computeIfAbsent(followerId, k -> new HashSet<>()).remove(followeeId);
     }
 }
 
diff --git a/solution/0300-0399/0355.Design Twitter/Solution.java b/solution/0300-0399/0355.Design Twitter/Solution.java
@@ -41,16 +41,12 @@ public List<Integer> getNewsFeed(int userId) {
     
     /** Follower follows a followee. If the operation is invalid, it should be a no-op. */
     public void follow(int followerId, int followeeId) {
-        Set<Integer> following = userFollowing.getOrDefault(followerId, new HashSet<>());
-        following.add(followeeId);
-        userFollowing.put(followerId, following);
+        userFollowing.computeIfAbsent(followerId, k -> new HashSet<>()).add(followeeId);
     }
     
     /** Follower unfollows a followee. If the operation is invalid, it should be a no-op. */
     public void unfollow(int followerId, int followeeId) {
-        Set<Integer> following = userFollowing.getOrDefault(followerId, new HashSet<>());
-        following.remove(followeeId);
-        userFollowing.put(followerId, following);
+        userFollowing.computeIfAbsent(followerId, k -> new HashSet<>()).remove(followeeId);
     }
 }
 
diff --git a/solution/0300-0399/0381.Insert Delete GetRandom O(1) - Duplicates allowed/README.md b/solution/0300-0399/0381.Insert Delete GetRandom O(1) - Duplicates allowed/README.md
@@ -132,11 +132,9 @@ class RandomizedCollection {
 
     /** Inserts a value to the collection. Returns true if the collection did not already contain the specified element. */
     public boolean insert(int val) {
-        Set<Integer> idxSet = m.getOrDefault(val, new HashSet<>());
-        idxSet.add(l.size());
-        m.put(val, idxSet);
+        m.computeIfAbsent(val, k -> new HashSet<>()).add(l.size());
         l.add(val);
-        return idxSet.size() == 1;
+        return m.get(val).size() == 1;
     }
 
     /** Removes a value from the collection. Returns true if the collection contained the specified element. */
diff --git a/solution/0300-0399/0381.Insert Delete GetRandom O(1) - Duplicates allowed/README_EN.md b/solution/0300-0399/0381.Insert Delete GetRandom O(1) - Duplicates allowed/README_EN.md
@@ -125,11 +125,9 @@ class RandomizedCollection {
 
     /** Inserts a value to the collection. Returns true if the collection did not already contain the specified element. */
     public boolean insert(int val) {
-        Set<Integer> idxSet = m.getOrDefault(val, new HashSet<>());
-        idxSet.add(l.size());
-        m.put(val, idxSet);
+        m.computeIfAbsent(val, k -> new HashSet<>()).add(l.size());
         l.add(val);
-        return idxSet.size() == 1;
+        return m.get(val).size() == 1;
     }
 
     /** Removes a value from the collection. Returns true if the collection contained the specified element. */
diff --git a/solution/0300-0399/0381.Insert Delete GetRandom O(1) - Duplicates allowed/Solution.java b/solution/0300-0399/0381.Insert Delete GetRandom O(1) - Duplicates allowed/Solution.java
@@ -9,16 +9,14 @@ public RandomizedCollection() {
         l = new ArrayList<>();
         rnd = new Random();
     }
-    
+
     /** Inserts a value to the collection. Returns true if the collection did not already contain the specified element. */
     public boolean insert(int val) {
-        Set<Integer> idxSet = m.getOrDefault(val, new HashSet<>());
-        idxSet.add(l.size());
-        m.put(val, idxSet);
+        m.computeIfAbsent(val, k -> new HashSet<>()).add(l.size());
         l.add(val);
-        return idxSet.size() == 1;
+        return m.get(val).size() == 1;
     }
-    
+
     /** Removes a value from the collection. Returns true if the collection contained the specified element. */
     public boolean remove(int val) {
         if (!m.containsKey(val)) {
@@ -41,7 +39,7 @@ public boolean remove(int val) {
         l.remove(lastIdx);
         return true;
     }
-    
+
     /** Get a random element from the collection. */
     public int getRandom() {
         int size = l.size();
diff --git a/solution/0700-0799/0721.Accounts Merge/README.md b/solution/0700-0799/0721.Accounts Merge/README.md
@@ -177,10 +177,7 @@ class Solution {
             List<String> account = accounts.get(i);
             for (int j = 1; j < account.size(); ++j) {
                 String email = account.get(j);
-                if (!mp.containsKey(pa)) {
-                    mp.put(pa, new HashSet<>());
-                }
-                mp.get(pa).add(email);
+                mp.computeIfAbsent(pa, k -> new HashSet<>()).add(email);
             }
         }
         List<List<String>> res = new ArrayList<>();
diff --git a/solution/0700-0799/0721.Accounts Merge/README_EN.md b/solution/0700-0799/0721.Accounts Merge/README_EN.md
@@ -111,10 +111,7 @@ class Solution {
             List<String> account = accounts.get(i);
             for (int j = 1; j < account.size(); ++j) {
                 String email = account.get(j);
-                if (!mp.containsKey(pa)) {
-                    mp.put(pa, new HashSet<>());
-                }
-                mp.get(pa).add(email);
+                mp.computeIfAbsent(pa, k -> new HashSet<>()).add(email);
             }
         }
         List<List<String>> res = new ArrayList<>();
diff --git a/solution/0700-0799/0721.Accounts Merge/Solutioin.java b/solution/0700-0799/0721.Accounts Merge/Solutioin.java
@@ -26,10 +26,7 @@ public List<List<String>> accountsMerge(List<List<String>> accounts) {
             List<String> account = accounts.get(i);
             for (int j = 1; j < account.size(); ++j) {
                 String email = account.get(j);
-                if (!mp.containsKey(pa)) {
-                    mp.put(pa, new HashSet<>());
-                }
-                mp.get(pa).add(email);
+                mp.computeIfAbsent(pa, k -> new HashSet<>()).add(email);
             }
         }
         List<List<String>> res = new ArrayList<>();
diff --git a/solution/0700-0799/0760.Find Anagram Mappings/README.md b/solution/0700-0799/0760.Find Anagram Mappings/README.md
@@ -67,9 +67,7 @@ class Solution {
     public int[] anagramMappings(int[] nums1, int[] nums2) {
         Map<Integer, Set<Integer>> map = new HashMap<>();
         for (int i = 0; i < nums2.length; ++i) {
-            Set<Integer> s = map.getOrDefault(nums2[i], new HashSet<>());
-            s.add(i);
-            map.put(nums2[i], s);
+            map.computeIfAbsent(nums2[i], k -> new HashSet<>()).add(i);
         }
         int[] res = new int[nums1.length];
         for (int i = 0; i < nums1.length; ++i) {
diff --git a/solution/0700-0799/0760.Find Anagram Mappings/README_EN.md b/solution/0700-0799/0760.Find Anagram Mappings/README_EN.md
@@ -14,12 +14,10 @@ We want to find an <i>index mapping</i> <code>P</code>, from <code>A</code> to <
 
 </p><p>
 
-These lists <code>A</code> and <code>B</code> may contain duplicates.  If there are multiple answers, output any of them.
+These lists <code>A</code> and <code>B</code> may contain duplicates. If there are multiple answers, output any of them.
 
 </p>
 
-
-
 <p>
 
 For example, given
@@ -50,8 +48,6 @@ and so on.
 
 </p>
 
-
-
 <p><b>Note:</b><ol>
 
 <li><code>A, B</code> have equal lengths in range <code>[1, 100]</code>.</li>
@@ -82,9 +78,7 @@ class Solution {
     public int[] anagramMappings(int[] nums1, int[] nums2) {
         Map<Integer, Set<Integer>> map = new HashMap<>();
         for (int i = 0; i < nums2.length; ++i) {
-            Set<Integer> s = map.getOrDefault(nums2[i], new HashSet<>());
-            s.add(i);
-            map.put(nums2[i], s);
+            map.computeIfAbsent(nums2[i], k -> new HashSet<>()).add(i);
         }
         int[] res = new int[nums1.length];
         for (int i = 0; i < nums1.length; ++i) {
diff --git a/solution/0700-0799/0760.Find Anagram Mappings/Solution.java b/solution/0700-0799/0760.Find Anagram Mappings/Solution.java
@@ -2,9 +2,7 @@ class Solution {
     public int[] anagramMappings(int[] nums1, int[] nums2) {
         Map<Integer, Set<Integer>> map = new HashMap<>();
         for (int i = 0; i < nums2.length; ++i) {
-            Set<Integer> s = map.getOrDefault(nums2[i], new HashSet<>());
-            s.add(i);
-            map.put(nums2[i], s);
+            map.computeIfAbsent(nums2[i], k -> new HashSet<>()).add(i);
         }
         int[] res = new int[nums1.length];
         for (int i = 0; i < nums1.length; ++i) {
diff --git a/solution/0900-0999/0981.Time Based Key-Value Store/README.md b/solution/0900-0999/0981.Time Based Key-Value Store/README.md
@@ -109,13 +109,11 @@ class TimeMap {
     public TimeMap() {
         ktv = new HashMap<>();
     }
-
+    
     public void set(String key, String value, int timestamp) {
-        TreeMap<Integer, String> tv = ktv.getOrDefault(key, new TreeMap<>());
-        tv.put(timestamp, value);
-        ktv.put(key, tv);
+        ktv.computeIfAbsent(key, k -> new TreeMap<>()).put(timestamp, value);
     }
-
+    
     public String get(String key, int timestamp) {
         if (!ktv.containsKey(key)) {
             return "";
diff --git a/solution/0900-0999/0981.Time Based Key-Value Store/README_EN.md b/solution/0900-0999/0981.Time Based Key-Value Store/README_EN.md
@@ -123,13 +123,11 @@ class TimeMap {
     public TimeMap() {
         ktv = new HashMap<>();
     }
-
+    
     public void set(String key, String value, int timestamp) {
-        TreeMap<Integer, String> tv = ktv.getOrDefault(key, new TreeMap<>());
-        tv.put(timestamp, value);
-        ktv.put(key, tv);
+        ktv.computeIfAbsent(key, k -> new TreeMap<>()).put(timestamp, value);
     }
-
+    
     public String get(String key, int timestamp) {
         if (!ktv.containsKey(key)) {
             return "";
diff --git a/solution/0900-0999/0981.Time Based Key-Value Store/Solution.java b/solution/0900-0999/0981.Time Based Key-Value Store/Solution.java
@@ -7,9 +7,7 @@ public TimeMap() {
     }
     
     public void set(String key, String value, int timestamp) {
-        TreeMap<Integer, String> tv = ktv.getOrDefault(key, new TreeMap<>());
-        tv.put(timestamp, value);
-        ktv.put(key, tv);
+        ktv.computeIfAbsent(key, k -> new TreeMap<>()).put(timestamp, value);
     }
     
     public String get(String key, int timestamp) {
diff --git a/solution/1100-1199/1181.Before and After Puzzle/README.md b/solution/1100-1199/1181.Before and After Puzzle/README.md
@@ -99,10 +99,7 @@ class Solution {
         for (int i = 0; i < phrases.length; ++i) {
             String phrase = phrases[i];
             String word = phrase.split(" ")[0];
-            if (!sameFirstWord.containsKey(word)) {
-                sameFirstWord.put(word, new HashSet<>());
-            }
-            sameFirstWord.get(word).add(i);
+            sameFirstWord.computeIfAbsent(word, k -> new HashSet<>()).add(i);
         }
         Set<String> res = new HashSet<>();
         for (int i = 0; i < phrases.length; ++i) {
diff --git a/solution/1100-1199/1181.Before and After Puzzle/README_EN.md b/solution/1100-1199/1181.Before and After Puzzle/README_EN.md
@@ -88,10 +88,7 @@ class Solution {
         for (int i = 0; i < phrases.length; ++i) {
             String phrase = phrases[i];
             String word = phrase.split(" ")[0];
-            if (!sameFirstWord.containsKey(word)) {
-                sameFirstWord.put(word, new HashSet<>());
-            }
-            sameFirstWord.get(word).add(i);
+            sameFirstWord.computeIfAbsent(word, k -> new HashSet<>()).add(i);
         }
         Set<String> res = new HashSet<>();
         for (int i = 0; i < phrases.length; ++i) {
diff --git a/solution/1100-1199/1181.Before and After Puzzle/Solution.java b/solution/1100-1199/1181.Before and After Puzzle/Solution.java
@@ -4,10 +4,7 @@ public List<String> beforeAndAfterPuzzles(String[] phrases) {
         for (int i = 0; i < phrases.length; ++i) {
             String phrase = phrases[i];
             String word = phrase.split(" ")[0];
-            if (!sameFirstWord.containsKey(word)) {
-                sameFirstWord.put(word, new HashSet<>());
-            }
-            sameFirstWord.get(word).add(i);
+            sameFirstWord.computeIfAbsent(word, k -> new HashSet<>()).add(i);
         }
         Set<String> res = new HashSet<>();
         for (int i = 0; i < phrases.length; ++i) {
diff --git a/solution/1200-1299/1258.Synonymous Sentences/README.md b/solution/1200-1299/1258.Synonymous Sentences/README.md
@@ -113,14 +113,8 @@ class Solution {
         Map<String, Set<String>> s = new HashMap<>();
         for (List<String> item : synonyms) {
             String a = find(item.get(0)), b = find(item.get(1));
-            if (!s.containsKey(a)) {
-                s.put(a, new HashSet<>());
-            }
-            if (!s.containsKey(b)) {
-                s.put(b, new HashSet<>());
-            }
-            s.get(a).add(item.get(0));
-            s.get(b).add(item.get(1));
+            s.computeIfAbsent(a, k -> new HashSet<>()).add(item.get(0));
+            s.computeIfAbsent(b, k -> new HashSet<>()).add(item.get(1));
         }
         List<List<String>> all = new ArrayList<>();
         for (String word : text.split(" ")) {
diff --git a/solution/1200-1299/1258.Synonymous Sentences/README_EN.md b/solution/1200-1299/1258.Synonymous Sentences/README_EN.md
diff --git a/solution/1200-1299/1258.Synonymous Sentences/Solution.java b/solution/1200-1299/1258.Synonymous Sentences/Solution.java
diff --git a/solution/1500-1599/1500.Design a File Sharing System/README.md b/solution/1500-1599/1500.Design a File Sharing System/README.md
diff --git a/solution/1500-1599/1500.Design a File Sharing System/README_EN.md b/solution/1500-1599/1500.Design a File Sharing System/README_EN.md
diff --git a/solution/1500-1599/1500.Design a File Sharing System/Solution.java b/solution/1500-1599/1500.Design a File Sharing System/Solution.java
diff --git a/solution/1700-1799/1722.Minimize Hamming Distance After Swap Operations/README.md b/solution/1700-1799/1722.Minimize Hamming Distance After Swap Operations/README.md
diff --git a/solution/1700-1799/1722.Minimize Hamming Distance After Swap Operations/README_EN.md b/solution/1700-1799/1722.Minimize Hamming Distance After Swap Operations/README_EN.md
diff --git a/solution/1700-1799/1722.Minimize Hamming Distance After Swap Operations/Solution.java b/solution/1700-1799/1722.Minimize Hamming Distance After Swap Operations/Solution.java

Original file line number	Diff line number	Diff line change
`@@ -38,13 +38,12 @@ private void bfs(Set<String> forward, Set<String> backward, Set<String> dict, bo`
`38`	`38`	`if (!backward.contains(temp) && !dict.contains(temp)) continue;`
`39`	`39`	`String key = !swap ? str : temp;`
`40`	`40`	`String val = !swap ? temp : str;`
`41`		`- if (!hs.containsKey(key)) hs.put(key, new ArrayList<>());`
`42`	`41`	`if (backward.contains(temp)) {`
`43`		`- hs.get(key).add(val);`
	`42`	`+ hs.computeIfAbsent(key, k -> new ArrayList<>()).add(val);`
`44`	`43`	`isConnected = true;`
`45`	`44`	`}`
`46`	`45`	`if (!isConnected && dict.contains(temp)) {`
`47`		`- hs.get(key).add(val);`
	`46`	`+ hs.computeIfAbsent(key, k -> new ArrayList<>()).add(val);`
`48`	`47`	`set3.add(temp);`
`49`	`48`	`}`
`50`	`49`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,9 +5,7 @@ public ValidWordAbbr(String[] dictionary) {`
`5`	`5`	`words = new HashMap<>();`
`6`	`6`	`for (String word : dictionary) {`
`7`	`7`	`String abbr = wordAbbr(word);`
`8`		`- Set<String> vals = words.getOrDefault(abbr, new HashSet<>());`
`9`		`- vals.add(word);`
`10`		`- words.put(abbr, vals);`
	`8`	`+ words.computeIfAbsent(abbr, k -> new HashSet<>()).add(word);`
`11`	`9`	`}`
`12`	`10`	`}`
`13`	`11`
Original file line number	Diff line number	Diff line change
`@@ -159,16 +159,12 @@ class Twitter {`
`159`	`159`
`160`	`160`	`/** Follower follows a followee. If the operation is invalid, it should be a no-op. */`
`161`	`161`	`public void follow(int followerId, int followeeId) {`
`162`		`- Set<Integer> following = userFollowing.getOrDefault(followerId, new HashSet<>());`
`163`		`- following.add(followeeId);`
`164`		`- userFollowing.put(followerId, following);`
	`162`	`+ userFollowing.computeIfAbsent(followerId, k -> new HashSet<>()).add(followeeId);`
`165`	`163`	`}`
`166`	`164`
`167`	`165`	`/** Follower unfollows a followee. If the operation is invalid, it should be a no-op. */`
`168`	`166`	`public void unfollow(int followerId, int followeeId) {`
`169`		`- Set<Integer> following = userFollowing.getOrDefault(followerId, new HashSet<>());`
`170`		`- following.remove(followeeId);`
`171`		`- userFollowing.put(followerId, following);`
	`167`	`+ userFollowing.computeIfAbsent(followerId, k -> new HashSet<>()).remove(followeeId);`
`172`	`168`	`}`
`173`	`169`	`}`
`174`	`170`
Original file line number	Diff line number	Diff line change
`@@ -154,16 +154,12 @@ class Twitter {`
`154`	`154`
`155`	`155`	`/** Follower follows a followee. If the operation is invalid, it should be a no-op. */`
`156`	`156`	`public void follow(int followerId, int followeeId) {`
`157`		`- Set<Integer> following = userFollowing.getOrDefault(followerId, new HashSet<>());`
`158`		`- following.add(followeeId);`
`159`		`- userFollowing.put(followerId, following);`
	`157`	`+ userFollowing.computeIfAbsent(followerId, k -> new HashSet<>()).add(followeeId);`
`160`	`158`	`}`
`161`	`159`
`162`	`160`	`/** Follower unfollows a followee. If the operation is invalid, it should be a no-op. */`
`163`	`161`	`public void unfollow(int followerId, int followeeId) {`
`164`		`- Set<Integer> following = userFollowing.getOrDefault(followerId, new HashSet<>());`
`165`		`- following.remove(followeeId);`
`166`		`- userFollowing.put(followerId, following);`
	`162`	`+ userFollowing.computeIfAbsent(followerId, k -> new HashSet<>()).remove(followeeId);`
`167`	`163`	`}`
`168`	`164`	`}`
`169`	`165`
Original file line number	Diff line number	Diff line change
`@@ -41,16 +41,12 @@ public List<Integer> getNewsFeed(int userId) {`
`41`	`41`
`42`	`42`	`/** Follower follows a followee. If the operation is invalid, it should be a no-op. */`
`43`	`43`	`public void follow(int followerId, int followeeId) {`
`44`		`- Set<Integer> following = userFollowing.getOrDefault(followerId, new HashSet<>());`
`45`		`- following.add(followeeId);`
`46`		`- userFollowing.put(followerId, following);`
	`44`	`+ userFollowing.computeIfAbsent(followerId, k -> new HashSet<>()).add(followeeId);`
`47`	`45`	`}`
`48`	`46`
`49`	`47`	`/** Follower unfollows a followee. If the operation is invalid, it should be a no-op. */`
`50`	`48`	`public void unfollow(int followerId, int followeeId) {`
`51`		`- Set<Integer> following = userFollowing.getOrDefault(followerId, new HashSet<>());`
`52`		`- following.remove(followeeId);`
`53`		`- userFollowing.put(followerId, following);`
	`49`	`+ userFollowing.computeIfAbsent(followerId, k -> new HashSet<>()).remove(followeeId);`
`54`	`50`	`}`
`55`	`51`	`}`
`56`	`52`