Java >> Java tutorial >  >> Tag >> String

String array i Java forklaret med eksempler

Denne Java String Array-artikel forklarer, hvordan man deklarerer, initialiserer og opretter String Arrays i Java og forskellige konverteringer, der kan udføres på String Array. I Java er arrays en fælles datastruktur til lagring af mange datatyper, lige fra elementære til brugerdefinerede. Vi vil ikke dække det grundlæggende i arrays og nogle af de mest almindelige operationer, der udføres på dem.

Hvad er en strengmatrix i Java?

Et array med strenge som elementer er muligt. Som et resultat kan en String Array defineres som en matrix, der indeholder mange strenge eller strengværdier. I Java er en strengmatrix en af ​​de mest brugte strukturer. Husk, at Javas 'main'-metode tager en String Array som input.

En string array er en samling af ting. Hvert element er en streng. Som du godt ved, er en streng et objekt i Java. På en String-array kan du udføre enhver handling, såsom sortering, tilføjelse af et element, joinforbindelse, opdeling, søgning osv.

I denne artikel gennemgår vi streng-arrayet i Java i dybden og de mange operationer og konverteringer, der kan udføres.

Erklæring af en strengmatrix

De to vigtigste måder at erklære en String Array på i Java inkluderer:med eller uden en størrelsesspecifikation. De to metoder til at erklære en String Array er angivet nedenfor.

String[] arrayVar ;   // declaring a string array without size
String[] arrayVar = new String[5];// Declaration of a string array with size

En String Array er deklareret som en regulær variabel uden størrelse i den første erklæring. Det er værd at bemærke, at du bliver nødt til at oprette dette array med nye, før du bruger det.

En String Array erklæres og instansieres i den anden erklæring ved hjælp af new. En streng-array med fem elementer ved navn 'arrayVar' er deklareret her. Fordi arrayet ikke er initialiseret, vil du se alle null-værdier, hvis du udskriver elementerne i dette array direkte. Lad os lave et program, der forklarer, hvordan man erklærer en String Array.

public class Codeunderscored
{
    public static void main(String[] args) {
         
        String[] arrayVarOne ;   // declaring a string array without size
        String[] arrayVarTwo = new String[5];// Declaration of a string array with size
 
        //System.out.println(myarray[0]);   //variable arrayVar might not have been initialized
        //show second array elements
        System.out.print(arrayVarTwo[0] + " " +arrayVarTwo[1]+ " " + arrayVarTwo[2]+ " " +
        arrayVarTwo[3]+ " " +arrayVarTwo[4]);
    }
}

Programmet ovenfor demonstrerer to metoder til at erklære en String Array. Den oprindelige erklæring er som tidligere nævnt blottet for størrelse og instansiering. Som et resultat skal du prøve noget med 'nyt' for at oprette dette array, før du bruger det. Array arrayVarOne bruges uden instansiering i det givne program, hvilket resulterer i en kompileringsfejl (kommenteret sætning).

Størrelsen er genstand for den anden erklæring. Som et resultat, når værdierne for individuelle String-array-elementer skrives, er de null, fordi arrayet ikke var udfyldt.

Opsætning af et strengmatrix

Når du har erklæret String Array, skal du udfylde den med nogle data. Ellers tildeles null-værdier til String-elementer som standardværdier. Som et resultat, efter at have erklæret arrayet, fortsætter vi med at initialisere det.

En String-array kan initialiseres inline med erklæringen eller efter den er blevet erklæret. Lad os først se på, hvordan man initialiserer en String-array inline.

String[] numArrayVar = {"one", "two", "three"};
String[] strArrayVar = new String[] {"one", "two", "three", "four"};

Initialiseringerne i String Array ovenfor er inline initialiseringer. String Array erklæres og initialiseres på samme tid. Du kan også bruge følgende kode til at oprette en String Array:

String[] strArrayVar = new String[5];
strArrayVar[0] = "one";
strArrayVar[1] = "two";
strArrayVar[2] = "three";
strArrayVar[3] = "four";
strArrayVar[4] = "five";

String Array erklæres først i dette tilfælde. De enkelte elementer får så værdier i den følgende linje. Efter initialisering af String Array, kan du bruge det generelt i dit program.

String arrays længde/størrelse

Du er klar over, at arrays har en længdeegenskab, der kan bruges til at bestemme størrelsen af ​​arrayet. Det gælder også for String Arrays. Yderligere bestemmes et arrays størrelse af størrelsen eller længden af ​​arrayet (enhver array). Som et resultat kan du bruge følgende sætning til at finde arrayets længde med navnet arrayVar.

