Java Language
arrays

Invoering

Syntaxis

• ArrayType[] myArray; // Arrays declareren
• ArrayType myArray[]; // Nog een geldige syntaxis (minder vaak gebruikt en afgeraden)
• ArrayType[][][] myArray; // Meerdimensionale gekartelde arrays (herhaal [] s)
• ArrayType myVar = myArray[index]; // Toegang tot (lees) element bij index
• myArray[index] = value; // Wijs waarde toe aan positie- index van array
• ArrayType[] myArray = new ArrayType[arrayLength]; // Syntaxis van de initialisatie van de array
• int[] ints = {1, 2, 3}; // Syntaxis van de initialisatie van de array met de opgegeven waarden, de lengte wordt afgeleid uit het aantal opgegeven waarden: {[value1 [, value2] *]}
• new int[]{4, -5, 6} // Can be used as argument, without a local variable
• int[] ints = new int[3]; // same as {0, 0, 0}
• int[][] ints = {{1, 2}, {3}, null}; // Multi-dimensionale array-initialisatie. int [] breidt Object uit (net als anyType []), dus null is een geldige waarde.

parameters

Arrays maken en initialiseren

Basisgevallen

int[]   numbers1 = new int[3];                 // Array for 3 int values, default value is 0
int[]   numbers2 = { 1, 2, 3 };                // Array literal of 3 int values
int[]   numbers3 = new int[] { 1, 2, 3 };      // Array of 3 int values initialized
int[][] numbers4 = { { 1, 2 }, { 3, 4, 5 } };  // Jagged array literal
int[][] numbers5 = new int[5][];               // Jagged array, one dimension 5 long
int[][] numbers6 = new int[5][4];              // Multidimensional array: 5x4

Arrays kunnen worden gemaakt met elk primitief of referentietype.

float[]  boats = new float[5];          // Array of five 32-bit floating point numbers.
double[] header = new double[] { 4.56, 332.267, 7.0, 0.3367, 10.0 };
                                       // Array of five 64-bit floating point numbers.
String[] theory = new String[] { "a", "b", "c" };
                                       // Array of three strings (reference type).
Object[] dArt = new Object[] { new Object(), "We love Stack Overflow.", new Integer(3) };
                                       // Array of three Objects (reference type).

Merk in het laatste voorbeeld op dat subtypen van het aangegeven arraytype zijn toegestaan in de array.

Arrays voor door de gebruiker gedefinieerde typen kunnen ook worden gebouwd vergelijkbaar met primitieve typen

UserDefinedClass[] udType = new UserDefinedClass[5];

Arrays, collecties en streams

// Parameters require objects, not primitives

// Auto-boxing happening for int 127 here
Integer[]       initial        = { 127, Integer.valueOf( 42 ) };
List<Integer>   toList         = Arrays.asList( initial );  // Fixed size! 

// Note: Works with all collections
Integer[]       fromCollection = toList.toArray( new Integer[toList.size()] );

//Java doesn't allow you to create an array of a parameterized type
List<String>[]  list = new ArrayList<String>[2];  // Compilation error!

// Streams - JDK 8+
Stream<Integer> toStream       = Arrays.stream( initial );
Integer[]       fromStream     = toStream.toArray( Integer[]::new );

Intro

Een array is een gegevensstructuur die een vast aantal primitieve waarden of verwijzingen naar objectinstanties bevat.

Elk item in een array wordt een element genoemd en elk element is toegankelijk via de numerieke index. De lengte van een array wordt bepaald wanneer de array wordt gemaakt:

int size = 42;
int[] array = new int[size];

De grootte van een array is vast tijdens runtime wanneer deze is geïnitialiseerd. Het kan niet worden gewijzigd na initialisatie. Als de grootte tijdens runtime moet kunnen worden gewijzigd, moet in plaats daarvan een Collection zoals ArrayList worden gebruikt. ArrayList slaat elementen op in een array en ondersteunt het wijzigen van de grootte door een nieuwe array toe te wijzen en elementen uit de oude array te kopiëren.

Als de array van een primitief type is, dwz

int[] array1 = { 1,2,3 };
int[] array2 = new int[10];

de waarden worden opgeslagen in de array zelf. Bij afwezigheid van een initialisatie (zoals in array2 hierboven), is de standaardwaarde die aan elk element wordt toegewezen 0 (nul).

Als het arraytype een objectverwijzing is, zoals in

SomeClassOrInterface[] array = new SomeClassOrInterface[10];

dan bevat de array verwijzingen naar objecten van het type SomeClassOrInterface . Die verwijzingen kunnen verwijzen naar een instantie van SomeClassOrInterface of elke subklasse (voor klassen) of implementatieklasse (voor interfaces) van SomeClassOrInterface . Als de arraydeclaratie geen initialisatie heeft, wordt de standaardwaarde null aan elk element toegewezen.

Omdat alle arrays int geïndexeerd zijn, moet de grootte van een array worden opgegeven door een int . De grootte van de array kan niet als long worden opgegeven:

long size = 23L;
int[] array = new int[size]; // Compile-time error:
                             // incompatible types: possible lossy conversion from
                             // long to int

Arrays gebruiken een op nul gebaseerd indexsysteem, wat betekent dat indexering begint bij 0 en eindigt bij length - 1 .

De volgende afbeelding vertegenwoordigt bijvoorbeeld een array met grootte 10 . Hier bevindt het eerste element zich op index 0 en het laatste element op index 9 , in plaats van het eerste element op index 1 en het laatste element op index 10 (zie onderstaande afbeelding).

Toegang tot elementen van arrays gebeurt in constante tijd . Dat betekent dat toegang tot het eerste element van de reeks dezelfde (tijd) kosten heeft voor toegang tot het tweede element, het derde element, enzovoort.

Java biedt verschillende manieren om arrays te definiëren en te initialiseren, inclusief letterlijke en constructeurnotaties . Bij het declareren van arrays met de new Type[length] constructor new Type[length] , wordt elk element geïnitialiseerd met de volgende standaardwaarden:

• 0 voor primitieve numerieke typen : byte , short , int , long , float en double .
• '\u0000' (null-teken) voor het char type.
• false voor het boolean type.
• null voor referentietypen .

Arrays van het primitieve type maken en initialiseren

int[] array1 = new int[] { 1, 2, 3 }; // Create an array with new operator and 
                                      // array initializer.
int[] array2 = { 1, 2, 3 };           // Shortcut syntax with array initializer.
int[] array3 = new int[3];            // Equivalent to { 0, 0, 0 }
int[] array4 = null;                  // The array itself is an object, so it
                                      // can be set as null.

