Matriu de cadenes de Java: tutorial amb exemples de codi

java string array tutorial with code examples

Proveu El Nostre Instrument Per Eliminar Problemes

Seleccioneu El Sistema Operatiu Trieu Un Programa De Projecció (Opcionalment)

Descriviu El Vostre Problema

Aquest tutorial sobre Java String Array explica com declarar, inicialitzar i crear matrius de cadenes a Java i les conversions que podem dur a terme a String Array:

Les matrius són una estructura de dades important a Java que s’utilitzen per emmagatzemar diferents tipus de dades, des de la primitiva fins a la definida per l’usuari. Ja hem vist els conceptes bàsics d'Arays i les altres operacions importants que es poden realitzar a Arrays.

En un dels nostres tutorials anteriors, hem debatut sobre els diversos tipus de dades que pot contenir una matriu.

=> Formació A-Z de Java per a principiants

Matriu de cadenes de Java i diversos mètodes

Un dels tipus de dades que poden contenir les matrius és una cadena. En aquest cas, la matriu s’anomena matriu String.

Què aprendreu:

Què és una matriu de cadenes a Java?
Conclusió
- Lectura recomanada

Què és una matriu de cadenes a Java?

Podem tenir una matriu amb cadenes com a elements. Per tant, podem definir una matriu de cadenes com una matriu que conté un nombre fix de cadenes o valors de cadena. La matriu de cadenes és una de les estructures més utilitzades a Java. Si ho recordeu, fins i tot l’argument de la funció ‘principal’ a Java és una matriu de cadenes.

La matriu de cadenes és una matriu d’objectes. Això es deu al fet que cada element és una cadena i sabeu que a Java, la cadena és un objecte. Podeu fer totes les operacions a la matriu de cadenes com ordenar, afegir un element, unir, dividir, cercar, etc.

En aquest tutorial, parlarem detalladament de la matriu de cadenes de Java juntament amb les diverses operacions i conversions que podem realitzar en matrius de cadenes.

Declaració d'una matriu de cadenes

Una matriu de cadenes es pot declarar de dues maneres, és a dir, amb una mida o sense especificar-ne la mida.

A continuació es detallen les dues maneres de declarar una matriu de cadenes.

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

A la primera declaració, una matriu de cadenes es declara igual que una variable normal sense mida. Tingueu en compte que abans d’utilitzar aquesta matriu, l’haureu d’instanciar amb una nova.

A la segona declaració, es declara una matriu de cadenes i s’instancia amb un nou. Aquí es declara una matriu de cadenes 'myarray' amb cinc elements. Si imprimiu directament els elements d'aquesta matriu, veureu tots els valors nuls ja que la matriu no està inicialitzada.

Implantem un programa que mostri una declaració de matriu de cadenes.

 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)); } }

Sortida:

Declaració d

El programa anterior mostra dues maneres de declarar una matriu de cadenes. Com es va esmentar anteriorment, la primera declaració no té mida ni instància. Per tant, abans d’utilitzar aquesta matriu, l’heu d’instanciar amb una nova. Al programa anterior, la matriu myarray s'utilitza sense instància i, per tant, resulta en un error del compilador (declaració comentada).

La segona declaració és amb la mida. Per tant, quan s’imprimeixen elements individuals d’aquesta matriu de cadenes, els valors de tots els elements són nuls ja que la matriu no s’ha inicialitzat.

Inicialització d'una matriu de cadenes

Un cop declarada la matriu de cadenes, haureu d'inicialitzar-la amb alguns valors. En cas contrari, els valors predeterminats assignats als elements de cadena són nuls. Així, després de la declaració, procedim a inicialitzar la matriu.

Una matriu de cadenes es pot inicialitzar en línia juntament amb la declaració o es pot inicialitzar després de declarar-la.

En primer lloc, vegem com es pot inicialitzar una matriu de cadenes en línia.

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

A la matriu de cadenes anterior, les inicialitzacions són inicialitzacions en línia. La matriu de cadenes s’inicialitza al mateix temps que es declara.

