Was ist der Unterschied zwischen String und String in Java?

StackOverflow https://stackoverflow.com/questions/2439243

Frage

Was ist der Unterschied zwischen String und String in Java?

Gibt es eine maximale Größe für String?

War es hilfreich?

Lösung

String wird verwendet, Zeichenketten zu manipulieren, die nicht geändert werden kann (read-only und unveränderlich).

StringBuffer wird verwendet, um Zeichen darzustellen, die geändert werden können.

Performance weise, StringBuffer ist schneller, wenn Verkettungen ausgeführt wird. Dies liegt daran, wenn Sie ein String verketten, sind Sie ein neues Objekt erstellen (intern) jedes Mal, da String unveränderlich ist.

Sie können auch StringBuilder verwenden, die StringBuffer ähnlich ist, außer es ist nicht synchronisiert. Die maximale Größe für eine dieser beiden ist Integer.MAX_VALUE (2 31 - 1 = 2,147,483,647) oder Maximal durch 2 geteilt Speichergröße (siehe Wie viele Zeichen kann ein Java-String? hat). Weitere Informationen hier .

Andere Tipps

Ein String ist unveränderlich, das heißt, wenn es erstellt wird, kann es sich nie ändern.

Ein StringBuffer (oder das nicht synchronisierten Cousin StringBuilder) werden verwendet, wenn Sie benötigen, ohne die Performance-Overhead ein String Stück für Stück zu konstruieren, aus vielen kleinen Strings auf dem Weg zu bauen.

Die maximale Länge für beide ist Integer.MAX_VALUE, weil sie intern als Arrays gespeichert sind, und Java-Arrays haben leider nur eine int für ihre Länge pseudo-Feld.

Die Leistungsverbesserung zwischen Strings und StringBuffers für mehrere Verkettung ist sehr bedeutsam. Wenn Sie den folgenden Testcode ausführen, werden Sie den Unterschied sehen. Auf meinem alten Laptop mit Java 6, erhalte ich diese Ergebnisse: 

Concat with String took: 1781ms
Concat with StringBuffer took: 0ms

public class Concat
{
    public static String concatWithString()
    {
        String t = "Cat";
        for (int i=0; i<10000; i++)
        {
            t = t + "Dog";
        }
        return t;
    }
    public static String concatWithStringBuffer()
    {
        StringBuffer sb = new StringBuffer("Cat");
        for (int i=0; i<10000; i++)
        {
            sb.append("Dog");
        }
        return sb.toString();
    }
    public static void main(String[] args)
    {
        long start = System.currentTimeMillis();
        concatWithString();
        System.out.println("Concat with String took: " + (System.currentTimeMillis() - start) + "ms");
        start = System.currentTimeMillis();
        concatWithStringBuffer();
        System.out.println("Concat with StringBuffer took: " + (System.currentTimeMillis() - start) + "ms");
    }
}

String                                          StringBuffer

Immutable                                       Mutable
String s=new String("karthik");                StringBuffer sb=new StringBuffer("karthik")
s.concat("reddy");                             sb.append("reddy");
System.out.println(s);                         System.out.println(sb);
O/P:karthik                                    O/P:karthikreddy

--->once we created a String object            ---->once we created a StringBuffer object
we can't perform any changes in the existing  we can perform any changes in the existing
object.If we are trying to perform any        object.It is nothing but mutablity of 
changes with those changes a new object       of a StrongBuffer object
will be created.It is nothing but Immutability
of a String object

Use String--->If you require immutabilty
Use StringBuffer---->If you require mutable + threadsafety
Use StringBuilder--->If you require mutable + with out threadsafety

String s=new String("karthik");
--->here 2 objects will be created one is heap and the other is in stringconstantpool(scp) and s is always pointing to heap object

String s="karthik"; 
--->In this case only one object will be created in scp and s is always pointing to that object only

String ist eine unveränderliche Klasse. Dies bedeutet, dass, wenn Sie eine Instanz einer Zeichenfolge instanziiert etwa so: 

String str1 = "hello";

Das Objekt im Speicher kann nicht verändert werden. Stattdessen haben Sie eine neue Instanz erstellen, kopieren Sie den alten String und Anfügen was sonst wie in diesem Beispiel: 

String str1 = "hello";
str1 = str1 + " world!";