Bij het declareren van een array, verschijnt [] als onderdeel van het type aan het begin van de aangifte (achter de typenaam), of als onderdeel van de aangever voor een bepaalde variabele (na variabelenaam), of beide:

int array5[];       /* equivalent to */  int[] array5;
int a, b[], c[][];  /* equivalent to */  int a; int[] b; int[][] c;
int[] a, b[];       /* equivalent to */  int[] a; int[][] b;
int a, []b, c[][];  /* Compilation Error, because [] is not part of the type at beginning
                       of the declaration, rather it is before 'b'. */    
// The same rules apply when declaring a method that returns an array:
int foo()[] { ... } /* equivalent to */  int[] foo() { ... }

In het volgende voorbeeld zijn beide verklaringen correct en kunnen ze zonder problemen worden gecompileerd en uitgevoerd. Zowel de Java-coderingsconventie als de Google Java Style Guide ontmoedigen het formulier met haakjes achter de naam van de variabele. De haakjes geven het arraytype aan en moeten worden weergegeven met de typeaanduiding . Hetzelfde moet worden gebruikt voor methode-retourhandtekeningen.

float array[]; /* and */ int foo()[] { ... } /* are discouraged */
float[] array; /* and */ int[] foo() { ... } /* are encouraged */

Het ontmoedigde type is bedoeld voor overgangsgebruikers van C , die bekend zijn met de syntaxis voor C die de haakjes achter de naam van de variabele heeft.

In Java is het mogelijk om arrays van maat 0 :

int[] array = new int[0]; // Compiles and runs fine.
int[] array2 = {};        // Equivalent syntax.

Omdat het echter een lege array is, kunnen er geen elementen uit worden gelezen of eraan worden toegewezen:

array[0] = 1;     // Throws java.lang.ArrayIndexOutOfBoundsException.
int i = array2[0]; // Also throws ArrayIndexOutOfBoundsException.

Dergelijke lege arrays zijn meestal nuttig als retourwaarden, zodat de aanroepcode zich alleen zorgen hoeft te maken over het omgaan met een array, in plaats van een mogelijke null die kan leiden tot een NullPointerException .

De lengte van een array moet een niet-negatief geheel getal zijn:

int[] array = new int[-1]; // Throws java.lang.NegativeArraySizeException

De array-grootte kan worden bepaald met behulp van een openbaar laatste veld genaamd length :

System.out.println(array.length); // Prints 0 in this case.

Opmerking : array.length retourneert de werkelijke grootte van de array en niet het aantal array-elementen waaraan een waarde is toegewezen, in tegenstelling tot ArrayList.size() die het aantal array-elementen retourneert waaraan een waarde is toegewezen.

Multidimensionale arrays maken en initialiseren

De eenvoudigste manier om een multidimensionale array te maken is als volgt:

int[][] a = new int[2][3];

Er worden twee int reeksen van drie lengtes gemaakt: a[0] en a[1] . Dit lijkt sterk op de klassieke C-stijl initialisatie van rechthoekige multidimensionale arrays.

U kunt tegelijkertijd maken en initialiseren:

int[][] a = { {1, 2}, {3, 4}, {5, 6} };

In tegenstelling tot C , waar alleen rechthoekige multidimensionale arrays worden ondersteund, hoeven binnenste arrays niet dezelfde lengte te hebben of zelfs te zijn gedefinieerd:

int[][] a = { {1}, {2, 3}, null };

Hier is a[0] een int array met één lengte, terwijl a[1] een int array met twee lengtes is en a[2] null . Dergelijke arrays worden gekartelde arrays of ragged arrays genoemd , dat wil zeggen, het zijn arrays van arrays. Multidimensionale arrays in Java worden geïmplementeerd als arrays van arrays, dwz array[i][j][k] is equivalent aan ((array[i])[j])[k] . In tegenstelling tot C # wordt de syntaxisarray array[i,j] niet ondersteund in Java.

Multidimensionale arrayrepresentatie in Java

Bron - Live op Ideone

Arrays van het referentietype maken en initialiseren

String[] array6 = new String[] { "Laurel", "Hardy" }; // Create an array with new 
                                                      // operator and array initializer.
String[] array7 = { "Laurel", "Hardy" };              // Shortcut syntax with array 
                                                      // initializer.
String[] array8 = new String[3];                      // { null, null, null }
String[] array9 = null;                               // null

Live op Ideone

Naast de String letterlijke en primitieven bovenstaande, de snelkoppeling syntaxis voor matrix initialisatie werkt ook met canonieke Object types:

Object[] array10 = { new Object(), new Object() };

Omdat arrays covariant zijn, kan een array van het referentietype worden geïnitialiseerd als een array van een subklasse, hoewel een ArrayStoreException wordt gegenereerd als u probeert een element in te stellen op iets anders dan een String :

Object[] array11 = new String[] { "foo", "bar", "baz" };
array11[1] = "qux"; // fine
array11[1] = new StringBuilder(); // throws ArrayStoreException

De sneltoetssyntaxis kan hiervoor niet worden gebruikt omdat de sneltoetssyntaxis een impliciet type Object[] zou hebben Object[] .

Een array kan worden geïnitialiseerd met nul elementen met behulp van String[] emptyArray = new String[0] . Een array met een lengte van nul zoals deze wordt bijvoorbeeld gebruikt voor het maken van een Array uit een Collection wanneer de methode het runtime-type van een object nodig heeft.

In zowel primitieve als referentietypes initialiseert een lege array-initialisatie (bijvoorbeeld String[] array8 = new String[3] ) de array met de standaardwaarde voor elk gegevenstype .

Arrays van generieke typen maken en initialiseren

In generieke klassen kunnen arrays van generieke typen niet op deze manier worden geïnitialiseerd vanwege type wissen :

public class MyGenericClass<T> {
    private T[] a;

    public MyGenericClass() {
        a = new T[5]; // Compile time error: generic array creation
    }
}

In plaats daarvan kunnen ze worden gemaakt met behulp van een van de volgende methoden: (merk op dat deze niet-gecontroleerde waarschuwingen genereren)

1. Door een Object en deze naar het generieke type te casten:

   a = (T[]) new Object[5];
   

   Dit is de eenvoudigste methode, maar omdat de onderliggende array nog steeds van het type Object[] , biedt deze methode geen typeveiligheid. Daarom wordt deze methode voor het maken van een array het beste alleen gebruikt binnen de generieke klasse - niet openbaar gemaakt.

