Ein Array ist eine wesentliche und am häufigsten verwendete Datenstruktur in Java . Aufgrund ihrer effizienten und produktiven Natur ist sie eine der von Programmierern am häufigsten verwendeten Datenstrukturen. Das Array ist eine Sammlung ähnlicher Datentypelemente. Es verwendet einen zusammenhängenden Speicherort zum Speichern der Elemente.

Ein String-Array ist ein Array aus einer festen Anzahl von String-Werten . Ein String ist eine Folge von Zeichen. Im Allgemeinen ist eine Zeichenfolge ein unveränderliches Objekt, was bedeutet, dass der Wert der Zeichenfolge nicht geändert werden kann. Das String-Array funktioniert ähnlich wie andere Datentypen von Arrays.

In Array Es kann nur ein fester Satz von Elementen gespeichert werden. Es handelt sich um eine indexbasierte Datenstruktur, die bei 0 beginnt^ThPosition. Das erste Element findet im Index 0 statt, das 2^ndDas Element findet in Index 1 statt und so weiter.

Die Hauptmethode {Public static void main[ String [] args]; } ist in Java ebenfalls ein String-Array.

Beachten Sie die folgenden Punkte zum String-Array:

• Es ist ein Objekt des Arrays.
• Es kann mit zwei Methoden deklariert werden; durch Angabe der Größe oder ohne Angabe der Größe.
• Die Initialisierung kann entweder zum Zeitpunkt der Deklaration oder durch Auffüllen der Werte nach der Deklaration erfolgen.
• Die Elemente können nach der Deklaration einem String-Array hinzugefügt werden.
• Das String-Array kann mithilfe der for-Schleife iteriert werden.
• Der Such- und Sortiervorgang kann für das String-Array durchgeführt werden.

Erklärung:

Kajal Aggarwal

Es gibt zwei Arten der Array-Deklaration: Entweder können wir die Größe des Arrays angeben oder ohne Angabe der Größe des Arrays. Ein String-Array kann wie folgt deklariert werden:

 String[] stringArray1 //Declaration of the String Array without specifying the size String[] stringArray2 = new String[2]; //Declarartion by specifying the size 

Eine andere Möglichkeit, das Array zu deklarieren, ist String strArray[] , die oben genannten Methoden sind jedoch effizienter und werden empfohlen.

stlc

Initialisierung:

Das String-Array kann einfach initialisiert werden. Unten ist die Initialisierung des String-Arrays:

 1. String[] strAr1=new String[] {'Ani', 'Sam', 'Joe'}; //inline initialization 2. String[] strAr2 = {'Ani', 'Sam', ' Joe'}; 3. String[] strAr3= new String[3]; //Initialization after declaration with specific size strAr3[0]= 'Ani'; strAr3[1]= 'Sam'; strAr3[2]= 'Joe'; 

Alle oben genannten drei Möglichkeiten werden zum Initialisieren des String-Arrays verwendet und haben denselben Wert.

Die 3^rdDie Methode ist eine Methode mit einer bestimmten Größe. Dabei kann der Wert des Index mithilfe der ( Arraylänge - 1 )-Formel, wenn wir auf die Elemente mit mehr als dem Index 2 im obigen Array zugreifen möchten. Es wird das werfen Java.lang.ArrayIndexOutOfBoundsException Ausnahme.

Sehen wir uns ein Beispiel eines String-Arrays an, um dessen Verhalten zu demonstrieren:

Iteration eines String-Arrays

