Introdução
Este tutorial explora as técnicas essenciais para criar e usar arrays de tamanho fixo em Java. Arrays são estruturas de dados fundamentais que permitem armazenar múltiplos elementos do mesmo tipo em uma única variável. Ao dominar arrays em Java, você adquirirá uma habilidade de programação crucial que serve como base para tópicos mais avançados.
Neste laboratório, você aprenderá como declarar, inicializar e manipular arrays através de prática. Cada passo se baseia no anterior, proporcionando uma compreensão abrangente das operações de array em Java.
Criando Seu Primeiro Array em Java
Arrays em Java são objetos que armazenam múltiplas variáveis do mesmo tipo. Diferente de outras estruturas de dados, uma vez que um array é criado, seu tamanho não pode ser alterado. Isso torna os arrays particularmente eficientes para armazenar um número predeterminado de elementos.
Declaração e Inicialização de Array
Arrays podem ser criados de diferentes maneiras. Vamos explorar os métodos mais comuns.
Criando um Array de Inteiros Simples
Primeiro, vamos criar um novo arquivo Java em nosso diretório de projeto. No WebIDE, clique no menu "File", selecione "New File" e nomeie-o como ArrayDemo.java.
Adicione o seguinte código ao seu arquivo:
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);
}
}
Para compilar e executar seu programa Java, abra um terminal no WebIDE (se ainda não estiver aberto) e execute os seguintes comandos:
javac ArrayDemo.java
java ArrayDemo
Você deve ver uma saída semelhante a esta:
Array elements after initialization:
numbers[0] = 0
numbers[1] = 0
numbers[2] = 0
numbers[3] = 0
numbers[4] = 0
Array length: 5
Como você pode ver, Java automaticamente inicializa todos os elementos em um array de inteiros com zero.
Inicialização de Array com Valores
Agora, vamos modificar nosso arquivo ArrayDemo.java para incluir outra forma de criar arrays - inicialização com valores específicos:
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]);
}
}
}
Compile e execute o programa atualizado:
javac ArrayDemo.java
java ArrayDemo
Você deve agora ver uma saída adicional:
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
Criando Arrays de Diferentes Tipos
Vamos criar um novo arquivo chamado ArrayTypes.java para demonstrar arrays de diferentes tipos de dados. No WebIDE, crie um novo arquivo e adicione o seguinte código:
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]);
}
}
}
Compile e execute este programa:
javac ArrayTypes.java
java ArrayTypes
Você verá a seguinte saída:
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
Observe que diferentes tipos de dados têm valores padrão diferentes:
- Tipos numéricos (int, double, etc.) são definidos como zero por padrão
- Boolean é definido como false por padrão
- Tipos de referência (String, objetos) são definidos como null por padrão
Este passo mostrou a você os conceitos básicos de criação de arrays em Java. Você aprendeu como declarar arrays, inicializá-los com e sem valores e criar arrays de diferentes tipos de dados.
Trabalhando com Elementos de Array
Agora que sabemos como criar arrays, vamos explorar como trabalhar com elementos de array. Isso inclui definir valores, acessar elementos e modificar o conteúdo do array.
Acessando e Modificando Elementos de Array
Crie um novo arquivo chamado ArrayOperations.java em seu WebIDE com o seguinte código:
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]);
}
}
}
Compile e execute este programa:
javac ArrayOperations.java
java ArrayOperations
Você deve ver esta saída:
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
Limites de Array e Tratamento de Exceções
Ao trabalhar com arrays, é crucial entender os limites do array. Arrays Java têm um tamanho fixo, e tentar acessar um elemento fora desses limites causará uma exceção.
Crie um novo arquivo chamado ArrayBoundaries.java com o seguinte código:
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) + ")");
}
}
}
Compile e execute este programa:
javac ArrayBoundaries.java
java ArrayBoundaries
Você deve ver uma saída como esta:
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)
Isso demonstra que Java realiza a verificação de limites em arrays. Tentar acessar numbers[3] lança uma exceção porque o array só tem elementos nos índices 0, 1 e 2.
Calculando e Armazenando Valores em Arrays
Vamos criar um exemplo prático onde calculamos valores e os armazenamos em um array. Crie um arquivo chamado 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]);
}
}
}
Compile e execute este programa:
javac TemperatureConverter.java
java TemperatureConverter
A saída será uma tabela de conversão de temperatura:
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
Este exemplo demonstra como os arrays podem ser usados para armazenar dados relacionados e realizar cálculos em múltiplos valores de forma eficiente.
Neste passo, você aprendeu como acessar e modificar elementos de array, lidar com limites de array e usar arrays para cálculos práticos. Essas habilidades formam a base para operações de array mais complexas.
Operações Avançadas com Arrays
Agora que você entende os conceitos básicos de arrays, vamos explorar operações mais sofisticadas, incluindo iteração de array, busca e uso de arrays com métodos.
Técnicas de Iteração de Array
Java fornece várias maneiras de iterar sobre os elementos de um array. Crie um novo arquivo chamado ArrayIteration.java com o seguinte código:
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++;
}
}
}
Compile e execute este programa:
javac ArrayIteration.java
java ArrayIteration
Você deve ver esta saída:
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
Cada método de iteração tem suas vantagens:
- Loop for padrão: Fornece acesso aos índices e elementos do array
- Loop for aprimorado: Sintaxe mais limpa quando você só precisa dos elementos
- Loop while: Útil quando a condição de iteração é mais complexa
Buscando Elementos em um Array
Vamos criar um programa que busca elementos em um array. Crie um arquivo chamado 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");
}
}
}
}
Compile e execute este programa:
javac ArraySearch.java
java ArraySearch
Você deve ver uma saída como esta:
33 found at position 2
50 not found in the array
79 found at position 6
Isso demonstra um algoritmo de busca linear básico, verificando cada elemento até que o valor alvo seja encontrado ou o array seja esgotado.
Passando Arrays para Métodos
Arrays podem ser passados para métodos assim como qualquer outra variável. Crie um arquivo chamado 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;
}
}
}
Compile e execute este programa:
javac ArrayMethods.java
java ArrayMethods
Você deve ver uma saída como esta:
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
Este exemplo demonstra vários conceitos importantes:
- Arrays podem ser passados para métodos como parâmetros
- Métodos podem retornar valores calculados a partir de arrays
- Mudanças feitas nos elementos do array dentro de um método são refletidas fora do método (arrays são passados por referência)
Encontrando Valores Máximos e Mínimos
Vamos criar um programa para encontrar os valores máximo e mínimo em um array. Crie um arquivo chamado 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;
}
}
Compile e execute este programa:
javac ArrayMinMax.java
java ArrayMinMax
Você deve ver uma saída como esta:
Array values: 42 17 88 23 56 9 71 33
Minimum value: 9
Maximum value: 88
Neste passo, você aprendeu várias operações avançadas com arrays, incluindo diferentes técnicas de iteração, busca de elementos, passagem de arrays para métodos e encontrar valores mínimos e máximos. Essas habilidades ajudarão você a trabalhar de forma mais eficaz com arrays em seus programas Java.
Aplicações Práticas de Arrays
Nesta etapa final, exploraremos aplicações práticas de arrays por meio de um exemplo completo. Criaremos um sistema simples de gerenciamento de notas que demonstra como os arrays podem ser usados em cenários de programação do mundo real.
Criando um Rastreador de Notas de Estudantes
Vamos construir um programa que gerencia as notas dos alunos. Este programa irá:
- Armazenar os nomes dos alunos e suas notas
- Calcular a média das notas
- Encontrar as notas mais altas e mais baixas
- Determinar quantos alunos tiveram notas acima da média
Crie um novo arquivo chamado GradeTracker.java em seu 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);
}
}
Compile e execute este programa:
javac GradeTracker.java
java GradeTracker
Você deve ver uma saída como esta:
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
Este programa demonstra como os arrays podem ser usados para gerenciar dados relacionados (nomes e notas dos alunos) e realizar cálculos sobre esses dados.
Adicionando Categorias de Notas
Agora, vamos aprimorar nosso rastreador de notas adicionando categorias de notas. Crie um novo arquivo chamado 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 + ")";
}
}
Compile e execute este programa:
javac EnhancedGradeTracker.java
java EnhancedGradeTracker
Você deve ver uma saída como esta:
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)
Este exemplo aprimorado demonstra:
- Usando múltiplos arrays para armazenar dados relacionados
- Criando métodos utilitários para cálculos e formatação
- Contando e categorizando dados
- Criando uma representação visual dos dados do array
Processando Dados de Array com Base em Condições
Para nosso exemplo final, vamos criar um programa que processa dados de array com base em condições. Crie um arquivo chamado 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);
}
}
Compile e execute este programa:
javac FilteredGrades.java
java FilteredGrades
Você deve ver uma saída como esta:
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%
Este exemplo demonstra:
- Usando lógica condicional com arrays
- Criando arrays filtrados com base em condições
- Calculando estatísticas a partir de dados de array
- Apresentando informações de forma formatada
Nesta etapa, você viu como os arrays podem ser aplicados para resolver problemas práticos. Você aprendeu a gerenciar dados relacionados, realizar cálculos e criar visualizações filtradas de dados de array com base em condições. Essas habilidades servirão como uma base sólida para trabalhar com arrays em aplicações Java do mundo real.
Resumo
Neste laboratório, você explorou as técnicas essenciais para criar e trabalhar com arrays de tamanho fixo em Java. Você aprendeu como:
- Declarar e inicializar arrays de diferentes tipos de dados
- Acessar e modificar elementos de array, respeitando os limites do array
- Iterar sobre arrays usando diferentes técnicas de loop
- Passar arrays para métodos e processar dados de array
- Encontrar valores mínimos e máximos em arrays
- Aplicar arrays a problemas práticos, como o rastreamento de notas
Arrays formam a base de muitas estruturas de dados em Java e são essenciais para o armazenamento e manipulação eficientes de dados. As habilidades que você desenvolveu neste laboratório servirão como blocos de construção para conceitos de programação mais avançados, como estruturas de dados dinâmicas, algoritmos e programação orientada a objetos.
Continue praticando com arrays, modificando os exemplos fornecidos, criando suas próprias aplicações baseadas em arrays e explorando a documentação Java para utilitários de array adicionais na classe java.util.Arrays.
