Industriële fabricage
Industrieel internet der dingen | Industriële materialen | Onderhoud en reparatie van apparatuur | Industriële programmering |
home  MfgRobots >> Industriële fabricage >  >> Industrial programming >> Java

Java arrays beheersen: declaratie, initialisatie en manipulatie

Java-arrays

Deze uitgebreide gids leidt je door elk aspect van Java-arrays – van declaratie en initialisatie tot efficiënte traversal en real-world toepassingen. Perfect voor beginners en ervaren ontwikkelaars.

Een array is een aaneengesloten geheugenblok dat meerdere waarden van hetzelfde type opslaat.

Bijvoorbeeld, om de namen van 100 mensen bij te houden, maak je een string-array die 100 namen kan opslaan:

String[] array = new String[100];

Let op de vaste grootte: eenmaal toegewezen, kan de array nooit groter worden dan 100 elementen.


Een array declareren in Java

In Java volgt array-declaratie deze syntax:

dataType[] arrayName;
  • dataType – primitieve types zoals int, char, double, byte of referentietypes zoals String of custom objects.
  • arrayName – een geldige identifier.

Voorbeeld:

double[] data;

Hier is data een array die double-waarden kan bevatten.

Hoeveel elementen kan het bevatten?

Je bepaalt de capaciteit door geheugen toe te wijzen:

// declareer een array
double[] data;
// wijz geheugen toe
data = new double[10];

De grootte van de array – of length – is nu 10.

Vaak worden declaratie en toewijzing gecombineerd:

double[] data = new double[10];

Arrays initialiseren

Arrays kunnen bij declaratie geïnitialiseerd worden met een waardenlijst:

// declareer en initialiseer
int[] age = {12, 4, 5, 2, 5};

Omdat je waarden opgeeft, deduceert Java de grootte (5 in dit geval).

Alternatief kun je een lege array instantiëren en waarden per index instellen:

// declareer een array
int[] age = new int[5];
// wijs waarden toe
age[0] = 12;
age[1] = 4;
age[2] = 5;
...
Java arrays beheersen: declaratie, initialisatie en manipulatie

Belangrijke punten:

  • Indices beginnen bij 0.
  • Het laatste element zit op n-1 als de grootte n is.

Elementen benaderen

Haal een waarde op met zijn index:

array[index]

Voorbeeldprogramma:

class Main {
    public static void main(String[] args) {
        int[] age = {12, 4, 5, 2, 5};
        System.out.println("Elementen van Array benaderen:");
        System.out.println("Eerste element: " + age[0]);
        System.out.println("Tweede element: " + age[1]);
        System.out.println("Derde element: " + age[2]);
        System.out.println("Vierde element: " + age[3]);
        System.out.println("Vijfde element: " + age[4]);
    }
}

Output

Elementen van Array benaderen:
Eerste element: 12
Tweede element: 4
Derde element: 5
Vierde element: 2
Vijfde element: 5

Lussen maken bulk-verwerking mogelijk.


Itereren over arrays

Klassieke for-lus gebruiken

class Main {
    public static void main(String[] args) {
        int[] age = {12, 4, 5};
        System.out.println("Met for-lus:");
        for (int i = 0; i < age.length; i++) {
            System.out.println(age[i]);
        }
    }
}

Output

Met for-lus:
12
4
5

De length-property geeft de array-grootte.

Enhanced for-lus gebruiken

class Main {
    public static void main(String[] args) {
        int[] age = {12, 4, 5};
        System.out.println("Met for-each lus:");
        for (int a : age) {
            System.out.println(a);
        }
    }
}

Output

Met for-each lus:
12
4
5

Som en gemiddelde van array-elementen

class Main {
    public static void main(String[] args) {
        int[] numbers = {2, -9, 0, 5, 12, -25, 22, 9, 8, 12};
        int sum = 0;
        Double average;
        for (int number : numbers) {
            sum += number;
        }
        int arrayLength = numbers.length;
        average = ((double)sum / (double)arrayLength);
        System.out.println("Som = " + sum);
        System.out.println("Gemiddelde = " + average);
    }
}

Output

Som = 36
Gemiddelde = 3.6

Dit voorbeeld demonstreert de enhanced for-lus, type casting en de length-property.


Multidimensionale arrays

Naast eendimensionale arrays ondersteunt Java multi-level arrays – arrays van arrays. Bijvoorbeeld:

double[][] matrix = { {1.2, 4.3, 4.0}, {4.1, -1.1} };

Hier is matrix een 2-D array (een matrix). Lees meer: Java multidimensionale array.


Aanbevolen lezing

  • Java Copy Array
  • Java Program to Print an Array
  • Java Program to Concatenate two Arrays
  • Java ArrayList to Array and Array to ArrayList
  • Java Dynamic Array

Java

  1. C# Arrays: Declaratie, Initialisatie en Operaties
  2. C# Jagged Arrays: Declaratie, Initialisatie en Toegang
  3. C++ Arrays Ontmaskerd: Declaratie, Initialisatie en Pointer‑Technieken
  4. C++ Dynamische Array‑Allocatie: Praktische Handleiding met Code‑Voorbeelden
  5. Java-operators beheersen: typen, syntax en praktische voorbeelden
  6. Java array-kopieertechnieken: een uitgebreide gids
  7. Java interfaces meesteren: concepten, implementatie en best practices
  8. Java Try-with-resources meesteren: automatische resource management uitgelegd
  9. Java Annotaties uitgelegd: typen, plaatsing en praktische voorbeelden
  10. Java Arrays Tutorial: Declaratie, Creatie en Initialisatie – Voorbeeldcode
  11. Een Array van Objecten in Java aanmaken: Stap-voor-stap gids