Was ist wirklich hören geschieht, ist, dass wir nicht das bestehende str1 Objekt aktualisieren ... wir sind Neuzuweisung alle zusammen, um neue Speicher, das Kopieren der „Hallo“ Daten und Anhängen von „world!“ bis zum Ende Einstellungen, dann die str1 Bezug auf diese neuen Speicher zu Punkt. So ist es wirklich eher wie dieses unter der Haube aussieht: 

String str1 = "hello";
String str2 = str1 + " world!";
str1 = str2;

So folgt daraus, dass dieser „kopiert + einfügen und verschiebt Material um im Speicher“ Prozess sehr teuer, wenn repitively besonders rekursiv durchgeführt werden kann.

Wenn Sie in dieser Situation sind, die String Dinge zu tun, immer und immer wieder verwenden. Es ist wandelbar und kann Strings bis zum Ende der aktuellen hängen, weil sie von einem [wachsenden Array] sind zurück (nicht 100%, wenn, dass die tatsächliche Datenstruktur ist, könnte eine Liste sein).

Aus dem API:

  

A threadsicher, veränderbare Folge von Zeichen. Ein String-Puffer ist wie ein String, kann aber geändert werden. Zu jedem Zeitpunkt enthält es einige bestimmte Abfolge von Zeichen, aber die Länge und Gehalt der Sequenz kann durch bestimmte Methodenaufrufe geändert werden.

Ein String wird verwendet, um eine einzelne Zeichenfolge aus vielen Saiten zu erstellen, zum Beispiel wenn Sie Teile eines String in einer Schleife anzuhängen.

Sie sollten einen String anstelle einem String verwenden, wenn Sie nur ein einziges Thema haben den String zugreifen, da der String nicht synchronisiert ist und somit schneller.

AFAIK gibt es keine Obergrenze für String Größe in Java als Sprache, aber die JVMs wahrscheinlich eine Obergrenze hat.

fand ich Interesse Antwort für vergleichen Performance String vs String von Reggie Hutcherso Quelle : http: // www.javaworld.com/javaworld/jw-03-2000/jw-0324-javaperf.html

Java stellt die String und String-Klassen und die String-Klasse werden Zeichenketten zu manipulieren, die nicht geändert werden kann. Einfach gesagt, werden gelesen Objekte vom Typ String nur und unveränderlich. Die String-Klasse wird verwendet, um Zeichen darzustellen, die geändert werden können.

Der signifikante Unterschied in der Leistung zwischen diesen beiden Klassen ist, dass String schneller als String ist, wenn einfache Verkettungen ausgeführt wird. In String-Manipulation Code, werden Zeichenketten routinemäßig verkettet. Mit Hilfe der String-Klasse werden Verkettungen typischerweise wie folgt durchgeführt: 

 String str = new String ("Stanford  ");
 str += "Lost!!";

Wenn Sie String zu verwenden, sind die gleiche Verkettung auszuführen, würden Sie Code, um das wie folgt aussieht: 

 StringBuffer str = new StringBuffer ("Stanford ");
 str.append("Lost!!");

Entwickler in der Regel davon ausgehen, dass das erste Beispiel oben ist effizienter, weil sie denken, dass das zweite Beispiel, das die Append Methode zur Verkettung verwendet, teurer ist als das erste Beispiel, die den Operator + verwendet, um verketten zwei String-Objekte.

Der Operator + erscheint unschuldig, aber der erzeugte Code einige Überraschungen erzeugt. Mit Hilfe eines String für Verkettung kann in der Tat produzieren Code, der als mit einem String deutlich schneller ist. Um herauszufinden, warum dies der Fall ist, müssen wir den erzeugten Bytecode aus unseren beiden Beispielen untersuchen. Der Bytecode für das Beispiel mit String sieht wie folgt aus: 

0 new #7 <Class java.lang.String>
3 dup 
4 ldc #2 <String "Stanford ">
6 invokespecial #12 <Method java.lang.String(java.lang.String)>
9 astore_1
10 new #8 <Class java.lang.StringBuffer>
13 dup
14 aload_1
15 invokestatic #23 <Method java.lang.String valueOf(java.lang.Object)>
18 invokespecial #13 <Method java.lang.StringBuffer(java.lang.String)>
21 ldc #1 <String "Lost!!">
23 invokevirtual #15 <Method java.lang.StringBuffer append(java.lang.String)>
26 invokevirtual #22 <Method java.lang.String toString()>
29 astore_1

Der Bytecode an Stellen 0 bis 9 ist, für die erste Zeile des Codes ausgeführt wird, nämlich: 

 String str = new String("Stanford ");

Dann wird der Bytecode an Position 10 bis 29 wird für die Verkettung ausgeführt: 

 str += "Lost!!";

