Immutability of String

slgobinath · slgobinath · commit 8e3cb22a0231 · 2015-03-03T07:23:29.000+05:30
diff --git a/stringimmutability/BestPractice.java b/stringimmutability/BestPractice.java
@@ -0,0 +1,17 @@
+/**
+* Modifying String object creates Garbage objects.
+* Java recommends to use either StringBuffer or StringBuilder.
+*
+* @author L.Gobinath
+*/
+public class BestPractice {
+    public static void main(String[] args) {
+        StringBuilder builder = new StringBuilder();
+
+        for (int i = 0; i < 10; i++) {
+            builder.append(i);
+        }
+        String result = builder.toString();
+        System.out.println(result);
+    }
+}
diff --git a/stringimmutability/EqualityOperator.java b/stringimmutability/EqualityOperator.java
@@ -0,0 +1,41 @@
+/**
+ * The == operator is used to compare two primitive data types.
+ * If it is used with references, it checks whether two references are refering the same object.
+ *
+ * @author L.Gobinath
+ */
+public class EqualityOperator {
+    public static void main(String[] args) {
+        Student stu1 = new Student(100);
+        Student stu2 = new Student(100);
+        Student stu3 = stu1;
+        if (stu1 == stu2) { // false
+            System.out.println("stu1 == stu2");
+        }
+        if (stu1.equals(stu2)) { // true
+            System.out.println("stu1 equals stu2");
+        }
+        if (stu1 == stu3) { // true
+            System.out.println("stu1 == stu3");
+        }
+    }
+}
+
+class Student {
+    int index;
+
+    public Student(int index) {
+        this.index = index;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof Student) {
+            Student stu = (Student) obj;
+            if (stu.index == this.index) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
diff --git a/stringimmutability/GarbageGenerator.java b/stringimmutability/GarbageGenerator.java
@@ -0,0 +1,18 @@
+/**
+* Modifying String object creates Garbage objects.
+* It is not recommended to modify a String object so many times.
+* This code is an example of bad practice in Java.
+*
+* @author L.Gobinath
+*/
+public class GarbageGenerator {
+    public static void main(String[] args) {
+        String result = "";
+
+        for (int i = 0; i < 10; i++) {
+            // Every time creates a new object
+            result += i;
+        }
+        System.out.println(result);
+    }
+}
diff --git a/stringimmutability/StringPool.java b/stringimmutability/StringPool.java
@@ -0,0 +1,19 @@
+/**
+* Same "Java" object is shared by both references.
+*
+* @author L.Gobinath
+*/
+public class StringPool {
+    public static void main(String[] args) {
+        String x = "Java";
+        String y = "Java";
+
+        System.out.println(x == y); //true
+        System.out.println(x.toLowerCase());    // java
+        System.out.println(x);  // Java
+        System.out.println(y);  // Java
+        x = x.toLowerCase();    // Update the reference
+        System.out.println(x);  // java
+        System.out.println(y);  // Java
+    }
+}
