Como criar arrays Java com tamanho fixo

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:

1. Arrays podem ser passados para métodos como parâmetros
2. Métodos podem retornar valores calculados a partir de arrays
3. 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á:

1. Armazenar os nomes dos alunos e suas notas
2. Calcular a média das notas
3. Encontrar as notas mais altas e mais baixas
4. 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:

1. Usando múltiplos arrays para armazenar dados relacionados
2. Criando métodos utilitários para cálculos e formatação
3. Contando e categorizando dados
4. 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:

1. Usando lógica condicional com arrays
2. Criando arrays filtrados com base em condições
3. Calculando estatísticas a partir de dados de array
4. 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.