JavaSE-4方法递归数组

皮革院长干测开

已于 2025-07-13 11:04:57 修改

阅读量499

点赞数 10

CC 4.0 BY-SA版权

文章标签： java 开发语言

于 2025-03-03 18:22:59 首次发布

本文链接：https://blog.csdn.net/2401_83117850/article/details/145825175

一、方法

public static 返回值类型方法名{

方法体；

}

1）修饰符：public static

2）形参返回值类型和实参返回值类型一致

3）方法名字：小驼峰

4）参数列表：如果方法没有参数就不写，需要指定参数类型，多个参数之间用逗号隔开。

5）方法必须写在类当中

6）方法不能嵌套定义：不能在一个方法的内部再定义另一个完整的方法

7）没有方法声明一说

二、方法调用怎样开辟栈帧的

当方法函数结束（大括号结束或者return结束）为调用的方法创建的栈帧将会回收

三、方法重载

一个必须一样（方法名）、一个必须不一样（参数）、一个不做要求（返回值）

四、递归

如果是void无返回值，则“归”以大括号结束来往回传递；

若是int这样有返回值，则“归”以return结束来往回传递；

递归过程就是先调用方法函数创建栈帧连续压栈，然后走到结束判断那一步再连续出栈。

斐波那契数列递归画成图是树形，有大量重复计算，效率不高。

具体题目已上传码云

五、数组

1. 基本数据类型数组

整数类型（byte、short、int、long）：默认值为 0。
浮点类型（float、double）：默认值为 0.0。
字符类型（char）：默认值为 '\u0000'，即空字符。
布尔类型（boolean）：默认值为 false。

2. 引用数据类型数组

引用数据类型数组的元素默认值为 null，表示不引用任何对象。

1. 先看 `func1` 的情况

传递本质：main 里的 array（实参）是引用，存着指向 {1,2,3,4} 数组的地址（比如图里的 0x13 ），调用 func1 时，会把这个地址拷贝一份给 func1 的形参 array ，此时形参和实参指向同一块堆内存 。
形参操作：但 func1 里执行 array = new int[10] ，这是让形参自己重新指向了一块新的堆内存（比如图里的 0x98 ）。这一步操作只改变了形参的指向，和 main 里实参 array 的指向（仍为 0x13 ）无关。所以执行完 func1 ，main 里的 array 指向没变化，打印还是 {1,2,3,4} 。

2. 再看 `func2` 的情况

传递本质：同样，调用 func2 时，main 里 array 的地址（0x13 ）拷贝给 func2 的形参 array ，形参和实参共享同一块堆内存的指向 。
形参操作：func2 里执行 array[0] = 99 ，这是通过形参的引用，直接操作了堆内存里数组的内容 。因为形参和实参指向的是同一块堆里的数组（{1,2,3,4} 所在的内存），所以堆里数组内容被修改后，main 里实参 array 再访问这块堆内存，拿到的就是修改后的数据（{99,2,3,4} ），打印结果就变了。

重点，数组的创建和初始化必须一步呵成，不然会报错

六、数组字符串

1. 使用 `Arrays.toString()` 方法（适用于基本数据类型数组和对象数组）

import java.util.Arrays;

public class ArrayToStringExample {
    public static void main(String[] args) {
        // 基本数据类型数组
        int[] intArray = {1, 2, 3, 4, 5};
        String intArrayString = Arrays.toString(intArray);
        System.out.println("基本数据类型数组转换结果: " + intArrayString);

        // 对象数组
        String[] stringArray = {"apple", "banana", "cherry"};
        String stringArrayString = Arrays.toString(stringArray);
        System.out.println("对象数组转换结果: " + stringArrayString);
    }
}

2. 多维数组使用 `Arrays.deepToString()` 方法

import java.util.Arrays;

public class MultiDimensionalArrayToStringExample {
    public static void main(String[] args) {
        int[][] multiArray = {{1, 2}, {3, 4}, {5, 6}};
        String result = Arrays.deepToString(multiArray);
        System.out.println("多维数组转换结果: " + result);
    }
}

方法名称格式均采用小驼峰，即第一个单词首字母小写其他单词首字母大写。

七、数组拷贝

1. 手动遍历拷贝

public class ManualCopyExample {
    public static void main(String[] args) {
        int[] originalArray = {1, 2, 3, 4, 5};
        int[] copiedArray = new int[originalArray.length];

        for (int i = 0; i < originalArray.length; i++) {
            copiedArray[i] = originalArray[i];
        }

        // 验证拷贝结果
        for (int num : copiedArray) {
            System.out.print(num + " ");
        }
    }
}

2. 使用 `System.arraycopy()` 方法

System.arraycopy() 是 Java 提供的一个高效的数组拷贝方法，它是一个本地方法native（查看源码时看不到具体的实现），底层由 C 或 C++ 实现。

public class SystemArrayCopyExample {
    public static void main(String[] args) {
        int[] originalArray = {1, 2, 3, 4, 5};
        int[] copiedArray = new int[originalArray.length];

        // 参数解释：原数组, 原数组起始位置, 目标数组, 目标数组起始位置, 要复制的元素个数
        System.arraycopy(originalArray, 0, copiedArray, 0, originalArray.length);

        // 验证拷贝结果
        for (int num : copiedArray) {
            System.out.print(num + " ");
        }
    }
}

3. 使用 `Arrays.copyOf()` 方法

Arrays.copyOf() 是 java.util.Arrays 类提供的一个静态方法，它可以创建一个新数组，并将原数组的元素复制到新数组中。