2. Door Array.newInstance met een parameter class:

   public MyGenericClass(Class<T> clazz) {
       a = (T[]) Array.newInstance(clazz, 5);
   }
   

   Hier moet de klasse T expliciet aan de constructor worden doorgegeven. Het geretourneerde type Array.newInstance is altijd Object . Deze methode is echter veiliger omdat de nieuw gecreëerde array altijd van het type T[] is en daarom veilig kan worden geëxternaliseerd.

Een array vullen na initialisatie

Arrays.fill(array8, "abc");        // { "abc", "abc", "abc" }

Arrays.fill(array8, 1, 2, "aaa");  // Placing "aaa" from index 1 to 2.

int[] array = new int[5];
Arrays.setAll(array, i -> i); // The array becomes { 0, 1, 2, 3, 4 }.

Afzonderlijke aangifte en initialisatie van arrays

De waarde van een index voor een array-element moet een geheel getal zijn (0, 1, 2, 3, 4, ...) en minder dan de lengte van de array (indexen zijn gebaseerd op nul). Anders wordt een ArrayIndexOutOfBoundsException gegenereerd:

int[] array9;             // Array declaration - uninitialized
array9 = new int[3];      // Initialize array  - { 0, 0, 0 }
array9[0] = 10;           // Set index 0 value - { 10, 0, 0 }
array9[1] = 20;           // Set index 1 value - { 10, 20, 0 }
array9[2] = 30;           // Set index 2 value - { 10, 20, 30 }

Arrays worden mogelijk niet opnieuw geïnitialiseerd met de syntaxis van de snelkoppeling van de array-initialisatie

Het is niet mogelijk om een array opnieuw te initialiseren via een sneltoetssyntaxis met een array-initialisatie, omdat een array-initialisatie alleen kan worden opgegeven in een velddeclaratie of declaratie van een lokale variabele, of als onderdeel van een expressie voor het maken van een array.

Het is echter mogelijk om een nieuwe array te maken en deze toe te wijzen aan de variabele die wordt gebruikt om naar de oude array te verwijzen. Hoewel dit tot gevolg heeft dat de array waarnaar wordt verwezen door die variabele opnieuw wordt geïnitialiseerd, is de inhoud van de variabele een volledig nieuwe array. Hiertoe kan de new operator worden gebruikt met een array-initialisatie en worden toegewezen aan de arrayvariabele:

// First initialization of array
int[] array = new int[] { 1, 2, 3 };

// Prints "1 2 3 ".
for (int i : array) {
    System.out.print(i + " ");
}

// Re-initializes array to a new int[] array.
array = new int[] { 4, 5, 6 };

// Prints "4 5 6 ".
for (int i : array) {
    System.out.print(i + " ");
}

array = { 1, 2, 3, 4 }; // Compile-time error! Can't re-initialize an array via shortcut 
                        // syntax with array initializer.

Live op Ideone

Een array maken op basis van een verzameling

Twee methoden in java.util.Collection maken een array uit een verzameling:

• Object[] toArray()

• <T> T[] toArray(T[] a)

Object[] toArray() kan als volgt worden gebruikt:

Set<String> set = new HashSet<String>();
set.add("red");
set.add("blue");

// although set is a Set<String>, toArray() returns an Object[] not a String[]
Object[] objectArray = set.toArray();

<T> T[] toArray(T[] a) kan als volgt worden gebruikt:

Set<String> set = new HashSet<String>();
set.add("red");
set.add("blue");

// The array does not need to be created up front with the correct size.
// Only the array type matters. (If the size is wrong, a new array will
// be created with the same type.)
String[] stringArray = set.toArray(new String[0]);  

// If you supply an array of the same size as collection or bigger, it
// will be populated with collection values and returned (new array
// won't be allocated)
String[] stringArray2 = set.toArray(new String[set.size()]);

Het verschil tussen beide is meer dan alleen untyped versus getypte resultaten. Hun prestaties kunnen ook verschillen (lees voor meer informatie dit gedeelte over prestatieanalyse ):

• Object[] toArray() maakt gebruik van arraycopy , die veel sneller is dan de arraycopy gebruikt in T[] toArray(T[] a) .
• T[] toArray(new T[non-zero-size]) moet de array tijdens runtime op nul zetten, terwijl T[] toArray(new T[0]) dat niet doet. Zulke vermijding doet de laatste sneller roepen dan de eerste. Gedetailleerde analyse hier: Arrays of Wisdom of the Ancients .

String[] strings = list.stream().toArray(String[]::new);

Voorbeelden uit twee antwoorden ( 1 , 2 ) op het converteren van 'ArrayList naar' String [] 'in Java op Stack Overflow.

Arrays to a String

int[] arr = {1, 2, 3, 4, 5};
System.out.println(Arrays.toString(arr));      // [1, 2, 3, 4, 5]

int[][] arr = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};
System.out.println(Arrays.deepToString(arr));  // [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

public class Cat { /* implicitly extends Object */
    @Override
    public String toString() {
      return "CAT!";
    }
}

Cat[] arr = { new Cat(), new Cat() };
System.out.println(Arrays.toString(arr));        // [CAT!, CAT!]

public class Dog {
    /* implicitly extends Object */
}

Dog[] arr = { new Dog() };
System.out.println(Arrays.toString(arr));        // [Dog@17ed40e0]

Een lijst maken van een array

De methode Arrays.asList() kan worden gebruikt om een List met vaste grootte te retourneren die de elementen van de gegeven array bevat. De resulterende List zal van hetzelfde parametertype zijn als het basistype van de array.

String[] stringArray = {"foo", "bar", "baz"};
List<String> stringList = Arrays.asList(stringArray);

Opmerking : deze lijst wordt ondersteund door ( een weergave van) de oorspronkelijke array, wat betekent dat wijzigingen in de lijst de array zullen veranderen en vice versa. Wijzigingen in de lijst die de grootte (en dus de arraylengte) zouden wijzigen, zullen echter een uitzondering veroorzaken.

Om een kopie van de lijst te maken, gebruikt u de constructor van java.util.ArrayList neemt u een Collection als argument:

String[] stringArray = {"foo", "bar", "baz"};
List<String> stringList = new ArrayList<String>(Arrays.asList(stringArray));

// Using Arrays.asList()

String[] stringArray = {"foo", "bar", "baz"};
List<String> stringList = new ArrayList<>(Arrays.asList(stringArray));

// Using ArrayList.addAll()

