logo

Tekenreeksen in Java

In het gegeven voorbeeld wordt slechts één object gemaakt. Ten eerste zal JVM geen enkel stringobject met de waarde Welcome vinden in de stringconstantepool, dus zal het een nieuw object aanmaken. Daarna zal het de string met de waarde Welcome in de pool vinden, het zal geen nieuw object aanmaken maar de verwijzing naar dezelfde instantie retourneren. In dit artikel leren we over Java-strings.

Wat zijn tekenreeksen in Java?

Strings zijn het type objecten dat het karakter van waarden kan opslaan en in Java wordt elk karakter opgeslagen in 16 bits, dat wil zeggen met behulp van UTF 16-bits codering. Een string gedraagt ​​zich hetzelfde als een array van karakters in Java.



Voorbeeld:

String name = 'Geeks';>
Tekenreeksvoorbeeld in Java

Tekenreeksvoorbeeld in Java

Hieronder ziet u een voorbeeld van een string in Java:



Java
// Java Program to demonstrate // String public class StringExample {  // Main Function  public static void main(String args[])  {  String str = new String('example');  // creating Java string by new keyword  // this statement create two object i.e  // first the object is created in heap  // memory area and second the object is  // created in String constant pool.  System.out.println(str);  } }>

Uitvoer
example>

Manieren om een ​​string te creëren

Er zijn twee manieren om een ​​string in Java te maken:

  • Tekenreeks letterlijk
  • Nieuw zoekwoord gebruiken

Syntaxis:

 = '';>

1. Tekenreeks letterlijk

Om Java geheugenefficiënter te maken (omdat er geen nieuwe objecten worden gemaakt als deze al in de reeksconstantenpool voorkomen).



Voorbeeld:

String demoString = techcodeview.com;>

2. Nieuw trefwoord gebruiken

  • String s = nieuwe String(Welkom);
  • In een dergelijk geval zal JVM een nieuw stringobject creëren in het normale (niet-pool) heapgeheugen en zal het letterlijke Welcome in de stringconstantepool worden geplaatst. De variabele s verwijst naar het object in de heap (niet-pool)

Voorbeeld:

panda's spil
String demoString = new String (techcodeview.com);>

Interfaces en klassen in tekenreeksen in Java

CharBuffer : Deze klasse implementeert de CharSequence-interface. Deze klasse wordt gebruikt om het gebruik van tekenbuffers in plaats van CharSequences mogelijk te maken. Een voorbeeld van dergelijk gebruik is het pakket met reguliere expressies java.util.regex.

Snaar : Het is een reeks karakters. In Java zijn objecten van String onveranderlijk, wat een constante betekent en niet meer kan worden gewijzigd nadat ze zijn gemaakt.

CharSequence-interface

CharSequence Interface wordt gebruikt voor het weergeven van de reeks tekens in Java.
Klassen die zijn geïmplementeerd met behulp van de CharSequence-interface worden hieronder vermeld en deze bieden veel functionaliteit zoals substring, lastoccurence, first instance, concatenate , toupper, tolower enz.

  1. Snaar
  2. StringBuffer
  3. StringBuilder

1. Snaar

String is een onveranderlijke klasse, wat een constante betekent en niet meer kan worden gewijzigd nadat deze is gemaakt. Als we dit willen veranderen, moeten we een nieuw object maken en zelfs de functionaliteit die het biedt, zoals toupper, tolower, enz. Deze retourneren allemaal een nieuw object, het is niet gewijzigd het oorspronkelijke voorwerp. Het is automatisch draadveilig.

Java 8-functies

Syntaxis

String str= 'geeks';  or String str= new String('geeks')>

2. StringBuffer

StringBuffer is een peer-klasse van Snaar , het is veranderlijk van aard en het is een thread-safe class, we kunnen het gebruiken als we een omgeving met meerdere threads en een gedeeld object van stringbuffer hebben, dat wil zeggen, gebruikt door meerdere threads. Omdat het threadsafe is, is er extra overhead en wordt het daarom voornamelijk gebruikt voor multithreaded programma's.

Syntaxis:

StringBuffer demoString = new StringBuffer('techcodeview.com');>

3. StringBuilder

