Einführung
Dieses Tutorial untersucht die wesentlichen Techniken zum Erstellen und Verwenden von Arrays fester Größe in Java. Arrays sind grundlegende Datenstrukturen, mit denen Sie mehrere Elemente desselben Typs in einer einzigen Variable speichern können. Durch die Beherrschung von Java-Arrays erwerben Sie eine entscheidende Programmierfähigkeit, die als Grundlage für fortgeschrittenere Themen dient.
In diesem Lab lernen Sie durch praktische Übungen, wie man Arrays deklariert, initialisiert und manipuliert. Jeder Schritt baut auf dem vorherigen auf und vermittelt Ihnen ein umfassendes Verständnis der Array-Operationen in Java.
Erstellen Ihres ersten Java-Arrays
Arrays in Java sind Objekte, die mehrere Variablen desselben Typs speichern. Im Gegensatz zu einigen anderen Datenstrukturen kann die Größe eines Arrays nach seiner Erstellung nicht mehr geändert werden. Dies macht Arrays besonders effizient für die Speicherung einer vorgegebenen Anzahl von Elementen.
Array-Deklaration und -Initialisierung
Arrays können auf verschiedene Arten erstellt werden. Lassen Sie uns die gängigsten Methoden untersuchen.
Erstellen eines einfachen Integer-Arrays
Erstellen wir zunächst eine neue Java-Datei in unserem Projektverzeichnis. Klicken Sie in der WebIDE auf das Menü "Datei", wählen Sie "Neue Datei" und nennen Sie sie ArrayDemo.java.
Fügen Sie den folgenden Code in Ihre Datei ein:
public class ArrayDemo {
public static void main(String[] args) {
// Method 1: Declare and initialize an array separately
int[] numbers; // Array declaration
numbers = new int[5]; // Array initialization with size 5
// Default values are assigned (all zeros for int array)
System.out.println("Array elements after initialization:");
for (int i = 0; i < numbers.length; i++) {
System.out.println("numbers[" + i + "] = " + numbers[i]);
}
System.out.println("\nArray length: " + numbers.length);
}
}
Um Ihr Java-Programm zu kompilieren und auszuführen, öffnen Sie ein Terminal in der WebIDE (falls noch nicht geöffnet) und führen Sie die folgenden Befehle aus:
javac ArrayDemo.java
java ArrayDemo
Sie sollten eine Ausgabe ähnlich dieser sehen:
Array elements after initialization:
numbers[0] = 0
numbers[1] = 0
numbers[2] = 0
numbers[3] = 0
numbers[4] = 0
Array length: 5
Wie Sie sehen können, initialisiert Java automatisch alle Elemente in einem Integer-Array mit Null.
Array-Initialisierung mit Werten
Ändern wir nun unsere Datei ArrayDemo.java, um eine weitere Möglichkeit zur Erstellung von Arrays einzubeziehen – die Initialisierung mit bestimmten Werten:
public class ArrayDemo {
public static void main(String[] args) {
// Method 1: Declare and initialize an array separately
int[] numbers; // Array declaration
numbers = new int[5]; // Array initialization with size 5
// Default values are assigned (all zeros for int array)
System.out.println("Array elements after initialization:");
for (int i = 0; i < numbers.length; i++) {
System.out.println("numbers[" + i + "] = " + numbers[i]);
}
System.out.println("\nArray length: " + numbers.length);
// Method 2: Initialize with specific values
int[] scores = {85, 90, 75, 88, 92};
System.out.println("\nScores array elements:");
for (int i = 0; i < scores.length; i++) {
System.out.println("scores[" + i + "] = " + scores[i]);
}
}
}
Kompilieren und führen Sie das aktualisierte Programm aus:
javac ArrayDemo.java
java ArrayDemo
Sie sollten jetzt eine zusätzliche Ausgabe sehen:
Array elements after initialization:
numbers[0] = 0
numbers[1] = 0
numbers[2] = 0
numbers[3] = 0
numbers[4] = 0
Array length: 5
Scores array elements:
scores[0] = 85
scores[1] = 90
scores[2] = 75
scores[3] = 88
scores[4] = 92
Erstellen von Arrays verschiedener Typen
Erstellen wir eine neue Datei namens ArrayTypes.java, um Arrays verschiedener Datentypen zu demonstrieren. Erstellen Sie in der WebIDE eine neue Datei und fügen Sie den folgenden Code hinzu:
public class ArrayTypes {
public static void main(String[] args) {
// String array
String[] names = new String[3];
names[0] = "Alice";
names[1] = "Bob";
names[2] = "Charlie";
System.out.println("String array elements:");
for (int i = 0; i < names.length; i++) {
System.out.println("names[" + i + "] = " + names[i]);
}
// Double array with initialization
double[] prices = {19.99, 29.99, 15.50, 99.99};
System.out.println("\nDouble array elements:");
for (int i = 0; i < prices.length; i++) {
System.out.println("prices[" + i + "] = " + prices[i]);
}
// Boolean array
boolean[] flags = new boolean[3];
flags[0] = true;
System.out.println("\nBoolean array elements:");
for (int i = 0; i < flags.length; i++) {
System.out.println("flags[" + i + "] = " + flags[i]);
}
}
}
Kompilieren und führen Sie dieses Programm aus:
javac ArrayTypes.java
java ArrayTypes
Sie sehen die folgende Ausgabe:
String array elements:
names[0] = Alice
names[1] = Bob
names[2] = Charlie
Double array elements:
prices[0] = 19.99
prices[1] = 29.99
prices[2] = 15.5
prices[3] = 99.99
Boolean array elements:
flags[0] = true
flags[1] = false
flags[2] = false
Beachten Sie, dass verschiedene Datentypen unterschiedliche Standardwerte haben:
- Numerische Typen (int, double usw.) haben standardmäßig den Wert Null
- Boolean hat standardmäßig den Wert false
- Referenztypen (String, Objekte) haben standardmäßig den Wert null
Dieser Schritt hat Ihnen die Grundlagen der Erstellung von Arrays in Java gezeigt. Sie haben gelernt, wie man Arrays deklariert, sie mit und ohne Werte initialisiert und Arrays verschiedener Datentypen erstellt.
Arbeiten mit Array-Elementen
Nachdem wir nun wissen, wie man Arrays erstellt, wollen wir untersuchen, wie man mit Array-Elementen arbeitet. Dies beinhaltet das Setzen von Werten, den Zugriff auf Elemente und das Ändern von Array-Inhalten.
Zugriff auf und Modifizierung von Array-Elementen
Erstellen Sie in Ihrer WebIDE eine neue Datei namens ArrayOperations.java mit dem folgenden Code:
public class ArrayOperations {
public static void main(String[] args) {
// Create an integer array
int[] numbers = new int[5];
// Assign values to array elements
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;
numbers[3] = 40;
numbers[4] = 50;
// Display the original array
System.out.println("Original array elements:");
for (int i = 0; i < numbers.length; i++) {
System.out.println("numbers[" + i + "] = " + numbers[i]);
}
// Access specific elements
int firstElement = numbers[0];
int thirdElement = numbers[2];
System.out.println("\nAccessing specific elements:");
System.out.println("First element: " + firstElement);
System.out.println("Third element: " + thirdElement);
// Modify array elements
numbers[1] = 25; // Change second element
numbers[4] = 55; // Change last element
// Display the modified array
System.out.println("\nArray after modification:");
for (int i = 0; i < numbers.length; i++) {
System.out.println("numbers[" + i + "] = " + numbers[i]);
}
}
}
Kompilieren und führen Sie dieses Programm aus:
javac ArrayOperations.java
java ArrayOperations
Sie sollten diese Ausgabe sehen:
Original array elements:
numbers[0] = 10
numbers[1] = 20
numbers[2] = 30
numbers[3] = 40
numbers[4] = 50
Accessing specific elements:
First element: 10
Third element: 30
Array after modification:
numbers[0] = 10
numbers[1] = 25
numbers[2] = 30
numbers[3] = 40
numbers[4] = 55
Array-Grenzen und Ausnahmebehandlung (Exception Handling)
Bei der Arbeit mit Arrays ist es entscheidend, die Array-Grenzen zu verstehen. Java-Arrays haben eine feste Größe, und der Versuch, auf ein Element außerhalb dieser Grenzen zuzugreifen, führt zu einer Ausnahme (Exception).
Erstellen Sie eine neue Datei namens ArrayBoundaries.java mit dem folgenden Code:
public class ArrayBoundaries {
public static void main(String[] args) {
int[] numbers = new int[3]; // Array with 3 elements (indices 0, 1, 2)
// Set values within boundaries
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;
System.out.println("Array elements within boundaries:");
for (int i = 0; i < numbers.length; i++) {
System.out.println("numbers[" + i + "] = " + numbers[i]);
}
// Demonstrating boundary checking with try-catch
System.out.println("\nAttempting to access elements outside boundaries:");
try {
// This is valid
System.out.println("Accessing numbers[2]: " + numbers[2]);
// This will cause an ArrayIndexOutOfBoundsException
System.out.println("Attempting to access numbers[3]: " + numbers[3]);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Error: " + e.getMessage());
System.out.println("Cannot access an index outside the array bounds (0 to " + (numbers.length-1) + ")");
}
}
}
Kompilieren und führen Sie dieses Programm aus:
javac ArrayBoundaries.java
java ArrayBoundaries
Sie sollten eine Ausgabe wie diese sehen:
Array elements within boundaries:
numbers[0] = 10
numbers[1] = 20
numbers[2] = 30
Attempting to access elements outside boundaries:
Accessing numbers[2]: 30
Error: Index 3 out of bounds for length 3
Cannot access an index outside the array bounds (0 to 2)
Dies zeigt, dass Java eine Bereichsprüfung (bounds checking) für Arrays durchführt. Der Versuch, auf numbers[3] zuzugreifen, wirft eine Ausnahme, da das Array nur Elemente an den Indizes 0, 1 und 2 hat.
Berechnen und Speichern von Werten in Arrays
Erstellen wir ein praktisches Beispiel, in dem wir Werte berechnen und in einem Array speichern. Erstellen Sie eine Datei namens TemperatureConverter.java:
public class TemperatureConverter {
public static void main(String[] args) {
// Array to store Celsius temperatures
double[] celsiusTemps = {0, 10, 20, 30, 40};
// Array to store converted Fahrenheit temperatures
double[] fahrenheitTemps = new double[celsiusTemps.length];
// Convert each Celsius temperature to Fahrenheit
for (int i = 0; i < celsiusTemps.length; i++) {
// Formula: F = C * 9/5 + 32
fahrenheitTemps[i] = celsiusTemps[i] * 9/5 + 32;
}
// Display the conversion table
System.out.println("Temperature Conversion Table:");
System.out.println("---------------------------");
System.out.println("Celsius | Fahrenheit");
System.out.println("---------------------------");
for (int i = 0; i < celsiusTemps.length; i++) {
System.out.printf("%-10.1f | %-10.1f\n",
celsiusTemps[i],
fahrenheitTemps[i]);
}
}
}
Kompilieren und führen Sie dieses Programm aus:
javac TemperatureConverter.java
java TemperatureConverter
Die Ausgabe ist eine Temperaturumrechnungstabelle:
Temperature Conversion Table:
---------------------------
Celsius | Fahrenheit
---------------------------
0.0 | 32.0
10.0 | 50.0
20.0 | 68.0
30.0 | 86.0
40.0 | 104.0
Dieses Beispiel zeigt, wie Arrays verwendet werden können, um zusammengehörige Daten zu speichern und Berechnungen für mehrere Werte effizient durchzuführen.
In diesem Schritt haben Sie gelernt, wie man auf Array-Elemente zugreift und diese modifiziert, Array-Grenzen behandelt und Arrays für praktische Berechnungen verwendet. Diese Fähigkeiten bilden die Grundlage für komplexere Array-Operationen.
Erweiterte Array-Operationen
Nachdem Sie nun die Grundlagen von Arrays verstanden haben, wollen wir uns anspruchsvollere Operationen ansehen, einschließlich Array-Iteration, Suche und die Verwendung von Arrays mit Methoden.
Array-Iterationstechniken
Java bietet mehrere Möglichkeiten, durch Array-Elemente zu iterieren. Erstellen Sie eine neue Datei namens ArrayIteration.java mit dem folgenden Code:
public class ArrayIteration {
public static void main(String[] args) {
// Create a sample array
String[] fruits = {"Apple", "Banana", "Cherry", "Date", "Elderberry"};
System.out.println("Array Iteration Methods:");
// Method 1: Standard for loop
System.out.println("\n1. Using standard for loop:");
for (int i = 0; i < fruits.length; i++) {
System.out.println("fruits[" + i + "] = " + fruits[i]);
}
// Method 2: Enhanced for loop (foreach)
System.out.println("\n2. Using enhanced for loop (foreach):");
for (String fruit : fruits) {
System.out.println(fruit);
}
// Method 3: While loop
System.out.println("\n3. Using while loop:");
int index = 0;
while (index < fruits.length) {
System.out.println("fruits[" + index + "] = " + fruits[index]);
index++;
}
}
}
Kompilieren und führen Sie dieses Programm aus:
javac ArrayIteration.java
java ArrayIteration
Sie sollten diese Ausgabe sehen:
Array Iteration Methods:
1. Using standard for loop:
fruits[0] = Apple
fruits[1] = Banana
fruits[2] = Cherry
fruits[3] = Date
fruits[4] = Elderberry
2. Using enhanced for loop (foreach):
Apple
Banana
Cherry
Date
Elderberry
3. Using while loop:
fruits[0] = Apple
fruits[1] = Banana
fruits[2] = Cherry
fruits[3] = Date
fruits[4] = Elderberry
Jede Iterationsmethode hat ihre Vorteile:
- Standard-For-Schleife: Bietet Zugriff auf Array-Indizes und -Elemente
- Erweiterte For-Schleife: Sauberere Syntax, wenn Sie nur die Elemente benötigen
- While-Schleife: Nützlich, wenn die Iterationsbedingung komplexer ist
Suchen nach Elementen in einem Array
Erstellen wir ein Programm, das nach Elementen in einem Array sucht. Erstellen Sie eine Datei namens ArraySearch.java:
public class ArraySearch {
public static void main(String[] args) {
// Create an array of numbers
int[] numbers = {10, 25, 33, 47, 52, 68, 79};
// Values to search for
int[] searchValues = {33, 50, 79};
for (int valueToFind : searchValues) {
boolean found = false;
int position = -1;
// Search through the array
for (int i = 0; i < numbers.length; i++) {
if (numbers[i] == valueToFind) {
found = true;
position = i;
break; // Exit the loop once found
}
}
// Display result
if (found) {
System.out.println(valueToFind + " found at position " + position);
} else {
System.out.println(valueToFind + " not found in the array");
}
}
}
}
Kompilieren und führen Sie dieses Programm aus:
javac ArraySearch.java
java ArraySearch
Sie sollten eine Ausgabe wie diese sehen:
33 found at position 2
50 not found in the array
79 found at position 6
Dies demonstriert einen einfachen linearen Suchalgorithmus, der jedes Element überprüft, bis der Zielwert gefunden oder das Array erschöpft ist.
Übergeben von Arrays an Methoden
Arrays können wie jede andere Variable an Methoden übergeben werden. Erstellen Sie eine Datei namens ArrayMethods.java:
public class ArrayMethods {
public static void main(String[] args) {
// Create an array
int[] values = {5, 10, 15, 20, 25};
// Display the original array
System.out.println("Original array:");
displayArray(values);
// Calculate and display the sum
int sum = calculateSum(values);
System.out.println("\nSum of all elements: " + sum);
// Calculate and display the average
double average = calculateAverage(values);
System.out.println("Average of all elements: " + average);
// Double all values in the array
doubleValues(values);
// Display the modified array
System.out.println("\nArray after doubling all values:");
displayArray(values);
}
// Method to display an array
public static void displayArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
// Method to calculate the sum of array elements
public static int calculateSum(int[] arr) {
int sum = 0;
for (int value : arr) {
sum += value;
}
return sum;
}
// Method to calculate the average of array elements
public static double calculateAverage(int[] arr) {
int sum = calculateSum(arr);
return (double) sum / arr.length;
}
// Method to double all values in the array
public static void doubleValues(int[] arr) {
for (int i = 0; i < arr.length; i++) {
arr[i] = arr[i] * 2;
}
}
}
Kompilieren und führen Sie dieses Programm aus:
javac ArrayMethods.java
java ArrayMethods
Sie sollten eine Ausgabe wie diese sehen:
Original array:
5 10 15 20 25
Sum of all elements: 75
Average of all elements: 15.0
Array after doubling all values:
10 20 30 40 50
Dieses Beispiel demonstriert mehrere wichtige Konzepte:
- Arrays können als Parameter an Methoden übergeben werden
- Methoden können aus Arrays berechnete Werte zurückgeben
- Änderungen an Array-Elementen innerhalb einer Methode werden außerhalb der Methode widergespiegelt (Arrays werden per Referenz übergeben)
Finden von Maximal- und Minimalwerten
Erstellen wir ein Programm, um die Maximal- und Minimalwerte in einem Array zu finden. Erstellen Sie eine Datei namens ArrayMinMax.java:
public class ArrayMinMax {
public static void main(String[] args) {
// Create an array of numbers
int[] numbers = {42, 17, 88, 23, 56, 9, 71, 33};
// Find minimum and maximum values
int min = findMinimum(numbers);
int max = findMaximum(numbers);
// Display the array
System.out.print("Array values: ");
for (int num : numbers) {
System.out.print(num + " ");
}
System.out.println();
// Display results
System.out.println("Minimum value: " + min);
System.out.println("Maximum value: " + max);
}
// Method to find the minimum value in an array
public static int findMinimum(int[] arr) {
// Start with the first element as the minimum
int min = arr[0];
// Compare with other elements
for (int i = 1; i < arr.length; i++) {
if (arr[i] < min) {
min = arr[i];
}
}
return min;
}
// Method to find the maximum value in an array
public static int findMaximum(int[] arr) {
// Start with the first element as the maximum
int max = arr[0];
// Compare with other elements
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
return max;
}
}
Kompilieren und führen Sie dieses Programm aus:
javac ArrayMinMax.java
java ArrayMinMax
Sie sollten eine Ausgabe wie diese sehen:
Array values: 42 17 88 23 56 9 71 33
Minimum value: 9
Maximum value: 88
In diesem Schritt haben Sie mehrere erweiterte Array-Operationen gelernt, darunter verschiedene Iterationstechniken, das Suchen nach Elementen, das Übergeben von Arrays an Methoden und das Finden von Minimal- und Maximalwerten. Diese Fähigkeiten helfen Ihnen, in Ihren Java-Programmen effektiver mit Arrays zu arbeiten.
Praktische Array-Anwendungen
In diesem letzten Schritt werden wir praktische Anwendungen von Arrays anhand eines vollständigen Beispiels untersuchen. Wir erstellen ein einfaches Notenverwaltungssystem, das zeigt, wie Arrays in realen Programmierszenarien verwendet werden können.
Erstellen eines Schülernoten-Trackers
Erstellen wir ein Programm, das Schülerleistungen verwaltet. Dieses Programm wird:
- Schülernamen und ihre Noten speichern
- Die Durchschnittsnote berechnen
- Die höchste und niedrigste Note finden
- Ermitteln, wie viele Schüler über dem Durchschnitt abgeschnitten haben
Erstellen Sie in Ihrer WebIDE eine neue Datei namens GradeTracker.java:
public class GradeTracker {
public static void main(String[] args) {
// Arrays to store student information
String[] studentNames = {"Alice", "Bob", "Charlie", "David", "Emma",
"Frank", "Grace", "Hannah", "Ian", "Julia"};
int[] studentGrades = {85, 92, 78, 65, 88, 72, 95, 83, 79, 91};
// Display all student records
System.out.println("Student Grade Records:");
System.out.println("---------------------");
System.out.println("Name\t\tGrade");
System.out.println("---------------------");
for (int i = 0; i < studentNames.length; i++) {
// Add extra tab for short names to align columns
String tab = studentNames[i].length() <= 5 ? "\t\t" : "\t";
System.out.println(studentNames[i] + tab + studentGrades[i]);
}
// Calculate statistics
int sum = 0;
int highest = studentGrades[0];
int lowest = studentGrades[0];
String highestStudent = studentNames[0];
String lowestStudent = studentNames[0];
for (int i = 0; i < studentGrades.length; i++) {
// Add to sum for average calculation
sum += studentGrades[i];
// Check for highest grade
if (studentGrades[i] > highest) {
highest = studentGrades[i];
highestStudent = studentNames[i];
}
// Check for lowest grade
if (studentGrades[i] < lowest) {
lowest = studentGrades[i];
lowestStudent = studentNames[i];
}
}
// Calculate average
double average = (double) sum / studentGrades.length;
// Count students above average
int aboveAverageCount = 0;
for (int grade : studentGrades) {
if (grade > average) {
aboveAverageCount++;
}
}
// Display statistics
System.out.println("\nClass Statistics:");
System.out.println("----------------");
System.out.printf("Class Average: %.2f\n", average);
System.out.println("Highest Grade: " + highest + " (" + highestStudent + ")");
System.out.println("Lowest Grade: " + lowest + " (" + lowestStudent + ")");
System.out.println("Number of students above average: " + aboveAverageCount);
}
}
Kompilieren und führen Sie dieses Programm aus:
javac GradeTracker.java
java GradeTracker
Sie sollten eine Ausgabe wie diese sehen:
Student Grade Records:
---------------------
Name Grade
---------------------
Alice 85
Bob 92
Charlie 78
David 65
Emma 88
Frank 72
Grace 95
Hannah 83
Ian 79
Julia 91
Class Statistics:
----------------
Class Average: 82.80
Highest Grade: 95 (Grace)
Lowest Grade: 65 (David)
Number of students above average: 5
Dieses Programm zeigt, wie Arrays verwendet werden können, um zusammengehörige Daten (Schülernamen und Noten) zu verwalten und Berechnungen für diese Daten durchzuführen.
Hinzufügen von Notenkategorien
Erweitern wir nun unseren Noten-Tracker, indem wir Notenkategorien hinzufügen. Erstellen Sie eine neue Datei namens EnhancedGradeTracker.java:
public class EnhancedGradeTracker {
public static void main(String[] args) {
// Arrays to store student information
String[] studentNames = {"Alice", "Bob", "Charlie", "David", "Emma",
"Frank", "Grace", "Hannah", "Ian", "Julia"};
int[] studentGrades = {85, 92, 78, 65, 88, 72, 95, 83, 79, 91};
// Create arrays to count grades in each category
int[] gradeCounts = new int[5]; // A, B, C, D, F
// Display all student records with grade categories
System.out.println("Student Grade Records:");
System.out.println("------------------------------");
System.out.println("Name\t\tScore\tGrade");
System.out.println("------------------------------");
for (int i = 0; i < studentNames.length; i++) {
// Calculate letter grade
char letterGrade = calculateGrade(studentGrades[i]);
// Count grades by category
switch (letterGrade) {
case 'A': gradeCounts[0]++; break;
case 'B': gradeCounts[1]++; break;
case 'C': gradeCounts[2]++; break;
case 'D': gradeCounts[3]++; break;
case 'F': gradeCounts[4]++; break;
}
// Add extra tab for short names to align columns
String tab = studentNames[i].length() <= 5 ? "\t\t" : "\t";
System.out.println(studentNames[i] + tab + studentGrades[i] + "\t" + letterGrade);
}
// Calculate statistics
double average = calculateAverage(studentGrades);
// Display statistics
System.out.println("\nClass Statistics:");
System.out.println("----------------");
System.out.printf("Class Average: %.2f\n", average);
// Display grade distribution
System.out.println("\nGrade Distribution:");
System.out.println("------------------");
System.out.println("A: " + displayStars(gradeCounts[0]));
System.out.println("B: " + displayStars(gradeCounts[1]));
System.out.println("C: " + displayStars(gradeCounts[2]));
System.out.println("D: " + displayStars(gradeCounts[3]));
System.out.println("F: " + displayStars(gradeCounts[4]));
}
// Method to calculate the letter grade from a numeric score
public static char calculateGrade(int score) {
if (score >= 90) {
return 'A';
} else if (score >= 80) {
return 'B';
} else if (score >= 70) {
return 'C';
} else if (score >= 60) {
return 'D';
} else {
return 'F';
}
}
// Method to calculate the average of an integer array
public static double calculateAverage(int[] arr) {
int sum = 0;
for (int value : arr) {
sum += value;
}
return (double) sum / arr.length;
}
// Method to create a string of stars representing a count
public static String displayStars(int count) {
StringBuilder stars = new StringBuilder();
for (int i = 0; i < count; i++) {
stars.append("*");
}
return stars.toString() + " (" + count + ")";
}
}
Kompilieren und führen Sie dieses Programm aus:
javac EnhancedGradeTracker.java
java EnhancedGradeTracker
Sie sollten eine Ausgabe wie diese sehen:
Student Grade Records:
------------------------------
Name Score Grade
------------------------------
Alice 85 B
Bob 92 A
Charlie 78 C
David 65 D
Emma 88 B
Frank 72 C
Grace 95 A
Hannah 83 B
Ian 79 C
Julia 91 A
Class Statistics:
----------------
Class Average: 82.80
Grade Distribution:
------------------
A: *** (3)
B: *** (3)
C: *** (3)
D: * (1)
F: (0)
Dieses erweiterte Beispiel demonstriert:
- Die Verwendung mehrerer Arrays zum Speichern zusammengehöriger Daten
- Das Erstellen von Hilfsmethoden für Berechnungen und Formatierung
- Das Zählen und Kategorisieren von Daten
- Das Erstellen einer visuellen Darstellung von Array-Daten
Verarbeiten von Array-Daten basierend auf Bedingungen
Für unser letztes Beispiel erstellen wir ein Programm, das Array-Daten basierend auf Bedingungen verarbeitet. Erstellen Sie eine Datei namens FilteredGrades.java:
public class FilteredGrades {
public static void main(String[] args) {
// Arrays to store student information
String[] studentNames = {"Alice", "Bob", "Charlie", "David", "Emma",
"Frank", "Grace", "Hannah", "Ian", "Julia"};
int[] studentGrades = {85, 92, 78, 65, 88, 72, 95, 83, 79, 91};
// Create a threshold for passing
int passingGrade = 75;
// Display all student records with pass/fail status
System.out.println("Student Grade Records:");
System.out.println("------------------------------");
System.out.println("Name\t\tScore\tStatus");
System.out.println("------------------------------");
// Count passing and failing students
int passingCount = 0;
for (int i = 0; i < studentNames.length; i++) {
String status = (studentGrades[i] >= passingGrade) ? "PASS" : "FAIL";
// Count passing students
if (studentGrades[i] >= passingGrade) {
passingCount++;
}
// Add extra tab for short names to align columns
String tab = studentNames[i].length() <= 5 ? "\t\t" : "\t";
System.out.println(studentNames[i] + tab + studentGrades[i] + "\t" + status);
}
// Create arrays to store only passing students
String[] passingStudents = new String[passingCount];
int[] passingScores = new int[passingCount];
// Fill the passing student arrays
int index = 0;
for (int i = 0; i < studentNames.length; i++) {
if (studentGrades[i] >= passingGrade) {
passingStudents[index] = studentNames[i];
passingScores[index] = studentGrades[i];
index++;
}
}
// Display only passing students
System.out.println("\nPassing Students (Score >= 75):");
System.out.println("------------------------------");
System.out.println("Name\t\tScore");
System.out.println("------------------------------");
for (int i = 0; i < passingStudents.length; i++) {
// Add extra tab for short names to align columns
String tab = passingStudents[i].length() <= 5 ? "\t\t" : "\t";
System.out.println(passingStudents[i] + tab + passingScores[i]);
}
// Calculate and display statistics
System.out.println("\nClass Statistics:");
System.out.println("----------------");
System.out.println("Total Students: " + studentNames.length);
System.out.println("Passing: " + passingCount);
System.out.println("Failing: " + (studentNames.length - passingCount));
System.out.printf("Pass Rate: %.1f%%\n",
(double) passingCount / studentNames.length * 100);
}
}
Kompilieren und führen Sie dieses Programm aus:
javac FilteredGrades.java
java FilteredGrades
Sie sollten eine Ausgabe wie diese sehen:
Student Grade Records:
------------------------------
Name Score Status
------------------------------
Alice 85 PASS
Bob 92 PASS
Charlie 78 PASS
David 65 FAIL
Emma 88 PASS
Frank 72 FAIL
Grace 95 PASS
Hannah 83 PASS
Ian 79 PASS
Julia 91 PASS
Passing Students (Score >= 75):
------------------------------
Name Score
------------------------------
Alice 85
Bob 92
Charlie 78
Emma 88
Grace 95
Hannah 83
Ian 79
Julia 91
Class Statistics:
----------------
Total Students: 10
Passing: 8
Failing: 2
Pass Rate: 80.0%
Dieses Beispiel demonstriert:
- Die Verwendung von bedingter Logik mit Arrays
- Das Erstellen von gefilterten Arrays basierend auf Bedingungen
- Das Berechnen von Statistiken aus Array-Daten
- Das Präsentieren von Informationen in formatierter Weise
In diesem Schritt haben Sie gesehen, wie Arrays zur Lösung praktischer Probleme eingesetzt werden können. Sie haben gelernt, wie man zusammengehörige Daten verwaltet, Berechnungen durchführt und gefilterte Ansichten von Array-Daten basierend auf Bedingungen erstellt. Diese Fähigkeiten dienen als solide Grundlage für die Arbeit mit Arrays in realen Java-Anwendungen.
Zusammenfassung
In diesem Lab haben Sie die wesentlichen Techniken zur Erstellung und Arbeit mit Arrays fester Größe in Java erkundet. Sie haben gelernt, wie man:
- Arrays verschiedener Datentypen deklariert und initialisiert
- Auf Array-Elemente zugreift und diese modifiziert, während Array-Grenzen beachtet werden
- Mit verschiedenen Schleifentechniken durch Arrays iteriert
- Arrays an Methoden übergibt und Array-Daten verarbeitet
- Minimal- und Maximalwerte in Arrays findet
- Arrays auf praktische Probleme wie Notenverfolgung anwendet
Arrays bilden die Grundlage vieler Datenstrukturen in Java und sind für eine effiziente Datenspeicherung und -manipulation unerlässlich. Die Fähigkeiten, die Sie in diesem Lab entwickelt haben, dienen als Bausteine für fortgeschrittenere Programmierkonzepte wie dynamische Datenstrukturen, Algorithmen und objektorientierte Programmierung.
Üben Sie weiter mit Arrays, indem Sie die bereitgestellten Beispiele modifizieren, Ihre eigenen Array-basierten Anwendungen erstellen und die Java-Dokumentation nach zusätzlichen Array-Dienstprogrammen in der Klasse java.util.Arrays durchsuchen.
