Java Language
arrayer

Introduktion

Syntax

• ArrayType[] myArray; // Förklarande matriser
• ArrayType myArray[]; // En annan giltig syntax (mindre vanligt förekommande och avskräckta)
• ArrayType[][][] myArray; // Deklarera flerdimensionella taggade matriser (upprepa [])
• ArrayType myVar = myArray[index]; // Åtkomst till (avläsning) element vid index
• myArray[index] = value; // Tilldela värde till positionens index för array
• ArrayType[] myArray = new ArrayType[arrayLength]; // Syntax för arrayinitialisering
• int[] ints = {1, 2, 3}; // Arrayinitialiseringssyntax med tillhandahållna värden, längden utgår från antalet angivna värden: {[värde1 [, värde2] *]}
• 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}; // Multidimensionell matrisinitialisering. int [] utökar Object (och det gör anyType []) så null är ett giltigt värde.

parametrar

Skapa och initiera matriser

Grundläggande fall

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

Matriser kan skapas med användning av valfri primitiv eller referens typ.

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).

För det sista exemplet, notera att undertyper av den deklarerade arraytypen är tillåtna i arrayen.

Matriser för användardefinierade typer kan också byggas på samma sätt som primitiva typer

UserDefinedClass[] udType = new UserDefinedClass[5];

Matriser, samlingar och strömmar

// 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

En matris är en datastruktur som innehåller ett fast antal primitiva värden eller referenser till objektinstanser.

Varje objekt i en matris kallas ett element, och varje element nås genom dess numeriska index. Längden på en matris fastställs när matrisen skapas:

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

Storleken på en matris fastställs vid körning när den initialiseras. Det kan inte ändras efter initialisering. Om storleken måste vara muterbar vid körning, bör en Collection som ArrayList användas istället. ArrayList lagrar element i en matris och stöder storleksändring genom att tilldela en ny matris och kopiera element från den gamla matrisen.

Om matrisen är av en primitiv typ, dvs.

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

värdena lagras i själva matrisen. I avsaknad av en initialisering (som i array2 ovan) är standardvärdet tilldelat varje element 0 (noll).

Om arraytypen är en objektreferens, som i

SomeClassOrInterface[] array = new SomeClassOrInterface[10];

sedan innehåller matrisen referenser till objekt av typen SomeClassOrInterface . Dessa referenser kan hänvisa till en instans av SomeClassOrInterface eller någon underklass (för klasser) eller implementeringsklass (för gränssnitt) av SomeClassOrInterface . Om matrisdeklarationen inte har någon initialisering tilldelas standardvärdet för null till varje element.

Eftersom alla arrayer är int indexerade måste storleken på en matris anges av en int . Storleken på matrisen kan inte anges som en long :

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

Arrays använder ett nollbaserat indexsystem, vilket innebär att indexering börjar vid 0 och slutar på length - 1 .

Till exempel representerar följande bild en matris med storlek 10 . Här är det första elementet vid index 0 och det sista elementet är på index 9 , istället för att det första elementet är vid index 1 och det sista elementet vid index 10 (se figur nedan).

Tillgång till element i matriser görs i konstant tid . Det betyder att åtkomst till det första elementet i matrisen har samma kostnad (i tid) för åtkomst till det andra elementet, det tredje elementet och så vidare.

Java erbjuder flera sätt att definiera och initiera matriser, inklusive bokstäver och konstruktörsnotationer . Vid deklarering av matriser med den new Type[length] -konstruktorn initialiseras varje element med följande standardvärden:

• 0 för primitiva numeriska typer : byte , short , int , long , float och double .
• '\u0000' (nolltecken) för char .
• false för den boolean typen.
• null för referenstyper .

Skapa och initiera matriser av primitiv typ

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.

När du anmäler en matris kommer [] att visas som en del av typen i början av deklarationen (efter typnamnet), eller som en del av deklaratören för en viss variabel (efter variabelnamn), eller båda:

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() { ... }

I följande exempel är båda deklarationerna korrekta och kan sammanställas och köras utan problem. Men både Java-kodningskonventionen och Google Java Style Guide avskräcker formen med parentes efter variabelnamnet - parenteserna identifierar matrisstypen och ska visas med typbeteckningen . Detsamma bör användas för signaturer med metodretur.

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

