Een array is een essentiële en meest gebruikte datastructuur in Java . Het is een van de meest gebruikte datastructuren door programmeurs vanwege zijn efficiënte en productieve karakter; De array is een verzameling vergelijkbare gegevenstype-elementen. Het gebruikt een aaneengesloten geheugenlocatie om de elementen op te slaan.
Een String Array is een array met een vast aantal String-waarden . Een String is een reeks karakters. Over het algemeen is een string een onveranderlijk object, wat betekent dat de waarde van de string niet kan worden gewijzigd. De String Array werkt op dezelfde manier als andere gegevenstypen van Array.
In Array , kan alleen een vaste set elementen worden opgeslagen. Het is een op indexen gebaseerde datastructuur, die begint vanaf 0epositie. Het eerste element vindt plaats in Index 0, en het 2nlelement zal plaatsvinden in Index 1, enzovoort.
De hoofdmethode {Public static void main[ String [] args]; } in Java is ook een String Array.
Beschouw de onderstaande punten over de String Array:
een kaart herhalen in Java
- Het is een object van de Array.
- Het kan op twee manieren worden gedeclareerd; door de maat op te geven of zonder de maat op te geven.
- Het kan worden geïnitialiseerd op het moment van de declaratie of door de waarden na de declaratie in te vullen.
- De elementen kunnen aan een String Array worden toegevoegd nadat deze is gedeclareerd.
- De String Array kan worden herhaald met behulp van de for-lus.
- De zoek- en sorteerbewerking kan worden uitgevoerd op de String Array.
Verklaring:
De Array-declaratie bestaat uit twee typen: we kunnen de grootte van de array specificeren of zonder de grootte van de array op te geven. Een String Array kan als volgt worden gedeclareerd:
String[] stringArray1 //Declaration of the String Array without specifying the size String[] stringArray2 = new String[2]; //Declarartion by specifying the size
Een andere manier om de array te declareren is String strArray[] , maar de hierboven gespecificeerde methoden zijn efficiënter en worden aanbevolen.
Initialisatie:
De String Array kan eenvoudig worden geïnitialiseerd. Hieronder vindt u de initialisatie van de String Array:
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 bovengenoemde drie manieren worden gebruikt om de String Array te initialiseren en hebben dezelfde waarde.
De 3rdmethode is een specifieke groottemethode. Hierin kan de waarde van de index worden gevonden met behulp van de ( arraylengte - 1 ) formule als we meer toegang willen krijgen tot de elementen dan index 2 in de bovenstaande array. Het zal de Java.lang.ArrayIndexOutOfBoundsException uitzondering.
Laten we een voorbeeld van String Array bekijken om het gedrag ervan te demonstreren:
Iteratie van String Array
rhel versus centos
De String Array kan worden herhaald met behulp van de for- en foreach-lus. Beschouw de onderstaande code:
String[] strAr = {'Ani', 'Sam', 'Joe'}; 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'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] = 'A'; // Adding Array elements sa[1] = 'B'; sa[2] = 'C'; sa[3] = 'D'; sa[4] = 'E'; System.out.println('Original Array Elements:' + Arrays.toString(sa)); int numberOfItems = 5; String newItem = 'F'; // Expanding Array Elements Later String newItem2 ='G'; sa[numberOfItems++] = newItem; sa[numberOfItems++] = newItem2; System.out.println('Array after adding two elements:' + 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[] = { '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)) ; } } </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 = {'A', 'B', 'C' }; // Printing the Original Array System.out.println('Initial Array: ' + Arrays.toString(sa)); int length_Var = sa.length; //Defining the array length variable String newElement = 'D'; // 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'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 = { 'Ani', 'Sam', 'Joe' }; boolean x = false; //initializing x to false int in = 0; //declaration of index variable String s = 'Sam'; // 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 = {'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)); } } </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;> Uitgang:
Original Array Elements:[A, B, C, D, E, null, null] Array after adding two elements:[A, B, C, D, E, F, G]
Uit het bovenstaande voorbeeld hebben we twee elementen toegevoegd aan een vooraf toegewezen array.
ArrayList gebruiken:
De ArrayLijst is een fascinerende datastructuur van de Java-verzamelingsframework . We kunnen eenvoudig elementen toevoegen aan een Snaar Array met behulp van een ArrayList als tussenliggende datastructuur.
Bekijk het onderstaande voorbeeld om te begrijpen hoe u elementen aan een String Array kunt toevoegen met behulp van ArrayList:
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)) ; } } Uitgang:
Initial Array: [A, B, C, D, E, F] Array with added value: [A, B, C, D, E, F, G]
Door een nieuwe array te maken:
Bij deze methode maken we een nieuwe array met een groter formaat dan de oorspronkelijke array en plaatsen we de elementen daarin. We kopiëren alle elementen naar de nieuw toegevoegde array.
Beschouw het onderstaande voorbeeld:
// 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 = {'A', 'B', 'C' }; // Printing the Original Array System.out.println('Initial Array: ' + Arrays.toString(sa)); int length_Var = sa.length; //Defining the array length variable String newElement = 'D'; // 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'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 = { 'Ani', 'Sam', 'Joe' }; boolean x = false; //initializing x to false int in = 0; //declaration of index variable String s = 'Sam'; // 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 = {'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)); } } </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;> Dit is hoe we elementen aan een String Array kunnen toevoegen. Laten we begrijpen hoe we elementen in String Array kunnen zoeken en sorteren.
Zoeken in een stringarray
Voor het zoeken naar een String uit de String Array wordt for loop gebruikt. Beschouw het onderstaande voorbeeld:
boolean om Java te stringen
public class StringArrayExample { public static void main(String[] args) { String[] strArray = { 'Ani', 'Sam', 'Joe' }; boolean x = false; //initializing x to false int in = 0; //declaration of index variable String s = 'Sam'; // 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 = {'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)); } } </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;> In het bovenstaande voorbeeld hebben we een Booleaanse variabele geïnitialiseerd X naar false en een indexvariabele om door de string te itereren. We hebben ook een lokale variabele String-variabele gedeclareerd S te worden doorzocht. Hier verlaat het trefwoord break de lus zodra de string wordt gevonden.
Sorteren in String-array
Het sorteren in de String-array is vrij eenvoudig. Het wordt uitgevoerd zoals in een traditionele array. We gebruiken een sort()-methode om de Array-elementen te sorteren. Sorteren is eenvoudiger dan zoeken.
Beschouw het onderstaande voorbeeld eens sorteer een 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)); } } Uitgang:
Entered Sports: [Cricket, Basketball, Football, Badminton, Tennis] Sorted Sports: [Badminton, Basketball, Cricket, Football, Tennis]
Uit het bovenstaande voorbeeld kunnen we zien dat de elementen uit een String Array zijn gesorteerd met behulp van de sort() methode.
We kunnen String Array ook converteren naar andere datastructuren zoals List, int Array, ArrayList en meer, en omgekeerd.