int len = arrayVar.length;

// Let's write a program to display the length of a String Array.

public class Codeunderscored
{
    public static void main(String[] args) {

    //declare and initialize a string array     
    String[] numArrayVar = {"one","two", "three", "four", "five"};
    int len = numArrayVar.length;  //get the array length

    //showing the length
    System.out.println("Length of numArrayVar{\"one\",\"two\", \"three\", \"four\", \"five\"}:" + len);
    }
}

Egenskaben length er praktisk, når du skal sløjfe gennem en streng-array for at behandle den eller udskrive den.

Generer gennem en streng-array og udskriver den

Vi har hidtil gennemgået deklarations-, initialiserings- og længdeegenskaberne for en String Array; nu er det tid til at gennemgå hvert array-element og udskrive String Array-elementerne. Du kan krydse en String Array ved at bruge for loop og enhanced for loop, ligesom ethvert andet array. En Java-metode nedenfor viser, hvordan man krydser/itererer arrayet og udlæser dets elementer ved hjælp af en forbedret for en loop.

public class Codeunderscored
{
    public static void main(String[] args) {
        //declaration and String Array initialization
        String[] numArrayVar = {"one","two", "three", "four", "five"};

        System.out.println("using for loop to show elements in the String Array:");

        // for loop for iterating over the given string array

        for(int i=0; i<numArrayVar.length;i++)
            System.out.print(numArrayVar[i] + " ");
     
        System.out.println("\n");
     
        System.out.println("using enhanced for loop to display elements in the String Array:");

        //iterating over the string array using  enhanced for loop

        for(String var:numArrayVar)
            System.out.print(var + " ");
    }
}

Både det sædvanlige for loop og advanced for loop bruges til at krydse strengarrayet i ovenstående applikation. Det er værd at bemærke, at der ikke er behov for at erklære en grænse eller en slutbetingelse i tilfælde af en forbedret for en sløjfe. Når du bruger ' for '-løkken, skal du definere start- og slutbetingelserne.

Føj til rækken af ​​strenge

Ligesom andre datastrukturer kan String Arrays have elementer tilføjet til dem. Dette afsnit ser på de forskellige teknikker til at tilføje et element til string-arrayet.

Brug af forhåndstildeling

Pre-allokering er en teknik til at allokere ressourcer før tid. Du genererer et array med en større størrelse ved hjælp af denne metode. For eksempel, hvis du skal gemme 5 elementer i et array, konstruerer du et 10-element array. Sidstnævnte giver dig simpelthen mulighed for at tilføje nye elementer til arrayets ende.

Det følgende er et eksempel på, hvordan man tilføjer et nyt element til det forudtildelte array.

import java.util.*;
public class Codeunderscored
{
    public static void main(String[] args) {
        String[] langArray = new String[7];
        // initial array values
        langArray[0] = "Python";
        langArray[1] = "Java";
        langArray[2] = "JavaScript";
        langArray[2] = "C++";
        System.out.println("The initial Array is:" + Arrays.toString(langArray));
        countOfItems = 4;
 
        // try adding new values to the array's end
        String newLang = "Go";
        colorsArray[countOfItems++] = newLang;
        System.out.println("Array after adding one element:" +  
                  Arrays.toString(langArray));
    }
}

Det er værd at bemærke, at arrayets tomme plads er sat til Null. Ulempen ved denne strategi er, at den spilder plads, fordi du måske har et omfattende array, der ikke bliver brugt.

Brug af et nyt array

Denne metode skaber et nyt array, der er mere omfattende end det originale array, så det nye element kan rummes. Efter generering af det nye array overføres alle det tidligere arrays elementer til det, og derefter tilføjes det nye element til slutningen. Det følgende er et eksempelprogram, der bruger det nye array til at tilføje et element.

importjava.util.*;
 
public class Codeunderscored
{
    public static void main(String[] args) {
        //original array
        String[] langArray = {"Python", "Java", "JavaScript", "C++" };    
        System.out.println("Original Array: " + Arrays.toString(langArray));
 
        //length of original array
        int initialLength = langArray.length;

        // Adding a new entry to the string array
        String newLang= "Go";

        // create a new array with a length that is greater than the previous array 
        String[] newArray = new String[ initialLength + 1 ];

        // all the elements of the original array should be copied to the new array
        for (int i=0; i <langArray .length; i++)
        {
            newArray[i] = langArray [i];
         }
        // near the end of the new array, add a new element
        newArray[newArray.length- 1] = newLang;

        // create a new Array that is identical to the original array and print it
        langArray = newArray;   
        System.out.println(" Displaying array items after adding a new item: " + Arrays.toString(langArray));
    }
}