StringBuilder in Java vertegenwoordigt een alternatief voor de String- en StringBuffer-klasse, omdat het een veranderlijke reeks tekens creëert en niet thread-safe is. Het wordt alleen binnen de thread gebruikt, dus er is geen extra overhead, dus het wordt voornamelijk gebruikt voor programma's met één thread.

Syntaxis:

StringBuilder demoString = new StringBuilder(); demoString.append('GFG');>

StringTokenizer

StringTokenizer klasse in Java wordt gebruikt om een ​​string in tokens op te splitsen.

Voorbeeld:

String-tokenizer in Java

Een StringTokenizer-object behoudt intern een huidige positie binnen de string die moet worden getokeniseerd. Sommige bewerkingen verplaatsen deze huidige positie voorbij de verwerkte tekens. Er wordt een token geretourneerd door een subtekenreeks te nemen van de tekenreeks die is gebruikt om het StringTokenizer-object te maken.

Java-trimstring

StringJoiner is een klasse in java.util pakket dat wordt gebruikt om een ​​reeks tekens (strings) te construeren, gescheiden door een scheidingsteken en optioneel beginnend met een opgegeven voorvoegsel en eindigend met een opgegeven achtervoegsel. Hoewel dit ook kan worden gedaan met behulp van de StringBuilder-klasse, waarbij na elke string een scheidingsteken wordt toegevoegd, biedt StringJoiner een eenvoudige manier om dat te doen zonder dat er veel code hoeft te worden geschreven.

Syntaxis:

public StringJoiner(CharSequence delimiter)>

Hierboven hebben we gezien dat we een string kunnen maken met String Literal.

String demoString =Welkom;

Hier controleert de JVM de String Constant Pool. Als de string niet bestaat, wordt er een nieuwe stringinstantie gemaakt en in een pool geplaatst. Als de string bestaat, wordt er geen nieuw object gemaakt. In plaats daarvan wordt de verwijzing naar dezelfde instantie geretourneerd. De cache waarin deze tekenreeksinstanties worden opgeslagen, staat bekend als de String Constant-pool of String Pool. In eerdere versies van Java bevond de String-pool zich tot JDK 6 in de PermGen-ruimte (Permanent Generation). Maar in JDK 7 wordt het verplaatst naar het hoofdheapgebied.

Onveranderlijke tekenreeks in Java

In Java zijn stringobjecten onveranderlijk. Onveranderlijk betekent eenvoudigweg onveranderlijk of onveranderlijk. Zodra een stringobject is gemaakt, kunnen de gegevens of de status ervan niet meer worden gewijzigd, maar wordt er een nieuw stringobject gemaakt.

Hieronder vindt u de implementatie van het onderwerp:

Java
// Java Program to demonstrate Immutable String in Java import java.io.*; class GFG {  public static void main(String[] args)  {  String s = 'Sachin';    // concat() method appends  // the string at the end  s.concat(' Tendulkar');    // This will print Sachin  // because strings are  // immutable objects  System.out.println(s);  } }>

Uitvoer
Sachin>

Hier wordt Sachin niet gewijzigd, maar wordt er een nieuw object gemaakt met Sachin Tendulkar. Daarom staat een string bekend als onveranderlijk.

Zoals u in de gegeven afbeelding kunt zien, worden er twee objecten gemaakt, maar verwijst de referentievariabele nog steeds naar Sachin en niet naar Sachin Tendulkar. Maar als we het expliciet toewijzen aan de referentievariabele, zal het verwijzen naar het Sachin Tendulkar-object.

sneltoets met alleen hoofdletters excel

Bijvoorbeeld:

Java
// Java Program to demonstrate Explicitly assigned strings import java.io.*; class GFG {  public static void main(String[] args)  {  String name = 'Sachin';  name = name.concat(' Tendulkar');  System.out.println(name);  } }>

Uitvoer
Sachin Tendulkar>

Geheugentoewijzing van string

Telkens wanneer een String-object als letterlijke waarde wordt gemaakt, wordt het object gemaakt in de String-constantenpool. Hierdoor kan JVM de initialisatie van String letterlijk optimaliseren.

Voorbeeld:

String demoString = 'Geeks';>

De string kan ook worden gedeclareerd met behulp van a nieuw operator, d.w.z. dynamisch toegewezen. Als String dynamisch wordt toegewezen, krijgt deze een nieuwe geheugenlocatie in de heap toegewezen. Deze tekenreeks wordt niet toegevoegd aan de tekenreeksconstantenpool.

