Java方法与数组

原创 已于 2025-11-26 13:37:18 修改 · 256 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

于 2025-11-26 13:36:34 首次发布

Java 方法与数组详解

方法（函数）

1. 方法的基本概念

方法是一段可重复使用的代码块，用于执行特定任务。

// 方法定义语法
[访问修饰符] [static] 返回值类型 方法名(参数列表) {
    // 方法体
    return 返回值; // 如果返回值类型不是void
}

2. 方法示例

public class MethodExample {
    
    // 无参数无返回值的方法
    public static void printHello() {
        System.out.println("Hello, World!");
    }
    
    // 带参数无返回值的方法
    public static void printMessage(String message) {
        System.out.println("消息: " + message);
    }
    
    // 带参数有返回值的方法
    public static int add(int a, int b) {
        return a + b;
    }
    
    // 方法重载 - 同名不同参数
    public static double add(double a, double b) {
        return a + b;
    }
    
    public static void main(String[] args) {
        // 调用方法
        printHello();
        printMessage("Java编程");
        
        int sum = add(5, 3);
        System.out.println("5 + 3 = " + sum);
        
        double doubleSum = add(5.5, 3.2);
        System.out.println("5.5 + 3.2 = " + doubleSum);
    }
}

3. 递归方法

public class RecursionExample {
    
    // 计算阶乘 - 递归方法
    public static int factorial(int n) {
        if (n == 0 || n == 1) {
            return 1;
        }
        return n * factorial(n - 1);
    }
    
    // 斐波那契数列 - 递归方法
    public static int fibonacci(int n) {
        if (n <= 1) {
            return n;
        }
        return fibonacci(n - 1) + fibonacci(n - 2);
    }
    
    public static void main(String[] args) {
        System.out.println("5的阶乘: " + factorial(5)); // 120
        System.out.println("第6个斐波那契数: " + fibonacci(6)); // 8
    }
}

数组

1. 数组的基本概念

数组是存储相同类型数据的集合。

public class ArrayBasic {
    
    public static void main(String[] args) {
        // 数组声明和初始化方式
        
        // 方式1: 声明后初始化
        int[] numbers1;
        numbers1 = new int[5];
        
        // 方式2: 声明同时初始化
        int[] numbers2 = new int[5];
        
        // 方式3: 直接赋值
        int[] numbers3 = {1, 2, 3, 4, 5};
        
        // 方式4: 声明时指定大小并赋值
        int[] numbers4 = new int[]{1, 2, 3, 4, 5};
        
        // 访问数组元素
        numbers1[0] = 10;  // 第一个元素
        numbers1[1] = 20;  // 第二个元素
        
        System.out.println("第一个元素: " + numbers1[0]);
        System.out.println("数组长度: " + numbers1.length);
    }
}

2. 数组遍历

public class ArrayTraversal {
    
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};
        
        // 方法1: for循环
        System.out.println("for循环遍历:");
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("索引 " + i + ": " + numbers[i]);
        }
        
        // 方法2: 增强for循环 (foreach)
        System.out.println("\n增强for循环遍历:");
        for (int num : numbers) {
            System.out.println("元素: " + num);
        }
        
        // 方法3: while循环
        System.out.println("\nwhile循环遍历:");
        int i = 0;
        while (i < numbers.length) {
            System.out.println("索引 " + i + ": " + numbers[i]);
            i++;
        }
    }
}

3. 多维数组

public class MultiDimensionalArray {
    
    public static void main(String[] args) {
        // 二维数组声明和初始化
        int[][] matrix1 = new int[3][3]; // 3x3矩阵
        
        // 直接初始化二维数组
        int[][] matrix2 = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        
        // 遍历二维数组
        System.out.println("二维数组遍历:");
        for (int i = 0; i < matrix2.length; i++) {
            for (int j = 0; j < matrix2[i].length; j++) {
                System.out.print(matrix2[i][j] + " ");
            }
            System.out.println();
        }
        
        // 不规则数组
        int[][] irregularArray = {
            {1},
            {2, 3},
            {4, 5, 6}
        };
        
        System.out.println("\n不规则数组:");
        for (int i = 0; i < irregularArray.length; i++) {
            for (int j = 0; j < irregularArray[i].length; j++) {
                System.out.print(irregularArray[i][j] + " ");
            }
            System.out.println();
        }
    }
}

4. 数组与方法的结合

public class ArrayWithMethods {
    
