Java中的String、StringBuilder和StringBuffer

字符串是一个字符序列。在java中，String对象是不可变的，这意味着一个常量，一旦创建就不能更改。初始化一个String是一个重要的支柱，作为深入理解的先决条件。现在，我们将证明——让我们考虑下面的代码，其中有三个连接函数，它们有三种不同类型的参数:String、StringBuffer和StringBuilder。

让我们通过下面的一个java程序来清除它们之间的理解，我们将从生成的输出中得出结论，找出java中String、StringBuilder和StringBuffer之间的区别。

示例：

// Java program to demonstrate difference between
// String, StringBuilder and StringBuffer
 
// Main class
class GFG {
 
    // Method 1
    // Concatenates to String
    public static void concat1(String s1)
    {
        s1 = s1 + "forgeeks";
    }
 
    // Method 2
    // Concatenates to StringBuilder
    public static void concat2(StringBuilder s2)
    {
        s2.append("forgeeks");
    }
 
    // Method 3
    // Concatenates to StringBuffer
    public static void concat3(StringBuffer s3)
    {
        s3.append("forgeeks");
    }
 
    // Method 4
    // Main driver method
    public static void main(String[] args)
    {
        // Custom input string
        // String 1
        String s1 = "Geeks";
 
        // Calling above defined method
        concat1(s1);
 
        // s1 is not changed
        System.out.println("String: " + s1);
 
        // String 1
        StringBuilder s2 = new StringBuilder("Geeks");
 
        // Calling above defined method
        concat2(s2);
 
        // s2 is changed
        System.out.println("StringBuilder: " + s2);
 
        // String 3
        StringBuffer s3 = new StringBuffer("Geeks");
 
        // Calling above defined method
        concat3(s3);
 
        // s3 is changed
        System.out.println("StringBuffer: " + s3);
    }
}

输出：

String: Geeks
StringBuilder: Geeksforgeeks
StringBuffer: Geeksforgeeks

输出的解释:

Concat1:在这个方法中，我们传递一个字符串“Geeks”，并执行“s1 = s1 +”forgeeks”。从main()传递的字符串没有改变，这是由于string是不可变的事实。改变string的值会创建另一个对象，concat1()中的s1存储对新字符串的引用。在main()和cocat1()中的引用s1指向不同的字符串。
Concat2:在这个方法中，我们传递了一个字符串“极客”，并执行“s2.append(“forgeeks”)”，它将字符串的实际值(主要)更改为“Geeksforgeeks”。这是因为StringBuilder是可变的，因此会改变它的值。
Concat3: StringBuilder与StringBuffer类似，除了线程安全方面的关键差异外，在所有地方都可以与StringBuffer兼容。StringBuffer是线程安全的，而StringBuilder不保证线程安全，这意味着StringBuffer中存在同步方法，每次控制一个线程访问，而在StringBuilder中看不到，因此是线程不安全的。

注意:现在你一定想知道什么时候使用哪一个，做参考如下:

如果字符串将在整个程序中保持不变，那么就使用string类对象，因为string对象是不可变的。

如果字符串可以更改(例如:在字符串的构造中有很多逻辑和操作)，并且只能从单个线程访问，那么使用StringBuilder就足够了。

如果字符串可以更改，并且将从多个线程访问，那么使用StringBuffer，因为StringBuffer是同步的，因此具有线程安全性。

如果你不想要线程安全，你也可以使用StringBuilder类，因为它不是同步的。

Java中字符串类型之间的转换

有时需要将不同类(如string、StringBuffer、StringBuilder)的字符串对象相互转换。下面是一些同样的技巧。让我们覆盖所有的用例如下:

从String到StringBuffer和StringBuilder
从StringBuffer和StringBuilder到String
从StringBuffer到StringBuilder，反之亦然

从String 到StringBuffer和StringBuilder

这是一种简单的方法，因为我们可以直接将String类对象传递给StringBuffer和StringBuilder类构造函数。由于String类在java中是不可变的，所以对于编辑字符串，我们可以通过将其转换为StringBuffer或StringBuilder类对象来执行相同的操作。

示例：

// Java program to demonstrate conversion from
// String to StringBuffer and StringBuilder
 
// Main class
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Custom input string
        String str = "Geeks";
 
        // Converting String object to StringBuffer object
        // by
        // creating object of StringBuffer class
        StringBuffer sbr = new StringBuffer(str);
 
        // Reversing the string
        sbr.reverse();
 
        // Printing the reversed string
        System.out.println(sbr);
 
        // Converting String object to StringBuilder object
        StringBuilder sbl = new StringBuilder(str);
 
        // Adding it to string using append() method
        sbl.append("ForGeeks");
 
        // Print and display the above appended string
        System.out.println(sbl);
    }
}

输出：

skeeG
GeeksForGeeks

从StringBuffer和StringBuilder到String

可以使用以下命令执行此转换 toString () 方法，该方法在StringBuffer和StringBuilder类中都被重写。
下面是演示这一点的java程序。注意，当我们使用 toString () 方法时，将分配一个新的String对象(在Heap区域)，并初始化为当前由StringBuffer对象表示的字符序列，这意味着对StringBuffer对象的后续更改不会影响String对象的内容。

示例：

// Java Program to Demonstrate Conversion from
// String to StringBuffer and StringBuilder
 
// Main class
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Creating objects of StringBuffer class
        StringBuffer sbr = new StringBuffer("Geeks");
        StringBuilder sbdr = new StringBuilder("Hello");
 
        // Converting StringBuffer object to String
        // using toString() method
        String str = sbr.toString();
 
        // Printing the above string
        System.out.println(
            "StringBuffer object to String : ");
        System.out.println(str);
 
        // Converting StringBuilder object to String
        String str1 = sbdr.toString();
 
        // Printing the above string
        System.out.println(
            "StringBuilder object to String : ");
        System.out.println(str1);
 
        // Changing StringBuffer object sbr
        // but String object(str) doesn't change
        sbr.append("ForGeeks");
 
        // Printing the above two strings on console
        System.out.println(sbr);
        System.out.println(str);
    }
}

输出：

StringBuffer object to String : 
Geeks
StringBuilder object to String : 
Hello
GeeksForGeeks
Geeks

从StringBuffer到StringBuilder，或者反过来

这种转换很棘手。没有直接的方法来转换相同的。在这种情况下，我们可以使用String类对象。我们首先将StringBuffer/StringBuilder对象转换为String toString () 方法，然后使用构造函数将String转换为StringBuilder/StringBuffer。

示例：

// Java program to Demonstrate conversion from
// String to StringBuffer and StringBuilder
 
// Main class
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Creating object of StringBuffer class and
        // passing our input string to it
        StringBuffer sbr = new StringBuffer("Geeks");
 
        // Storing value StringBuffer object in String and
        // henceforth converting StringBuffer object to
        // StringBuilder class
        String str = sbr.toString();
        StringBuilder sbl = new StringBuilder(str);
 
        // Printing the StringBuilder object on console
        System.out.println(sbl);
    }
}