Das String-Array kann mit der for- und foreach-Schleife iteriert werden. Betrachten Sie den folgenden Code:

 String[] strAr = {&apos;Ani&apos;, &apos;Sam&apos;, &apos;Joe&apos;}; for (int i=0; i<strar.length; i++) { system.out.println(strar[i]); } for ( string str: strar) sytem.out.println(str); < pre> <h2>Adding Elements to a String Array</h2> <p>We can easily add the elements to the String Array just like other data types. It can be done using the following three methods:</p> <ul> <tr><td>Using Pre-Allocation of the Array</td>  </tr><tr><td>Using the Array List</td>  </tr><tr><td>By creating a new Array</td>  </tr></ul> <p>let&apos;s understand the above methods:</p> <h3>Using Pre-Allocation of the Array:</h3> <p>In this method, we already have an Array of larger size. For example, if we require to store the 10 elements, then we will create an Array of size 20. It is the easiest way to expand the Array elements.</p> <p>Consider the below example to add elements in a pre-allocated array.</p> <pre> // Java Program to add elements in a pre-allocated Array import java.util.Arrays; public class StringArrayDemo { public static void main(String[] args) { String[] sa = new String[7]; // Creating a new Array of Size 7 sa[0] = &apos;A&apos;; // Adding Array elements sa[1] = &apos;B&apos;; sa[2] = &apos;C&apos;; sa[3] = &apos;D&apos;; sa[4] = &apos;E&apos;; System.out.println(&apos;Original Array Elements:&apos; + Arrays.toString(sa)); int numberOfItems = 5; String newItem = &apos;F&apos;; // Expanding Array Elements Later String newItem2 =&apos;G&apos;; sa[numberOfItems++] = newItem; sa[numberOfItems++] = newItem2; System.out.println(&apos;Array after adding two elements:&apos; + Arrays.toString(sa)); } } </pre> <p> <strong>Output:</strong> </p> <pre> Original Array Elements:[A, B, C, D, E, null, null] Array after adding two elements:[A, B, C, D, E, F, G] </pre> <p>From the above example, we have added two elements in a pre-allocated Array.</p> <h3>Using ArrayList:</h3> <p>The <a href="/java-arraylist">ArrayList</a> is a fascinating data structure of the <a href="/collections-java">Java collection framework</a> . We can easily add elements to a <a href="/java-string">String</a> Array using an ArrayList as an intermediate data structure.</p> <p>Consider the below example to understand how to add elements to a String Array using ArrayList :</p> <pre> import java.util.ArrayList; import java.util.Arrays; import java.util.List; public class StringArrayDemo1 { public static void main(String[] args) { // Defining a String Array String sa[] = { &apos;A&apos;, &apos;B&apos;, &apos;C&apos;, &apos;D&apos;, &apos;E&apos;, &apos;F&apos; }; // System.out.println(&apos;Initial Array:
&apos; + Arrays.toString(sa)); String ne = &apos;G&apos;; // Define new element to add Listl = new ArrayList( Arrays.asList(sa)); // Convert Array to ArrayList l.add(ne); // Add new element in ArrayList l sa = l.toArray(sa); // Revert Conversion from ArrayList to Array // printing the new Array System.out.println(&apos;Array with added Value: 
&apos; + Arrays.toString(sa)) ; } } </pre> <p> <strong>Output:</strong> </p> <pre> Initial Array: [A, B, C, D, E, F] Array with added value: [A, B, C, D, E, F, G] </pre> <h3>By Creating a New Array:</h3> <p>In this method, we will create a new Array with a larger size than the initial Array and accommodate the elements in it. We will copy all the elements to the newly added Array.</p> <p>Consider the below example:</p> <pre> // Java Program to add elements in a String Array by creating a new Array import java.util.Arrays; public class StringArrayDemo2 { public static void main(String[] args) { //Declaring Initial Array String[] sa = {&apos;A&apos;, &apos;B&apos;, &apos;C&apos; }; // Printing the Original Array System.out.println(&apos;Initial Array: &apos; + Arrays.toString(sa)); int length_Var = sa.length; //Defining the array length variable String newElement = &apos;D&apos;; // Defining new element to add //define new array with extended length String[] newArray = new String[ length_Var + 1 ]; //Adding all the elements to initial Array for (int i=0; i <sa.length; i++) { newarray[i]="sa" [i]; } specifying the position of added elements ( last) newarray[newarray.length- 1]="newElement;" make it original and print sa="newArray;" system.out.println('updated array: ' + arrays.tostring(sa)); < pre> <p> <strong>Output:</strong> </p> <pre> Initial Array: [A, B, C] updated Array: [A, B, C, D] </pre> <p>This is how we can add elements to a String Array. Let&apos;s understand how to search and sort elements in String Array.</p> <h2>Searching in String Array</h2> <p>For searching a String from the String Array, for loop is used. Consider the below example:</p> <pre> public class StringArrayExample { public static void main(String[] args) { String[] strArray = { &apos;Ani&apos;, &apos;Sam&apos;, &apos;Joe&apos; }; boolean x = false; //initializing x to false int in = 0; //declaration of index variable String s = &apos;Sam&apos;; // String to be searched // Iteration of the String Array for (int i = 0; i <strarray.length; i++) { if(s.equals(strarray[i])) in="i;" x="true;" break; } if(x) system.out.println(s +' string is found at index '+in); else not the array'); < pre> <p> <strong>Output:</strong> </p> <pre> Sam String is found at index 1 </pre> <p>In the above example, we have initialized a boolean variable <strong>x</strong> to false and an index variable to iterate through the string. Also, we have declared a local variable String variable <strong>s</strong> to be searched. Here, the break keyword will exit the loop as soon as the string is found.</p> <h2>Sorting in String Array</h2> <p>The sorting in the String array is quite easy. It is performed like in a traditional array. We use a sort() method to sort the Array elements. Sorting is easier than searching.</p> <p>Consider the below example to <a href="/how-sort-string-array-java">sort a String Array</a> :</p> <pre> //Java Program to sort elements in a String Array import java.util.Arrays; public class StringArraySorting { public static void main(String[] args) { // Adding String values String[] colors = {&apos;Cricket&apos;,&apos;Basketball&apos;,&apos;Football&apos;,&apos;Badminton&apos;,&apos;Tennis&apos;}; // Print Original values System.out.println(&apos;Entered Sports: &apos;+Arrays.toString(colors)); Arrays.sort(colors); // Sorting Elements // Print Sorted Values System.out.println(&apos;Sorted Sports: &apos;+Arrays.toString(colors)); } } </pre> <p> <strong>Output:</strong> </p> <pre> Entered Sports: [Cricket, Basketball, Football, Badminton, Tennis] Sorted Sports: [Badminton, Basketball, Cricket, Football, Tennis] </pre> <p>From the above example, we can see the elements from a String Array is sorted using the sort() method.</p> <p>We can also convert String Array to other data structures such as List, int Array, ArrayList, and more and vice-versa.</p> <hr></strarray.length;></pre></sa.length;></pre></strar.length;>

Ausgabe:

double, um Java zu stringen

 Original Array Elements:[A, B, C, D, E, null, null] Array after adding two elements:[A, B, C, D, E, F, G] 

Aus dem obigen Beispiel haben wir zwei Elemente in einem vorab zugewiesenen Array hinzugefügt.

Verwenden von ArrayList:

Der Anordnungsliste ist eine faszinierende Datenstruktur der Java-Sammlungsframework . Wir können ganz einfach Elemente zu a hinzufügen Zeichenfolge Array, das eine ArrayList als Zwischendatenstruktur verwendet.

String-Builder

