快速通过Java基础细节内容（二）

4.方法

4.1 方法的基本格式

权限修饰符 是否静态 返回值类型 方法名(形式参数列表){ 方法体 }

核心: 形式参数列表，返回值类型

4.2 方法分类

有参数有返回值 
	最常用的模式，在开发中非常友好，方便代码操作

无参数无返回值
	一般为测试方法，展示方法，内置方法。
	
无参数有返回值
	生产者方法
	
有参数无返回值
	消费者方法

5.数组

5.1 数组解决的问题和尚未解决的问题

数组作为一个最为基础的整体性数据，可以用于存储
	1. 相同数据
	2. 多个数据元素

同时面临其他问题
	1. 数据类型支持不友好。
	2. 数组容量不可变。
	3. 数值配套方法少

5.2 数组基本格式

数据类型[] 数组名 = new 数据类型[容量];

数据类型
	明确当前数组存储数据类型，严格要求数据类型一致化[] 
	1. 当前创建的为数组类型
	2. 数组名为引用数据类型
数组名
	1. 操作数组使用的名称，存储当前数组占用内存空间【首地址】
	2. 数组名为引用数据类型
new 
	1. 根据当前数据所需，在内存的【堆区】申请所需的内存空间
	2. 对于当前内存空间中数据内容进行擦除操作。
数据类型
	前后一致，严格遵从数据类型一致化要求
[容量]
	1. 在 int 范围以内(0~Integer.MAX_VALUE - 8)
	2. 数组容量一旦确定，无法修改。

5.3 数组细节小问题

数组赋值数组问题

(main方法)
public static void main(String[] args) {
        int[] arr = new int[10];
        arr[5] = 10;

        int[] arr2 = new int[10];
        arr2[2] = 100;

        // 数组名是一个引用数据类型变量，可以进行赋值操作，赋值内容是【地址】
        arr = arr2;

        arr2[2] = 200;
        arr[5] = 100;

        System.out.println(arr[5]);//100
        System.out.println(arr[2]);//200
        System.out.println("-----------------------------");
        System.out.println(arr2[2]);//200
        System.out.println(arr2[5]);//100
    }

6.数组相关操作

6.1 典型案例：

指定数值中最大值元素所有对应下标位置，要求存储到另一个数组中

（使用尾插法，仅一个for循环解决此问题）

import java.util.Arrays;

public class demo {
    //指定数值中最大值元素所有对应下标位置，要求存储到另一个数组中
    /*
    int[] arr = {21, 21, 5, 21, 9, 21, 4, 6, 21, 10};
    其他数组:
    int[] indexArray = {0, 1, 3, 5, 8};
     */
    public static void main(String[] args) {
        int[] arr = {1, 13, 5, 21, 9, 21, 21, 6, 21, 10};
        int[] ints = new int[10];

        int count = getCount(arr, ints);

        System.out.println(count);
        //加一个limit截断
        Arrays.stream(ints).limit(count).forEach(System.out::print);

    }

    /**
     * 指定数值中最大值元素所有对应下标位置，要求存储到另一个数组中
     * @param arr 处时传入数组值
     * @param ints 相应新数组
     * @return 返回最大元素个数
     */
    public static int getCount(int[] arr, int[] ints) {
        int max = 0;
        int count = 0;
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > arr[max]){
                max = i;
                count = 0;
                ints[count++] = i;
            } else if (arr[i] == arr[max]) {
                ints[count++] = i;
            }
        }
        return count;
    }
}

从数组中指定下标开始，到指定下标结束，获取数据存储到新数组中

注意：该问题的细节问题，需要考虑下表内容是否合法，尾插法的应用

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

public class demo {
    //从数组中指定下标开始，到指定下标结束，获取数据存储到新数组中
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int[] arr = {21, 21, 5, 21, 9, 21, 4, 6, 21, 10};
        
        //指定下标值
        int start = scanner.nextInt();
        int end = scanner.nextInt();

        int[] ints = getInts(arr, start, end);

        System.out.println(Arrays.toString(ints));

    }

    public static int[] getInts(int[] arr, int start, int end) {
        if (start > end || start < 0 || end > arr.length-1){
            throw new IllegalArgumentException("输入数据不合法！！！");
        }

        int[] ints = new int[end - start];
        int count = 0;
        for (int i = start; i < end; i++) {
            ints[count++] = arr[i];
        }
        return ints;
    }
}

指定数组内容逆序

import java.util.Arrays;

public class demo {
    //指定数组内容逆序
    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};

        for (int i = 0; i < arr.length/2; i++) {
            int temp = arr[i];
            arr[i] = arr[arr.length - i -1];
            arr[arr.length - i -1] = temp;
        }

        System.out.println(Arrays.toString(arr));

    }
}

在数组指定下标位置添加或删除元素(注意考虑数据内容合法性)

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

public class demo {
    //在数组指定下标位置添加元素
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};

        System.out.println("输入指定元素值a:");
        int a = scanner.nextInt();
        System.out.println("输入指定元素插入的下标值b:");
        int b = scanner.nextInt();

        if (add(arr, a, b)){
            System.out.println(Arrays.toString(arr));
        }else {
            System.out.println("输入数据不合法！！！");
        }

        System.out.println(Arrays.toString(arr));

    }

    //添加元素方法
    public static boolean add(int[] arr, int a, int b) {
        if (b > arr.length - 1 || b < 0){
            return false;
        }

        for (int i = arr.length - 1; i > b; i--) {
            arr[i] = arr[i - 1];
        }
        arr[b] = a;
        return true;
    }
    
    //删除元素方法
    public static int remove(int[] arr, int k) {
        if (k < 0 || k > arr.length -1){
            throw new IllegalArgumentException("输入数据不合法！！！");
        }
        int temp = arr[k];
        for (int i = k; i < arr.length -1; i++) {
            arr[i] = arr[i + 1];
        }
        arr[arr.length - 1] = 0;
        return temp;
    }
    
}

6.2 选择排序

public class demo {
    //选择排序算法推演
    public static void main(String[] args) {
        int[] arr = {0, 21, 5, 21, 9, 21, 4, 6, 21, 10};

        for (int i = 0; i < arr.length; i++) {
            int min = i;
            for (int j = i; j < arr.length; j++) {
                if (arr[min] > arr[j]){
                    min = j;
                }
            }

            //此交换方法在此问题中交换存在安全隐患(会更改数组值)
			// arr[min]=arr[min]+arr[i];
			// arr[i]=arr[min]-arr[i];
			// arr[min]=arr[min]-arr[i];

            int t = arr[min];
            arr[min] = arr[i];
            arr[i] = t;
			
            //打印交换过程
            for (int j = 0; j < arr.length; j++) {
                System.out.print(arr[j] + " ");
            }
            
            System.out.println();
        }
    }
}

6.3 冒泡排序

public class demo {
    //冒泡排序演示
    public static void main(String[] args) {
        int[] arr = {2, 21, 5, 13, 9, 210, 4, 6, 23, 10};

        for (int i = 0; i < arr.length - 1; i++) {
            //注意j下标的范围j < arr.length - 1 - i (-1 为了防止数组下标越界)
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]){
                    arr[j] = arr[j + 1] + arr[j];
                    arr[j + 1] = arr[j] - arr[j + 1];
                    arr[j] = arr[j] - arr[j + 1];
                }
            }
            for (int j = 0; j < arr.length; j++) {
                System.out.print(arr[j] + " ");
            }
            System.out.println();
        }
    }
}

动图演示