Введение
Этот учебник рассматривает основные методы создания и использования массивов фиксированного размера в Java. Массивы — это фундаментальные структуры данных, позволяющие хранить несколько элементов одного типа в одной переменной. Освоив массивы Java, вы приобретете важный навык программирования, который служит основой для более продвинутых тем.
В этой лабораторной работе вы узнаете, как объявлять, инициализировать и манипулировать массивами на основе практических упражнений. Каждый шаг опирается на предыдущий, обеспечивая всестороннее понимание операций с массивами в Java.
Создание вашего первого массива Java
Массивы в Java — это объекты, которые хранят несколько переменных одного типа. В отличие от некоторых других структур данных, после создания массива его размер изменить нельзя. Это делает массивы особенно эффективными для хранения предопределенного количества элементов.
Объявление и инициализация массива
Массивы можно создавать разными способами. Давайте рассмотрим наиболее распространенные методы.
Создание простого целочисленного массива
Сначала давайте создадим новый файл Java в каталоге нашего проекта. В WebIDE щелкните меню «Файл», выберите «Новый файл» и назовите его ArrayDemo.java.
Добавьте следующий код в свой файл:
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);
}
}
Чтобы скомпилировать и запустить вашу программу Java, откройте терминал в WebIDE (если он еще не открыт) и выполните следующие команды:
javac ArrayDemo.java
java ArrayDemo
Вы должны увидеть вывод, похожий на этот:
Array elements after initialization:
numbers[0] = 0
numbers[1] = 0
numbers[2] = 0
numbers[3] = 0
numbers[4] = 0
Array length: 5
Как видите, Java автоматически инициализирует все элементы в целочисленном массиве нулем.
Инициализация массива со значениями
Теперь давайте изменим наш файл ArrayDemo.java, чтобы включить другой способ создания массивов — инициализацию с определенными значениями:
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]);
}
}
}
Скомпилируйте и запустите обновленную программу:
javac ArrayDemo.java
java ArrayDemo
Теперь вы должны увидеть дополнительный вывод:
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
Создание массивов разных типов
Давайте создадим новый файл с именем ArrayTypes.java, чтобы продемонстрировать массивы разных типов данных. В WebIDE создайте новый файл и добавьте следующий код:
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]);
}
}
}
Скомпилируйте и запустите эту программу:
javac ArrayTypes.java
java ArrayTypes
Вы увидите следующий вывод:
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
Обратите внимание, что разные типы данных имеют разные значения по умолчанию:
- Числовые типы (int, double и т. д.) по умолчанию равны нулю.
- Boolean по умолчанию равен false.
- Ссылочные типы (String, объекты) по умолчанию равны null.
На этом шаге вы узнали основы создания массивов в Java. Вы узнали, как объявлять массивы, инициализировать их со значениями и без них, а также создавать массивы разных типов данных.
Работа с элементами массива
Теперь, когда мы знаем, как создавать массивы, давайте рассмотрим, как работать с элементами массива. Это включает в себя установку значений, доступ к элементам и изменение содержимого массива.
Доступ и изменение элементов массива
Создайте новый файл с именем ArrayOperations.java в вашем WebIDE со следующим кодом:
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]);
}
}
}
Скомпилируйте и запустите эту программу:
javac ArrayOperations.java
java ArrayOperations
Вы должны увидеть следующий вывод:
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
Границы массива и обработка исключений
При работе с массивами крайне важно понимать границы массива. Массивы Java имеют фиксированный размер, и попытка получить доступ к элементу за пределами этих границ вызовет исключение.
Создайте новый файл с именем ArrayBoundaries.java со следующим кодом:
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) + ")");
}
}
}
Скомпилируйте и запустите эту программу:
javac ArrayBoundaries.java
java ArrayBoundaries
Вы должны увидеть вывод, подобный этому:
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)
Это демонстрирует, что Java выполняет проверку границ для массивов. Попытка доступа к numbers[3] вызывает исключение, потому что в массиве есть элементы только по индексам 0, 1 и 2.
Вычисление и хранение значений в массивах
Давайте создадим практический пример, в котором мы вычисляем значения и сохраняем их в массиве. Создайте файл с именем 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]);
}
}
}
Скомпилируйте и запустите эту программу:
javac TemperatureConverter.java
java TemperatureConverter
Вывод будет таблицей преобразования температуры:
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
Этот пример демонстрирует, как массивы можно использовать для хранения связанных данных и эффективного выполнения вычислений над несколькими значениями.
На этом шаге вы узнали, как получать доступ к элементам массива и изменять их, обрабатывать границы массива и использовать массивы для практических вычислений. Эти навыки составляют основу для более сложных операций с массивами.
Расширенные операции с массивами
Теперь, когда вы понимаете основы массивов, давайте рассмотрим более сложные операции, включая итерацию по массивам, поиск и использование массивов с методами.
Методы итерации по массивам
Java предоставляет несколько способов итерации по элементам массива. Создайте новый файл с именем ArrayIteration.java со следующим кодом:
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++;
}
}
}
Скомпилируйте и запустите эту программу:
javac ArrayIteration.java
java ArrayIteration
Вы должны увидеть следующий вывод:
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
Каждый метод итерации имеет свои преимущества:
- Стандартный цикл for: Предоставляет доступ к индексам и элементам массива.
- Расширенный цикл for: Более чистый синтаксис, когда вам нужны только элементы.
- Цикл while: Полезен, когда условие итерации более сложное.
Поиск элементов в массиве
Давайте создадим программу, которая ищет элементы в массиве. Создайте файл с именем 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");
}
}
}
}
Скомпилируйте и запустите эту программу:
javac ArraySearch.java
java ArraySearch
Вы должны увидеть вывод, подобный этому:
33 found at position 2
50 not found in the array
79 found at position 6
Это демонстрирует базовый алгоритм линейного поиска, проверяющий каждый элемент, пока не будет найдено целевое значение или массив не будет исчерпан.
Передача массивов в методы
Массивы можно передавать в методы так же, как и любые другие переменные. Создайте файл с именем 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;
}
}
}
Скомпилируйте и запустите эту программу:
javac ArrayMethods.java
java ArrayMethods
Вы должны увидеть вывод, подобный этому:
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
Этот пример демонстрирует несколько важных концепций:
- Массивы можно передавать в методы в качестве параметров.
- Методы могут возвращать значения, вычисленные из массивов.
- Изменения, внесенные в элементы массива внутри метода, отражаются за пределами метода (массивы передаются по ссылке).
Поиск максимального и минимального значений
Давайте создадим программу для поиска максимального и минимального значений в массиве. Создайте файл с именем 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;
}
}
Скомпилируйте и запустите эту программу:
javac ArrayMinMax.java
java ArrayMinMax
Вы должны увидеть вывод, подобный этому:
Array values: 42 17 88 23 56 9 71 33
Minimum value: 9
Maximum value: 88
На этом шаге вы изучили несколько расширенных операций с массивами, включая различные методы итерации, поиск элементов, передачу массивов в методы и поиск минимальных и максимальных значений. Эти навыки помогут вам более эффективно работать с массивами в ваших программах Java.
Практическое применение массивов
На этом заключительном шаге мы рассмотрим практическое применение массивов на примере полного примера. Мы создадим простую систему управления оценками, которая демонстрирует, как массивы можно использовать в реальных сценариях программирования.
Создание системы отслеживания оценок студентов
Давайте создадим программу, которая управляет оценками студентов. Эта программа будет:
- Хранить имена студентов и их оценки.
- Вычислять среднюю оценку.
- Находить самые высокие и самые низкие оценки.
- Определять, сколько студентов набрали баллы выше среднего.
Создайте новый файл с именем GradeTracker.java в вашем WebIDE:
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);
}
}
Скомпилируйте и запустите эту программу:
javac GradeTracker.java
java GradeTracker
Вы должны увидеть вывод, подобный этому:
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
Эта программа демонстрирует, как массивы можно использовать для управления связанными данными (именами и оценками студентов) и выполнения вычислений над этими данными.
Добавление категорий оценок
Теперь давайте улучшим нашу систему отслеживания оценок, добавив категории оценок. Создайте новый файл с именем 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 + ")";
}
}
Скомпилируйте и запустите эту программу:
javac EnhancedGradeTracker.java
java EnhancedGradeTracker
Вы должны увидеть вывод, подобный этому:
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)
Этот улучшенный пример демонстрирует:
- Использование нескольких массивов для хранения связанных данных.
- Создание вспомогательных методов для вычислений и форматирования.
- Подсчет и категоризацию данных.
- Создание визуального представления данных массива.
Обработка данных массива на основе условий
Для нашего последнего примера давайте создадим программу, которая обрабатывает данные массива на основе условий. Создайте файл с именем 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);
}
}
Скомпилируйте и запустите эту программу:
javac FilteredGrades.java
java FilteredGrades
Вы должны увидеть вывод, подобный этому:
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%
Этот пример демонстрирует:
- Использование условной логики с массивами.
- Создание отфильтрованных массивов на основе условий.
- Вычисление статистики из данных массива.
- Представление информации в отформатированном виде.
На этом шаге вы увидели, как массивы можно применять для решения практических задач. Вы научились управлять связанными данными, выполнять вычисления и создавать отфильтрованные представления данных массива на основе условий. Эти навыки послужат прочной основой для работы с массивами в реальных приложениях Java.
Резюме
В этой лабораторной работе вы изучили основные методы создания и работы с массивами фиксированного размера в Java. Вы узнали, как:
- Объявлять и инициализировать массивы различных типов данных.
- Получать доступ к элементам массива и изменять их, соблюдая границы массива.
- Итерировать по массивам, используя различные методы циклов.
- Передавать массивы в методы и обрабатывать данные массива.
- Находить минимальные и максимальные значения в массивах.
- Применять массивы для решения практических задач, таких как отслеживание оценок.
Массивы являются основой многих структур данных в Java и необходимы для эффективного хранения и обработки данных. Навыки, которые вы развили в этой лабораторной работе, послужат строительными блоками для более продвинутых концепций программирования, таких как динамические структуры данных, алгоритмы и объектно-ориентированное программирование.
Продолжайте практиковаться с массивами, изменяя предоставленные примеры, создавая собственные приложения на основе массивов и изучая документацию Java для получения дополнительных утилит работы с массивами в классе java.util.Arrays.
