2021-07-12

数组

变量: 存储单个数据
数组: 存储多个数据
索引（下标）:
第一个空间: 0
最后一个空间 : 数组名.length-1
数组的长度:
数组名.length
操作数组中的数据:
数组名[索引|下标]->确定数组中的某一块空间操作空间中的数据内容

Java 语言中提供的数组是用来存储固定大小的同类型元素。
数组是一组相同数据类型元素的集合。在Java中数组属于引用类型，即数组是一个对象。这里的数据类型不仅含八大基本数据类型，还包含引用数据类型，如数组里面可以存数组,数组里面可以存放字符串。

1. 数组的特点。

1. 其长度是确定的，数组一旦被创建，其长度就不可变
2. 其元素必须是相同的类型，不可出现混合的类型
3. 数组中的元素可以是任何数据类型，包括基本类型和引用类型
4. 数组变量属于引用类型，数组也可以看作是对象，数组中的每个元素相当于该对象的成员变量。
5. 数组本身就是对象，Java中的对象在堆中，因此数组无论保存原始类型还是其他对象类型，数组本身是在堆中的。

2. 数组的优缺点
   优点：

1. 按照索引查询元素速度快
2. 能存储大量数据
3. 按照索引遍历数组方便
   缺点：
4. 根据内容查找 元素速度慢
5. 数组的大小一经确定不能改变
6. 数组只能存储一种类型的数据
7. 增加、删除元素效率慢
8. 未封闭任何方法，所有操作都需要用户自己定义

一维数组

结构 ：
数组的声明
数据类型[] 数组名; --> 推荐
数据类型 数组名[];

数组的初始化
动态初始化: 先创建数组对象,然后赋值
数据类型[] 数组名 = new 数据类型[长度];
数据类型: 任意的数据类型
数组中存放数据的类型

           		 **不同类型的数组每一个空间存在默认值:
                整数:0   小数:0.0  布尔: false 字符:空字符  引用: null**

        静态初始化: 创建数组对象的同时赋值
            数据类型[]  数组名 = new 数据类型[]{值1,值2,值3...};
            数据类型[]  数组名 = {值1,值2,值3...};

public static void main(String[] args) {
// 声明
int[] arr1;
double arr2[];
//动态初始化
arr1 = new int[3];
arr2 = new double[5];
//为数组赋值
arr1[0] = 100;
arr1[1] = 101;
arr1[2] = 102;
//获取数组中的数据
System.out.println(arr1[0]);
System.out.println(arr1[1]);
System.out.println(arr1[2]);
//静态初始化
String[] arr3 = new String[]{“张三”,“李四”,“王五”,“赵六”};
System.out.println(arr3[0]);
System.out.println(arr3[1]);
System.out.println(arr3[2]);
System.out.println(arr3[3]);
//System.out.println(arr3[4]);
char[] arr4 = {‘a’,‘b’,‘c’};
System.out.println(arr4[0]);
System.out.println(arr4[1]);
System.out.println(arr4[2]);
System.out.println(arr4.length);
/数组中的最后一个数据/
System.out.println(arr4[arr4.length-1]);
}

二维数组

数组中存放数组
声明：
		数据类型[][] 数组名;   -->推荐
        数据类型 数组名[][];
        数据类型[] 数组名[];
        数据类型 [][]数组名;

初始化：
动态初始化 : 先创建数组然后赋值
数据类型[][] 数组名 = new 数据类型[外层的二维的长度][内层的一维的长度];
特点: 内层的每一个一维数组长度相同
数据类型[][] 数组名 = new 数据类型[外层的二维的长度][];
特点: 内层的每一个一维数组没有构建,长度有构建的时候指定
内层的每一个一维数组的创建按照一维数组的创建方式(动态,静态)
静态初始化 : 创建数组的同时赋值
数据类型[][] 数组名 = new 数据类型[][]{{值1,值2,值…},{值1,值2,值…},{值1,值2,值…}…};
数据类型[][] 数组名 = {{值1,值2,值…},{值1,值2,值…},{值1,值2,值…}…};

    操作二维数组中的数据
        数组名[外层二维索引][内层一维的索引]

public static void main(String[] args) {
    //动态
    //数据类型[][] 数组名 = new 数据类型[外层的二维的长度][内层的一维的长度];
    int[][] arr1 = new int[2][3];
    //赋值
    arr1[0][0] = 1;
    arr1[0][1] = 2;
    arr1[0][2] = 3;
    arr1[1][0] = 4;
    arr1[1][1] = 5;
    arr1[1][2] = 6;
    System.out.println(arr1[0][0]);
    System.out.println(arr1[0][1]);
    System.out.println(arr1[0][2]);
    System.out.println(arr1[1][0]);
    System.out.println(arr1[1][1]);
    System.out.println(arr1[1][2]);
    //数据类型[][] 数组名 = new 数据类型[外层的二维的长度][];
    double arr2[][] = new double[2][];
    //构建每一个一维数组
    arr2[0] = new double[3];
    arr2[0][0] = 1.1;
    arr2[0][1] = 2.2;
    arr2[0][2] = 3.3;
    arr2[1] = new double[]{3.3,4.4};
    System.out.println(arr2[0][0]);
    System.out.println(arr2[0][1]);
    System.out.println(arr2[0][2]);
    System.out.println(arr2[1][0]);
    System.out.println(arr2[1][1]);
    //静态初始化
    char[][] arr3 = new char[][]{{'a'},{'b','c'},{'d','e','f'}};
    System.out.println(arr3[0][0]);
    System.out.println(arr3[1][0]);
    System.out.println(arr3[1][1]);
    System.out.println(arr3[2][0]);
    System.out.println(arr3[2][1]);
    System.out.println(arr3[2][2]);
    System.out.println(arr3.length);
}

数组的遍历：
1.普通for循环
2.增强for循环|for…each
for(数据类型 变量名i:数组名|集合名){
每一次循环中,i代表数组中的每一个数据
}

 **注意:
    普通循环遍历操作索引,索引控制变化情况
    增强for循环遍历数组,只能从前到后遍历**

public static void main(String[] args) {
   int[] arr = {1,2,3,4};
   //普通for循环
    //变量控制数组的索引
    for(int i=0;i<=arr.length-1;i++){
        System.out.println(arr[i]);
    }
    //增强for循环
    for(int i:arr){
        System.out.println(i);
    }
}