Den avskräckta typen är avsedd att rymma övergångs-C-användare , som är bekanta med syntaxen för C som har parenteserna efter variabelns namn.

I Java är det möjligt att ha matriser i storlek 0 :

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

Men eftersom det är en tom matris kan inga element läsas från det eller tilldelas det:

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

Sådana tomma matriser är vanligtvis användbara som returvärden, så att anropskoden bara behöver oroa sig för att hantera en matris, snarare än ett potentiellt null som kan leda till en NullPointerException .

Längden på en matris måste vara ett icke-negativt heltal:

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

Matrisstorleken kan bestämmas med hjälp av ett offentligt slutfält som kallas length :

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

Obs : array.length returnerar den verkliga storleken på arrayen och inte antalet arrayelement som tilldelades ett värde, till skillnad från ArrayList.size() som returnerar antalet arrayelement som tilldelades ett värde.

Skapa och initiera multidimensionella matriser

Det enklaste sättet att skapa en multidimensionell matris är enligt följande:

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

Det kommer att skapa två tre-längd int arrays - a[0] och a[1] . Detta liknar den klassiska C-stilinitialiseringen av rektangulära flerdimensionella matriser.

Du kan skapa och initialisera samtidigt:

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

Till skillnad från C , där endast rektangulära flerdimensionella matriser stöds, behöver inre matriser inte vara av samma längd, eller ens definierade:

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

Här är a[0] en en-längd int array, medan a[1] är en två-längd int array och a[2] är null . Uppsättningar som detta kallas taggade matriser eller trasiga matriser , det vill säga de är matriser av matriser. Flerdimensionella matriser i Java implementeras som matriser av matriser, dvs array[i][j][k] motsvarar ((array[i])[j])[k] . Till skillnad från C # stöds inte array[i,j] i Java.

Flerdimensionell matrisrepresentation i Java

Källa - Live på Ideone

Skapa och initiera referenstypmatriser

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 på Ideone

Förutom String bokstäverna och primitiven som visas ovan fungerar genvägssyntaxen för arrayinitialisering också med kanoniska Object :

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

Eftersom matriser är kovarianta kan en matris av referenstyp initialiseras som en matris av en underklass, även om en ArrayStoreException kastas om du försöker ställa in ett element till något annat än en String :

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

Genvägssyntaxen kan inte användas för detta eftersom genvägssyntaxen skulle ha en implicit typ av Object[] .

En matris kan initieras med nollelement genom att använda String[] emptyArray = new String[0] . Till exempel används en matris med noll längd som denna för att skapa en Array från en Collection när metoden behöver runtime-typen för ett objekt.

I både primitiva och referenstyper kommer en tom matrisinitialisering (till exempel String[] array8 = new String[3] ) att initialisera matrisen med standardvärdet för varje datatyp .

Skapa och initiera arrayer av generisk typ

I generiska klasser kan matriser av generiska typer inte initialiseras på detta sätt på grund av radering av typ :

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

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

Istället kan de skapas med hjälp av en av följande metoder: (Observera att dessa kommer att generera okontrollerade varningar)

1. Genom att skapa ett Object array och kasta det till den generiska typen:

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

   Detta är den enklaste metoden, men eftersom den underliggande matrisen fortfarande är av typen Object[] denna metod inte typsäkerhet. Därför används denna metod för att skapa en matris bäst endast inom den generiska klassen - inte exponerad offentligt.

2. Genom att använda Array.newInstance med en klassparameter:

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

   Här måste klassen för T uttryckligen överföras till konstruktören. Array.newInstance är alltid Object . Men den här metoden är säkrare eftersom den nyskapade matrisen alltid är av typ T[] och därför kan externiseras på ett säkert sätt.

Fylla på en matris efter initieringen

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 }.

Separat deklaration och initialisering av matriser

Värdet på ett index för ett arrayelement måste vara ett heltal (0, 1, 2, 3, 4, ...) och mindre än längden på arrayen (indexen är nollbaserad). Annars kastas en ArrayIndexOutOfBoundsException :

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 }

Matriser kanske inte initialiseras igen med artainitieringsgenvägssyntax

Det är inte möjligt att återinitiera en matris via en genvägssyntax med en arrayinitierare eftersom en arrayinitierare endast kan specificeras i en fältdeklaration eller lokal variabeldeklaration, eller som en del av ett arrayskapningsuttryck.