Voorbeeld:

String demoString = new String('Geeks');>

Als u deze string in de constante pool wilt opslaan, moet u deze interneren.

Voorbeeld:

String internedString = demoString.intern();  // this will add the string to string constant pool.>

Het verdient de voorkeur om String-literals te gebruiken, omdat JVM hierdoor de geheugentoewijzing kan optimaliseren.

Een voorbeeld dat laat zien hoe u een String declareert

Java
// Java code to illustrate String import java.io.*; import java.lang.*; class Test {  public static void main(String[] args)  {  // Declare String without using new operator  String name = 'techcodeview.com';  // Prints the String.  System.out.println('String name = ' + name);  // Declare String using new operator  String newString = new String('techcodeview.com');  // Prints the String.  System.out.println('String newString = ' + newString);  } }>

Uitvoer
String name = techcodeview.com String newString = techcodeview.com>


Opmerking: String Object wordt gemaakt in het Heap-gebied en Literals worden opgeslagen in een speciaal geheugengebied dat bekend staat als de string-constantepool.

Waarom is de String-pool verhuisd van PermGen naar de normaal hoopgebied?

De PermGen-ruimte is beperkt, de standaardgrootte is slechts 64 MB. het was een probleem met het maken en opslaan van te veel stringobjecten in de PermGen-ruimte. Daarom is de String-pool verplaatst naar een groter heap-gebied. Om Java geheugenefficiënter te maken, wordt het concept van letterlijke strings gebruikt. Door het gebruik van het trefwoord ‘nieuw’ zal de JVM een nieuw stringobject creëren in het normale heapgebied, zelfs als hetzelfde stringobject aanwezig is in de stringpool.

Linux-architectuur

Bijvoorbeeld:

String demoString = new String('Bhubaneswar');>

Laten we het concept eens bekijken met een Java-programma en de feitelijke JVM-geheugenstructuur visualiseren:

Hieronder vindt u de implementatie van de bovenstaande aanpak:

Java
// Java program and visualize the // actual JVM memory structure // mentioned in image class StringStorage {  public static void main(String args[])  {  // Declaring Strings  String s1 = 'TAT';  String s2 = 'TAT';  String s3 = new String('TAT');  String s4 = new String('TAT');  // Printing all the Strings  System.out.println(s1);  System.out.println(s2);  System.out.println(s3);  System.out.println(s4);  } }>

Uitvoer
TAT TAT TAT TAT>
Stringpool op Java

Stringpool op Java

Opmerking: Alle objecten in Java worden op een heap opgeslagen. De referentievariabele heeft betrekking op het object dat is opgeslagen in het stapelgebied, maar kan ook in andere objecten zijn opgenomen, waardoor ze ook in het heapgebied worden geplaatst.

Voorbeeld 1:

Java
// Construct String from subset of char array // Driver Class class GFG {  // main function  public static void main(String args[])  {  byte ascii[] = { 71, 70, 71 };  String firstString = new String(ascii);  System.out.println(firstString);  String secondString = new String(ascii, 1, 2);  System.out.println(secondString);  } }>

Uitvoer
GFG FG>

Voorbeeld 2:

Java
// Construct one string from another class GFG {  public static void main(String args[])  {  char characters[] = { 'G', 'f', 'g' };  String firstString = new String(characters);  String secondString = new String(firstString);  System.out.println(firstString);  System.out.println(secondString);  } }>

Uitvoer
Gfg Gfg>

Veel Gestelde Vragen

1. Wat zijn tekenreeksen in Java?

Strings zijn de typen objecten die tekens als elementen kunnen opslaan.

2. Waarom zijn stringobjecten onveranderlijk in Java?

Omdat Java het concept van letterlijke tekenreeks gebruikt. Stel dat er 5 referentievariabelen zijn, die allemaal naar één object Sachin verwijzen. Als één referentievariabele de waarde van het object verandert, wordt deze beïnvloed door alle referentievariabelen. Daarom zijn stringobjecten onveranderlijk in Java.

3. Waarom gebruikt Java het concept van letterlijke tekenreeksen?

Om Java geheugenefficiënter te maken (omdat er geen nieuwe objecten worden gemaakt als deze al in de reeksconstantenpool voorkomen).