Fordi softwaren skal vedligeholde to arrays, resulterer denne teknik i hukommelse og ydeevne overhead.

ArrayList som en type samling

ArrayList som en mellemliggende datastruktur kan også bruges til at tilføje et element til en String-array. Det følgende er et eksempel.

import java.io.*;
import java.lang.*;
import java.util.*;
 
class Codeunderscored {
 
    public static void main(String[] args)
    {
          // initial array  definition
          String langArray[]
            = { "Java", "Python", "C++", "C#", "JavaScript", "Go" };
 
        // printing of the original array
        System.out.println("Initial Array:\n"
                           + Arrays.toString(langArray));
 
        // new element to be added
        String newLang = "Ruby";
 
        // convert the array to arrayList
        List<String>langList
            = new ArrayList<String>(
                  Arrays.asList(langArray));
 
        // Add the new element to the arrayList
        langList.add(newLang);
 
        // Convert the Arraylist back to array
        langArray = langList.toArray(numArray);
 
        // showing the array that has been the changed
        System.out.println("\nArray with value " + newLang
                           + " added:\n"
                           + Arrays.toString(langArray));
    }
}

String-arrayet omdannes først til en ArrayList ved hjælp af asList-metoden, som det ses i ovenstående applikation. Tilføj metoden bruges derefter til at tilføje det nye element til ArrayList. ArrayList transformeres tilbage til et array, når elementet indsættes. Sammenlignet med de tidligere tilgange er denne mere effektiv.

Hvad en strengmatrix indeholder

Metoden 'indeholder' kan afgøre, om en given streng er til stede i strengarrayet. Fordi denne metode hører til ArrayList, skal du først konvertere string-arrayet til en ArrayList. 'Indeholder'-teknikken er demonstreret i følgende eksempel.

import java.io.*;
import java.lang.*;
import java.util.*;
 
class Codeunderscored {
 
     public static void main(String[] args)
    {         
         String[] programmingLanguages = new String[]{"C++", "Java", "Go", "C", "Python"};
 
        // Convert String Array to List
        List<String>languagesList = Arrays.asList(programmingLanguages);
        String languageToCheck = "Java";
        if(languagesList .contains(languageToCheck)){
           System.out.println("The Langugae " + languageToCheck + " is present in the string array");
        }
       else
       System.out.println("The Language " + languageToCheck + " is not present in string array" );
    }
}

Vi startede med at bestemme, om den givne strengmatrix indeholder strengen 'Go'. En relevant besked vises, da den er til stede. Den streng, der skal testes, ændres derefter til 'JavaScript'. 'Indeholder'-metoden returnerer falsk i dette scenarie.

Det er værd at bemærke, at den streng, der leveres som en parameter til funktionen indeholder, altid skelner mellem store og små bogstaver. Hvis vi sender 'go' som parameter til contains-metoden i ovenstående implementering, vil den returnere falsk.

Hvordan sorterer du et string-array

'Sortering i arrays' er allerede blevet dækket i dybden. Metoderne til sortering af en strengmatrix ligner dem til sortering af andre matrixer. 'Sorteringsmetoden' for klassen 'Arrays' er implementeret nedenfor og sorterer strengene i arrayet i alfabetisk rækkefølge.

import java.util.*;
 
class Codeunderscored {
 
     public static void main(String[] args)
    {
        String[] programmingLanguages = {"Python","C++","C#","Python","JavaScript"};
        System.out.println("The initial array: "+Arrays.toString(programmingLanguages));
        Arrays.sort(programmingLanguages);
        System.out.println("Sorted array: "+Arrays.toString(programmingLanguages));
    }
}

Outputtet fra den foregående software inkluderer både det originale input-array og et alfabetisk sorteret output-array.

Søger efter en streng i strengmatrixen

Du kan også søge efter en bestemt streng i en String Array ved at krydse hvert element i String Array, ud over den 'indeholder' teknik, vi lige har nævnt. Hvert element i String Array vil blive sammenlignet med String, der skal søges i.

