Add files via upload

Author: AvinandanBose

ConcurrentHashMapMethods24.java

@@ -0,0 +1,25 @@
+import java.util.concurrent.ConcurrentHashMap;
+
+public class ConcurrentHashMapMethods24 {
+
+    //reduceKeysToLong​(long parallelismThreshold, ToLongFunction<? super K> transformer, long basis, LongBinaryOperator reducer)
+    public static void main(String[] args) throws Exception {
+
+        ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>();
+        map.put(1, "1");
+        map.put(2, "2");
+        map.put(3, "3");
+        map.put(4, "4");
+        System.out.println("Map:" + map);
+
+        long result = map.reduceKeysToLong(2, k -> {
+            System.out.println("Key:" + k);
+            return k;
+        }, 1, (k1, k2) -> {
+            System.out.println("Key1:" + k1 + " Key2:" + k2);
+            return k1 + k2;
+        });
+        System.out.println("Result:" + result);
+
+    }
+}

ConcurrentHashMapMethods25.java

@@ -0,0 +1,24 @@
+import java.util.concurrent.ConcurrentHashMap;
+public class ConcurrentHashMapMethods25 {
+
+    //reduceToDouble​(long parallelismThreshold, ToDoubleBiFunction<? super K,​? super V> transformer, double basis, DoubleBinaryOperator reducer)
+    public static void main(String[] args) throws Exception {
+
+        ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>();
+        map.put(1, "1");
+        map.put(2, "2");
+        map.put(3, "3");
+        map.put(4, "4");
+        System.out.println("Map:" + map);
+
+        double result = map.reduceToDouble(2, (k, v) -> {
+            System.out.println("Key:" + k + " Value:" + v);
+            return Double.parseDouble(v);
+        }, 2, (v1, v2) -> {
+            System.out.println("Value1:" + v1 + " Value2:" + v2);
+            return v1 + v2;
+        });
+        System.out.println("Result:" + result);
+
+    }
+}

ConcurrentHashMapMethods26.java

@@ -0,0 +1,23 @@
+import java.util.concurrent.ConcurrentHashMap;
+
+public class ConcurrentHashMapMethods26 {
+    //reduceToInt​(long parallelismThreshold, ToIntBiFunction<? super K,​? super V> transformer, int basis, IntBinaryOperator reducer)
+    public static void main(String[] args) throws Exception {
+
+        ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>();
+        map.put(1, "1");
+        map.put(2, "2");
+        map.put(3, "3");
+        map.put(4, "4");
+        System.out.println("Map:" + map);
+
+        int result = map.reduceToInt(2, (k, v) -> {
+            System.out.println("Key:" + k + " Value:" + v);
+            return Integer.parseInt(v);
+        }, 0, (v1, v2) -> {
+            System.out.println("Value1:" + v1 + " Value2:" + v2);
+            return v1 + v2;
+        });
+        System.out.println("Result:" + result);
+    }
+}

ConcurrentHashMapMethods27.java

@@ -0,0 +1,26 @@
+import java.util.concurrent.ConcurrentHashMap;
+
+public class ConcurrentHashMapMethods27 {
+   // reduceToLong​(long parallelismThreshold, ToLongBiFunction<? super K,​? super V> transformer, long basis, LongBinaryOperator reducer)
+
+    public static void main(String[] args) throws Exception {
+
+        ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>();
+        map.put(1, "1");
+        map.put(2, "2");
+        map.put(3, "3");
+        map.put(4, "4");
+        System.out.println("Map:" + map);
+
+        long result = map.reduceToLong(2, (k, v) -> {
+            System.out.println("Key:" + k + " Value:" + v);
+            return Long.parseLong(v);
+        }, 1, (k1, k2) -> {
+            System.out.println("Key1:" + k1 + " Key2:" + k2);
+            return k1 + k2;
+        });
+        System.out.println("Result:" + result);
+
+    }
+    
+}

ConcurrentHashMapMethods28.java

