Java String Array - Tutorial cu exemple de cod

java string array tutorial with code examples

Încercați Instrumentul Nostru Pentru Eliminarea Problemelor

Selectați Sistemul De Operare Alegeți Un Program De Proiecție (Opțional)

Descrie -Ți Problema

Acest tutorial despre Java String Array explică cum să declarăm, să inițializăm și să creăm matrice de șiruri în Java și conversiile pe care le putem efectua pe matrice de șiruri:

Tablourile sunt o structură de date importantă în Java care sunt utilizate pentru a stoca diferite tipuri de date de la primitive la definite de utilizator. Am văzut deja elementele de bază ale matricelor și celelalte operații majore care pot fi efectuate pe matrice.

Într-unul dintre tutorialele noastre anterioare, am discutat despre diferitele tipuri de date pe care le poate deține o matrice.

=> A-Z de formare Java pentru începători

Java String Array și diverse metode

Unul dintre tipurile de date pe care tablourile le pot conține este un șir. În acest caz, matricea se numește matrice String.

Ce veți învăța:

Ce este o matrice de șiruri în Java?
Concluzie
- Lectură recomandată

Ce este o matrice de șiruri în Java?

Putem avea o matrice cu șiruri ca elemente. Astfel, putem defini o matrice de șiruri ca o matrice care conține un număr fix de șiruri sau valori de șir. String array este o structură care este cel mai frecvent utilizată în Java. Dacă vă amintiți, chiar argumentul funcției „principale” în Java este un String Array.

String array este un set de obiecte. Acest lucru se datorează faptului că fiecare element este un șir și știți că în Java, șirul este un obiect. Puteți face toate operațiunile pe matrice String, cum ar fi sortarea, adăugarea unui element, alăturarea, divizarea, căutarea etc.

În acest tutorial, vom discuta în detaliu matricea de șiruri în Java, împreună cu diferitele operații și conversii pe care le putem efectua pe matricile de șiruri.

Declararea unei matrice de șiruri

O matrice de șiruri poate fi declarată în două moduri, adică cu o dimensiune sau fără a specifica dimensiunea.

Mai jos sunt prezentate cele două modalități de declarare a unui String Array.

String() myarray ; //String array declaration without size String() myarray = new String(5);//String array declaration with size

În prima declarație, o matrice de șiruri este declarată la fel ca o variabilă normală, fără nicio dimensiune. Rețineți că, înainte de a utiliza această matrice, va trebui să o instanțiați cu una nouă.

În a doua declarație, un String Array este declarat și instanțiat folosind nou. Aici este declarată o matrice String „myarray” cu cinci elemente. Dacă tipăriți direct elementele acestui tablou, veți vedea toate valorile nule, deoarece tabloul nu este inițializat.