String[] stringArray = {"foo", "bar", "baz"};
ArrayList<String> list = new ArrayList<>();
list.addAll(Arrays.asList(stringArray));

// Using Collections.addAll()

String[] stringArray = {"foo", "bar", "baz"};
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, stringArray);

// Using Streams

int[] ints = {1, 2, 3};
List<Integer> list = Arrays.stream(ints).boxed().collect(Collectors.toList());

String[] stringArray = {"foo", "bar", "baz"};
List<Object> list = Arrays.stream(stringArray).collect(Collectors.toList());

Belangrijke opmerkingen met betrekking tot het gebruik van de methode Arrays.asList ()

• Deze methode retourneert List , wat een instantie is van Arrays$ArrayList (statische binnenklasse van Arrays ) en niet java.util.ArrayList . De resulterende List heeft een vaste grootte. Dat betekent dat het toevoegen of verwijderen van elementen niet wordt ondersteund en een UnsupportedOperationException :

  stringList.add("something"); // throws java.lang.UnsupportedOperationException
  

• Een nieuwe List kan worden gemaakt door een array-backed List aan de constructor van een nieuwe List . Dit maakt een nieuwe kopie van de gegevens, die een veranderlijke grootte heeft en die niet wordt ondersteund door de oorspronkelijke array:

  List<String> modifiableList = new ArrayList<>(Arrays.asList("foo", "bar"));
  

• Door <T> List<T> asList(T... a) aan te roepen op een primitieve array, zoals een int[] , wordt een List<int[]> geproduceerd waarvan het enige element de primitieve array in plaats van de werkelijke elementen is van de bronarray.

  De reden voor dit gedrag is dat primitieve typen niet kunnen worden gebruikt in plaats van generieke typeparameters, dus de hele primitieve array vervangt in dit geval de generieke typeparameter. Om een primitieve array naar een List te converteren, moet u eerst de primitieve array omzetten in een array van het overeenkomstige wrapper-type (dwz Arrays.asList op een geheel Integer[] plaats van een int[] ).

  Daarom wordt dit false afgedrukt:

  int[] arr = {1, 2, 3};      // primitive array of int
  System.out.println(Arrays.asList(arr).contains(1));
  

  Demo bekijken

  Aan de andere kant zal dit true drukken:

  Integer[] arr = {1, 2, 3};  // object array of Integer (wrapper for int)
  System.out.println(Arrays.asList(arr).contains(1));
  

  Demo bekijken

  Dit wordt ook true afgedrukt, omdat de array wordt geïnterpreteerd als een geheel Integer[] ):

  System.out.println(Arrays.asList(1,2,3).contains(1));
  

  Demo bekijken

Multidimensionale en gekartelde arrays

Het is mogelijk om een array met meer dan één dimensie te definiëren. In plaats van toegang te krijgen door een enkele index te bieden, wordt een multidimensionale array benaderd door een index voor elke dimensie op te geven.

De declaratie van een multidimensionale array kan worden gedaan door [] voor elke dimensie toe te voegen aan een reguliere array-decleratie. Als u bijvoorbeeld een tweedimensionale int array wilt maken, voegt u een andere set haakjes aan de verklaring toe, zoals int[][] . Dit gaat door voor driedimensionale arrays ( int[][][] ) enzovoort.

Een tweedimensionale array met drie rijen en drie kolommen definiëren:

int rows = 3;
int columns = 3;
int[][] table = new int[rows][columns];

De array kan worden geïndexeerd en hieraan waarden toewijzen met dit construct. Merk op dat de niet-toegewezen waarden de standaardwaarden zijn voor het type array, in dit geval 0 voor int .

table[0][0] = 0;
table[0][1] = 1;
table[0][2] = 2;

Het is ook mogelijk om een dimensie per keer te instantiëren en zelfs niet-rechthoekige arrays te maken. Dit worden vaker gekartelde arrays genoemd .

int[][] nonRect = new int[4][];

Het is belangrijk op te merken dat hoewel het mogelijk is om elke dimensie van gekartelde array te definiëren, het voorafgaande niveau moet worden gedefinieerd.

// valid
String[][] employeeGraph = new String[30][];

// invalid
int[][] unshapenMatrix = new int[][10];

// also invalid
int[][][] misshapenGrid = new int[100][][10];

Hoe multidimensionale arrays worden weergegeven in Java