    // 方法接收数组作为参数
    public static void printArray(int[] arr) {
        System.out.print("数组元素: ");
        for (int num : arr) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
    
    // 方法返回数组
    public static int[] createArray(int size, int defaultValue) {
        int[] arr = new int[size];
        for (int i = 0; i < size; i++) {
            arr[i] = defaultValue;
        }
        return arr;
    }
    
    // 修改数组元素的方法
    public static void multiplyArray(int[] arr, int multiplier) {
        for (int i = 0; i < arr.length; i++) {
            arr[i] *= multiplier;
        }
    }
    
    // 查找数组中的最大值
    public static int findMax(int[] arr) {
        if (arr.length == 0) {
            throw new IllegalArgumentException("数组不能为空");
        }
        
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }
    
    // 数组排序（冒泡排序）
    public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 交换元素
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
    
    public static void main(String[] args) {
        int[] testArray = {5, 2, 8, 1, 9};
        
        System.out.println("原始数组:");
        printArray(testArray);
        
        System.out.println("最大值: " + findMax(testArray));
        
        multiplyArray(testArray, 2);
        System.out.println("乘以2后的数组:");
        printArray(testArray);
        
        bubbleSort(testArray);
        System.out.println("排序后的数组:");
        printArray(testArray);
        
        int[] newArray = createArray(5, 10);
        System.out.println("新创建的数组:");
        printArray(newArray);
    }
}

5. 数组工具类 Arrays

import java.util.Arrays;
import java.util.Scanner;

public class ArraysUtilityExample {
    
    public static void main(String[] args) {
        int[] numbers = {5, 2, 8, 1, 9, 3};
        
        // 数组排序
        Arrays.sort(numbers);
        System.out.println("排序后: " + Arrays.toString(numbers));
        
        // 二分查找（必须先排序）
        int index = Arrays.binarySearch(numbers, 8);
        System.out.println("元素8的索引: " + index);
        
        // 数组填充
        int[] filledArray = new int[5];
        Arrays.fill(filledArray, 7);
        System.out.println("填充后: " + Arrays.toString(filledArray));
        
        // 数组比较
        int[] arr1 = {1, 2, 3};
        int[] arr2 = {1, 2, 3};
        int[] arr3 = {1, 2, 4};
        
        System.out.println("arr1 equals arr2: " + Arrays.equals(arr1, arr2));
        System.out.println("arr1 equals arr3: " + Arrays.equals(arr1, arr3));
        
        // 数组复制
        int[] original = {1, 2, 3, 4, 5};
        int[] copy = Arrays.copyOf(original, 3); // 复制前3个元素
        System.out.println("复制后: " + Arrays.toString(copy));
        
        int[] rangeCopy = Arrays.copyOfRange(original, 1, 4); // 复制索引1到3
        System.out.println("范围复制: " + Arrays.toString(rangeCopy));
    }
}

综合示例

import java.util.Arrays;
import java.util.Scanner;

public class StudentGradeSystem {
    
    // 计算平均分
    public static double calculateAverage(int[] grades) {
        if (grades.length == 0) {
            return 0.0;
        }
        
        int sum = 0;
        for (int grade : grades) {
            sum += grade;
        }
        return (double) sum / grades.length;
    }
    
    // 查找最高分
    public static int findHighestGrade(int[] grades) {
        if (grades.length == 0) {
            return -1;
        }
        
        int max = grades[0];
        for (int i = 1; i < grades.length; i++) {
            if (grades[i] > max) {
                max = grades[i];
            }
        }
        return max;
    }
    
    // 统计及格人数
    public static int countPassingGrades(int[] grades, int passingGrade) {
        int count = 0;
        for (int grade : grades) {
            if (grade >= passingGrade) {
                count++;
            }
        }
        return count;
    }
    
    // 显示成绩统计
    public static void displayGradeStatistics(int[] grades) {
        System.out.println("成绩统计:");
        System.out.println("所有成绩: " + Arrays.toString(grades));
        System.out.println("平均分: " + calculateAverage(grades));
        System.out.println("最高分: " + findHighestGrade(grades));
        System.out.println("及格人数: " + countPassingGrades(grades, 60));
        
        // 成绩分布
        int[] distribution = new int[5]; // 0-59, 60-69, 70-79, 80-89, 90-100
        for (int grade : grades) {
            if (grade < 60) distribution[0]++;
            else if (grade < 70) distribution[1]++;
            else if (grade < 80) distribution[2]++;
            else if (grade < 90) distribution[3]++;
            else distribution[4]++;
        }
        
        System.out.println("\n成绩分布:");
        System.out.println("0-59: " + distribution[0] + "人");
        System.out.println("60-69: " + distribution[1] + "人");
        System.out.println("70-79: " + distribution[2] + "人");
        System.out.println("80-89: " + distribution[3] + "人");
        System.out.println("90-100: " + distribution[4] + "人");
    }
    
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.print("请输入学生人数: ");
        int studentCount = scanner.nextInt();
        
        int[] grades = new int[studentCount];
        
        System.out.println("请输入" + studentCount + "个学生的成绩:");
        for (int i = 0; i < studentCount; i++) {
            System.out.print("学生" + (i + 1) + "的成绩: ");
            grades[i] = scanner.nextInt();
        }
        
        displayGradeStatistics(grades);
        scanner.close();
    }
}

总结

  1. 方法：

    • 提高代码重用性和可读性

    • 支持方法重载（同名不同参）

    • 可以递归调用

  2. 数组：

    • 存储相同类型数据的集合

    • 长度固定，创建后不能改变

    • 支持多维数组

    • 与Collections框架相比更基础但性能更好

这些概念是Java编程的基础，熟练掌握后就可以为学习更复杂的数据结构和算法打下坚实基础了哦！！！

@.小泽
关注
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值