També podeu inicialitzar la matriu de cadenes de la següent manera:

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

Aquí es declara primer el String Array. A continuació, a la línia següent, els elements individuals tenen valors assignats. Un cop inicialitzada la matriu de cadenes, podeu utilitzar-la al programa normalment.

Longitud / mida d'una matriu de cordes

Ja sabeu que per obtenir la mida de la matriu, les matrius tenen una propietat anomenada 'longitud'. Això també és cert per a les matrius de cadenes.

La mida o longitud de la matriu (qualsevol matriu) dóna el nombre d'elements presents a la matriu. Per tant, per obtenir la longitud de la matriu anomenada myarray, podeu donar la següent expressió.

int len = myarray.length;

Implantem un programa que generarà la longitud d'una matriu de cadenes.

 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); } }

Sortida:

Mida d

La propietat length és útil quan cal iterar a través de la matriu de cadenes per processar-la o simplement imprimir-la.

Iteració i impressió d'una matriu de cadenes

Fins ara, hem debatut sobre la propietat de declaració, inicialització i longitud d’una matriu de cadenes i ara és hora que recorrem cada element de la matriu i també imprimim els elements de matriu de cadenes.

Com passa amb totes les matrius, podeu fer una iteració sobre una matriu de cadenes mitjançant bucle for i millorat per bucle.

A continuació es mostra un Implementació Java que demostra l’ús d’un bucle millorat per recórrer / iterar la matriu i imprimir-ne els elements.

 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 Sortida: 
  
 Al programa anterior, tant per a bucle com per a bucle s'utilitzen per recórrer la matriu de cadenes. Tingueu en compte que, en el cas del bucle millorat, no cal especificar el límit o la condició final. En el cas del bucle 'for', heu d'especificar la condició inicial i final.
 Afegeix a la matriu de cadenes
 Igual que la resta de tipus de dades, també podeu afegir elements per a matrius de cadenes. En aquesta secció, vegem els diversos mètodes per afegir un element a la matriu de cadenes.
 Mitjançant la preassignació
 En aquest mètode, creeu una matriu de mida més gran. Per exemple, si heu d'emmagatzemar 5 elements a la matriu, llavors creeu una matriu amb la mida 10. D'aquesta manera, podeu afegir fàcilment nous elements al final de la matriu.
  A continuació es mostra un exemple que implementa l’addició d’un element a la matriu preasignada. 
 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)); } }  Sortida: 
  
 Tingueu en compte que l'espai no ocupat de la matriu està definit com a Null. L’inconvenient d’aquest mètode és que hi ha un malbaratament d’espai, ja que podeu crear una gran matriu que pot romandre desocupada.
 Utilitzant una nova matriu
 En aquest mètode, creeu una nova matriu amb una mida superior a la matriu original perquè pugueu acomodar el nou element. Després de crear la nova matriu, tots els elements de la matriu original es copien a aquesta matriu i, a continuació, s'afegeix el nou element al final de la matriu.
  A continuació es mostra un exemple de programa per afegir un element mitjançant la nova matriu. 