^{Afbeeldingsbron: http://math.hws.edu/eck/cs124/javanotes3/c8/s5.html}

Letterlijke initialisatie van oneffenheden

Multidimensionale arrays en gekartelde arrays kunnen ook worden geïnitialiseerd met een letterlijke uitdrukking. Het volgende verklaart en vult een 2x3 int array:

int[][] table = {
    {1, 2, 3},
    {4, 5, 6}
};

Opmerking : gekartelde subreeksen kunnen ook null . De volgende code declareert en vult bijvoorbeeld een tweedimensionale int array waarvan de eerste subarray null , de tweede subarray een lengte van nul heeft, de derde subarray een lengte heeft en de laatste subarray een array met twee lengtes is:

int[][] table = {
    null,
    {},
    {1},
    {1,2}
};

Voor multidimensionale array is het mogelijk om arrays met een dimensie op lager niveau te extraheren met hun indices:

int[][][] arr = new int[3][3][3];
int[][] arr1 = arr[0]; // get first 3x3-dimensional array from arr
int[] arr2 = arr1[0]; // get first 3-dimensional array from arr1
int[] arr3 = arr[0]; // error: cannot convert from int[][] to int[]

ArrayIndexOutOfBoundsException

De ArrayIndexOutOfBoundsException wordt gegenereerd wanneer een niet-bestaande index van een array wordt gebruikt.

Arrays worden op nul gebaseerd geïndexeerd, dus de index van het eerste element is 0 en de index van het laatste element is de array.length - 1 minus 1 (dwz array.length - 1 ).

Daarom moet elk verzoek voor een array-element door de index i voldoen aan de voorwaarde 0 <= i < array.length , anders wordt de ArrayIndexOutOfBoundsException geworpen.

De volgende code is een eenvoudig voorbeeld waarbij een ArrayIndexOutOfBoundsException wordt gegenereerd.

String[] people = new String[] { "Carol", "Andy" };

// An array will be created:
// people[0]: "Carol"
// people[1]: "Andy"

// Notice: no item on index 2. Trying to access it triggers the exception:
System.out.println(people[2]);  // throws an ArrayIndexOutOfBoundsException.

Output:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2
    at your.package.path.method(YourClass.java:15)

Merk op dat de illegale index waartoe toegang wordt verkregen ook is opgenomen in de uitzondering ( 2 in het voorbeeld); deze informatie kan nuttig zijn om de oorzaak van de uitzondering te achterhalen.

Om dit te voorkomen, controleert u eenvoudig of de index zich binnen de grenzen van de array bevindt:

int index = 2;
if (index >= 0 && index < people.length) {
    System.out.println(people[index]);
} 

De lengte van een array krijgen

Arrays zijn objecten die ruimte bieden om maximaal elementen van het opgegeven type op te slaan. De grootte van een array kan niet worden gewijzigd nadat de array is gemaakt.

int[] arr1 = new int[0];
int[] arr2 = new int[2];
int[] arr3 = new int[]{1, 2, 3, 4};
int[] arr4 = {1, 2, 3, 4, 5, 6, 7};

int len1 = arr1.length; // 0
int len2 = arr2.length; // 2
int len3 = arr3.length; // 4
int len4 = arr4.length; // 7

Het length in een array slaat de grootte van een array op. Het is een final veld en kan niet worden gewijzigd.

Deze code toont het verschil tussen de length van een array en het aantal objecten dat een array opslaat.

public static void main(String[] args) {
    Integer arr[] = new Integer[] {1,2,3,null,5,null,7,null,null,null,11,null,13};

    int arrayLength = arr.length;
    int nonEmptyElementsCount = 0;

    for (int i=0; i<arrayLength; i++) {
        Integer arrElt = arr[i];
        if (arrElt != null) {
            nonEmptyElementsCount++;
        }
    }

    System.out.println("Array 'arr' has a length of "+arrayLength+"\n"
                            + "and it contains "+nonEmptyElementsCount+" non-empty values");
}

Resultaat:

Array 'arr' has a length of 13
and it contains 7 non-empty values

Arrays vergelijken voor gelijkheid

Array-typen nemen hun implementaties equals() (en hashCode() ) over van java.lang.Object , dus equals() retourneert alleen true wanneer vergeleken wordt met exact hetzelfde arrayobject. Gebruik java.util.Arrays.equals om arrays voor gelijkheid te vergelijken op basis van hun waarden, die voor alle java.util.Arrays.equals overbelast is.

int[] a = new int[]{1, 2, 3};
int[] b = new int[]{1, 2, 3};
System.out.println(a.equals(b)); //prints "false" because a and b refer to different objects
System.out.println(Arrays.equals(a, b)); //prints "true" because the elements of a and b have the same values

Wanneer het elementtype een referentietype is, Arrays.equals() equals() op de arrayelementen om gelijkheid te bepalen. In het bijzonder, als het elementtype zelf een matrixtype is, zal identiteitsvergelijking worden gebruikt. Als u multidimensionale arrays wilt vergelijken voor gelijkheid, gebruikt u Arrays.deepEquals() plaats zoals hieronder:

int a[] = { 1, 2, 3 };
int b[] = { 1, 2, 3 };

Object[] aObject = { a }; // aObject contains one element
Object[] bObject = { b }; // bObject contains one element

System.out.println(Arrays.equals(aObject, bObject)); // false
System.out.println(Arrays.deepEquals(aObject, bObject));// true

Omdat sets en kaarten equals() en hashCode() , zijn arrays over het algemeen niet nuttig als hashCode() of hashCode() . Zowel om ze in een hulpklasse Werktuigen equals() en hashCode() wat betreft de arrayelementen of converteren naar List instances en opslaan van de lijsten.

Arrays om te streamen

String[] arr = new String[] {"str1", "str2", "str3"};
Stream<String> stream = Arrays.stream(arr);

int[] intArr = {1, 2, 3};
IntStream intStream = Arrays.stream(intArr);

int[] values = {1, 2, 3, 4};
IntStream intStream = Arrays.stream(values, 2, 4);

Stream<Integer> intStream = Stream.of(1, 2, 3);
Stream<String> stringStream = Stream.of("1", "2", "3");
Stream<Double> doubleStream = Stream.of(new Double[]{1.0, 2.0});

Herhalen over arrays

U kunt arrays herhalen met behulp van Enhanced for Loop (aka Foreach) of met array-indices:

int[] array = new int[10];

// using indices: read and write
for (int i = 0; i < array.length; i++) {
    array[i] = i;
}

// extended for: read only
for (int e : array) {
    System.out.println(e);
}

Het is vermeldenswaard dat er geen directe manier is om een Iterator op een array te gebruiken, maar via de Arrays-bibliotheek kan deze eenvoudig worden omgezet in een lijst om een Iterable object te verkrijgen.

Voor arrays in box gebruikt u Arrays.asList :

Integer[] boxed = {1, 2, 3};
Iterable<Integer> boxedIt = Arrays.asList(boxed); // list-backed iterable
Iterator<Integer> fromBoxed1 = boxedIt.iterator();

Gebruik voor primitieve arrays (met behulp van Java 8) streams (specifiek in dit voorbeeld - Arrays.stream -> IntStream ):

int[] primitives = {1, 2, 3};
IntStream primitiveStream = Arrays.stream(primitives); // list-backed iterable
PrimitiveIterator.OfInt fromPrimitive1 = primitiveStream.iterator();

Als je geen streams kunt gebruiken (geen Java 8), kun je ervoor kiezen om de guave- bibliotheek van Google te gebruiken:

Iterable<Integer> fromPrimitive2 = Ints.asList(primitives);

In tweedimensionale arrays of meer kunnen beide technieken op een iets complexere manier worden gebruikt.

Voorbeeld:

int[][] array = new int[10][10];

for (int indexOuter = 0; indexOuter < array.length; indexOuter++) {
    for (int indexInner = 0; indexInner < array[indexOuter].length; indexInner++) {
        array[indexOuter][indexInner] = indexOuter + indexInner;
    }
}

for (int[] numbers : array) {
    for (int value : numbers) {
        System.out.println(value);
    }
}

Het is onmogelijk om een array op een niet-uniforme waarde in te stellen zonder een op index gebaseerde lus te gebruiken.

Natuurlijk kun je ook while of do-while loops gebruiken bij het itereren met behulp van indices.

Een waarschuwing: als u array-indices gebruikt, moet u ervoor zorgen dat de index tussen 0 en array.length - 1 (beide inclusief). Maak geen hard gecodeerde veronderstellingen over de arraylengte, anders kunt u uw code breken als de arraylengte verandert, maar uw hard gecodeerde waarden niet.

Voorbeeld:

int[] numbers = {1, 2, 3, 4};

public void incrementNumbers() {
    // DO THIS :
    for (int i = 0; i < numbers.length; i++) {
        numbers[i] += 1; //or this: numbers[i] = numbers[i] + 1; or numbers[i]++;      
    }
 
    // DON'T DO THIS :
    for (int i = 0; i < 4; i++) {
        numbers[i] += 1;
    }
}

Het is ook het beste als u geen dure berekeningen gebruikt om de index te krijgen, maar de index gebruikt om te herhalen en als u andere waarden nodig hebt, berekent u die.

Voorbeeld:

public void fillArrayWithDoubleIndex(int[] array) {
    // DO THIS :
    for (int i = 0; i < array.length; i++) {
        array[i] = i * 2;
    }
 
    // DON'T DO THIS :
    int doubleLength = array.length * 2;
    for (int i = 0; i < doubleLength; i += 2) {
        array[i / 2] = i;
    }
}

Toegang tot arrays in omgekeerde volgorde

int[] array = {0, 1, 1, 2, 3, 5, 8, 13};
for (int i = array.length - 1; i >= 0; i--) {
   System.out.println(array[i]);
}

Tijdelijke matrices gebruiken om herhaling van codes te verminderen

Itereren over een tijdelijke array in plaats van code herhalen kan uw code schoner maken. Het kan worden gebruikt wanneer dezelfde bewerking wordt uitgevoerd op meerdere variabelen.

// we want to print out all of these
String name = "Margaret";
int eyeCount = 16;
double height = 50.2;
int legs = 9;
int arms = 5;


// copy-paste approach:
System.out.println(name);
System.out.println(eyeCount);
System.out.println(height);
System.out.println(legs);
System.out.println(arms);


// temporary array approach:
for(Object attribute : new Object[]{name, eyeCount, height, legs, arms})
    System.out.println(attribute);

// using only numbers
for(double number : new double[]{eyeCount, legs, arms, height})
    System.out.println(Math.sqrt(number));

Houd er rekening mee dat deze code niet moet worden gebruikt in prestatie-kritieke secties, omdat er elke keer dat de lus wordt ingevoerd een array wordt gemaakt en dat primitieve variabelen naar de array worden gekopieerd en dus niet kunnen worden gewijzigd.

Arrays kopiëren

Java biedt verschillende manieren om een array te kopiëren.

for loop

int[] a = { 4, 1, 3, 2 };
int[] b = new int[a.length]; 
for (int i = 0; i < a.length; i++) {
    b[i] = a[i];
}

Merk op dat het gebruik van deze optie met een Object-array in plaats van een primitieve array de kopie vult met verwijzing naar de originele inhoud in plaats van een kopie ervan.

Object.clone ()

Omdat arrays zijn Object s in Java, kunt u gebruik maken Object.clone() .

int[] a = { 4, 1, 3, 2 };
int[] b = a.clone(); // [4, 1, 3, 2]

Merk op dat de Object.clone methode voor een array een ondiepe kopie uitvoert, dwz dat deze een verwijzing naar een nieuwe array retourneert die naar dezelfde elementen verwijst als de bronarray.

Arrays.copyOf ()

java.util.Arrays biedt een eenvoudige manier om de kopie van een array naar een andere uit te voeren. Hier is het basisgebruik:

int[] a = {4, 1, 3, 2};
int[] b = Arrays.copyOf(a, a.length); // [4, 1, 3, 2]

Merk op dat Arrays.copyOf ook een overbelasting biedt waarmee u het type van de array kunt wijzigen:

Double[] doubles = { 1.0, 2.0, 3.0 };
Number[] numbers = Arrays.copyOf(doubles, doubles.length, Number[].class);

System.arraycopy ()

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) Kopieert een array van de opgegeven public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) , beginnend op de opgegeven positie, naar de opgegeven positie van de doelarray.