Når den første forekomst af strengen er lokaliseret, er søgningen afsluttet. Derefter returneres det passende indeks for strengen i arrayet. En relevant meddelelse vises, hvis strengen ikke findes før slutningen af ​​strengarrayet. Følgende Java-program demonstrerer denne implementering.

import java.util.*;

class Codeunderscored {
    public static void main(String[] args)
    {
      String[] compCompanies = { "Google", "DELL", "HP", "IBM", "Air BnB" };
        boolean found = false;
        int index = 0;
        String searchStr = "DELL";
       for (int i = 0; i <compCompanies .length; i++) {
       if(searchStr.equals(compCompanies[i])) {
            index = i; found = true;
            break;
            }
        }
       if(found)
          System.out.println( searchStr +" is available at the index "+index);
        else
          System.out.println( searchStr +" is not present in the array");
 
    }
}

Når strengen 'DELL' findes i en given strengmatrix, returnerer ovenstående program det indeks, der svarer til det.

Konvertering af strengmatrix til streng

Lad os se på, hvordan man opretter en streng fra en strengmatrix. Vi vil gennemgå tre alternative måder at implementere det på, hver med et eksempel.

toString-metoden i aktion

Den første metode bruger 'Arrays'-klassens toString-funktion. Den accepterer en strengmatrix som en parameter og returnerer matrixens strengrepræsentation. ToString-metoden er demonstreret i Java-applikationen nedenfor.

import java.util.*;
public class Codeunderscored {
    public static void main(String args[])
    {
        // string declaration
        String[] strArray = {"Coding","is","my","favorite","hobby"};
 
        System.out.println("The String array converted to string:" + Arrays.toString(strArray));
    }
}

'toString'-metoden bruges i ovenstående software til at vise strengrepræsentationen af ​​den angivne strengmatrix.

StringBuilder.Append()-metoden

Klassen 'StringBuilder' er den næste mulighed for at omdanne et strengarray til en streng. Opret et StringBuilder-objekt, og brug StringBuilders 'Tilføj'-funktion til at tilføje string-array-medlemmerne til StringBuilder-objektet. Efter at have tilføjet alle array-medlemmer til StringBuilder-objektet, kan du bruge 'toString'-metoden til at erhverve strengrepræsentationen.

import java.util.*;
public class Codeunderscored {
    public static void main(String args[])
    {
        //string array
       String[] strArray = {"Coding","is","my","favorite","hobby"};
       System.out.print("The initial string array is:");
        //print string array
        for(String val:strArray)
              System.out.print(val + " ");
 
        System.out.println("\n");

        //using a string array to create a stringbuilder object
        StringBuilder stringBuilder = new StringBuilder();
         int i;
        for (i= 0; i <strArray.length; i++) {
             stringBuilder.append(strArray[i]+ " ");
        }
        //print the String
        System.out.println("obtaining the string from string array:" + stringBuilder.toString());
    }
}

Den foregående software bruger StringBuilder-klassen til at konvertere en strengmatrix til en streng.

Anvendelse af Join Operation

Du kan også bruge String-klassens 'join'-funktion til at konvertere en strengmatrix til en strengrepræsentation. 'Join'-handlingen kræver to argumenter:den første er strengens separator eller afgrænsning, og den anden er streng-arrayet. Derudover adskilles strengen derefter af separatoren, der leveres af joinproceduren (første argument).

Programmet nedenfor viser, hvordan man bruger join-operationen til at hente en streng fra en String Array.

import java.util.*;
public class Codeunderscored {
     public static void main(String args[])
    {
        //string array
        String[] strArray = {"Coding","is","my","favorite","hobby"};
        System.out.println("The initial string array is:");  
     
        // string array printing
        for(String val:strArray)
           System.out.print(val + " ");

        System.out.println("\n");
        //form a string from string array using join operation
        String combinedString = String.join(" ", strArray);
        //print the string
        System.out.println(" The String that is obtained from string array:" + combinedString);
    }
}

Konvertering af en streng til en tilsvarende række af strenge

Lad os se på at konvertere en streng til et strengarray omvendt. Denne konvertering kan udføres på to måder.

Brug af splitoperationen

Split-operationen af ​​String-klassen er den indledende metode til at transformere en streng til en streng-array. Et afgrænsningstegn (komma, mellemrum osv.) kan bruges til at adskille en streng og returnere den nyoprettede strengmatrix. Opdelingsoperationen er vist i følgende eksempel.

