În exemplul dat, va fi creat un singur obiect. În primul rând, JVM nu va găsi niciun obiect șir cu valoarea Welcome în pool-ul constant de șir, așa că va crea un nou obiect. După aceea, va găsi șirul cu valoarea Welcome în pool, nu va crea un nou obiect ci va returna referința la aceeași instanță. În acest articol, vom afla despre șirurile Java.
Ce sunt șirurile în Java?
Șirurile sunt tipul de obiecte care pot stoca caracterul valorilor și în Java, fiecare caracter este stocat pe 16 biți, adică folosind codificarea UTF pe 16 biți. Un șir acționează la fel ca o matrice de caractere în Java.
Exemplu:
mașină virtuală java
String name = 'Geeks';>
Exemplu de șiruri în Java
Mai jos este un exemplu de șir în 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); } }> Ieșire
example>
Modalități de a crea un șir
Există două moduri de a crea un șir în Java:
- Literal șir
- Se utilizează un cuvânt cheie nou
Sintaxă:
= '';>
1. Literal șir
Pentru a face Java mai eficient memoria (deoarece nu sunt create obiecte noi dacă există deja în pool-ul constant de șiruri).
Exemplu:
String demoString = techcodeview.com;>
2. Folosind un cuvânt cheie nou
- String s = new String(Bine ați venit);
- Într-un astfel de caz, JVM va crea un nou obiect șir în memoria heap normală (non-pool) și literalul Welcome va fi plasat în pool-ul constant șir. Variabila s se va referi la obiectul din heap (non-pool)
Exemplu:
String demoString = new String (techcodeview.com);>
Interfețe și clase în șiruri în Java
CharBuffer : Această clasă implementează interfața CharSequence. Această clasă este folosită pentru a permite ca bufferele de caractere să fie folosite în locul CharSequences. Un exemplu de astfel de utilizare este pachetul cu expresii regulate java.util.regex.
Şir : Este o succesiune de caractere. În Java, obiectele String sunt imuabile, ceea ce înseamnă o constantă și nu pot fi modificate odată create.
Interfața CharSequence
Interfața CharSequence este folosită pentru reprezentarea secvenței de caractere în Java.
Clasele care sunt implementate folosind interfața CharSequence sunt menționate mai jos și acestea oferă o mare parte din funcționalități cum ar fi subșir, lastoccurence, prima apariție, concatenate, toupper, tolower etc.
- Şir
- StringBuffer
- StringBuilder
1. Snur
String este o clasă imuabilă, ceea ce înseamnă o constantă și nu poate fi schimbată odată creată și dacă dorim să schimbăm, trebuie să creăm un nou obiect și chiar și funcționalitatea pe care o oferă, cum ar fi toupper, tolower, etc. toate acestea returnează un nou obiect, nu se modifică. obiectul original. Este automat sigur pentru fire.
Sintaxă
String str= 'geeks'; or String str= new String('geeks')>2. StringBuffer
StringBuffer este o clasă de egali Şir , este mutabil în natură și este o clasă sigură pentru thread, îl putem folosi atunci când avem un mediu cu mai multe fire și un obiect partajat al string buffer, adică folosit de mai multe fire. Deoarece este sigur pentru fire, există o supraîncărcare suplimentară, deci este folosit în principal pentru programe cu mai multe fire.
Sintaxă:
StringBuffer demoString = new StringBuffer('techcodeview.com');>3. StringBuilder
StringBuilder în Java reprezintă o alternativă la String și StringBuffer Class, deoarece creează o secvență mutabilă de caractere și nu este sigură pentru fire. Este folosit numai în cadrul firului de execuție, deci nu există o suprasarcină suplimentară, deci este folosit în principal pentru programul cu un singur fir.
Sintaxă:
StringBuilder demoString = new StringBuilder(); demoString.append('GFG');>StringTokenizer
StringTokenizer clasa în Java este folosită pentru a rupe un șir în token-uri.
Exemplu:
Un obiect StringTokenizer menține intern o poziție curentă în șirul care urmează să fie tokenizat. Unele operații avansează această poziție curentă dincolo de caracterele procesate. Un token este returnat prin preluarea unui subșir al șirului care a fost folosit pentru a crea obiectul StringTokenizer.
StringJoiner este o clasă în java.util pachet care este folosit pentru a construi o secvență de caractere (șiruri) separate printr-un delimitator și opțional începând cu un prefix furnizat și se termină cu un sufix furnizat. Deși acest lucru se poate face și cu ajutorul clasei StringBuilder pentru a adăuga un delimitator după fiecare șir, StringJoiner oferă o modalitate ușoară de a face asta fără mult cod de scris.
Sintaxă:
public StringJoiner(CharSequence delimiter)>
Am văzut mai sus că putem crea un șir prin String Literal.
String demoString =Bun venit;
Aici JVM verifică pool-ul constant de șiruri. Dacă șirul nu există, atunci o nouă instanță de șir este creată și plasată într-un pool. Dacă șirul există, atunci nu va crea un obiect nou. Mai degrabă, va returna referința la aceeași instanță. Cache-ul care stochează aceste instanțe de șir este cunoscut sub numele de grupul String Constant sau String Pool. În versiunile anterioare de Java până la JDK 6 String pool era localizat în spațiul PermGen (Permanent Generation). Dar în JDK 7 este mutat în zona heap principală.
Șir imuabil în Java
În Java, obiectele șir sunt imuabile. Imuabil înseamnă pur și simplu nemodificabil sau neschimbabil. Odată ce un obiect șir este creat, datele sau starea acestuia nu pot fi modificate, dar este creat un nou obiect șir.
Mai jos este implementarea subiectului:
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); } }> Ieșire
Sachin>
Aici Sachin nu este schimbat, dar este creat un nou obiect cu Sachin Tendulkar. De aceea un șir este cunoscut ca imuabil.
După cum puteți vedea în figura dată, sunt create două obiecte, dar variabila de referință se referă la Sachin și nu la Sachin Tendulkar. Dar dacă o atribuim în mod explicit variabilei de referință, se va referi la obiectul Sachin Tendulkar.
De exemplu:
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); } }> Ieșire
Sachin Tendulkar>
Alocarea memoriei de șir
Ori de câte ori un obiect String este creat ca un literal, obiectul va fi creat în pool-ul de constante String. Acest lucru permite JVM să optimizeze inițializarea literalului String.
Exemplu:
String demoString = 'Geeks';>
Șirul poate fi declarat și folosind a nou operator, adică alocat dinamic. În cazul în care String sunt alocate dinamic, li se atribuie o nouă locație de memorie în heap. Acest șir nu va fi adăugat la pool-ul de constante String.
Exemplu:
String demoString = new String('Geeks');>Dacă doriți să stocați acest șir în pool-ul constant, va trebui să îl internați.
Exemplu:
String internedString = demoString.intern(); // this will add the string to string constant pool.>
Este de preferat să se utilizeze literale String, deoarece permite JVM să optimizeze alocarea memoriei.
Un exemplu care arată cum se declară un șir
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); } }> Ieșire
String name = techcodeview.com String newString = techcodeview.com>
Notă: Obiectul String este creat în zona Heap, iar literalele sunt stocate într-o zonă specială de memorie cunoscută sub numele de pool constant de șir.
De ce s-a mutat grupul String de la PermGen la cel zonă normală de grămadă?
Spațiul PermGen este limitat, dimensiunea implicită este de doar 64 MB. a fost o problemă cu crearea și stocarea prea multor obiecte șir în spațiul PermGen. De aceea, piscina String a fost mutată într-o zonă mai mare de grămadă. Pentru a eficientiza memoria Java, se folosește conceptul de șir literal. Prin utilizarea cuvântului cheie „nou”, JVM-ul va crea un nou obiect șir în zona heap normală, chiar dacă același obiect șir este prezent în pool-ul șir.
De exemplu:
String demoString = new String('Bhubaneswar');>Să aruncăm o privire asupra conceptului cu un program Java și să vizualizăm structura reală a memoriei JVM:
Mai jos este implementarea abordării de mai sus:
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); } }> Ieșire
TAT TAT TAT TAT>
Pool de șiruri în Java
Notă: Toate obiectele din Java sunt stocate într-un heap. Variabila de referință este la obiectul stocat în zona stivei sau pot fi conținute în alte obiecte, ceea ce le pune și în zona heap.
Exemplul 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); } }> Ieșire
GFG FG>
Exemplul 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); } }> Ieșire
Gfg Gfg>
întrebări frecvente
1. Ce sunt șirurile de caractere în Java?
Șirurile de caractere sunt tipurile de obiecte care pot stoca caractere ca elemente.
2. De ce obiectele șir sunt imuabile în Java?
Deoarece java folosește conceptul de șir literal. Să presupunem că există 5 variabile de referință, toate se referă la un singur obiect Sachin. Dacă o variabilă de referință modifică valoarea obiectului, aceasta va fi afectată de toate variabilele de referință. De aceea, obiectele șir sunt imuabile în Java.
Actrița Rubina Dilaik
3. De ce folosește Java conceptul de șir literal?
Pentru a face Java mai eficient memoria (deoarece nu sunt create obiecte noi dacă există deja în pool-ul constant de șiruri).