quin és el millor netejador de registre gratuït
 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  Sortida: 
  
 Aquest enfocament es tradueix clarament en la sobrecàrrega de la memòria i el rendiment, ja que heu de mantenir dues matrius al programa.
 Utilitzant ArrayList
 També podeu afegir un element a la matriu de cadenes mitjançant ArrayList com a estructura de dades intermèdia.
  A continuació es mostra un exemple. 
 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)); } }  Sortida: 
  
 Com es mostra al programa anterior, la matriu de cadenes es converteix primer en una ArrayList mitjançant el mètode asList. A continuació, el nou element s'afegeix a l'ArrayList mitjançant el mètode add. Un cop afegit l'element, ArrayList es torna a convertir a la matriu.
 Aquest és un enfocament més eficient en comparació amb els comentats anteriorment.
 Conté una matriu de cadenes
 En cas que vulgueu saber si hi ha una cadena determinada a la matriu de cadenes o no, podeu utilitzar el mètode 'conté'. Per a això, primer heu de convertir la matriu de cadenes a ArrayList ja que aquest mètode pertany a ArrayList.
  La següent implementació mostra l’ús del mètode ‘conté’. 
 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' ); } }  Sortida: 
  
 En primer lloc, hem comprovat si la matriu de cadena donada conté la cadena 'Java'. Quan està present, es mostra un missatge adequat. A continuació, canviem la cadena que s'ha de marcar a 'C #'. En aquest cas, el mètode 'conté' torna fals.
  
 Tingueu en compte que, pel mètode conté, la cadena passada com a argument sempre distingeix entre majúscules i minúscules. Per tant, en la implementació anterior, si proporcionem 'java' com a argument per a conté el mètode, llavors tornarà fals.
 Ordeneu una matriu de cadenes
 Ja hem vist un tema detallat sobre 'Ordenació en matrius'. Els mètodes per ordenar una matriu de cadenes són els mateixos que les altres matrius.
  A continuació es mostra una implementació del mètode ‘sort’ de la classe ‘Arrays’ que ordena les cadenes de la matriu en ordre alfabètic. 
 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)); } } Sortida: 
  
 La sortida del programa anterior mostra la matriu d'entrada original, així com la matriu de sortida ordenada alfabèticament.
 Cerqueu una cadena a la matriu de cadenes
 A part del mètode 'conté' que acabem de comentar, també podeu cercar una cadena concreta en una matriu de cadenes recorrent cada element de la matriu de cadenes. Aquí, comparareu cada element de la matriu de cadenes amb la cadena a cercar.
 La cerca s'acaba quan es troba la primera aparició de la cadena i es retorna l'índex corresponent de la cadena a la matriu. Si la cadena no es troba fins al final de la matriu de cadenes, es mostrarà un missatge adequat.
  Aquesta implementació es mostra al següent programa 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  Sortida: 
  
 El programa anterior cerca la cadena 'Pen' en una matriu de cadenes determinada i retorna el seu índex corresponent quan es troba.
 Converteix matriu de cadena en cadena
 Analitzem les maneres de convertir la matriu de cadena en cadena. Discutirem tres mètodes diferents per fer-ho amb un exemple de cadascun.
 Utilitzant el mètode toString
 El primer mètode és utilitzar el mètode ‘toString’ de la classe ‘Arrays’. Pren la matriu de cadenes com a argument i retorna la representació de cadena de la matriu.
  El següent programa Java mostra l’ús del mètode 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)); } }  Sortida: 
  
 El programa anterior utilitza el mètode 'toString' per mostrar la representació de cadena de la matriu de cadenes donada.
 Utilitzant el mètode StringBuilder.Append ()
 El següent enfocament de convertir la matriu de cadena en cadena és utilitzar la classe ‘StringBuilder’. Heu de crear un objecte de tipus StringBuilder i fer servir el mètode ‘Add’ de StringBuilder per afegir els elements de la matriu de cadenes a l’objecte StringBuilder un per un.
 Un cop s’afegeixin tots els elements de la matriu a l’objecte StringBuilder, podeu utilitzar el mètode ‘toString’ d’aquest objecte per obtenir finalment la representació de la cadena.
 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  Sortida: 
  
 El programa anterior mostra la conversió de matriu de cadena a cadena mitjançant la classe StringBuilder.
