programmera.net -> java -> normal     för utskrift      info@programmera.net

Array

1. Array
2. Skapa en array
3. Räckvidd
4. Array och null
5. Att kopiera en array
6. Konvertera Arrayer
7. Arrays

1. Array

Med en array kan man på ett enkelt sätt lagra en grupp primitiver eller objekt. Arrayen påminner om gränssnittet List som beskrivs på sidan som handlar om  samlingar  men har inte lika många metoder. Det unika med array är att man kan lagra primitiva typer utan att först omvandla dem till objekt. Denna funktionalitet gör att klassen används ofta. En array är en subklass till Object.

2. Skapa en array

När man hanterar en array är det enda tillfälle man får använda hakparantesen i Java. Arrayen deklareras genom att du skriver en typ (klass eller primitiv) och hakparanteser. Här kommer några regler:

  • Arrayer kan innehålla arrayer, så för varje par av hakparanteser du skriver får arrayen en extra dimension.
  • I multidimensionella arrayer behöver inte arrayerna en nivå ner vara av samma storlek.
  • En array fylls med defaultvärden då den skapas. En int[] fylls med 0, en Object[] med null osv..
  • Paranteser kan sättas bakom typen eller bakom variabelnamnet.
Enligt den sista regeln är följande två satser identiska:
byte[] a, b, c[];
byte a[],b[],c[][];
Nu kommer ett exempel där vi testar att skapa några arrayer:
class TestArrayCreate{
  public static void main (String[] arg){

    long[] la={2,4,7};
    for(int i=0; i<la.length; i++){
      System.out.print(la[i]+" ");
    }
    System.out.println();
    
    int[] ia=new int[3];
    ia[0]=1;
    ia[2]=3;
    for(int i=0; i<ia.length; i++){
      System.out.print(ia[i]+" ");
    }
    System.out.println();
    
    String[][] sa={{"Hej", "Alla", "Glada"},{"Men","Vad"},{"?"}};
    for(int i=0; i<sa.length; i++){
      for(int j=0; j<sa[i].length; j++){
        System.out.print(sa[i][j]+" ");
      }
    }
  }
}
Vi kör programmet:
[olle@dev1]$ java TestArrayCreate
2 4 7
1 0 3
Hej Alla Glada Men Vad ?
Här har ia[1] satts till 0.

3. Räckvidd

Nedan följer några fakta om arrayens räckvidd:

  • Efter att en array har skapats kan den inte ändra storlek.
  • Man kan få reda på arrayens räckvidd genom length som är klassens enda egna medlem, förutom de som den ärver av Object.
  • När man vill hämta t.ex. det fjärde elementet i en array a skiver man a[3].
  • Om man försöker använda ett index utanför arrayens räckvidd kastas ArrayIndexOutOfBoundException som är runtime, JVM gör en kontroll varje gång man använder ett index, vilket kan undvikas med System.arraycopy(), se nedan.
  • Försöker man komma åt ett element men använder ett index av typen long kompilerar inte programmet.

4. Array och null

En array kan mycket väl vara och innehålla null. Nedan ges ett exempel:
class TestArrayNull{
  public static void main (String[] args){
    int[][] a={{1,2},null};
    for(int i=0; i<a.length; i++){
      for(int j=0; j<a[0].length; j++){
        System.out.println(a[i][j]);
      }
    }
  }
}
Programmet kör tills NullPointerException kastas:
[olle@dev1]$ java TestArrayNull
1
2
Exception in thread "main" java.lang.NullPointerException
       at TestArrayNull.main(TestArrayNull.java:6)

5. Att kopiera en array

Det finns tre sätt att kopiera en array till en annan:

  • Med en loop.
  • Med System.arraycopy().
  • Med clone(), eftersom array implementerar Cloneable.
Eftersom JVM gör en indexkontroll varje gång man använder en array så blir prestandan dålig då man använder den första metoden:
class TestArrayCopy{
  public static void main (String[] arg){
    int[] a=new int[1000];
    int[] b=new int[1000];
    for(int i=0; i<a.length; i++){
      a[i]=i;
    }
    // Copy a to b
    for(int i=0; i<a.length; i++){
      b[i]=a[i];
    }
    System.out.println("4="+b[4]);
  }
}
Här kommer JVM att göra 1000 indexkontroller då en hade räckt. Ett snabbare sätt att kopiera är att använda System.arraycopy():
class TestArrayCopy2{
  public static void main (String[] arg){
    int[] a=new int[1000];
    int[] b=new int[1000];
    for(int i=0; i<a.length; i++){
      a[i]=i;
    }
    // Copy a to b
    System.arraycopy(a,0,b,0,a.length);
    System.out.println("4="+b[4]);
  }
}
Detta funkar lika bra:
[olle@dev1]$ java TestArrayCopy2
4=4
Den tredje metoden är att använda arrayens clone() som skapar en kopia av arrayen. Denna metod är en överriden Object-metod:
class TestArrayClone{
  public static void main (String[] arg){
    int[] a=new int[1000];
    int[] b;
    for(int i=0; i<a.length; i++){
      a[i]=i;
    }
    // Copy a to b
    b=(int[]) a.clone();
    System.out.println("4="+b[4]);
  }
}
Denna metod fukar också:
[olle@dev1]$ java TestArrayClone
4=4

6. Konvertera Arrayer

En referens av typen A[] kan referera till B[] om B är en sublklass till A:
class A{ String sayA="Im super";}
class B extends A{ String sayB="Im extended";}
class TestArrayConv{
  public static void main (String[] arg){
    B[] b      =new B[3];
    b[0]       =new B();
    b[1]       =new B();
    A[] a      =b;
    System.out.println("sayA="+a[0].sayA);
    Object[] o =a;
    B[] b2     =(B[]) o;
    System.out.println("sayB="+b2[0].sayB);
  }
}
Vi får:
[olle@dev1]$ java TestArrayConv
sayA=Im super
sayB=Im extended
Det enda en array innehållande primitiver kan konverteras till är Object, eftersom array ärver av Object.

7. Arrays

Klassen java.util.Arrays innehåller en del praktiska metoder då man vill sortera eller söka i en array. Arrays har bara statiska metoder och ingen konstruktor. Nedan listas några metoder:

Metod Returtyp Statisk Beskrivning
sort(a)  void  Ja  Sorterar arrayen a. Om a innehåller objekt så måste alla elementen implementerar Comparable.
sort(Obj[], Comparator)  void  Ja  Sorterar arrayen Obj[] med hjälp av Comparator.
equals(a,b)  boolean  Ja  Returnerar true om alla elementen i a och b är lika.
fill(a,value)  void  Ja  Fyller arrayen a med value.
binarySearch(a,value)  int  Ja  Returnerar positionen av value i a.
asList(Obj[])  List  Ja  Returnerar en List innehållande samma objekt som Obj[].

Vi gör ett testprogram:
import java.util.*;

class TestArrays{
  public static void main (String[] arg){
    int[] a={7,12,3,6};
    Arrays.sort(a);
    for(int i=0; i<a.length; i++){
      System.out.println(a[i]);
    }
  }
}
Vid en körning får vi:
[olle@dev1]$ java TestArrays
3
6
7
12