Java基础03-方法与数组

方法

方法的定义

在Java中,方法是一组执行特定任务的代码块。方法定义由以下几个部分组成:

修饰符 返回类型 方法名(参数列表) {
    // 方法体
}
  • 修饰符:指定方法的访问权限(public、private等)。
  • 返回类型:指定方法返回值的类型,如果方法不返回值,使用 void
  • 方法名:定义方法的名称。
  • 参数列表:定义方法接受的参数,可以有零个或多个。
  • 方法体:包含方法实际执行的代码块。

一个简单的例子:

public int add(int a, int b) {
    return a + b;
}

方法的形参与实参

  • 形参(形式参数):在方法定义中声明的变量,用于接收传递给方法的值。
  • 实参(实际参数):在方法调用时提供的具体值,赋给方法定义中的形参。

例如,在上述add方法中,ab就是形参,而在调用方法时传递给它的具体数字就是实参:

int result = add(3, 5); // 这里的3和5就是实参

方法的返回值

  • 返回值是方法执行后产生的结果,它的类型由方法定义时指定的返回类型决定。
  • 如果方法声明为 void,表示不返回任何值。
  • 使用 return 语句将值返回给调用方。

例如,在前面的add方法中,返回类型是int,并使用 return a + b; 返回计算结果。

方法的重载

  • 方法重载是指在同一个类中,可以有多个方法具有相同的名称,但参数列表不同。
  • 重载方法的参数类型、个数或顺序必须不同。
  • 编译器根据调用的方法和提供的参数来决定调用哪个重载版本。

例如:

public int add(int a, int b) {
    return a + b;
}

public double add(double a, double b) {
    return a + b;
}

这两个add方法是重载关系,一个接收整数,另一个接收双精度浮点数。

重载示例

public class BookManager {

    // 添加图书,接收图书名和作者
    public void addBook(String title, String author) {
        System.out.println("Added book: " + title + " by " + author);
        // 其他逻辑...
    }

    // 添加图书,接收图书名、作者和出版年份
    public void addBook(String title, String author, int year) {
        System.out.println("Added book: " + title + " by " + author + ", published in " + year);
        // 其他逻辑...
    }

    // 添加图书,接收图书名、作者、出版年份和ISBN号
    public void addBook(String title, String author, int year, String isbn) {
        System.out.println("Added book: " + title + " by " + author + ", published in " + year + ", ISBN: " + isbn);
        // 其他逻辑...
    }

    public static void main(String[] args) {
        BookManager bookManager = new BookManager();

        // 不同的方法版本,根据需要选择
        bookManager.addBook("The Catcher in the Rye", "J.D. Salinger");
        bookManager.addBook("To Kill a Mockingbird", "Harper Lee", 1960);
        bookManager.addBook("1984", "George Orwell", 1949, "978-0451524935");
    }
}

数组

数组的定义

  • 数组是一种存储相同类型数据的数据结构。在Java中,数组是对象,可以存储基本数据类型或对象。
  • 数组的定义包括声明和实例化两个步骤。

数组是引用类型,存在堆内存。

// 声明数组
数据类型[] 数组名;

// 实例化数组
数组名 = new 数据类型[数组长度];

例如,声明并实例化一个整数数组:

int[] numbers;
numbers = new int[5]; // 创建一个包含5个整数的数组

数组的四种赋值方式

  • 数组元素可以通过索引进行赋值。数组的索引从0开始,最大索引是数组长度减1。

  • 使用默认的初始值来初始化数组中的每一个元素:

    int[] scores = new int[3];
    

    在这种方式中,scores 数组被初始化为包含3个整数的数组,每个元素都会被赋予默认的初始值,对于整数数组来说,默认初始值是0。

  • 先声明,然后再赋予默认的初始值:

    int[] scores;
    scores = new int[3];
    

    这种方式将数组的声明和实例化分成两个步骤,同样,scores 数组被初始化为包含3个整数的数组,每个元素被赋予默认的初始值。

  1. 先声明,然后再使用指定的值进行初始化:

    int[] scores = new int[]{56, 78, 98};
    

    在这种方式中,数组的声明和初始化在一行完成,同时指定了每个元素的具体值。

  2. 简化的数组常量值赋值方式:

    int[] scores = {56, 78, 98};
    

    这种方式是对第三种方式的简化,Java 编译器会根据提供的常量值自动确定数组的长度。

数组的遍历

求数组的长度 arr.length

  • 使用循环结构(如for循环或while循环)可以遍历数组中的所有元素。
