New Examples

Author: lokeshgupta1981

pom.xml

@@ -99,6 +99,11 @@
             <artifactId>commons-compress</artifactId>
             <version>1.21</version>
         </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-math3</artifactId>
+            <version>3.5</version>
+        </dependency>
     </dependencies>
     <build>
         <sourceDirectory>src/main/java</sourceDirectory>

src/main/java/com/howtodoinjava/core/basic/README.md

@@ -8,4 +8,5 @@
 6. [Java 14 - Pattern Matching for instanceof](https://howtodoinjava.com/java14/pattern-matching-instanceof/)
 7. [Java While Loop](https://howtodoinjava.com/java/basics/while-loop-in-java/)
 8. [Java String substring()](https://howtodoinjava.com/java/string/java-string-substring-example/)
-9. [Printf-Style Output Formatting in Java](https://howtodoinjava.com/java/basics/printf-style-output-formatting/)
+9. [Printf-Style Output Formatting in Java](https://howtodoinjava.com/java/basics/printf-style-output-formatting/)
+10. [Java – Round Off Double or Float Values to 2 Decimal Places](https://howtodoinjava.com/java/basics/round-off-n-decimal-places/)

src/main/java/com/howtodoinjava/core/basic/RoundOffFloats.java

@@ -0,0 +1,36 @@
+package com.howtodoinjava.core.basic;
+
+import java.math.BigDecimal;
+import java.math.MathContext;
+import java.text.DecimalFormat;
+import org.apache.commons.math3.dfp.DfpField.RoundingMode;
+import org.apache.commons.math3.util.Precision;
+
+public class RoundOffFloats {
+
+  public static void main(String[] args) {
+    float number = 123.456f;
+
+    //1. Apache commons Math's Precision
+    float roundedOffNumber = Precision.round(number, 2, RoundingMode.ROUND_HALF_EVEN.ordinal());
+    System.out.println(roundedOffNumber); //123.45
+
+    //2 - Math.round()
+    System.out.println(roundUp(number, 2));
+
+    //3 - Print formatted value with DecimalFormat
+    DecimalFormat df = new DecimalFormat("###.##");
+    System.out.println(df.format(number));
+
+    //4 - BigDecimal
+    BigDecimal bd = new BigDecimal(number);
+    BigDecimal roundedOffBd = bd.setScale(2, java.math.RoundingMode.HALF_EVEN);
+    System.out.println(roundedOffBd);
+  }
+
+  public static double roundUp(double value, int places) {
+    double scale = Math.pow(10, places);
+    return Math.round(value * scale) / scale;
+  }
+
+}

src/main/java/com/howtodoinjava/core/collections/map/InvertedMap.java

@@ -0,0 +1,92 @@
+package com.howtodoinjava.core.collections.map;
+
+import com.google.common.collect.BiMap;
+import com.google.common.collect.HashBiMap;
+import com.google.common.collect.ImmutableBiMap;
+import com.google.common.collect.ImmutableMultimap;
+import com.google.common.collect.Multimap;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.stream.Collectors;
+import org.apache.commons.collections4.BidiMap;
+import org.apache.commons.collections4.MapUtils;
+import org.apache.commons.collections4.bidimap.DualHashBidiMap;
+
+public class InvertedMap {
+
+  public static void main(String[] args) {
+    Map<String, String> map = Map.of("key1", "value1", "key2", "value2");
+    System.out.println(map);
+
+    Map<String, Integer> originalMap = new HashMap<>();
+    originalMap.put("Key1", 1);
+    originalMap.put("Key2", 2);
+
+    Map<Integer, String> invertedMap = new HashMap<>();
+    for (Entry<String, Integer> entry : originalMap.entrySet()) {
+      invertedMap.put(entry.getValue(), entry.getKey());
+    }
+    System.out.println(invertedMap);     //{1=Key1, 2=Key2}
+
+    Map<Integer, String> inverseMap2 = originalMap.entrySet()
+        .stream()
+        .collect(Collectors.toMap(Entry::getValue, Entry::getKey));
+
+    Map<Integer, String> mapWithDuplicateValues = new HashMap<Integer, String>();
+    mapWithDuplicateValues.put(1, "Value1");
+    mapWithDuplicateValues.put(2, "Value2");
+    mapWithDuplicateValues.put(3, "Value2");
+
+    HashMap<String, List<Integer>> inverseMap = new HashMap<String, List<Integer>>();
+
+    for (Entry<Integer, String> entry : mapWithDuplicateValues.entrySet()) {
+      if (inverseMap.containsKey(entry.getValue())) {
+        inverseMap.get(entry.getValue()).add(entry.getKey());
+      } else {
+        List<Integer> list = new ArrayList<Integer>();
+        list.add(entry.getKey());
+        inverseMap.put(entry.getValue(), list);
+      }
+    }
+    System.out.println(inverseMap);
+
+    /*inverseMap = originalMap.entrySet()
+        .stream()
+        .collect(Collectors.groupingBy(Entry::getValue,
+            Collectors.mapping(Entry::getKey, Collectors.toList())));
+
+    System.out.println(inverseMap);*/
+
+    BiMap<Integer, String> biMap = ImmutableBiMap.of(1, "Key1", 2, "Key2", 3, "Key3");
+    BiMap<String, Integer> inverseBiMap = biMap.inverse();
+
+    System.out.println(inverseBiMap);              //{Key1=1, Key2=2, Key3=3}
+
+    //
+    biMap = HashBiMap.create();
+    BiMap<String, Integer> inversedMap = biMap.inverse();
+    System.out.println(inversedMap);          //{Key1=1, Key2=2, Key3=3}
+
+    Multimap<Integer, String> multimap = ImmutableMultimap.of(1, "Key1", 1, "Key2", 2, "Key3");
+    System.out.println(multimap); //{1=[Key1, Key2], 2=[Key3]}
+
+    BidiMap bidiMap = new DualHashBidiMap();
+    bidiMap.put(1, "Value1");
+    bidiMap.put(2, "Value2");
+
+    System.out.println(bidiMap.inverseBidiMap());         //{Value1=1, Value2=2}
+
+    Map<Integer, String> hashMap = new HashMap<Integer, String>();
+    hashMap.put(1,"Value1");
+    hashMap.put(2,"Value2");
+    hashMap.put(3,"Value2");
+
+    Map<String,Integer> inversedMap1 = MapUtils.invertMap(hashMap);
+    System.out.println(inversedMap1);  //{Value1=1, Value2=3}
+
+  }
+
+}