public class Codeunderscored {
public static void main(String args[])
    {
        //declare a string
        String strVar = "This is unit code test prerequisites";
        // To split a string into a string array, use the split function.
        String[] strArray = strVar.split(" ", 6);
 
        System.out.println("The resultant String Array after splitting the string is \"" + strVar + "\":");
      
      //showing the string array
        int i;
        for (i=0;i<strArray.length;i++)
             System.out.println("strArray[" + i+ "]=" + strArray[i]);
    }
}

Ovenstående program opdeler strengen baseret på mellemrum og returnerer en 5-element streng matrix ved hjælp af splitfunktionen.

Brug af et regulært udtryksmønster

Regulære udtryk er en tilgang til at konvertere en streng til en strengmatrix. Du kan definere et mønster, og derefter vil den givne streng blive opdelt efter mønsteret. Du kan bruge Java.util-pakkens Regex Pattern-klasse. Et eksempel på anvendelse af mønstre til at konvertere en streng til en String Array er vist nedenfor.

import java.util.Arrays;
import java.util.regex.Pattern;
 
public class Codeunderscored {
    public static void main(String args[])
    {
        // string declaration
        String strVar = "This is unit code test prerequisites";
        System.out.println("The initial string is:" + strVar + "\n");
        String[] strArray = null;
 
        //split string on space(" ")
        Pattern pattern = Pattern.compile(" ");

        //using the pattern split on string to get string array
        strArray = pattern.split( strVar );
 
        //printing the string array
        System.out.println("The resultant String Array after splitting the string using regex pattern:");
        for (int i=0;i<strArray .length;i++)
            System.out.println("strArray[" + i+ "]=" + strArray[i]);
    }
}

Det mønster, vi har leveret i ovenstående program, er et mellemrumstegn. Som et resultat er strengen opdelt i mellemrum, hvilket returnerer strengarrayet. Som du kan se, er regulære udtryk og mønstre en væsentligt mere effektiv programmeringstilgang.

Konvertering af en strengmatrix til liste

Du kan også lave en liste ud af en strengmatrix. Der er et par måder at gøre dette på, som vi har angivet nedenfor.

Brug af tilpasset kode

Den første måde er at omdanne en strengmatrix til en liste ved hjælp af skræddersyet kode. En strengmatrix gennemses i denne funktion, og hvert medlem føjes til listen ved hjælp af listens tilføjelsesmetode. Det demonstreres i følgende program.

import java.util.*;
 
public class Codeunderscored
{
    public static void main( String[] args )
    {
        //string array declaration
        String[] compCompanies = { "Google", "DELL", "HP", "IBM", "Air BnB" };

        System.out.println("The original string array:" + Arrays.toString(compCompanies));

        //definition of the arraylist with size same as string array
        List<String>strArrayList = new ArrayList<String>(numArray.length);
        //add string array elements to arraylist
        for (String str:compCompanies) {
           strArrayList.add(str );
        }
         System.out.println("\n The Arraylist that is created from string array:");
        //print the arraylist
        for (String str : strArrayList)
        {
             System.out.print(str + " " );
        }
    }
}

Først fremstilles en liste, som vist i programmet ovenfor. For-hver-løkken bruges derefter til at tilføje hver indgang i streng-arrayet til listen. Listen udskrives derefter.

Brug af collections.addAll()-metoden

Den anden teknik til at omdanne et string-array til en liste er at bruge Collections frameworkets 'addAll'-metode. AddAll()-metoden tager en ArrayList og en string-array som input og overfører string-arrayets indhold til ArrayList. AddAll-metoden konverterer en strengmatrix til en liste i følgende software.

import java.util.*;
 
public class Codeunderscored
{
    public static void main( String[] args )
    {
        //a string array
        String[] compArray = { "DELL", "IBM", "Chromebook", "Lenovo", "Toshiba" };
        System.out.println("The original string array:" + Arrays.toString(vehiclesArray));

        //arraylist with size same as string array definition
        List<String> strArrayList = new ArrayList<String>(compArray .length);
 
        //add string array items to arraylist using Collections.addAll method
        Collections.addAll(strArrayList, compArray );
 
        System.out.println("\nArraylist  is created from string array:");
 
        // arraylist printing
        for (String str : strArrayList)
        {
             System.out.print(str + " " );
        }
    }
}

Ved at bruge samlinger omdannede vi et medfølgende strengarray til en liste i den tidligere software. addAll er en metode, der tilføjer alt til en liste.