Betrachten Sie das folgende Beispiel, um zu verstehen, wie Sie mithilfe von ArrayList Elemente zu einem String-Array hinzufügen:

 import java.util.ArrayList; import java.util.Arrays; import java.util.List; public class StringArrayDemo1 { public static void main(String[] args) { // Defining a String Array String sa[] = { 'A', 'B', 'C', 'D', 'E', 'F' }; // System.out.println('Initial Array:
' + Arrays.toString(sa)); String ne = 'G'; // Define new element to add Listl = new ArrayList( Arrays.asList(sa)); // Convert Array to ArrayList l.add(ne); // Add new element in ArrayList l sa = l.toArray(sa); // Revert Conversion from ArrayList to Array // printing the new Array System.out.println('Array with added Value: 
' + Arrays.toString(sa)) ; } } 

Ausgabe:

 Initial Array: [A, B, C, D, E, F] Array with added value: [A, B, C, D, E, F, G] 

Durch Erstellen eines neuen Arrays:

Bei dieser Methode erstellen wir ein neues Array mit einer größeren Größe als das ursprüngliche Array und nehmen die darin enthaltenen Elemente auf. Wir kopieren alle Elemente in das neu hinzugefügte Array.

Betrachten Sie das folgende Beispiel:

 // Java Program to add elements in a String Array by creating a new Array import java.util.Arrays; public class StringArrayDemo2 { public static void main(String[] args) { //Declaring Initial Array String[] sa = {&apos;A&apos;, &apos;B&apos;, &apos;C&apos; }; // Printing the Original Array System.out.println(&apos;Initial Array: &apos; + Arrays.toString(sa)); int length_Var = sa.length; //Defining the array length variable String newElement = &apos;D&apos;; // Defining new element to add //define new array with extended length String[] newArray = new String[ length_Var + 1 ]; //Adding all the elements to initial Array for (int i=0; i <sa.length; i++) { newarray[i]="sa" [i]; } specifying the position of added elements ( last) newarray[newarray.length- 1]="newElement;" make it original and print sa="newArray;" system.out.println(\'updated array: \' + arrays.tostring(sa)); < pre> <p> <strong>Output:</strong> </p> <pre> Initial Array: [A, B, C] updated Array: [A, B, C, D] </pre> <p>This is how we can add elements to a String Array. Let&apos;s understand how to search and sort elements in String Array.</p> <h2>Searching in String Array</h2> <p>For searching a String from the String Array, for loop is used. Consider the below example:</p> <pre> public class StringArrayExample { public static void main(String[] args) { String[] strArray = { &apos;Ani&apos;, &apos;Sam&apos;, &apos;Joe&apos; }; boolean x = false; //initializing x to false int in = 0; //declaration of index variable String s = &apos;Sam&apos;; // String to be searched // Iteration of the String Array for (int i = 0; i <strarray.length; i++) { if(s.equals(strarray[i])) in="i;" x="true;" break; } if(x) system.out.println(s +\' string is found at index \'+in); else not the array\'); < pre> <p> <strong>Output:</strong> </p> <pre> Sam String is found at index 1 </pre> <p>In the above example, we have initialized a boolean variable <strong>x</strong> to false and an index variable to iterate through the string. Also, we have declared a local variable String variable <strong>s</strong> to be searched. Here, the break keyword will exit the loop as soon as the string is found.</p> <h2>Sorting in String Array</h2> <p>The sorting in the String array is quite easy. It is performed like in a traditional array. We use a sort() method to sort the Array elements. Sorting is easier than searching.</p> <p>Consider the below example to <a href="/how-sort-string-array-java">sort a String Array</a> :</p> <pre> //Java Program to sort elements in a String Array import java.util.Arrays; public class StringArraySorting { public static void main(String[] args) { // Adding String values String[] colors = {&apos;Cricket&apos;,&apos;Basketball&apos;,&apos;Football&apos;,&apos;Badminton&apos;,&apos;Tennis&apos;}; // Print Original values System.out.println(&apos;Entered Sports: &apos;+Arrays.toString(colors)); Arrays.sort(colors); // Sorting Elements // Print Sorted Values System.out.println(&apos;Sorted Sports: &apos;+Arrays.toString(colors)); } } </pre> <p> <strong>Output:</strong> </p> <pre> Entered Sports: [Cricket, Basketball, Football, Badminton, Tennis] Sorted Sports: [Badminton, Basketball, Cricket, Football, Tennis] </pre> <p>From the above example, we can see the elements from a String Array is sorted using the sort() method.</p> <p>We can also convert String Array to other data structures such as List, int Array, ArrayList, and more and vice-versa.</p> <hr></strarray.length;></pre></sa.length;>

So können wir Elemente zu einem String-Array hinzufügen. Lassen Sie uns verstehen, wie Elemente in einem String-Array gesucht und sortiert werden.

Suche im String-Array

Zum Suchen eines Strings aus dem String-Array wird die for-Schleife verwendet. Betrachten Sie das folgende Beispiel:

Wo finde ich meine Browsereinstellungen?

 public class StringArrayExample { public static void main(String[] args) { String[] strArray = { &apos;Ani&apos;, &apos;Sam&apos;, &apos;Joe&apos; }; boolean x = false; //initializing x to false int in = 0; //declaration of index variable String s = &apos;Sam&apos;; // String to be searched // Iteration of the String Array for (int i = 0; i <strarray.length; i++) { if(s.equals(strarray[i])) in="i;" x="true;" break; } if(x) system.out.println(s +\' string is found at index \'+in); else not the array\'); < pre> <p> <strong>Output:</strong> </p> <pre> Sam String is found at index 1 </pre> <p>In the above example, we have initialized a boolean variable <strong>x</strong> to false and an index variable to iterate through the string. Also, we have declared a local variable String variable <strong>s</strong> to be searched. Here, the break keyword will exit the loop as soon as the string is found.</p> <h2>Sorting in String Array</h2> <p>The sorting in the String array is quite easy. It is performed like in a traditional array. We use a sort() method to sort the Array elements. Sorting is easier than searching.</p> <p>Consider the below example to <a href="/how-sort-string-array-java">sort a String Array</a> :</p> <pre> //Java Program to sort elements in a String Array import java.util.Arrays; public class StringArraySorting { public static void main(String[] args) { // Adding String values String[] colors = {&apos;Cricket&apos;,&apos;Basketball&apos;,&apos;Football&apos;,&apos;Badminton&apos;,&apos;Tennis&apos;}; // Print Original values System.out.println(&apos;Entered Sports: &apos;+Arrays.toString(colors)); Arrays.sort(colors); // Sorting Elements // Print Sorted Values System.out.println(&apos;Sorted Sports: &apos;+Arrays.toString(colors)); } } </pre> <p> <strong>Output:</strong> </p> <pre> Entered Sports: [Cricket, Basketball, Football, Badminton, Tennis] Sorted Sports: [Badminton, Basketball, Cricket, Football, Tennis] </pre> <p>From the above example, we can see the elements from a String Array is sorted using the sort() method.</p> <p>We can also convert String Array to other data structures such as List, int Array, ArrayList, and more and vice-versa.</p> <hr></strarray.length;>

Im obigen Beispiel haben wir eine boolesche Variable initialisiert X auf „false“ und eine Indexvariable zum Durchlaufen der Zeichenfolge. Außerdem haben wir eine lokale Variable String-Variable deklariert S gesucht werden. Hier verlässt das Schlüsselwort break die Schleife, sobald die Zeichenfolge gefunden wird.

Sortieren im String-Array

Die Sortierung im String-Array ist recht einfach. Es wird wie in einem herkömmlichen Array ausgeführt. Wir verwenden eine sort()-Methode, um die Array-Elemente zu sortieren. Sortieren ist einfacher als Suchen.

Betrachten Sie das folgende Beispiel Sortieren Sie ein String-Array :

 //Java Program to sort elements in a String Array import java.util.Arrays; public class StringArraySorting { public static void main(String[] args) { // Adding String values String[] colors = {'Cricket','Basketball','Football','Badminton','Tennis'}; // Print Original values System.out.println('Entered Sports: '+Arrays.toString(colors)); Arrays.sort(colors); // Sorting Elements // Print Sorted Values System.out.println('Sorted Sports: '+Arrays.toString(colors)); } } 

Ausgabe:

 Entered Sports: [Cricket, Basketball, Football, Badminton, Tennis] Sorted Sports: [Badminton, Basketball, Cricket, Football, Tennis] 

Aus dem obigen Beispiel können wir sehen, dass die Elemente eines String-Arrays mit der Methode sort() sortiert werden.

Wir können String Array auch in andere Datenstrukturen wie List, int Array, ArrayList und mehr konvertieren und umgekehrt.