int[] numbers = {10, 20, 30, 40, 50};

// 使用for循环遍历数组
for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]);
}

// 使用增强for循环遍历数组(下面会详细介绍)
for (int num : numbers) {
    System.out.println(num);
}

增强for循环与可变参数:

  • Java 5及以上版本引入了增强for循环,用于简化数组和集合的遍历。
  • 可变参数(Varargs)是Java 5中引入的一种简化传递可变数量参数的语法。
// 增强for循环遍历数组
int[] numbers = {10, 20, 30};
for (int num : numbers) {
    System.out.println(num);
}

// 可变参数的方法
public static void printNumbers(int... nums) {
    for (int num : nums) {
        System.out.println(num);
    }
}

// 调用可变参数的方法
printNumbers(10, 20, 30, 40);

在增强for循环中,不需要使用索引,直接遍历数组中的每个元素。可变参数允许方法接受可变数量的参数,使得调用者在传递参数时更加灵活。在上面的例子中,printNumbers 方法可以接受任意数量的整数参数。

多维数组

二维数组

二维数组是数组的数组,每个元素都是一个一维数组。在 Java 中,你可以这样声明和初始化一个二维数组:

// 声明和初始化一个二维数组
int[][] twoDArray = new int[3][4];

// 或者
int[][] anotherTwoDArray = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };

上面的例子中,twoDArray 是一个 3x4 的二维数组,而 anotherTwoDArray 则是一个初始化后的 3x3 二维数组。

三维数组

同样,你可以创建三维数组:

// 声明和初始化一个三维数组
int[][][] threeDArray = new int[2][3][4];

// 或者
int[][][] anotherThreeDArray = { { {1, 2}, {3, 4}, {5, 6} }, { {7, 8}, {9, 10}, {11, 12} } };

上述代码中,threeDArray 是一个 2x3x4 的三维数组,anotherThreeDArray 是一个初始化后的 2x3x2 三维数组。

访问多维数组的元素

访问多维数组的元素需要使用相应的索引。例如,访问二维数组的元素:

int value = twoDArray[1][2]; // 获取第二行第三列的值

同样,对于三维数组:

int value = threeDArray[0][1][2]; // 获取第一个“块”中的第二行第三列的值

注意事项

  • 数组索引从0开始。
  • 多维数组的各维度的大小可以不同,但每个维度的大小在声明时必须确定。

算法

当涉及到排序算法和查找算法时,Java 提供了很多灵活的工具,但了解一些基本的排序算法和查找算法仍然是很有用的。以下是冒泡排序、选择排序、插入排序和二分查找的简要介绍:

冒泡排序(Bubble Sort)

冒泡排序是一种基础的排序算法,它重复地遍历数组,每次比较相邻的两个元素,如果它们的顺序错误就交换它们,直到整个数组有序。

public class BubbleSort {
    public static void bubbleSort(int[] array) {
        int n = array.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    // 交换array[j]和array[j+1]
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
}

选择排序(Selection Sort)

选择排序是一种简单直观的排序算法,每次找到数组中的最小元素并将其放在已排序部分的末尾。

public class SelectionSort {
    public static void selectionSort(int[] array) {
        int n = array.length;
        for (int i = 0; i < n - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < n; j++) {
                if (array[j] < array[minIndex]) {
                    minIndex = j;
                }
            }
            // 交换array[i]和array[minIndex]
            int temp = array[i];
            array[i] = array[minIndex];
            array[minIndex] = temp;
        }
    }
}

插入排序(Insertion Sort)

插入排序是一种简单直观的排序算法,通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。

public class InsertionSort {
    public static void insertionSort(int[] array) {
        int n = array.length;
        for (int i = 1; i < n; i++) {
            int key = array[i];
            int j = i - 1;
            while (j >= 0 && array[j] > key) {
                array[j + 1] = array[j];
                j--;
            }
            array[j + 1] = key;
        }
    }
}

二分查找(Binary Search)

二分查找是一种高效的查找算法,但要求数据是有序的。它通过将待查找区域缩小一半的方式快速定位目标元素。

public class BinarySearch {
    public static int binarySearch(int[] array, int target) {
        int low = 0;
        int high = array.length - 1;

        while (low <= high) {
            int mid = low + (high - low) / 2;

            if (array[mid] == target) {
                return mid; // 找到目标元素
            } else if (array[mid] < target) {
                low = mid + 1; // 在右半边继续搜索
            } else {
                high = mid - 1; // 在左半边继续搜索
            }
        }

        return -1; // 目标元素不在数组中
    }
}