Să implementăm un program care arată o declarație String Array.

 public class Main { public static void main(String() args) { String() myarray; //declaration of string array without size String() strArray = new String(5); //declaration with size //System.out.println(myarray(0)); //variable myarray might not have been initialized //display elements of second array System.out.print(strArray(0) + ' ' +strArray(1)+ ' ' + strArray(2)+ ' ' + strArray(3)+ ' ' +strArray(4)); } }

Ieșire:

Declararea unui array de șiruri - ieșire

Programul de mai sus prezintă două moduri de declarare a unui String Array. Așa cum am menționat mai devreme, prima declarație este fără dimensiune și instanțiere. Prin urmare, înainte de a utiliza această matrice, ar trebui să o instanțiați folosind noua. În programul de mai sus, matricea matrice este utilizată fără instanțierea și astfel rezultă o eroare a compilatorului (declarație comentată).

A doua declarație este cu dimensiunea. Deci, atunci când sunt tipărite elemente individuale ale acestei matrice de șiruri, valorile tuturor elementelor sunt nule deoarece matricea nu a fost inițializată.

Inițializarea A String Array

Odată ce matricea de șiruri este declarată, ar trebui să o inițializăm cu câteva valori. În caz contrar, valorile implicite care sunt atribuite elementelor String sunt nule. Astfel, după declarație, procedăm la inițializarea matricei.

O matrice String poate fi inițializată fie în linie împreună cu declarația, fie poate fi inițializată după declararea acesteia.

În primul rând, să vedem cum poate fi inițializată o linie String.

 String() numarray = {“one”, “two”, “three”}; String() strArray = new String() {“one”, “two”, “three”, “four”};

În matricea de șiruri de mai sus, inițializările sunt inițializări în linie. String Array este inițializat în același timp cu declarația.

De asemenea, puteți inițializa matricea de șiruri după cum urmează:

String() strArray = new String(3); strArray(0) = “one”; strArray(1) = “two”; strArray(2) = “three”;

Aici este declarat primul String Array. Apoi, în linia următoare, elementelor individuale li se atribuie valori. Odată ce matricea de șiruri este inițializată, o puteți folosi în program în mod normal.

Lungimea / dimensiunea unei matrice de șiruri

Știți că pentru a obține dimensiunea matricei, matricile au o proprietate numită „lungime”. Acest lucru este valabil și pentru matricile de șiruri.

Dimensiunea sau lungimea matricei (orice matrice) oferă numărul de elemente prezente în matrice. Astfel, pentru a obține lungimea matricei numită myarray, puteți da următoarea expresie.

int len = myarray.length;

Să implementăm un program care va afișa Lungimea unei matrice de șiruri.

 public class Main { public static void main(String() args) { //declare and initialize a string array String() numArray = {'one','two', 'three', 'four', 'five'}; int len = numArray.length; //get the length of array //display the length System.out.println('Length of numArray{'one','two', 'three', 'four', 'five'}:' + len); } }

Ieșire:

Dimensiunea unui șir de șiruri - Ieșire

Proprietatea length este utilă atunci când trebuie să iterați prin matrice de șiruri pentru a o procesa sau pur și simplu pentru a o imprima.

Iterarea și tipărirea unei matrice de șiruri

Până în prezent, am discutat despre declarația, inițializarea și proprietatea lungimii unui String Array, iar acum a venit timpul să traversăm fiecare element al matricei și să imprimăm, de asemenea, elementele String Array.

Ca și în cazul tuturor matricelor, puteți itera peste o matrice de șiruri folosind bucla pentru și îmbunătățită pentru bucla.

Dat mai jos este un Implementare Java care demonstrează utilizarea unei bucle îmbunătățite pentru a traversa / itera matricea și a imprima elementele acesteia.

 public class Main { public static void main(String() args) { //declare and initialize a string array String() numArray = {'one','two', 'three', 'four', 'five'}; System.out.println('String Array elements displayed using for loop:'); // for loop to iterate over the string array for(int i=0; i Ieșire: 
  
 În programul de mai sus, atât pentru buclă, cât și îmbunătățit pentru buclă sunt utilizate pentru traversarea matricei de șiruri. Rețineți că, în cazul buclei îmbunătățite, nu este necesar să specificați limita sau condiția finală. În cazul buclei „pentru”, trebuie să specificați condiția de început și sfârșit.
 Adăugați la matrice de șiruri
 La fel ca și celelalte tipuri de date, puteți adăuga și elemente pentru String Arrays. În această secțiune, să vedem diferitele metode pentru a adăuga un element la matricea de șiruri.
 Utilizarea prealocării
 În această metodă, creați o matrice cu o dimensiune mai mare. De exemplu, dacă trebuie să stocați 5 elemente în matrice, atunci veți crea o matrice cu dimensiunea 10. În acest fel puteți adăuga cu ușurință elemente noi la sfârșitul matricei.
  Un exemplu care implementează adăugarea unui element la matricea prealocată este prezentat mai jos. 
 import java.util.*; public class Main { public static void main(String() args) { String() colorsArray = new String(5); // initial array values colorsArray(0) = 'Red'; colorsArray(1) = 'Green'; colorsArray(2) = 'Blue'; System.out.println('Original Array:' + Arrays.toString(colorsArray)); intnumberOfItems = 3; // try to add new value at the end of the array String newItem = 'Yellow'; colorsArray(numberOfItems++) = newItem; System.out.println('Array after adding one element:' + Arrays.toString(colorsArray)); } }  Ieșire: 
  
 Rețineți că spațiul neocupat din matrice este setat la Null. Dezavantajul acestei metode este că există o pierdere de spațiu, deoarece s-ar putea crea o matrice mare care poate rămâne neocupată.
 Folosind o nouă matrice
 În această metodă, creați o nouă matrice cu o dimensiune mai mare decât matricea originală, astfel încât să puteți găzdui noul element. După crearea noii matrice, toate elementele matricei originale sunt copiate în această matrice și apoi noul element este adăugat la sfârșitul matricei.
  Un exemplu de program pentru adăugarea unui element folosind noua matrice este prezentat mai jos. 
Întrebări de interviuri pe bază de scenariu sq sql
 importjava.util.*; public class Main { public static void main(String() args) { //original array String() colorsArray = {'Red', 'Green', 'Blue' }; System.out.println('Original Array: ' + Arrays.toString(colorsArray)); //length of original array int orig_length = colorsArray.length; //new element to be added to string array String newElement = 'Orange'; //define new array with length more than the original array String() newArray = new String( orig_length + 1 ); //add all elements of original array to new array for (int i=0; i  Ieșire: 
  
 Această abordare duce în mod clar la memorie și performanță, deoarece trebuie să mențineți două tablouri în program.
 Folosind ArrayList
 De asemenea, puteți adăuga un element la matricea String utilizând ArrayList ca structură de date intermediară.
  Un exemplu este prezentat mai jos. 
 import java.io.*; import java.lang.*; import java.util.*; class Main { public static void main(String() args) { // define initial array String numArray() = { 'one', 'two', 'three', 'four', 'five', 'six' }; // print the original array System.out.println('Initial Array:
' + Arrays.toString(numArray)); // new element to be added String newElement = 'seven'; // convert the array to arrayList ListnumList = new ArrayList( Arrays.asList(numArray)); // Add the new element to the arrayList numList.add(newElement); // Convert the Arraylist back to array numArray = numList.toArray(numArray); // print the changed array System.out.println('
Array with value ' + newElement + ' added:
' + Arrays.toString(numArray)); } }  Ieșire: 
  
 Așa cum se arată în programul de mai sus, matricea de șiruri este mai întâi convertită într-un ArrayList folosind metoda asList. Apoi, noul element este adăugat la ArrayList folosind metoda add. Odată ce elementul este adăugat, ArrayList este convertit înapoi în matrice.
 Aceasta este o abordare mai eficientă în comparație cu cele discutate anterior.
 String Array Conține
 În cazul în care doriți să știți dacă un anumit șir este prezent sau nu în matricea de șiruri, puteți utiliza metoda „conține”. Pentru aceasta, trebuie mai întâi să convertiți matricea de șiruri în ArrayList, deoarece această metodă aparține ArrayList.
  Următoarea implementare arată utilizarea metodei „conține”. 
 import java.io.*; import java.lang.*; import java.util.*; class Main { public static void main(String() args) { String() words = new String(){'C++', 'Java', 'C', 'Python'}; // Convert String Array to List Listwordslist = Arrays.asList(words); String tochk = 'Java'; if(wordslist.contains(tochk)){ System.out.println('The word ' + tochk + ' present in string array'); } else System.out.println('The word ' + tochk + ' not present in string array' ); } }  Ieșire: 
  
 În primul rând, am verificat dacă matricea de șiruri dată conține șirul „Java”. Pe măsură ce este prezent, este afișat un mesaj adecvat. Apoi, schimbăm șirul care trebuie bifat în „C #”. În acest caz, metoda „conține” returnează fals.
  
 Rețineți că, pentru metoda conține, șirul transmis ca argument este întotdeauna sensibil la majuscule. Astfel, în implementarea de mai sus, dacă oferim „java” ca argument pentru metoda conține, atunci acesta va reveni fals.
 Sortează o matrice de șiruri
 Am văzut deja un subiect detaliat despre „Sortarea în matrice”. Metodele de sortare a unei matrice de șiruri sunt la fel ca și celelalte matrice.
  Mai jos este prezentată o implementare a metodei „sort” a clasei „Matrice” care sortează șirurile din matrice în ordine alfabetică. 
 import java.util.*; class Main { public static void main(String() args) { String() colors = {'red','green','blue','white','orange'}; System.out.println('Original array: '+Arrays.toString(colors)); Arrays.sort(colors); System.out.println('Sorted array: '+Arrays.toString(colors)); } } Ieșire: 
  
 Ieșirea programului de mai sus arată matricea de intrare originală, precum și matricea de ieșire care este sortată alfabetic.
cum deschid un fișier apk
 Căutați un șir în matricea de șiruri
 În afară de metoda „conține” pe care tocmai am discutat-o, puteți căuta și un anumit șir într-o matrice de șiruri parcurgând fiecare element al matricei de șiruri. Aici, veți compara fiecare element din matricea de șiruri cu șirul de căutat.
 Căutarea se termină când se găsește prima apariție a șirului și se returnează indexul corespunzător al șirului din matrice. Dacă șirul nu este găsit până la sfârșitul matricei de șiruri, atunci se afișează un mesaj adecvat.
  Această implementare este prezentată în următorul program Java. 
 import java.util.*; class Main { public static void main(String() args) { String() strArray = { 'Book', 'Pencil', 'Eraser', 'Color', 'Pen' }; boolean found = false; int index = 0; String searchStr = 'Pen'; for (int i = 0; i  Ieșire: 
  
 Programul de mai sus caută șirul „Pen” într-o matrice de șiruri dată și returnează indexul corespunzător atunci când este găsit.
 Convertiți String Array în String
 Să discutăm despre modalitățile de a converti matricea de șiruri în șir. Vom discuta trei metode diferite pentru a face acest lucru cu un exemplu de fiecare.
 Folosind metoda toString
 Prima metodă este utilizarea metodei „toString” din clasa „Arrays”. Acesta ia matricea de șiruri ca argument și returnează reprezentarea șirului matricei.
  Următorul program Java arată utilizarea metodei toString. 
 import java.util.*; public class Main { public static void main(String args()) { //declare a string String() str_Array = {'This','is','Software','Testing','Help'}; System.out.println('String array converted to string:' + Arrays.toString(str_Array)); } }  Ieșire: 
  
 Programul de mai sus folosește metoda „toString” pentru a afișa reprezentarea șirului matricei de șiruri date.
 Folosind metoda StringBuilder.Append ()
 Următoarea abordare a conversiei matricei de șiruri în șir este prin utilizarea clasei „StringBuilder”. Ar trebui să creați un obiect de tip StringBuilder și să utilizați metoda „Append” a StringBuilder pentru a adăuga elementele de matrice de șiruri la obiectul StringBuilder unul câte unul.
 Odată ce toate elementele matrice sunt atașate la obiectul StringBuilder, puteți utiliza metoda „toString” pe acest obiect pentru a obține în cele din urmă reprezentarea șirului.
 import java.util.*; public class Main { public static void main(String args()) { //string array String() str_Array = {'This','is','Software','Testing','Help'}; System.out.print('Original string array:'); //print string array for(String val:str_Array) System.out.print(val + ' '); System.out.println('
'); //construct a stringbuilder object from given string array StringBuilder stringBuilder = new StringBuilder(); for (int i = 0; i  Ieșire: 
  
 Programul de mai sus arată conversia matricei de șiruri în șiruri folosind clasa StringBuilder.
 Utilizarea operației Join
 De asemenea, puteți utiliza operațiunea „join” a clasei String pentru a schimba matricea de șiruri într-o reprezentare de șiruri.
 Operațiunea „unire” ia două argumente, primul este separatorul sau delimitatorul șirului și al doilea argument este matricea de șiruri. Operația de asociere returnează apoi șirul separat printr-un separator specificat (primul argument).
  Verificați următorul program care demonstrează utilizarea operației de asociere pentru a obține un șir dintr-o matrice de șiruri. 
 import java.util.*; public class Main { public static void main(String args()) { //string array String() str_Array = {'This','is','Software','Testing','Help'}; System.out.println('Original string array:'); //print the string array for(String val:str_Array) System.out.print(val + ' '); System.out.println('
'); //form a string from string array using join operation String joinedString = String.join(' ', str_Array); //print the string System.out.println('String obtained from string array:' + joinedString); } }  Ieșire: 
  
 Convertiți șirul în matrice de șiruri
 Să vedem operația inversă de conversie a unui șir într-o matrice de șiruri. Există două metode pentru a face această conversie.
 Utilizarea operației Split
 Prima metodă de conversie a unui șir în matrice de șiruri este utilizarea operației de divizare a clasei String. Puteți împărți șirul pe un delimitator specificat (virgulă, spațiu etc.) și puteți returna matricea de șiruri recent generată.
  Următoarea implementare demonstrează utilizarea operației de divizare. 
 public class Main { public static void main(String args()) { //declare a string String myStr = 'This is Software Testing Help'; //use split function to split the string into a string array String() str_Array = myStr.split(' ', 5); System.out.println('String Array after splitting the string '' + myStr + '':'); //display the string array for (int i=0;i
 Programul de mai sus folosește funcția de divizare pentru a împărți șirul în funcție de spațiu și returnează o matrice de șiruri cu 5 elemente.
 Folosind modelul Regex
 Următoarea metodă pentru a converti șirul într-o matrice de șiruri este utilizând expresii regulate. Puteți specifica un model și apoi puteți împărți șirul dat în funcție de modelul specificat.
 Poți să folosești Clasa Regex Pattern aparținând pachetului java.util.
  Dat mai jos este un exemplu de utilizare a modelelor pentru a converti șirul în String Array. 
 import java.util.Arrays; import java.util.regex.Pattern; public class Main { public static void main(String args()) { //declare a string String myStr = 'This is Java series tutorial'; System.out.println('The original string:' + myStr + '
'); String() str_Array = null; //split string on space(' ') Pattern pattern = Pattern.compile(' '); //use pattern split on string to get string array str_Array = pattern.split(myStr ); //print the string array System.out.println('String Array after splitting the string using regex pattern:'); for (int i=0;i
 În programul de mai sus, modelul pe care l-am specificat este un caracter spațial. Astfel, șirul este împărțit în spații și returnează matricea de șiruri. După cum puteți deduce deja, utilizarea expresiilor și modelelor regulate este un mod mult mai eficient de programare.
 Conversia matrice de șiruri în listă
 De asemenea, puteți converti matricea de șiruri într-o listă. Am enumerat câteva metode pentru a face acest lucru
 Utilizarea codului personalizat
 Prima metodă este de a utiliza cod personalizat pentru a converti matricea de șiruri în listă. În această metodă, o matrice de șiruri este traversată și fiecare element este adăugat la listă utilizând metoda add a listei.
  Următorul program arată această implementare. 
 import java.util.*; public class Main { public static void main( String() args ) { //a string array String() numArray = { 'One', 'Two', 'Three', 'Four', 'Five' }; System.out.println('The string array:' + Arrays.toString(numArray)); //define arraylist with size same as string array Liststr_ArrayList = new ArrayList(numArray.length); //add string array elements to arraylist for (String str:numArray) { str_ArrayList.add(str ); } System.out.println('
Arraylist created from string array:'); //print the arraylist for (String str : str_ArrayList) { System.out.print(str + ' ' ); } } }  Ieșire: 
  
 După cum se arată în programul de mai sus, este creată mai întâi o listă. Apoi, folosind bucla pentru fiecare, fiecare element al matricei de șiruri este adăugat la listă. În cele din urmă, lista este tipărită.
 Folosind metoda Collections.addAll ()
 A doua metodă de conversie a matricei de șiruri într-o listă este folosirea metodei „addAll” din cadrul Colecțiilor. Metoda addAll () ia ArrayList și matricea de șiruri ca intrare și copiază conținutul matricei de șiruri în ArrayList.
  Următorul program arată utilizarea metodei addAll pentru a converti matricea de șiruri în listă. 
 import java.util.*; public class Main { public static void main( String() args ) { //a string array String() vehiclesArray = { 'moped', 'car', 'SUV', 'bicycle', 'bus' }; System.out.println('The string array:' + Arrays.toString(vehiclesArray)); //define arraylist with size same as string array List str_ArrayList = new ArrayList(vehiclesArray.length); //add string array elements to arraylist using Collections.addAll method Collections.addAll(str_ArrayList, vehiclesArray ); System.out.println('
Arraylist created from string array:'); //print the arraylist for (String str : str_ArrayList) { System.out.print(str + ' ' ); } } }  Ieșire: 
  
 În programul de mai sus, am convertit o matrice de șiruri dată într-o listă folosind metoda Collections.addAll.
 Utilizarea Arrays.asList ()
 În cele din urmă, clasa Array oferă metoda „asList ()” care convertește matricea de șiruri date în listă direct.
Întrebări și răspunsuri de interviu pentru programul Java
  Mai jos este prezentat un program Java care folosește asList. 
 import java.util.*; public class Main { public static void main( String() args ) { //a string array String() vehiclesArray = { 'moped', 'car', 'SUV', 'bicycle', 'bus' }; System.out.println('The string array:' + Arrays.toString(vehiclesArray)); //Convert array to list using asList method List str_ArrayList = Arrays.asList(vehiclesArray ); System.out.println('
Arraylist created from string array:'); //print the arraylist for (String str : str_ArrayList) { System.out.print(str + ' ' ); } } }  Ieșire: 
  
 Așa cum se arată mai sus, metoda asList din clasa Arrays convertește matricea în listă și returnează această listă.
 Convertiți lista în matrice de șiruri
 În secțiunea anterioară, am văzut câteva metode pentru a converti matricea de șiruri în listă. Acum, să vedem metodele pentru a converti lista într-o matrice de șiruri.
 Utilizarea ArraList.get ()
 Prima metodă este obținerea unei metode ArrayList care returnează elementele individuale ale listei. Puteți parcurge ArrayList și apelați la metoda get care va returna un element care poate fi apoi atribuit locației matricei.
  Următorul program arată această implementare. 
 import java.util.*; public class Main { public static void main( String() args ) { //ArrayList initialization ArrayList str_ArrayList= new ArrayList(); //add items to the arraylist str_ArrayList.add('str1'); str_ArrayList.add('str2'); str_ArrayList.add('str3'); str_ArrayList.add('str4'); str_ArrayList.add('str5'); //ArrayList to Array Conversion String str_Array() = new String(str_ArrayList.size()); for(int j =0;j Ieșire: 
  
 Programul de mai sus arată conversia ArrayList în matrice de șiruri folosind metoda get.
 Folosind metoda ArrayList.toArray ()
 ArrayList oferă o metodă „toArray ()” care returnează o reprezentare matrice a ArrayList. Astfel, puteți obține o matrice de șiruri dintr-un șir ArrayList folosind această metodă.
  Verificați următorul program care utilizează metoda toArray. 
 import java.util.*; public class Main { public static void main( String() args ) { //ArrayList initialization ArrayList str_ArrayList= new ArrayList(); //add items to the arraylist str_ArrayList.add('Mumbai'); str_ArrayList.add('Delhi'); str_ArrayList.add('Pune'); str_ArrayList.add('Chennai'); str_ArrayList.add('Kolkata'); //ArrayList to Array Conversion using toArray method String str_Array()=str_ArrayList.toArray(new String(str_ArrayList.size())); //print array elements System.out.println('String array obtained from string arraylist:'); for(String ary: str_Array){ System.out.print(ary + ' '); } } }  Ieșire: 
  
 Mai întâi, elementele sunt adăugate la ArrayList și apoi folosind metoda „toArray”, lista este convertită într-o matrice de șiruri.
 Convertiți String Array în Int Array
 Uneori este posibil să fie nevoie să faceți operații pe numere. În acest caz, dacă matricea dvs. de șiruri are conținut numeric, atunci este recomandabil să convertiți această matrice de șiruri în matrice int. Pentru aceasta, trebuie să utilizați funcția „parseInt” pe fiecare element de matrice și să extrageți numărul întreg.
  Următorul program arată conversia matricei de șiruri într-o matrice int. 
 import java.util.*; public class Main { public static void main( String() args ) { //string arrya declaration String () str_Array = {'10', '20','30', '40','50'}; //print the string array System.out.println('Original String Array:'); for(String val:str_Array) System.out.print(val + ' '); System.out.println('
The integer array obtained from string array:'); //declare an int array int () int_Array = new int (str_Array.length); //assign string array values to int array for(int i=0; i Ieșire: 
  
 În programul de mai sus, avem o matrice de șiruri care conține numerele ca șiruri. În acest program, fiecare dintre elementele matricei de șiruri este analizat utilizând funcția ‘parseInt’ și atribuit unui tablou de tip int.
 Rețineți că această conversie va funcționa numai pe o matrice de șiruri care are elemente numerice. Dacă oricare dintre elementele din matricea de șiruri este non-numerică, atunci compilatorul aruncă „java.lang.NumberFormatException”.
 întrebări frecvente
  Q # 1) Care este diferența dintre o matrice și un șir în Java? 
  Răspuns:  Matricea este o secvență contiguă de elemente. Șirul este o secvență de caractere terminată de un caracter nul. Șirurile sunt imuabile, adică odată definite nu pot fi modificate. Orice modificare a fost făcută pentru rezultatele șirului într-un șir nou.
 Tablourile sunt modificabile. Tablourile pot conține elemente de diferite tipuri de date, inclusiv șiruri.
  Q # 2) Cum declarați o matrice în Java? 
  Răspuns: Modul general de a declara o matrice în java este:
  tastați array_name ();  
Sau 
  tastați () array_name; 
 Prin urmare, dacă myarray este o variabilă de matrice cu elemente de tip int, atunci această matrice poate fi declarată ca:
  int myarray ();  
Sau 
  int () myarray; 
  Î # 3) Cum creez o matrice de șiruri? 
  Răspuns: Dacă strArray este o matrice de șiruri, atunci declarația sa poate fi:
  String () strArray;  
Sau 
  String strArray (); 
  Q # 4) Ce este argumentul String ()? 
  Răspuns: String () args în Java este o serie de șiruri care conțin argumente din linia de comandă care pot fi transmise unui program Java.
  Q # 5) Arrays poate conține șiruri? 
  Răspuns:  Da. La fel cum matricile pot conține alte tipuri de date, cum ar fi char, int, float, matricele pot conține și șiruri. În acest caz, matricea devine o matrice de „matrice de caractere” deoarece șirul poate fi vizualizat ca o secvență sau o matrice de caractere.
 Concluzie
 În acest tutorial, am văzut detaliile String Array în Java. Am parcurs toate conceptele majore legate de matrice de șiruri, inclusiv declararea, definirea și inițializarea matricei de șiruri în Java.
 Am discutat, de asemenea, mai multe operațiuni precum căutarea, sortarea, unirea etc. și conversia matricei de șiruri în listă, șir, matrice int, etc. Cu aceasta, finalizăm discuția noastră despre matricile de șiruri.
   În tutorialele noastre ulterioare, vom discuta matricele multidimensionale în Java.  
  => Aflați Java din Scratch aici  
  Lectură recomandată
    Tutorial Java Array Length cu exemple de cod  
  Java String cu buffer de șiruri și tutorial pentru generatorul de șiruri  
  Tutorial JAVA pentru începători: peste 100 de tutoriale video Java practice  
  Cum să sortați o matrice în Java - Tutorial cu exemple  
  Inversați o matrice în Java - 3 metode cu exemple  
  Tutorial C # String - Metode de șiruri cu exemple de coduri  
  String Array C ++: Implementare și reprezentare cu exemple  
  Cuvânt cheie Java „acest”: Tutorial cu exemple de cod