Hieronder een voorbeeld van gebruik

int[] a = { 4, 1, 3, 2 };
int[] b = new int[a.length];
System.arraycopy(a, 0, b, 0, a.length); // [4, 1, 3, 2]

Arrays.copyOfRange ()

Hoofdzakelijk gebruikt om een deel van een array te kopiëren, kunt u het ook gebruiken om een hele array naar een ander te kopiëren, zoals hieronder:

int[] a = { 4, 1, 3, 2 };
int[] b = Arrays.copyOfRange(a, 0, a.length); // [4, 1, 3, 2]

Arrays gieten

Arrays zijn objecten, maar hun type wordt bepaald door het type van de ingesloten objecten. Daarom kan men niet alleen A[] naar T[] casten, maar elk A-lid van de specifieke A[] moet naar een T object worden gegoten. Algemeen voorbeeld:

public static <T, A> T[] castArray(T[] target, A[] array) {
    for (int i = 0; i < array.length; i++) {
        target[i] = (T) array[i];
    }
    return target;
}

Dus, gegeven een A[] array:

T[] target = new T[array.Length];
target = castArray(target, array);

Java SE biedt hiervoor de methode Arrays.copyOf(original, newLength, newType) :

Double[] doubles = { 1.0, 2.0, 3.0 };
Number[] numbers = Arrays.copyOf(doubles, doubles.length, Number[].class);

Verwijder een element uit een array

Java biedt geen directe methode in java.util.Arrays om een element uit een array te verwijderen. Om het uit te voeren, kunt u de oorspronkelijke array naar een nieuwe kopiëren zonder het element dat moet worden verwijderd of uw array naar een andere structuur converteren die de verwijdering mogelijk maakt.

ArrayList gebruiken

U kunt de array naar een java.util.List converteren, het element verwijderen en de lijst als volgt weer in een array omzetten:

String[] array = new String[]{"foo", "bar", "baz"};

List<String> list = new ArrayList<>(Arrays.asList(array));
list.remove("foo");

// Creates a new array with the same size as the list and copies the list
// elements to it.
array = list.toArray(new String[list.size()]);

System.out.println(Arrays.toString(array)); //[bar, baz]

System.arraycopy gebruiken

System.arraycopy() kan worden gebruikt om een kopie van de oorspronkelijke array te maken en het gewenste element te verwijderen. Hieronder een voorbeeld:

int[] array = new int[] { 1, 2, 3, 4 }; // Original array.
int[] result = new int[array.length - 1]; // Array which will contain the result.
int index = 1; // Remove the value "2".

// Copy the elements at the left of the index.
System.arraycopy(array, 0, result, 0, index);
// Copy the elements at the right of the index.
System.arraycopy(array, index + 1, result, index, array.length - index - 1);