@@ -0,0 +1,21 @@
+import java.util.concurrent.ConcurrentHashMap;
+public class ConcurrentHashMapMethods28 {
+
+    //reduceValues​(long parallelismThreshold, BiFunction<? super V,​? super V,​? extends V> reducer)
+
+    public static void main(String[] args) throws Exception {
+        ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();
+        map.put("one", "1");
+        map.put("two", "2");
+        map.put("three", "3");
+        map.put("four", "4");
+        System.out.println("Map:" + map);
+
+        String result = map.reduceValues(2, (v1, v2) -> {
+            System.out.println("Value1:" + v1 + " Value2:" + v2);
+            return v1 + v2;
+        });
+        System.out.println("Result:" + result);
+    }
+    
+}

ConcurrentHashMapMethods29.java

@@ -0,0 +1,23 @@
+import java.util.concurrent.ConcurrentHashMap;
+public class ConcurrentHashMapMethods29 {
+
+    //reduceValues​(long parallelismThreshold, Function<? super V,​? extends U> transformer, BiFunction<? super U,​? super U,​? extends U> reducer)
+
+    public static void main(String[] args) throws Exception {
+        ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();
+        map.put("one", "1");
+        map.put("two", "2");
+        map.put("three", "3");
+        map.put("four", "4");
+        System.out.println("Map:" + map);
+
+        String result = map.reduceValues(2, v -> {
+            System.out.println("Value:" + v);
+            return v;
+        }, (v1, v2) -> {
+            System.out.println("Value1:" + v1 + " Value2:" + v2);
+            return v1 + v2;
+        });
+        System.out.println("Result:" + result);
+    }
+}

ConcurrentHashMapMethods30.java

@@ -0,0 +1,27 @@
+import java.util.concurrent.ConcurrentHashMap;
+
+public class ConcurrentHashMapMethods30 {
+
+    //reduceValuesToDouble​(long parallelismThreshold, ToDoubleFunction<? super V> transformer, double basis, DoubleBinaryOperator reducer)
+
+    public static void main(String[] args) throws Exception {
+
+        ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>();
+        map.put(1, "1");
+        map.put(2, "2");
+        map.put(3, "3");
+        map.put(4, "4");
+        System.out.println("Map:" + map);
+
+        double result = map.reduceValuesToDouble(2, v -> {
+            System.out.println("Value:" + v);
+            return Double.parseDouble(v);
+        }, 2, (v1, v2) -> {
+            System.out.println("Value1:" + v1 + " Value2:" + v2);
+            return v1 + v2;
+        });
+        System.out.println("Result:" + result);
+
+    }
+    
+}

ConcurrentHashMapMethods31.java

@@ -0,0 +1,24 @@
+import java.util.concurrent.ConcurrentHashMap;
+public class ConcurrentHashMapMethods31 {
+    //reduceValuesToInt​(long parallelismThreshold, ToIntFunction<? super V> transformer, int basis, IntBinaryOperator reducer)
+
+    public static void main(String[] args) throws Exception {
+
+        ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>();
+        map.put(1, "1");
+        map.put(2, "2");
+        map.put(3, "3");
+        map.put(4, "4");
+        System.out.println("Map:" + map);
+
+        int result = map.reduceValuesToInt(2, v -> {
+            System.out.println("Value:" + v);
+            return Integer.parseInt(v);
+        }, 1, (v1, v2) -> {
+            System.out.println("Value1:" + v1 + " Value2:" + v2);
+            return v1 + v2;
+        });
+        System.out.println("Result:" + result);
+
+    }
+}

ConcurrentHashMapMethods32.java

@@ -0,0 +1,24 @@
+import java.util.concurrent.ConcurrentHashMap;
+public class ConcurrentHashMapMethods32 {
+    //reduceValuesToLong​(long parallelismThreshold, ToLongFunction<? super V> transformer, long basis, LongBinaryOperator reducer)
+
+    public static void main(String[] args) throws Exception {
+
+        ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>();
+        map.put(1, "1");
+        map.put(2, "2");
+        map.put(3, "3");
+        map.put(4, "4");
+        System.out.println("Map:" + map);
+
+        long result = map.reduceValuesToLong(2, v -> {
+            System.out.println("Value:" + v);
+            return Long.parseLong(v);
+        }, 1, (v1, v2) -> {
+            System.out.println("Value1:" + v1 + " Value2:" + v2);
+            return v1 + v2;
+        });
+        System.out.println("Result:" + result);
+
+    }
+}