java详解 --- 数组

今天继续来说一下关于数组的问题.

一.数组练习

首先先来说一下关于数组的两个问题:
根据索引找元素和根据元素找索引.
1.根据索引找元素
(查表法)需求:封装一个函数,传入数字1 返回汉字一; 数字2 返回汉字二 ….
先根据需求封装一个函数

public static char findNumber(int a) {
        // 需要一个容器把中文数据保存一下
        char[] array = new char[]{"一","二","三","四","五","六","七"};
        // 按照传入的数组查找对应的值
        return array[a - 1]; 

    }

然后在main函数中输出

har rel = findNumber(4);
        System.out.println(rel);

得到结果

2.根据元素找索引
需求:定义一个数组,数组的值分别为3.6.11.22
在数组中查找11的位置
先封装一个函数

public static int findIndex(int array[] , int number) {
        // 定义一个索引 为了返回值
        // 如果索引的初值为0 当数组长度为零时会直接返回零
        // 这样会与数组下标真正为零时混淆
        // 所以定义初值为-1
        int index = -1;
        // 遍历数组,查找对应的索引
        for (int i = 0; i < array.length; i++) {
            // 如果值相等 就保存索引
            if (array[i] == number) {
                // return返回值
                // 这里已经把值返回了,相当于程序结束了
                // 后面再写代码就没有意义了
                index = i; // 保存查找出来的下标
                break;// 只要有相等的值 就停止循环
            }
        }
        // 把查找到的下标返回
        return index;
    }

在main函数中输出

int[] array = new int[] {3,6,11,22};
        int index = findIndex(array, 11);
        System.out.println(index);

得到结果

二.数组的反转

根据字面意思解释下就是说把原数组中的元素的位置进行改变 .
既然要改变元素位置,先来看看怎么改变其中两个元素的位置
1.需求:编写一个函数 交换两个数的值

public static void change(int a,int b) {
        int temp = 0;//定义空值存放数据
        temp = a;
        a = b;
        b = temp;
        System.out.println("a = " + a + " " + "b = " + b);

    }

在main函数中输出

public static void main(String[] args) {
change(3,4);
}

得到结果

2.反向输出数组
接下来就是怎么实现数组的反转了.下面给出实例:
需求:反响输出数组int[] array = new int[] {1,2,3,4,5,6};
计算的规律:
array[0] 和 array[array.length - 1 - 0]交换
array[1] 和 array[array.length - 1 - 1]交换
array[2] 和 array[array.length - 1 - 2]交换
–>
array[ i ] 和 array[array.length - 1 - i ]交换

int[] array = new int[] {1,2,3,4,5,6};
        // num 表示交换的次数 *重点*
        int num = array.length / 2;
        for (int i = 0; i < num; i++) {
            int temp = 0;
            temp = array[i];
            array[i] = array[array.length - 1 - i];
            array[array.length - 1 - i] = temp;
        }
        System.out.println(Arrays.toString(array));

输出结果

三.数组的排序

数组排序的方法有很多,我们主要说说冒泡排序和选择排序这两个.
1.冒泡排序
什么是冒泡排序呢?
冒泡排序是两个比较相邻的元素,如果第一个比第二个大,就交换它们俩位置下标.对每一个相邻元素作同样的工作，从开始第一对到结尾的最后一对.针对除了最后一个元素以外所有的元素重复以上的步骤,直到没有任何一对数组需要比较.
简单来说,冒泡排序的核心就是相邻两个数比较大小,交换位置.
以数组3 2 5 1为例:
根据冒泡排序的核心分析下怎么排序
分析:
原数: 3 2 5 1
第一次排序:
3 2 5 1 –> 2 3 5 1 –> 2 3 5 1 –> 2 3 1 5 确定一个数(把最大值放在最后面)
array.length - 1 - 0 –>没有确定数减0找规律
第二次排序:
2 3 1 5 –> 2 1 3 5 又确定一个数
array.length - 1 - 1–>确定一个数就少一个数
第三次排序:
2 1 3 5 –> 1 2 3 5 又确定一个数
array.length - 1 - 2–>确定两个数就少两个数
–>
array.length - 1 - i–>确定i个数就少i个数
根据以上分析,封装一个函数

public static void sort(int array[]) {
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                int temp = 0;
                temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(array));
    }

在main函数中输出

public static void main(String[] args) {

        int[] array = new int[] {2,3,5,1};
        // 传入的数组 相当于把数组的首地址传过去了
        // 注意:这里是地址的传递
        // 拿到地址 就可以随便更改数组元素的位置
        // 这时sort函数中 就是对原数组的操作
        sort(array);

输出结果

2.选择排序
选择排序是首先在未排序序列中找到最小元素,存放到排序列的起始位置,然后,再从剩余未排序元素中继续寻找最小元素,然后放到排序序列的末尾. 以此类推,直到所有元素均排序完毕
简单来说,选择排序的核心是选择一个数与下一个数进行比较(用这个数和数组中的每一个数进行比较). 一般来说,就选数组下标第0个数交换位置
同样以3 2 5 1为例:

int[] array = new int[] {3,2,5,1};
        // 外循环 -1 --> 最后一个数不用比较
        // 内循环 j 的初始值要从1开始
        // 因为array[0] 和 array[0]不用比较
        // 内循环 +i --> 每一趟比较确定一个数
        // 也就是说每次都可以少比一个数
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 1 + i; j < array.length; j++) {
                if (array[j] < array[i]) {
                    /*
                     * 分析: 谁 和 谁进行交换
                     * array[i] 和 array[j]进行比较并换位
                     * array[j] 每一个数
                     * array[i] 确定一个数
                    */
                    int temp = array[j];
                    array[j] = array[i];
                    array[i] = temp;    
                }
            }
        }
        System.out.println(Arrays.toString(array));

输出结果

但实际上日常的开发中,我们都是优先使用系统给出的数组排序方法,系统给你的方法肯定比你自己写的好:

int[] array = new int[] {7,5,10,56,3,18};
        // 该方法没有返回值 实际上这个方法操作的是原数组
        Arrays.sort(array); // -->数组排序
        System.out.println(Arrays.toString(array));

得到结果

四.二维数组

二维数组说白了就和一维数组一样,也是容器,保存的是多个一维数组并且是相同类型的一维数组.
声明方式和一维数组一样,主要的声明方式是:
数据类型[][] 数组名 = 初值;
声明方式也是两种:
1.声明方法一:

        // 声明了有两个一维数组 并且每个一维数组中是三个元素的二维数组
        // 注意:声明时需要把它有几个一维数组声明出来
        // 声明方式一:
        /*int[][] array = new int[2][3];
        array[0][0] = 8;
        System.out.println(array[0][0]);*/

2.声明方式二:

int[][] array = new int[][]{
            {1,2,3,4}, // array[0].length
            {2,5,8,0}, // array[1].length
            {1,3,1,4}, // array[2].length
        };

3.遍历二维数组
二维数组和一维数组一样,也是有遍历的:

int[][] array = new int[][]{
            {1,2,3,4}, // array[0].length
            {2,5,8,0}, // array[1].length
            {1,3,1,4}, // array[2].length
        };
        // array.length 二维数组的长度指的是 有几个一维数组 
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }

输出结果