数组

1.数组

是相同数据类型的多个数据组成的一个集合.

2.定义语法

方案一:(数组的静态声明法)
注意:
1)数据中的每个数据称为元素,元素允许重复
2)元素的数据类型必须和数组类型一致
3)多个元素之前使用逗号隔开,最后一个元素后面的’,’可以省略

数据类型[] 标识符 = {数据1,数据2,数据3,...};
int[] arr01 = { -1, 2, 3, 412, 41, 1 };

方案二:(数组的动态声明法)

数据类型[] 标识符 = new 数据类型[数组长度];
//6是数组长度--当前数组允许存储元素最多的个数
int[] arr02 = new int[6];

方案三:(很少使用)

数据类型[] 标识符 = new 数据类型[]{数据1,数据2,数据3,...};
double[] arr = new double[] {12.3,421.1,2,1};

省略了数组的长度,数组长度通过后面{}里面元素的个数自行确定.

3.获取数组元素的值

语法:
数组的标识符[下标];
下标是一个整型数据,从0开始,最后一个元素下标是数组长度-1

char[] cc = { 'h', 'e', 'l', 'l','o' };
System.out.println(cc[0]);//h
System.out.println(cc[1]);//e
System.out.println(cc[2]);//l
System.out.println(cc[3]);//l
System.out.println(cc[4]);//o

如果下标是负数或者大于等于数组长度,会导致ArrayIndexOutOfBoundException错误.

4.数组的遍历

使用for循环访问数组元素—>数组的遍历
我们可以通过 数组变量.length 的方式获取数组的长度
注意:
1)循环变量i必须是整型;
2)i从0开始,最大到数组长度-1;
看见数组第一件事先写个for循环

5.数组遍历的简单方式(增强for循环)

语法:

for(数据类型 标识符 : 数组的名字){
//循环体中使用标识符去访问数据
}

数据类型必须和数组中存放的数据类型一致
注意:数组元素中没有全部赋值,未赋值的元素采用默认值:
整数 0
浮点 0.0
char ‘ ‘
String null
boolean false

相比for的区别:
1)forEach永远不会出现数组下标越界问题
2)forEach中循环变量i代表具体的元素,
for中循环变量i代表下标.
3)在需要用到数组下标的地方,forEach不如for好用

double[] arr = new double[5];
// 设置数组的初始值
arr[0] = 1.1;
arr[1] = 12.2;
arr[3] = 1;
//数组的遍历
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i] + " ");
}
// 只有一个条件
for (double number : arr) {
    // 使用number直接访问元素即可
    // number不是下标,是数组当前的元素
    System.out.println(number + " ");
}

6.冒泡排序(面试必问)

对一堆无序的数字进行排序的方案,

每一次比较相邻的两个元素(相邻比较),根据需要决定是否进行交换(合规交换)
每一轮比较交换完毕之后,总能把最值放到最后
下一轮比较时,之前的最值不再参与,剩下的元素按照规则比较,以此类推…
需要的轮数=元素的个数-1
每一轮中比较的次数=待比较的元素个数-1

public class BubbleSort {
    public static void main(String[] args) {
        // 定义数组存放所有的待排序数字
        int[] arr = { 3, 1, 5, 2, 6, 7, -1, 3, 9 };
        //外层循环处理好边界到length-1
        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 t = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = t;
                }
            }
        }
        for (int a : arr) {
            System.out.println(a);
        }
    }
}

7.选择排序(面试可能会问)

预先选择一个位置,假设该位置是最值,必须指定一个顺序(从前往后,从后往前).把后面所有的待比较的数和当前位置的数比较,合规之后使用第三方的index记录合规数值的位置(数组中元素的下标),等到最后一个元素比较完毕后,再进行交换.一次比较重,交换只发生一次
选择排序比冒泡排序效率高.

public class SelectSort {
    public static void main(String[] args) {
        int[] arr = { 3, 1, 5, 2, 6, 7, -1, 3, 9 };
        // 外层循环控制轮数
        for (int i = 0; i < arr.length - 1; i++) {
            // 假设的最小值
            int t = i;
            // 内层循环负责找到一个最小值放到从前面数第一个待排序的位置
            for (int j = i; j < arr.length - 1; j++) {
                // 如果记录比最小值arr[t]还小,更新t
                if (arr[t] > arr[j]) {
                    t = j;
                }
            }
            if (t != i) {
                int temp = arr[i];
                arr[i] = arr[t];
                arr[t] = temp;
            }
        }
        for (int a : arr) {
            System.out.println(a);
        }
    }
}

8.二维数组

类似于矩阵,用于手机硬件开发和设计,例如相机,指纹识别模块
在线选座,电影院等

8.1二维数组的定义

方案一: 数据类型\[\]\[\] 变量名 = {{},{},{}};

int[][] arr = { { 1, 2, 3 }, { 4, 5 }, { 12, 22, 33 } };

二维数组的每一个元素又是一个一维数组
方案二:
数据类型[][] 变量名 = new int[2][3];
[2][3] 是二维数组的长度,2是宽度,3是高度;
即这个二维数组一共有两个元素,每个元素都是一个一维数组,里面存放3个元素

int[][] arr1 = new int[3][4];
//给元素赋值
arr[0][0] = 12;
arr[0][1] = 13;
arr[0][2] = 11;

方案三:
数据类型[][] 变量名 = new 数据类型[][]{};

String[][] arr2 = new String[][] { { "如果", "有西瓜" }, { "我要吃", "雪糕", "喝可乐" } };

8.2二维数组的遍历

for(){
    //拆分出的每个数组
}

String[][] arr2 = new String[][] { { "如果", "有西瓜" }, { "我要吃", "雪糕", "喝可乐" } };
// 遍历
for (int i = 0; i < arr2.length; i++) {
    //获取里面的每一个元素--->是一个一维数组
    String[] innerArr = arr2[i];
    for(String s:innerArr) {
        System.out.print(s+" ");
    }
    System.out.println();
}