Zeichenfolge in Java

Eine Zeichenfolge ist eine Folge von Zeichen, aber in Java werden sie als Objekte behandelt und sind ihrer Natur nach unveränderlich; Java stellt das Paket java.lang.String mit verschiedenen Methoden zur Verfügung, um einen String zu bearbeiten, aber wir können auch einen veränderlichen String in Java erstellen.

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

Wie definiere ich einen String in Java?

Wir können es definieren, indem wir das String-Literal und neue Schlüsselwörter verwenden. Der Unterschied besteht jedoch darin, dass das Literal das neue Objekt erst erstellt, wenn es nicht im String-Pool verfügbar ist. Das neue Schlüsselwort erstellt jedoch immer das neue Objekt, unabhängig vom String-Konstantenpool, da es einen String im Heap-Bereich erstellt.

• Veränderlicher String
• Unveränderliche Zeichenfolge

Wie erstelle ich einen String in Java?

In Java können wir Zeichenfolgen auf zwei Arten definieren:

• Durch die Verwendung eines String-Literals
• Durch die Verwendung eines neuen Schlüsselworts

1. String-Literal

Der String, den wir mithilfe von Literalen erstellen, geht direkt in den String-Konstantenpool. Das heißt, wenn die angeforderte Zeichenfolge bereits im Zeichenfolgenpool vorhanden ist, wird die vorhandene Zeichenfolge zurückgegeben. Wenn die angeforderte Zeichenfolge nicht vorhanden ist, wird nur eine neue Instanz der Zeichenfolge erstellt und zur späteren Referenz im Pool abgelegt. Die JVM führt all diese Dinge aus.

Syntax:

String s="abc";
String s1 = "abc" ;

Im obigen Szenario würde nur ein Objekt im String-Pool erstellt, da JVM das angeforderte Objekt nicht finden kann, es also erstellt und im Pool ablegt und s1 nur auf diese Referenz verweist zur weiteren Verwendung. String-Literale sparen also auch Speicher, indem sie nicht dieselbe Instanz erneut erstellen. Daher machen sie unseren Codespeicher effizient.

2. neues Schlüsselwort

In Java verwenden wir das Schlüsselwort new, um ein neues Objekt zu erstellen. Immer wenn wir ein neues Schlüsselwort verwenden, wird ein neues Objekt für uns erstellt. Außerdem wird ein mit einem neuen Schlüsselwort erstelltes Objekt im Heap-Speicherbereich abgelegt.

Syntax:

String s = new Stirng("abc");

Im obigen Beispiel wird dieses Objekt im Heap-Speicherbereich und nicht im String-Pool abgelegt, da wir es mit dem Schlüsselwort new erstellen.

Beispiel:

public class Main {
public static void main(String[] args) {
String s = "abc";
String s1 = "abc";
String ss = new String("abc");
System.out.println("Output will be :: " + s + " "+ s1 +" "+ ss);
}
}

Ausgabe:

Regeln und Vorschriften für String in Java

Es ist unveränderlich, daher können wir seinen einmal zugewiesenen Wert nicht ändern. Um also einen veränderlichen String zu erstellen, müssen wir dafür einen String-Puffer verwenden.

Ein paar Punkte müssen beachtet werden:

•  Achten Sie beim Definieren einer Zeichenfolge darauf, dass diese immer in doppelte Anführungszeichen gesetzt wird.
• Sie sind unveränderlich, d. h. der Wert kann nach der Zuweisung nicht mehr geändert werden.
• Der „+“-Operator kann zwei oder mehr Zeichenfolgen verketten.
• Wir können die Zeichenfolge direkt einer Variablen zuweisen, ohne ihren Konstruktor aufzurufen.

Methoden der String-Klasse in Java

Es stehen folgende Methoden zur Verfügung:

• trim()
• toUpperCase
• toLowerCase
• valueOf(int value)
• toLowerCase(Locale l)
• praktikant()
• indexOf(int ch)
• indexOf(String substring, int fromIndex)
• indexOf(String substring)
• split(String regex, int limit)
• concat(String str)
• indexOf(int ch, int fromIndex)
• length()
• gleich (Objekt ein anderes)
• join(CharSequence-Trennzeichen, Iterable-Elemente)
• isEmpty()
• ersetzen(char alt, char neu)
• equalsIgnoreCase(String another)
• split(String regex)
• toUpperCase(Locale l)
• enthält(CharSequence s)
• charAt(int index)
• replace(CharSequence old, CharSequence new)
• join(CharSequence-Trennzeichen, CharSequence…-Elemente)
• substring(int beginIndex)
• ubstring(int beginIndex, int endIndex)
• String-Klasse in Java implementiert eine andere Schnittstelle mit dem Namen
• Serialisierbar
• Vergleichbar
• CharSequence

Außerdem implementiert die String-Klasse eine weitere Schnittstelle, nämlich die CharSequence-Schnittstelle; StringBuilder und String Buffer implementieren diese Schnittstelle ebenfalls. StringBuffer und StringBuilder werden verwendet, um die veränderbare Zeichenfolge in Java zu erstellen.

Beispiel – Verwendung von StringBuffer

Code:

public class Demo{
public static void main(String[] args) {
StringBuffer sb=new StringBuffer("creating string ");
sb.append("executed");//original string will get chnage
System.out.println("Result is " +sb);//it will print creating string executed
}
}

Ausgabe:

Beispiel – Verwendung von StringBuilder

Code:

public class Main{
public static void main(String[] args) {
StringBuilder sb=new StringBuilder("Creating string");
sb.append(" using string Builder");//original will get change
System.out.println("Result is "+sb);
}
}

Ausgabe:

Beispiele

Unten sind die Beispiele:

Beispiel #1

Code:

public class Main{
public static void main(String[] args) {
String s1="demoforsting";
System.out.println("String is " +s1.substring(2,4));
System.out.println( "with one parameter " +s1.substring(2));
}
}

Ausgabe:

Example #2

Code:

public class Demo{
public static void main(String[] args) {
String s1="abc";
String s2="abc";
String s3="ABC";
String s4="java";
System.out.println("Result is " +s1.equals(s2));//true
System.out.println("Result is " +s1.equals(s3));//false
System.out.println("Result is " +s1.equals(s4));//false
}
}

Output:

Example #3

Code:

public class Demo{
public static void main(String[] args) {
String s1="convert it into uppercase";
String upper=s1.toUpperCase();
System.out.println("result is "+upper);
}
}

Output:

Example #4

Code:

public class Demo{
public static void main(String[] args) {
String s1="CONVERT IT INTO LOWER CASE";
String s1upper=s1.toLowerCase();
System.out.println("result is "+s1upper);
}
}

Output:

Example #5

Code:

public class Main{
public static void main(String[] args) {
String name="Demo to check contains method";
System.out.println("Result for conatins mehtod is " +name.contains("check"));
System.out.println("Result for conatins mehtod is " +name.contains("method"));
System.out.println("Result for conatins mehtod is " +name.contains("move"));
}
}

Output:

Example #6

Code:

public class Main{
public static void main(String[] args) {
String str1 = "Demo for";
String str2 = "Concat";
String str3 = "Method";
// doing for string one
String str4 = str1.concat(str2);
System.out.println("Result is "+str4);
// for multiple string
String str5 = str1.concat(str2).concat(str3);
System.out.println("Result is "+str5);
}
}

Output:

Example #7

Code:

public class Main {
public static void main(String[] args) {
String s1 =" Provide space to see use of trim method in java ";
System.out.println(s1.length());
System.out.println("without trim output is "+s1); //Not using trim here
String tr = s1.trim();
System.out.println(tr.length());
System.out.println("with trim output is "+tr); //using trim here
}
}

Output:

Conclusion

So java string is an immutable object that provides security in various aspects like URL reading, database username and password, port, and many other things. But if we want to create a mutable string, we should use a string buffer and builder.

Das obige ist der detaillierte Inhalt vonZeichenfolge in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!