System.out.println(Arrays.toString(result)); //[1, 3, 4]

Met behulp van Apache Commons Lang

Om een element eenvoudig te verwijderen, kunt u de Apache Commons Lang- bibliotheek gebruiken en vooral de statische methode removeElement() van de klasse ArrayUtils . Hieronder een voorbeeld:

int[] array = new int[]{1,2,3,4};
array = ArrayUtils.removeElement(array, 2); //remove first occurrence of 2
System.out.println(Arrays.toString(array)); //[1, 3, 4]

Array Covariiance

Objectmatrices zijn covariant, wat betekent dat, net zoals Integer een subklasse van Number , Integer[] een subklasse van Number[] . Dit lijkt misschien intuïtief, maar kan leiden tot verrassend gedrag:

Integer[] integerArray = {1, 2, 3};
Number[] numberArray = integerArray;  // valid
Number firstElement = numberArray[0]; // valid
numberArray[0] = 4L;                  // throws ArrayStoreException at runtime

Hoewel Integer[] een subklasse van Number[] , kan het alleen Integer s bevatten en wordt geprobeerd een Long element toe te wijzen aan een Long element.

Merk op dat dit gedrag uniek is voor arrays en kan worden voorkomen door in plaats daarvan een generieke List gebruiken:

List<Integer> integerList = Arrays.asList(1, 2, 3);
//List<Number> numberList = integerList;  // compile error
List<? extends Number> numberList = integerList;
Number firstElement = numberList.get(0);
//numberList.set(0, 4L);                  // compile error

Het is niet nodig dat alle arrayelementen hetzelfde type delen, zolang ze maar een subklasse van het type van de array zijn:

interface I {}

class A implements I {}
class B implements I {}
class C implements I {}

I[] array10 = new I[] { new A(), new B(), new C() }; // Create an array with new
                                                     // operator and array initializer.

I[] array11 = { new A(), new B(), new C() };         // Shortcut syntax with array
                                                     // initializer.

I[] array12 = new I[3];                              // { null, null, null }

I[] array13 = new A[] { new A(), new A() };          // Works because A implements I.

Object[] array14 = new Object[] { "Hello, World!", 3.14159, 42 }; // Create an array with
                                                     // new operator and array initializer.

Object[] array15 = { new A(), 64, "My String" };     // Shortcut syntax 
                                                     // with array initializer.

Hoe verander je de grootte van een array?

Het eenvoudige antwoord is dat u dit niet kunt doen. Nadat een array is gemaakt, kan de grootte ervan niet meer worden gewijzigd. In plaats daarvan kan een array alleen worden "aangepast" door een nieuwe array met de juiste grootte te maken en de elementen van de bestaande array naar de nieuwe te kopiëren.

String[] listOfCities = new String[3];   // array created with size 3.
listOfCities[0] = "New York";
listOfCities[1] = "London";
listOfCities[2] = "Berlin";

Stel (bijvoorbeeld) dat een nieuw element moet worden toegevoegd aan de array listOfCities zoals hierboven gedefinieerd. Om dit te doen, moet u:

1. maak een nieuwe array met maat 4,
2. kopieer de bestaande 3 elementen van de oude array naar de nieuwe array op offsets 0, 1 en 2, en
3. voeg het nieuwe element toe aan de nieuwe array bij offset 3.

Er zijn verschillende manieren om het bovenstaande te doen. Vóór Java 6 was de meest beknopte manier:

String[] newArray = new String[listOfCities.length + 1];
System.arraycopy(listOfCities, 0, newArray, 0, listOfCities.length);
newArray[listOfCities.length] = "Sydney";

Vanaf Java 6 kunnen de methoden Arrays.copyOf en Arrays.copyOfRange dit eenvoudiger doen:

String[] newArray = Arrays.copyOf(listOfCities, listOfCities.length + 1);
newArray[listOfCities.length] = "Sydney";

Raadpleeg het volgende voorbeeld voor andere manieren om een array te kopiëren. Houd er rekening mee dat u bij het wijzigen van het formaat een array-kopie nodig hebt met een andere lengte dan het origineel.

• Arrays kopiëren

Een beter alternatief voor het wijzigen van de reeks

Er zijn twee grote nadelen met het wijzigen van het formaat van een array zoals hierboven beschreven:

• Het is inefficiënt. Als u een array groter (of kleiner) wilt maken, kopieert u veel of alle bestaande arrayelementen en wijst u een nieuw arrayobject toe. Hoe groter de reeks, hoe duurder het wordt.
• U moet alle "live" variabelen kunnen bijwerken die verwijzingen naar de oude array bevatten.

Een alternatief is om de array te maken met een grootte die groot genoeg is om mee te beginnen. Dit is alleen mogelijk als u die grootte nauwkeurig kunt bepalen voordat u de array toewijst . Als u dat niet kunt doen, rijst het probleem van het wijzigen van het formaat van de array opnieuw.

Het andere alternatief is om een datastructuurklasse te gebruiken die wordt aangeboden door de Java SE-klassenbibliotheek of een bibliotheek van derden. Het "collecties" -raamwerk van Java SE biedt bijvoorbeeld een aantal implementaties van de List , Set en Map API's met verschillende runtime-eigenschappen. De klasse ArrayList komt het dichtst in de buurt van de prestatiekenmerken van een gewone array (bijv. O (N) opzoeken, O (1) ophalen en instellen, O (N) willekeurig invoegen en verwijderen) en biedt tegelijkertijd een efficiënter formaat zonder het referentie-update probleem.

(De efficiëntie voor het wijzigen van de grootte van ArrayList komt voort uit de strategie van het verdubbelen van de grootte van de reeks back-ups bij elke grootte wijzigen. Voor een typisch gebruik betekent dit dat u slechts af en toe het formaat wijzigt. Wanneer u gedurende de levensduur van de lijst afschrijft, worden de kosten per insert is O(1) . Het kan mogelijk zijn om dezelfde strategie te gebruiken bij het wijzigen van het formaat van een gewone array.)

Een element zoeken in een array

Er zijn veel manieren om de locatie van een waarde in een array te vinden. In de volgende voorbeeldfragmenten wordt ervan uitgegaan dat de array een van de volgende is:

  String[] strings = new String[] { "A", "B", "C" };
  int[] ints = new int[] { 1, 2, 3, 4 };

Bovendien stelt elke index of index2 op ofwel de index van het vereiste element, of -1 als het element niet aanwezig is.

Arrays.binarySearch (alleen voor gesorteerde arrays)

  int index = Arrays.binarySearch(strings, "A");
  int index2 = Arrays.binarySearch(ints, 1);