Denn interessant hier. Der Bytecode für die Verkettung erzeugt ein Stringbuffer-Objekt erzeugt, ruft dann seine append Methode: das temporäre Stringbuffer-Objekt an der Stelle 10 erzeugt wird, und seine append Methode wird an der Position 23 bezeichnet, da der String-Klasse unveränderlich ist, ein Stringbuffer verwendet werden, müssen für Verkettung.

Nach der Verkettung auf dem String Objekt ausgeführt wird, muss es konvertiert wieder in einen String sein. Dies wird mit dem Aufruf der Methode toString an der Stelle getan 26. Diese Methode erstellt ein neues String-Objekt aus dem temporären Stringobjekt. Die Schaffung dieses temporäre String Objekt und dessen anschließende Umwandlung zurück in ein String-Objekt sind sehr teuer.

Zusammenfassend die beiden Codezeilen oben Ergebnis bei der Schaffung von drei Objekten:

  1. Ein String-Objekt an der Stelle 0
  2. Ein Stringobjekt an der Stelle 10
  3. Ein String-Objekt an der Stelle 26

Lassen Sie uns nun einen Blick auf die Bytecode für das Beispiel erzeugt String mit: 

0 new #8 <Class java.lang.StringBuffer>
3 dup
4 ldc #2 <String "Stanford ">
6 invokespecial #13 <Method java.lang.StringBuffer(java.lang.String)>
9 astore_1
10 aload_1 
11 ldc #1 <String "Lost!!">
13 invokevirtual #15 <Method java.lang.StringBuffer append(java.lang.String)>
16 pop

Der Bytecode an Stellen 0 bis 9 für die erste Zeile Code ausgeführt: 

 StringBuffer str = new StringBuffer("Stanford ");

Der Bytecode an Position 10 bis 16 dann für die Verkettung ausgeführt wird: 

 str.append("Lost!!");

Beachten Sie, dass, wie es der Fall bei dem ersten Beispiel ist, ruft dieser Code die Append-Methode eines Stringobjekts. Im Gegensatz zu dem ersten Beispiel, jedoch gibt es keine Notwendigkeit, eine temporäre String zu erstellen und sie dann in ein Objekt String zu konvertieren. Dieser Code erstellt nur ein Objekt, das String, an der Stelle 0.

Abschließend ist String Verkettung deutlich schneller als String-Verkettung. Offensichtlich Stringbuffers sollten, wenn möglich, in dieser Betriebsart verwendet werden. Wenn die Funktionalität der String-Klasse gewünscht ist, hält eine Stringbuffer zur Verkettung und anschließend eine Konvertierung zu String durchgeführt wird.

Durch den Druck des Hash-Code des String / String Objekts nach jeder Operation Append auch beweisen, String-Objekt wird immer intern jedes Mal mit neuen Werten neu erstellt, anstatt das gleiche String-Objekt. 

public class MutableImmutable {

/**
 * @param args
 */
public static void main(String[] args) {
    System.out.println("String is immutable");
    String s = "test";
    System.out.println(s+"::"+s.hashCode());
    for (int i = 0; i < 10; i++) {
        s += "tre";
        System.out.println(s+"::"+s.hashCode());
    }

    System.out.println("String Buffer is mutable");

    StringBuffer strBuf = new StringBuffer("test");
    System.out.println(strBuf+"::"+strBuf.hashCode());
    for (int i = 0; i < 10; i++) {
        strBuf.append("tre");
        System.out.println(strBuf+"::"+strBuf.hashCode());
    }

 }

}

Ausgabe: Er druckt Objektwert zusammen mit seinem Hash-Code 

    String is immutable
    test::3556498
    testtre::-1422435371
    testtretre::-1624680014
    testtretretre::-855723339
    testtretretretre::2071992018
    testtretretretretre::-555654763
    testtretretretretretre::-706970638
    testtretretretretretretre::1157458037
    testtretretretretretretretre::1835043090
    testtretretretretretretretretre::1425065813
    testtretretretretretretretretretre::-1615970766
    String Buffer is mutable
    test::28117098
    testtre::28117098
    testtretre::28117098
    testtretretre::28117098
    testtretretretre::28117098
    testtretretretretre::28117098
    testtretretretretretre::28117098
    testtretretretretretretre::28117098
    testtretretretretretretretre::28117098
    testtretretretretretretretretre::28117098
    testtretretretretretretretretretre::28117098