Ved brug af metoden arrays.asList()

Endelig har Array-klassen en 'asList()'-metode, der direkte konverterer en string-array til en liste. Et Java-program, der bruger asList, er vist nedenfor.

import java.util.*;
 
public class Codeunderscored
{
     public static void main( String[] args )
    {
        //a string array
         String[] compArray = { "DELL", "IBM", "Chromebook", "Lenovo", "Toshiba" };
        System.out.println("The string array:" + Arrays.toString(compArray));
 
        //Conversion of Array to list using asList method
        List<String> strArrayList = Arrays.asList( compArray );
 
        System.out.println("\nThe Arraylist created from string array:");
 
        // arraylist printing
        for (String str : strArrayList)
        {
             System.out.print(str + " " );
        }
    }
}

AsList-funktionen i Arrays-klassen konverterer et array til en liste og returnerer det, som det ses ovenfor.

Sådan konverterer du en liste til en strengmatrix

Vi så et par metoder til at konvertere en strengmatrix til en liste i det forrige afsnit. Lad os se på teknikkerne til at konvertere en liste til en strengmatrix.

Ved brug af ArrayList.get-metoden()

Den første metode er ArrayList get-metoden, som returnerer listens elementer. Du kan krydse ArrayList og bruge get-metoden til at hente et element, som derefter kan allokeres til en array-placering. Det demonstreres i følgende program.

import java.util.*;
 
public class Codeunderscored
{
    public static void main( String[] args )
    {
        //ArrayList initialization
         ArrayList<String> strArrayList= new ArrayList<String>();
        

	//adding new items to the arraylist
        strArrayList.add("maize");
        strArrayList.add("beans");
        strArrayList.add("potatoes");
        strArrayList.add("yams");
        strArrayList.add("sorghum");
         
        //ArrayList to Array Conversion
        String strArrayVar[] = new String[strArrayList .size()];              
        for(int j =0;j<strArrayList .size();j++){
         strArrayVar[j] = strArrayList.get(j);
         }
        //print array elements
        System.out.println("The String array is obtained from string arraylist:");
        for(String ary: strArrayVar){
        System.out.print(ary + " ");
        }
    }
}

Elementerne føjes først til ArrayList, og derefter transformeres listen til en string-array ved hjælp af 'toArray'-metoden.

String array til heltals array

Du skal muligvis udføre operationer på tal på et tidspunkt. I dette scenarie, hvis dit strengmatrix indeholder numeriske data, anbefales det, at du konverterer det til et int-array. For at gøre det skal du anvende 'parseInt'-funktionen på hvert array-element og udtrække heltal. Programmet nedenfor forklarer, hvordan man konverterer et string-array til et int-array.

import java.util.*;
 
public class Codeunderscored
{
     public static void main( String[] args )
    {
       //string arrya declaration
       String [] strVar = {"30", "40","50", "60","70"};
      
     //printing of the string array
      System.out.println("The Original String Array:");
      for(String val:strVar)
         System.out.print(val + " ");
 
         System.out.println("\nThe integer array obtained from string array:");
        //declare an int array
        int [] intArray = new int [strVar .length];

        //assigning the string array values to int array
        for(int i=0; i<intArray .length; i++) {
           int_Array[i] = Integer.parseInt(str_Array[i]);
      }
      //display the int array
      System.out.println(Arrays.toString(int_Array));
    }
}

Vi har en strengmatrix i ovenstående applikation, der inkluderer tallene som strenge. Hvert string-array-element analyseres ved hjælp af 'parseInt'-funktionen og tildeles et int-array i dette program. Denne konvertering vil kun fungere med en strengmatrix med numeriske medlemmer. Compileren kaster et 'java.lang.NumberFormatException', hvis nogen af ​​indtastningerne i string-arrayet er ikke-numeriske.

Konklusion

I Java er et array en grundlæggende og meget brugt datastruktur. Arrayet er en samling af sammenlignelige datatypeelementer. Faktisk er det en af ​​de mest brugte datastrukturer af programmører på grund af dens effektivitet og produktivitet. Elementerne er gemt i et enkelt hukommelsesområde.

Et array, der omfatter et fast antal strengværdier, er kendt som et string-array. På den anden side omtales en række af karakterer som en streng. En streng er et uforanderligt objekt, hvilket betyder, at dens værdi ikke kan ændres. Derudover fungerer String Array på samme måde som andre Array-datatyper.


Java tag