com obrir el fitxer .java
 Ús de l’operació Join
 També podeu utilitzar l’operació ‘unir-se’ de la classe String per canviar la matriu de cadenes en una representació de cadena.
 L'operació 'unir' té dos arguments, el primer és el separador o delimitador de la cadena i el segon argument és la matriu de cadenes. L'operació d'unió retorna la cadena separada per un separador especificat (primer argument).
  Comproveu el programa següent que demostra l'ús de l'operació d'unió per obtenir una cadena d'una matriu de cadenes. 
 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); } }  Sortida: 
  
 Converteix la cadena a la matriu de cadenes
 Vegem l’operació inversa de convertir una cadena en una matriu de cadenes. Hi ha dos mètodes per fer aquesta conversió.
 Utilització de l’operació Split
 El primer mètode per convertir una cadena a una matriu de cadenes és utilitzar l’operació de divisió de la classe String. Podeu dividir la cadena en un delimitador especificat (coma, espai, etc.) i tornar la matriu de cadenes acabada de generar.
  La següent implementació demostra l'ús de l'operació dividida. 
 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
 El programa anterior utilitza la funció de divisió per dividir la cadena en funció de l'espai i retorna una matriu de cadenes de 5 elements.
 Utilitzant el patró Regex
 El següent mètode per convertir la cadena en una matriu de cadenes és mitjançant expressions regulars. Podeu especificar un patró i després dividir la cadena donada segons el patró especificat.
 Pots fer servir Classe de patró Regex pertanyent al paquet java.util.
  A continuació es mostra un exemple d’utilitzar patrons per convertir una cadena a matriu de cadenes. 
 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
 Al programa anterior, el patró que hem especificat és un caràcter espacial. Per tant, la cadena es divideix en espais i retorna la matriu de cadenes. Com ja es pot deduir, l’ús d’expressions i patrons regulars és una manera de programar molt més eficient.
 Converteix la matriu de cadenes a la llista
 També podeu convertir una matriu de cadenes a una llista. Hem enumerat alguns mètodes per fer-ho
 Utilitzant el codi personalitzat
 El primer mètode és utilitzar codi personalitzat per convertir una matriu de cadenes a una llista. En aquest mètode, es recorre una matriu de cadenes i cada element s’afegeix a la llista mitjançant el mètode add de la llista.
  El programa següent mostra aquesta implementació. 
 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 + ' ' ); } } }  Sortida: 
  
 Com es mostra al programa anterior, primer es crea una llista. A continuació, utilitzant el bucle per a cada bucle, cada element de la matriu de cadenes s'afegeix a la llista. Finalment, s’imprimeix la llista.
 Utilitzant el mètode Collections.addAll ()
 El segon mètode de conversió de matriu de cadenes a una llista és mitjançant el mètode ‘addAll’ del marc de col·leccions. El mètode addAll () pren ArrayList i la matriu de cadenes com a entrada i copia el contingut de la matriu de cadenes a ArrayList.
  El programa següent mostra l'ús del mètode addAll per convertir una matriu de cadenes a una llista. 
 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 + ' ' ); } } }  Sortida: 
  
 Al programa anterior, hem convertit una matriu de cadenes donada en una llista mitjançant el mètode Collections.addAll.
 Ús de Arrays.asList ()
 Finalment, la classe Array proporciona el mètode ‘asList ()’ que converteix directament la matriu de cadenes donada a la llista.