Det är dock möjligt att skapa en ny matris och tilldela den till den variabel som används för att referera till den gamla matrisen. Även om detta resulterar i att matrisen som refereras av att variabeln initialiseras, är variabelinnehållet en helt ny matris. För att göra detta kan den new operatören användas med en arrayinitierare och tilldelas arrayvariabeln:

// 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 på Ideone

Skapa en matris från en samling

Två metoder i java.util.Collection skapar en matris från en samling:

• Object[] toArray()

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

Object[] toArray() kan användas enligt följande:

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 användas på följande sätt:

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()]);

Skillnaden mellan dem är mer än bara att ha otypade eller typade resultat. Deras prestanda kan också variera (för mer information, se avsnittet om prestationsanalys ):

• Object[] toArray() använder vektoriserad arraycopy , vilket är mycket snabbare än den arraycopy används i T[] toArray(T[] a) .
• T[] toArray(new T[non-zero-size]) behöver noll ut matrisen vid körning, medan T[] toArray(new T[0]) inte gör det. Ett sådant undvikande gör att den senare ringer snabbare än den förra. Detaljerad analys här: Arrays of Wisdom of the Ancient .

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

Exempel tagna från två svar ( 1 , 2 ) till Konvertera 'ArrayList till' String [] 'i Java på 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]

Skapa en lista från en matris

Arrays.asList() kan användas för att returnera en List med fast storlek som innehåller elementen i den angivna arrayen. Den resulterande List kommer att vara av samma parametertyp som matrisens bastyp.

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

Obs! Den här listan stöds av ( en vy av) den ursprungliga matrisen, vilket innebär att alla ändringar i listan kommer att ändra arrayen och vice versa. Ändringar av listan som skulle ändra dess storlek (och därmed arrayens längd) kommer dock att kasta ett undantag.

För att skapa en kopia av listan använder du konstruktören av java.util.ArrayList tar en Collection som ett 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());

Viktiga anmärkningar relaterade till Arrays.asList-metoden

• Denna metod returnerar List , som är ett exempel på Arrays$ArrayList (statisk inre klass för Arrays ) och inte java.util.ArrayList . Den resulterande List är av fast storlek. Det betyder att tillägg eller borttagning av element inte stöds och kommer att kasta en UnsupportedOperationException :

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

• En ny List kan skapas genom att skicka en array-backad List till konstruktören av en ny List . Detta skapar en ny kopia av uppgifterna, som har ändrad storlek och som inte stöds av den ursprungliga matrisen:

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

• Att ringa <T> List<T> asList(T... a) på en primitiv matris, till exempel en int[] , kommer att producera en List<int[]> vars enda element är den primära källan i stället för de faktiska elementen av källarrayen.

  Anledningen till detta beteende är att primitiva typer inte kan användas i stället för parametrar för generisk typ, så att hela den primitiva matrisen ersätter den generiska parametern i detta fall. För att konvertera en primitiv matris till en List , konvertera först den primitiva matrisen till en matris av motsvarande omslagstyp (dvs. ring Arrays.asList på ett Integer[] istället för ett int[] ).

  Därför kommer detta att skriva ut false :

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

  Visa demo

  Å andra sidan kommer detta att skriva ut true :

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

  Visa demo

  Detta kommer också att skriva ut true , eftersom matrisen kommer att tolkas som ett Integer[] ):

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

  Visa demo

Multidimensionella och Jagged Arrays

Det är möjligt att definiera en matris med mer än en dimension. I stället för att få åtkomst genom att tillhandahålla ett enda index, åtgår en flerdimensionell matris genom att ange ett index för varje dimension.

Förklaringen av flerdimensionell matris kan göras genom att lägga till [] för varje dimension till en regelbunden matrisdekleration. Till exempel, för att skapa en tvådimensionell int matris, lägg till en annan uppsättning parenteser till deklarationen, t.ex. int[][] . Detta fortsätter för tredimensionella matriser ( int[][][] ) och så vidare.

Så här definierar du en tvådimensionell matris med tre rader och tre kolumner:

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

Arrayen kan indexeras och tilldela värden till den med denna konstruktion. Observera att de icke tilldelade värdena är standardvärdena för typen av en matris, i detta fall 0 för int .

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

Det är också möjligt att instansera en dimension åt gången och till och med göra icke-rektangulära matriser. Dessa kallas ofta skuggade matriser .

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