import java.util.Arrays;

public class ArraysCopyOfExample {
    public static void main(String[] args) {
        int[] originalArray = {1, 2, 3, 4, 5};
        int[] copiedArray = Arrays.copyOf(originalArray, originalArray.length);

        // 验证拷贝结果
        for (int num : copiedArray) {
            System.out.print(num + " ");
        }
    }
}

Arrays.copyOf() 方法接受两个参数，原数组和新数组的长度。如果新数组长度大于原数组长度，会用默认值填充剩余部分；如果小于原数组长度，则只复制前一部分元素。

4. 使用 `clone()` 方法

数组对象可以调用 clone() 方法来创建一个新的数组，该数组包含与原数组相同的元素。

public class CloneExample {
    public static void main(String[] args) {
        int[] originalArray = {1, 2, 3, 4, 5};
        int[] copiedArray = originalArray.clone();

        // 验证拷贝结果
        for (int num : copiedArray) {
            System.out.print(num + " ");
        }
    }
}

clone() 方法会创建一个新的数组对象，新数组的元素与原数组相同。对于基本数据类型数组，这是一种浅拷贝；对于对象数组，同样是浅拷贝，即只复制对象的引用，而不是对象本身。

浅拷贝和深拷贝的区别

浅拷贝：只复制对象的引用，而不复制对象本身。对于基本数据类型数组，浅拷贝会复制元素的值；对于对象数组，浅拷贝只会复制对象的引用，多个引用指向同一个对象。
深拷贝：会创建一个新的对象，而不是复制引用。对于对象数组的深拷贝，需要手动复制每个对象，而不是仅仅复制引用。

例如，对于对象数组的深拷贝，需要在拷贝过程中为每个对象创建新的实例：

import java.util.Arrays;

class Person {
    String name;

    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return name;
    }
}

public class DeepCopyExample {
    public static void main(String[] args) {
        Person[] originalArray = {new Person("Alice"), new Person("Bob")};
        Person[] copiedArray = new Person[originalArray.length];

        for (int i = 0; i < originalArray.length; i++) {
            copiedArray[i] = new Person(originalArray[i].name);
        }

        // 修改原数组中的元素
        originalArray[0].name = "Charlie";

        // 验证深拷贝结果
        System.out.println(Arrays.toString(copiedArray));
    }
}

在这个示例中，通过手动为每个 Person 对象创建新的实例，实现了对象数组的深拷贝。修改原数组中的元素不会影响到拷贝数组中的元素。

八、二维数组

九、操作数组的工具类Arrays

在 Java 中，java.util.Arrays 是一个非常实用的工具类，它提供了一系列静态方法用于操作数组，涵盖数组的排序、查找、填充、比较等多种功能。

1. 数组排序

sort() 方法：用于对数组进行排序，有多种重载形式，可以对不同类型的数组（如 int、double、char 等）进行升序排序，也可以指定排序的范围。

import java.util.Arrays;

public class ArraysSortExample {
    public static void main(String[] args) {
        int[] arr = {5, 2, 8, 1, 9};
        // 对整个数组进行排序
        Arrays.sort(arr);
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

parallelSort() 方法：在 Java 8 及以后版本中引入，用于并行排序，当数组长度较大时，使用该方法可以提高排序性能。

import java.util.Arrays;

public class ArraysParallelSortExample {
    public static void main(String[] args) {
        int[] arr = {5, 2, 8, 1, 9};
        // 并行排序
        Arrays.parallelSort(arr);
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

2. 数组查找

binarySearch() 方法：用于在已排序的数组中进行二分查找，返回指定元素的索引。如果元素不存在，则返回一个负数。

import java.util.Arrays;

public class ArraysBinarySearchExample {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        // 查找元素 3 的索引
        int index = Arrays.binarySearch(arr, 3);
        System.out.println("元素 3 的索引是: " + index);
    }
}

3. 数组填充

fill() 方法：用于将指定的值填充到数组的每个元素中，也可以指定填充的范围。

import java.util.Arrays;

public class ArraysFillExample {
    public static void main(String[] args) {
        int[] arr = new int[5];
        // 将数组的所有元素填充为 10
        Arrays.fill(arr, 10);
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

4. 数组比较

equals() 方法：用于比较两个数组是否相等，即数组的长度和对应位置的元素都相等。

import java.util.Arrays;

public class ArraysEqualsExample {
    public static void main(String[] args) {
        int[] arr1 = {1, 2, 3};
        int[] arr2 = {1, 2, 3};
        // 比较两个数组是否相等
        boolean isEqual = Arrays.equals(arr1, arr2);
        System.out.println("两个数组是否相等: " + isEqual);
    }
}

5. 数组转换为字符串

toString() 方法：用于将数组转换为字符串，方便输出数组的内容。

import java.util.Arrays;

public class ArraysToStringExample {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        // 将数组转换为字符串
        String str = Arrays.toString(arr);
        System.out.println("数组转换为字符串: " + str);
    }
}

6. 数组复制

copyOf() 方法：用于复制数组，可以指定复制的长度。如果指定的长度大于原数组的长度，会在新数组的末尾填充默认值；如果指定的长度小于原数组的长度，则会截取原数组的前部分元素。

import java.util.Arrays;

public class ArraysCopyOfExample {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        // 复制数组，指定新数组的长度为 5
        int[] newArr = Arrays.copyOf(arr, 5);
        for (int num : newArr) {
            System.out.print(num + " ");
        }
    }
}