com obriu un fitxer jar
  A continuació es mostra un programa Java que utilitza 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 + ' ' ); } } }  Sortida: 
  
 Com es mostra més amunt, el mètode asList de la classe Arrays converteix la matriu en llista i retorna aquesta llista.
 Converteix la llista a la matriu de cadenes
 A la secció anterior, vam veure alguns mètodes per convertir una matriu de cadenes a una llista. Ara, vegem els mètodes per convertir la llista en una matriu de cadenes.
 Utilitzant ArraList.get ()
 El primer mètode és obtenir un mètode d'ArrayList que retorna els elements individuals de la llista. Podeu recórrer l'ArrayList i trucar al mètode get que retornarà un element que després es pot assignar a la ubicació de la matriu.
  El programa següent mostra aquesta implementació. 
 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 Sortida: 
  
 El programa anterior mostra la conversió d'ArrayList a matriu de cadenes mitjançant el mètode get.
 Utilitzant el mètode ArrayList.toArray ()
 ArrayList proporciona un mètode 'toArray ()' que retorna una representació de matriu d'ArrayList. Per tant, podeu obtenir una matriu de cadenes d'una cadena ArrayList mitjançant aquest mètode.
  Comproveu el programa següent que utilitza el mètode 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 + ' '); } } }  Sortida: 
  
 Primer, s’afegeixen els elements a la llista Array i, després, mitjançant el mètode ‘toArray’, la llista es converteix en una matriu de cadenes.
 Converteix matriu de cadenes en matriu Int
 De vegades és possible que hagueu de fer operacions amb números. En aquest cas, si la vostra matriu de cadenes té contingut numèric, és recomanable convertir aquesta matriu de cadenes a matriu int. Per a això, heu d’utilitzar la funció ‘parseInt’ a cada element de la matriu i extreure’n l’enter.
  El programa següent mostra la conversió de la matriu de cadenes en una matriu 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 Sortida: 
  
 Al programa anterior, tenim una matriu de cadenes que conté els números com a cadenes. En aquest programa, cadascun dels elements de la matriu de cadenes s’analitza mitjançant la funció ‘parseInt’ i s’assigna a una matriu de tipus int.
 Tingueu en compte que aquesta conversió només funcionarà en una matriu de cadenes que tingui elements numèrics. Si algun dels elements de la matriu de cadena no és numèric, el compilador llança ‘java.lang.NumberFormatException’.
 Preguntes freqüents
  Q # 1) Quina diferència hi ha entre una matriu i una cadena a Java? 
  Resposta:  La matriu és una seqüència contigua d'elements. La cadena és una seqüència de caràcters acabada per un caràcter nul. Les cadenes són immutables, és a dir, un cop definides no es poden canviar. Qualsevol canvi es va fer als resultats de la cadena en una cadena nova.
 Les matrius són mutables. Les matrius poden contenir elements de diversos tipus de dades, incloses les cadenes.
  Q # 2) Com es declara una matriu a Java? 
  Resposta: La forma general de declarar una matriu a Java és:
  escriviu array_name ();  
O bé 
  escriviu () array_name; 
 Per tant, si myarray és una variable de matriu amb elements de tipus int, aquesta matriu es pot declarar com:
  int myarray ();  
O bé 
  int () myarray; 
  P # 3) Com puc crear una matriu de cordes? 
  Resposta: Si strArray és una matriu de cadenes, la seva declaració pot ser:
  String () strArray;  
O bé 
  String strArray (); 
  Q # 4) Què és l'argument de String ()? 
  Resposta: String () args a Java és una matriu de cadenes que contenen arguments de línia de comandes que es poden passar a un programa Java.
  P # 5) Les matrius poden contenir cordes? 
  Resposta:  Sí. Igual que les matrius poden contenir altres tipus de dades com ara char, int, float, les matrius també poden contenir cadenes. En aquest cas, la matriu es converteix en una matriu de ‘matriu de caràcters’, ja que la cadena es pot veure com una seqüència o matriu de caràcters.
 Conclusió
 En aquest tutorial, hem vist els detalls de la matriu de cadenes a Java. Vam revisar tots els conceptes principals relacionats amb la matriu de cadenes, inclosa la declaració, la definició i la inicialització de la matriu de cadenes a Java.
 També hem debatut sobre diverses operacions, com ara buscar, ordenar, unir, etc. i convertir la matriu de cadenes a la llista, cadena, matriu int, etc. Amb això, completem la nostra discussió sobre matrius de cadenes.
   En els nostres tutorials posteriors, parlarem de matrius multidimensionals a Java.  
  => Apreneu Java de Scratch aquí  
  Lectura recomanada
    Tutorial de longitud de matriu de Java amb exemples de codi  
  Java String amb buffer de cadenes i tutorial de Generador de cadenes  
  Tutorial JAVA per a principiants: més de 100 tutorials pràctics de vídeo Java  
  Com ordenar una matriu a Java: tutorial amb exemples  
  Inverteix una matriu a Java: 3 mètodes amb exemples  
  Tutorial de cadenes C #: mètodes de cadenes amb exemples de codi  
  String Array C ++: Implementació i representació amb exemples  
  Paraula clau 'aquesta' de Java: tutorial amb exemples de codi