Det är viktigt att notera att även om det är möjligt att definiera någon dimension av det taggade arrayet måste dess föregående nivå definieras.

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

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

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

Hur flerdimensionella arrayer representeras i Java

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

Jagged array bokstavlig intialisering

Multidimensionella matriser och taggade matriser kan också initialiseras med ett bokstavligt uttryck. Följande deklarerar och fyller ett 2x3 int array:

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

Obs : Jaggade delområden kan också vara null . Exempelvis deklarerar och fyller följande kod en tvådimensionell int matris vars första delgrupp är null , den andra delgruppen är av noll längd, den tredje delgruppen är av en längd och den sista delgruppen är en tvålängdsgrupp:

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

För flerdimensionell matris är det möjligt att extrahera matriser med lägre nivå genom deras index:

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

ArrayIndexOutOfBoundsException kastas när ett icke-existerande index för en matris öppnas.

Matriser är nollbaserade indexerade, så indexet för det första elementet är 0 och indexet för det sista elementet är matriskapaciteten minus 1 (dvs. array.length - 1 ).

Därför måste varje begäran om ett arrayelement av indexet i uppfylla villkoret 0 <= i < array.length , annars ArrayIndexOutOfBoundsException .

Följande kod är ett enkelt exempel där en ArrayIndexOutOfBoundsException kastas.

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.

Produktion:

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

Observera att det illegala indexet som öppnas också ingår i undantaget ( 2 i exemplet); denna information kan vara användbar för att hitta orsaken till undantaget.

För att undvika detta, kontrollera helt enkelt att indexet ligger inom gränserna för matrisen:

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

Få längden på en matris

Matriser är objekt som ger utrymme att lagra upp till dess storlek på element av specificerad typ. En matris storlek kan inte ändras efter att matrisen har skapats.

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

Den length fältet i en array lagrar storleken på en array. Det är ett final fält och kan inte ändras.

Den här koden visar skillnaden mellan length på en matris och mängden objekt en array lagrar.

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

Resultat:

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

Jämföra matriser för jämlikhet

Arraytyper ärver sina equals() (och hashCode() ) -implementeringar från java.lang.Object , så equals() kommer bara att återkomma sann när man jämför med exakt samma arrayobjekt. För att jämföra matriser för jämlikhet baserat på deras värden, använd java.util.Arrays.equals , som är överbelastad för alla arraytyper.

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

När elementtypen är en referenstyp, Arrays.equals() equals() på arrayelementen för att bestämma jämlikhet. I synnerhet, om elementtypen i sig är en array-typ, kommer identitetsjämförelse att användas. För att jämföra multidimensionella matriser för jämlikhet, använd Arrays.deepEquals() istället enligt nedan:

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

Eftersom uppsättningar och kartor använder equals() och hashCode() är matriser i allmänhet inte användbara som uppsättningselement eller kartnycklar. Antingen slå in dem i en hjälpare klass som implementerar equals() och hashCode() i termer av gruppelementen, eller konvertera dem till List instanser och lagra listorna.

Matriser för att strömma

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

Iterating över matriser

Du kan iterera över matriser antingen genom att använda förbättrad för loop (aka foreach) eller med hjälp av arrayindex:

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

Det är värt att notera här att det inte finns något direkt sätt att använda en Iterator på en Array, men genom Arrays-biblioteket kan det enkelt konverteras till en lista för att få ett Iterable objekt.

För matriser i rutor använder du Arrays.asList :

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

För primitiva matriser (med java 8) använd strömmar (specifikt i det här exemplet - Arrays.stream -> IntStream ):

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

Om du inte kan använda strömmar (ingen java 8) kan du välja att använda Googles guava- bibliotek:

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

I tvådimensionella matriser eller mer kan båda teknikerna användas på ett lite mer komplext sätt.

Exempel:

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

Det är omöjligt att ställa in en matris till något icke-enhetligt värde utan att använda en indexbaserad slinga.

Naturligtvis kan du också använda loopar while do-while itererar med index.

En varning: när du använder matrisindex, se till att indexet är mellan 0 och array.length - 1 (båda inkluderar). Gör inte hårdkodade antaganden om arrayens längd, annars kan du bryta din kod om arrayens längd ändras men dina hårdkodade värden inte gör det.

Exempel:

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

Det är också bäst om du inte använder snygga beräkningar för att få indexet men använder indexet för att iterera och om du behöver olika värden beräkna dessa.