Ein StringBuffer oder sein jüngerer und schnellerer Bruder StringBuilder wird dann bevorzugt, wenn Sie eine Menge von String-Verkettungen im Geschmack von

gehen do 
string += newString;

oder äquivalent 

string = string + newString;

, da die obigen Konstrukte erzeugt implizit neue string jedes Mal, das eine große Leistung und Drop sein wird. Ein StringBuffer / StringBuilder ist unter den Hauben am besten mit einem dynamisch dehnbaren List<Character> verglichen werden.

A String ist ein unveränderliches Zeichenfeld.

A StringBuffer ist ein veränderbares Zeichenfeld. Oft konvertiert zurück zu String, wenn Sie fertig mutiert.

Da sowohl ein Array ist, ist die maximale Größe für beide gleich die maximale Größe einer ganze Zahl, die 2 ^ 31-1 (siehe JavaDoc Besuche auch die JavaDoc sowohl für String und StringBuffer) .Dies ist, weil das .length Argument ein Array ist eine primitive int. (Siehe Arrays ).

String ist unveränderlich, was bedeutet, dass, wenn Sie einen Vorgang auf einem String führen Sie wirklich einen ganz neuen String zu schaffen.

String ist wandelbar, und Sie anhängen, um es kann sowie seine Länge auf 0 zurückgesetzt.

In der Praxis scheint der Compiler String während String Verkettung aus Leistungsgründen zu verwenden . 

String is immutable.

Warum? Überprüfen Sie hier . 

StringBuffer is not. It is thread safe.

Weitere Fragen wie, wann welche und andere Konzepte verwenden a href folgend herausgefunden werden <= „http://www.acquireandinspire.org/2013/01/string-string-builder-string-buffer.html“ rel = "nofollow"> diese .

Hope, das hilft.

Während ich verstehe, dass dies Differenzierungsfaktor kein großes ist, bemerkte ich heute, dass String (und String) bietet einige interessante Methoden, die String nicht.

  • reverse ()
  • setCharAt ()

Die Unterschiede sind

  1. Nur in String Klasse + Operator ist überlastet. Wir können zwei String-Objekt mit concat + Operator, aber im Fall von String können wir nicht.

  2. String Klasse überschreibt toString (), equals (), hashCode () von Object Klasse, aber String nur Überschreibungen toString (). 

    String s1 = new String("abc");
String s2 = new String("abc");
System.out.println(s1.equals(s2));  // output true

StringBuffer sb1 = new StringBuffer("abc");
StringBuffer sb2 = new StringBuffer("abc");
System.out.println(sb1.equals(sb2));  // output false

  3. String Klasse ist sowohl Serializable sowie Vergleichbare , sondern String ist nur Serializable . 

    Set<StringBuffer> set = new TreeSet<StringBuffer>();
set.add(sb1);
set.add(sb2);
System.out.println(set);  // gives ClassCastException because there is no Comparison mechanism

  4. Wir können ein String-Objekt mit erstellen und ohne neuen Operator, aber String Objekt kann nur unter Verwendung erstellt werden neuen Operator.

  5. String ist unveränderlich, aber String ist wandelbar.
  6. String synchronisiert, während String nicht.
  7. String ist mit einer eingebauten reverse () Methode, aber String dosen't es haben.

Performance weise String ist viel besser als String; weil, wenn Sie Verkettung auf String-Objekt dann neues String-Objekt auf jeder Verkettung erstellt.

anwenden

Hauptregel: String ist unveränderlich (nicht änderbar) und String ist wandelbar (Veränderbare)

Hier ist das programmatische Experiment, in dem Sie den Performance-Unterschied bekommen 

public class Test {

  public static int LOOP_ITERATION= 100000;

  public static void stringTest(){
    long startTime = System.currentTimeMillis();
    String string = "This";
    for(int i=0;i<LOOP_ITERATION;i++){
        string = string+"Yasir";
    }

    long endTime = System.currentTimeMillis();
    System.out.println(endTime - startTime);    
  }

  public static void stringBufferTest(){
    long startTime = System.currentTimeMillis();
    StringBuffer stringBuffer = new StringBuffer("This");
    for(int i=0;i<LOOP_ITERATION;i++){
        stringBuffer.append("Yasir");
    }

    long endTime = System.currentTimeMillis();
    System.out.println(endTime - startTime);
  }

  public static void main(String []args){
    stringTest()
    stringBufferTest(); 
  }
 }

Ausgabe von String ist in meiner Maschine    14800

Ausgabe von String ist in meiner Maschine   14

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top