Java数组

什么是数组？

数组： 相同数据类型的有序集合， 一段连续的内存空间
结构：

数组的声明
数据类型[] 数组名; --> 推荐使用
数据类型 数组名[];
数组的初始化
动态初始化: 先创建数组对象,然后赋值
数据类型[] 数组名 = new 数据类型[长度];
数据类型: 任意的数据类型
数组中存放数据的类型
不同类型的数组每一个空间存在默认值:
整数:0 小数:0.0 布尔: false 字符:空字符 引用: null
静态初始化: 创建数组对象的同时赋值
数据类型[] 数组名 = new 数据类型[]{值1,值2,值3…};
数据类型[] 数组名 = {值1,值2,值3…};
数组的长度：数组名.length
索引|下标:
第一个空间: 0
最后一个空间 : 数组名.length-1

        // 声明
        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]);

数组的特点

1. 其长度是确定的。 数组一旦被创建，它的大小就是不可以改变的。
2. 其元素必须是相同类型,不允许出现混合类型。
3. 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
4. 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。

数组的优缺点

一、优点： 1、按照索引查询元素速度快；
2、能存储大量数据；
3、按照索引遍历数组方便；
4、数组定义简单，而且访问很方便；
5、可以随机访问其中的元素。
二、缺点：
1、根据内容查找元素速度慢；
2、数组的大小一经确定不能改变，不适合动态存储；
3、数组智能存储一种类型的数据；
4、增加、删除元素效率慢；
5、未封装任何方法，所有操作都需要用户自己定义；
6、数组的空间必须是连续的，这就造成数组在内存中分配空间时必须找到一块连续的内存空间。所以数组不可能定义的太大，因为内存中不可能有那么多大的连续的内存空间，而解决这个问题的方法就是使用链表。

数组的遍历

数组的遍历
普通for循环

       //普通for循环
        //变量控制数组的索引
        for(int i=0;i<=arr.length-1;i++){
            System.out.println(arr[i]);
        }

增强for循环
for(数据类型 变量名i:数组名|集合名){
每一次循环中,i代表数组中的每一个数据
}

//增强for循环
        for(int i:arr){
            System.out.println(i);
        }

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

二维数组

二维数组: 了解
数组中存放数组

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

//数据类型[][] 数组名 = 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]);

二维数组的遍历方式:

    1. 普通嵌套普通

//1.普通for循环
		for(int i = 0;i<arr.length;i++){  //数组的长度是三，每一个一维数组都是不规则的
			for(int j = 0;j<arr[i].length;j++){
				System.out.print(arr[i][j]+"\t");
			}
			System.out.println();
		}

    2. 普通嵌套增强 

//2.普通嵌套增强
        for(int i = 0;i<arr.length;i++){
            for(char ch:arr[i]){
                System.out.println(ch);
            }
        }

    3. 增强嵌套增强

//3. 增强嵌套增强
        for(char[] chars:arr){
            for(char ch:chars){
                System.out.println(ch);
            }
        }

    4. 增强嵌套普通

for(int [] b: arr){
			for(int j = 0;j<b.length;j++){
				System.out.print(b[j]+"\t");
			}
			System.out.println();
			
		}