Exempel:

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

Åtkomst till Arrays i omvänd ordning

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

Använda tillfälliga arrayer för att minska kodrepetitionen

Itertering över en tillfällig matris istället för att upprepa kod kan göra din kod renare. Det kan användas där samma operation utförs på flera variabler.

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

Kom ihåg att den här koden inte ska användas i prestandakritiska avsnitt, eftersom en matris skapas varje gång slingan matas in och att primitiva variabler kopieras till arrayen och därför inte kan modifieras.

Kopiera matriser

Java ger flera sätt att kopiera en matris.

för slinga

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

Observera att om du använder det här alternativet med en Objektmatris istället för en primitiv matris kommer du att fylla kopian med referens till det ursprungliga innehållet istället för en kopia av det.

Object.clone ()

Eftersom matriser är Object i Java kan du använda Object.clone() .

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

Observera att metoden Object.clone för en matris utför en grund kopia , dvs att den returnerar en referens till en ny matris som refererar till samma element som källarrayen.

Arrays.copyOf ()

java.util.Arrays är ett enkelt sätt att utföra en kopia av en matris till en annan. Här är den grundläggande användningen:

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

Observera att Arrays.copyOf också ger en överbelastning som gör att du kan ändra arraytypen:

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) Kopierar en matris från den angivna källarrayen, som börjar vid den angivna positionen, till den angivna positionen för destinationsgruppen.

Nedanför ett exempel på användning

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 ()

Vanligtvis används för att kopiera en del av en matris, du kan också använda den för att kopiera hela matrisen till en annan enligt nedan:

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

Gjutning Arrays

Matriser är objekt, men deras typ definieras av typen av de innehållade objekten. Därför kan man inte bara kasta A[] till T[] , utan varje A-medlem i det specifika A[] måste kastas till ett T objekt. Generiskt exempel:

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

Således, med tanke på en A[] -uppsättning:

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

Java SE tillhandahåller metoden Arrays.copyOf(original, newLength, newType) för detta ändamål:

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

Ta bort ett element från en matris

Java tillhandahåller inte en direkt metod i java.util.Arrays att ta bort ett element från en matris. För att utföra det kan du antingen kopiera den ursprungliga arrayen till en ny utan elementet för att ta bort eller konvertera din array till en annan struktur som tillåter borttagning.

Använda ArrayList

Du kan konvertera arrayen till en java.util.List , ta bort elementet och konvertera listan tillbaka till en array enligt följande:

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]

Använda System.arraycopy

System.arraycopy() kan användas för att göra en kopia av den ursprungliga matrisen och ta bort det element du vill ha. Nedanför ett exempel:

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]

Använda Apache Commons Lang

För att enkelt ta bort ett element kan du använda Apache Commons Lang- biblioteket och särskilt den statiska metoden removeElement() för klassen ArrayUtils . Nedanför ett exempel:

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 Covariance

Objektmatriser är kovarianta, vilket innebär att precis som Integer är en underklass av Number , är Integer[] en underklass av Number[] . Detta kan verka intuitivt, men kan resultera i överraskande beteende:

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

Även om Integer[] är en underklass av Number[] , kan den bara innehålla Integer och försöka tilldela ett Long element kastar ett undantag för körning.

Observera att detta beteende är unikt för matriser och kan undvikas genom att använda en generisk List istället:

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

Det är inte nödvändigt att alla arrayelement delar samma typ, så länge de är en underklass av arrayens typ:

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.

Hur ändrar du storleken på en matris?

Det enkla svaret är att du inte kan göra det. När en matris har skapats kan dess storlek inte ändras. Istället kan en matris bara "ändras" genom att skapa en ny matris med lämplig storlek och kopiera elementen från den befintliga matrisen till den nya.

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

Anta (till exempel) att ett nytt element måste läggas till i listOfCities array definierad som ovan. För att göra detta måste du:

1. skapa en ny matris med storlek 4,
2. kopiera de befintliga tre elementen i den gamla matrisen till den nya matrisen med förskjutningar 0, 1 och 2, och
3. lägg till det nya elementet i den nya matrisen vid offset 3.

Det finns olika sätt att göra ovanstående. Innan Java 6 var det mest kortfattade sättet:

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

Från Java 6 och framåt kan Arrays.copyOf och Arrays.copyOfRange göra detta enklare:

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