Een Arrays.asList (alleen voor niet-primitieve arrays)

  int index = Arrays.asList(strings).indexOf("A");
  int index2 = Arrays.asList(ints).indexOf(1);  // compilation error

Een Stream

  int index = IntStream.range(0, strings.length)
                       .filter(i -> "A".equals(strings[i]))
                       .findFirst()
                       .orElse(-1); // If not present, gives us -1.
  // Similar for an array of primitives

Lineair zoeken met behulp van een lus

  int index = -1;
  for (int i = 0; i < array.length; i++) {
      if ("A".equals(array[i])) {
          index = i;
          break;
      }            
  }
  // Similar for an array of primitives

Lineair zoeken met bibliotheken van derden, zoals org.apache.commons

  int index = org.apache.commons.lang3.ArrayUtils.contains(strings, "A");
  int index2 = org.apache.commons.lang3.ArrayUtils.contains(ints, 1);

Opmerking: Direct lineair zoeken gebruiken is efficiënter dan in een lijst opnemen.

Testen of een array een element bevat

De bovenstaande voorbeelden kunnen worden aangepast om te testen of de array een element bevat door eenvoudig te testen of de berekende index groter of gelijk is aan nul.

Als alternatief zijn er ook enkele meer beknopte variaties:

boolean isPresent = Arrays.asList(strings).contains("A");

boolean isPresent = Stream<String>.of(strings).anyMatch(x -> "A".equals(x));

boolean isPresent = false;
for (String s : strings) {
    if ("A".equals(s)) {
        isPresent = true;
        break;
    }
}

boolean isPresent = org.apache.commons.lang3.ArrayUtils.contains(ints, 4);

Sorteermatrices

Sorteerarrays kunnen eenvoudig worden gedaan met de Arrays api.

import java.util.Arrays;

// creating an array with integers
int[] array = {7, 4, 2, 1, 19};
// this is the sorting part just one function ready to be used
Arrays.sort(array);
// prints [1, 2, 4, 7, 19]
System.out.println(Arrays.toString(array));

Sorteer reeksen arrays:

String is geen numerieke gegevens, het definieert zijn eigen volgorde die lexicografische volgorde wordt genoemd, ook wel alfabetische volgorde genoemd. Wanneer u een array van String sort() methode sort() , sorteert deze de array in de natuurlijke volgorde die wordt gedefinieerd door de vergelijkbare interface, zoals hieronder wordt weergegeven:

Toenemende bestelling

String[] names = {"John", "Steve", "Shane", "Adam", "Ben"};
System.out.println("String array before sorting : " + Arrays.toString(names));
Arrays.sort(names); 
System.out.println("String array after sorting in ascending order : " + Arrays.toString(names));

Output:

String array before sorting : [John, Steve, Shane, Adam, Ben]    
String array after sorting in ascending order : [Adam, Ben, John, Shane, Steve]

Afnemende bestelling

Arrays.sort(names, 0, names.length, Collections.reverseOrder());
System.out.println("String array after sorting in descending order : " + Arrays.toString(names));

Output:

String array after sorting in descending order : [Steve, Shane, John, Ben, Adam]

Een objectmatrix sorteren

Om een objectarray te sorteren, moeten alle elementen de interface Comparable of Comparator implementeren om de sorteervolgorde te definiëren.

We kunnen beide sort(Object[]) gebruiken om een objectarray in zijn natuurlijke volgorde te sorteren, maar u moet ervoor zorgen dat alle elementen in de array Comparable moeten implementeren.

Bovendien moeten ze ook onderling vergelijkbaar zijn, bijvoorbeeld e1.compareTo(e2) mag geen ClassCastException voor elementen e1 en e2 in de array gooien. Als alternatief kunt u een objectmatrix op aangepaste volgorde sort(T[], Comparator) methode sort(T[], Comparator) , zoals in het volgende voorbeeld.

// How to Sort Object Array in Java using Comparator and Comparable
Course[] courses = new Course[4];
courses[0] = new Course(101, "Java", 200);
courses[1] = new Course(201, "Ruby", 300);
courses[2] = new Course(301, "Python", 400);
courses[3] = new Course(401, "Scala", 500);
       
System.out.println("Object array before sorting : " + Arrays.toString(courses));
       
Arrays.sort(courses);
System.out.println("Object array after sorting in natural order : " + Arrays.toString(courses));
       
Arrays.sort(courses, new Course.PriceComparator());
System.out.println("Object array after sorting by price : " + Arrays.toString(courses));
       
Arrays.sort(courses, new Course.NameComparator());
System.out.println("Object array after sorting by name : " + Arrays.toString(courses));

Output:

Object array before sorting : [#101 Java@200 , #201 Ruby@300 , #301 Python@400 , #401 Scala@500 ]    
Object array after sorting in natural order : [#101 Java@200 , #201 Ruby@300 , #301 Python@400 , #401 Scala@500 ]    
Object array after sorting by price : [#101 Java@200 , #201 Ruby@300 , #301 Python@400 , #401 Scala@500 ]    
Object array after sorting by name : [#101 Java@200 , #301 Python@400 , #201 Ruby@300 , #401 Scala@500 ]

Arrays omzetten tussen primitieven en boxtypen

Soms is conversie van primitieve typen naar boxtypen noodzakelijk.

Om de array te converteren, is het mogelijk streams te gebruiken (in Java 8 en hoger):

int[] primitiveArray = {1, 2, 3, 4};
Integer[] boxedArray = 
    Arrays.stream(primitiveArray).boxed().toArray(Integer[]::new);

In lagere versies kan dit gebeuren door de primitieve array te itereren en deze expliciet naar de boxed array te kopiëren:

int[] primitiveArray = {1, 2, 3, 4};
Integer[] boxedArray = new Integer[primitiveArray.length];
for (int i = 0; i < primitiveArray.length; ++i) {
    boxedArray[i] = primitiveArray[i]; // Each element is autoboxed here
}

Op dezelfde manier kan een boxed array worden geconverteerd naar een array van zijn primitieve tegenhanger:

Integer[] boxedArray = {1, 2, 3, 4};
int[] primitiveArray = 
    Arrays.stream(boxedArray).mapToInt(Integer::intValue).toArray();

Integer[] boxedArray = {1, 2, 3, 4};
int[] primitiveArray = new int[boxedArray.length];
for (int i = 0; i < boxedArray.length; ++i) {
    primitiveArray[i] = boxedArray[i]; // Each element is outboxed here
}