这些算法是基础的排序和查找算法,理解它们有助于建立对算法的基本认识。在实际应用中,Java 的 Arrays 类提供了一些现成的排序算法,而查找算法可以使用 Arrays.binarySearch() 方法。

Arrays工具类

java.util.Arrays 类是 Java 标准库中提供的一个实用工具类,用于对数组进行各种常见操作,包括排序、搜索、比较等。这个类包含了大量的静态方法,使得数组处理更加方便和高效。以下是一些 Arrays 类的常用方法:

转换方法

  1. Arrays.toString() 方法用于返回指定数组的字符串表示形式。该方法将数组元素转换为字符串,并用逗号分隔,同时在数组的开头和结尾添加方括号。

    int[] arr = {1, 2, 3, 4, 5};
    String arrayString = Arrays.toString(arr);
    System.out.println(arrayString);
    
    [1, 2, 3, 4, 5]
    
    
  2. Arrays.asList() 方法用于将指定数组转换为一个固定大小的列表。

    import java.util.Arrays;
    import java.util.List;
    
    public class ArraysAsListExample {
        public static void main(String[] args) {
            // 创建一个数组
            String[] array = {"apple", "banana", "orange"};
    
            // 使用Arrays.asList()将数组转换为List
            List<String> list = Arrays.asList(array);
    
            // 输出List的内容
            System.out.println("List: " + list);
    
            // 修改数组,会影响到列表
            array[0] = "grape";
    
            // 输出修改后的List
            System.out.println("Modified List: " + list);
        }
    }
    
    List: [apple, banana, orange]
    Modified List: [grape, banana, orange]
    

排序方法

  1. sort(T[] array) 对数组进行升序排序。可以选择提供一个自定义的比较器。

    int[] arr = {3, 1, 4, 1, 5, 9, 2, 6};
    Arrays.sort(arr);
    
  2. parallelSort(T[] array) 类似于 sort 方法,但是可以在多线程环境中并行执行排序,提高性能。

    int[] arr = {3, 1, 4, 1, 5, 9, 2, 6};
    Arrays.parallelSort(arr);
    

操作数组元素的方法

  1. fill(T[] array, T val) 将数组的所有元素都设置为指定的值。

    int[] arr = new int[5];
    Arrays.fill(arr, 42);
    
  2. copyOf(T[] original, int newLength)
    copyOfRange(T[] original, int from, int to)
    用于复制数组的一部分或整个数组。

    int[] arr = {1, 2, 3, 4, 5};
    int[] copy = Arrays.copyOf(arr, arr.length);
    System.out.println("copy = " + Arrays.toString(copy));
    
    int[] copy1 = Arrays.copyOfRange(arr, 1, 3);
    System.out.println("copy1 = " + Arrays.toString(copy1));
    
    int[] destinationArray = new int[arr.length];
    System.arraycopy(arr, 0, destinationArray, 0, arr.length);
    System.out.println("destinationArray = " + Arrays.toString(destinationArray));
    
    
    copy = [1, 2, 3, 4, 5]
    copy1 = [2, 3]
    destinationArray = [1, 2, 3, 4, 5]
    

搜索方法

  1. binarySearch(T[] a, T key)binarySearch(T[] a, int fromIndex, int toIndex, T key) 使用二分查找算法在有序数组中搜索指定元素。

    int[] arr = {1, 2, 3, 4, 5};
    int index = Arrays.binarySearch(arr, 3);
    System.out.println("index = " + index);
    
    index = 2
    

比较方法

  1. equals(T[] a, T[] a2) 比较两个数组是否相等。

    int[] arr1 = {1, 2, 3};
    int[] arr2 = {1, 2, 3};
    boolean isEqual = Arrays.equals(arr1, arr2);
    System.out.println("isEqual = " + isEqual);
    
    isEqual = true
    
    
  2. deepEquals(Object[] a1, Object[] a2) 深度比较两个对象数组是否相等(适用于多维数组)。

    int[][] arr1 = {{1, 2}, {3, 4}};
    int[][] arr2 = {{1, 2}, {3, 4}};
    boolean isEqual = Arrays.deepEquals(arr1, arr2);
    System.out.println("isEqual = " + isEqual);
    
    isEqual = true
    
    

你可能感兴趣的:(#,Java基础,java,python,开发语言)