För andra sätt att kopiera en matris, se följande exempel. Kom ihåg att du behöver en matriskopia med en annan längd än originalet när du ändrar storleken.

• Kopiera matriser

Ett bättre alternativ till storleksändring

Det finns två stora nackdelar med att ändra storlek på en matris som beskrivits ovan:

• Det är ineffektivt. Att göra en matris större (eller mindre) innebär att kopiera många eller alla befintliga arrayelement och tilldela ett nytt arrayobjekt. Ju större matris, desto dyrare blir det.
• Du måste kunna uppdatera alla "live" -variabler som innehåller referenser till den gamla matrisen.

Ett alternativ är att skapa matrisen med en tillräckligt stor storlek till att börja med. Detta är bara genomförbart om du kan bestämma den storleken exakt innan du tilldelar matrisen . Om du inte kan göra det uppstår problemet med att ändra storlek på matrisen igen.

Det andra alternativet är att använda en datastrukturklass som tillhandahålls av Java SE-klassbiblioteket eller ett tredjepartsbibliotek. Exempelvis tillhandahåller Java SE "samlingar" ett antal implementationer av List , Set och Map API med olika runtime-egenskaper. ArrayList klassen är närmast prestandaegenskaperna för en vanlig matris (t.ex. O (N) -sökning, O (1) get and set, O (N) slumpmässig infogning och radering) samtidigt som det ger effektivare storlek utan referensuppdateringsproblem.

(Storleksändringseffektiviteten för ArrayList kommer från dess strategi att fördubbla storleken på stöduppsättningen på varje storlek. För ett typiskt användningsfall betyder det att du bara ändrar storleken ibland. per insert är O(1) . Det kan vara möjligt att använda samma strategi när du ändrar storleken på en vanlig matris.)

Hitta ett element i en matris

Det finns många sätt att hitta platsen för ett värde i en matris. Följande exempelavsnitt antar alla att matrisen är en av följande:

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

Dessutom sätter var och en index eller index2 till antingen indexet för det obligatoriska elementet, eller -1 om elementet inte finns.

Använda Arrays.binarySearch (endast för sorterade matriser)

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

Använda en Arrays.asList (endast för icke-primitiva matriser)

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

Använda en 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

Linjär sökning med en slinga

  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

Linjär sökning med hjälp av tredjepartsbibliotek som org.apache.commons

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

Obs: Att använda en direkt linjär sökning är effektivare än att lägga in en lista.

Testa om en matris innehåller ett element

Exemplen ovan kan anpassas för att testa om matrisen innehåller ett element genom att helt enkelt testa för att se om det beräknade indexet är större eller lika med noll.

Alternativt finns det också några mer kortfattade variationer:

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

Sortera matriser

Sortering av matriser kan enkelt göras med 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));

Sortera strängmatriser:

String är inte en numerisk data, den definierar sin egen ordning som kallas lexikografisk ordning, även känd som alfabetisk ordning. När du sorterar en matris med sträng med hjälp av sort() sorterar den array i naturlig ordning definierad av jämförbart gränssnitt, som visas nedan:

Ökande ordning

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

Produktion:

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

Minskar ordningen

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

Produktion:

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

Sortera ett objektuppsättning

För att sortera ett objektuppsättning måste alla element implementera antingen Comparable eller Comparator gränssnitt för att definiera sorteringens ordning.

Vi kan använda endera sort(Object[]) för att sortera ett objektuppsättning i dess naturliga ordning, men du måste se till att alla element i matrisen måste implementera Comparable .

Dessutom måste de vara ömsesidigt jämförbara, till exempel e1.compareTo(e2) får inte kasta en ClassCastException för några element e1 och e2 i matrisen. Alternativt kan du sortera en Objektgrupp i anpassad ordning med sort(T[], Comparator) som visas i följande exempel.

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

Produktion:

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 ]

Konvertera matriser mellan primitiva och boxade typer

Ibland är det nödvändigt att konvertera primitiva typer till boxade typer.

För att konvertera matrisen är det möjligt att använda strömmar (i Java 8 och högre):

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

Med lägre versioner kan det vara genom att iterera den primitiva matrisen och uttryckligen kopiera den till rutan:

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
}

På liknande sätt kan en boxad matris konverteras till en matris med dess primitiva motsvarighet:

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
}