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
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.
- Snaar
- StringBuffer
- 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:

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
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).