2021.07.12 Java学习笔记之数组

数组

        数组对于每个编程语言来说都是重要的数据结构之一，不过每个语言对于数组的实现以及处理也不相同。

        Java中提供的数组是用来存储固定大小的同类型元素。

        数组就是相同数据的有序集合，在内存中是一段连续的内存空间

        数组：

                1. 引用数据类型

                2. 长度一旦确定就不可以改变，

                3. 存储的多个数据要求数据类型保持一致

                4. 数组是有序的

 一维数组

        数组的长度获取（数组名.length:返回一个整形数据），数组的下标|索引是从零开始，从数组名.length-1结束

        数组的结构：

                数组的声明：

                        数据类型[ ][ ]  数组名；|  数据类型 数组名 [ ] [ ]

                数组的初始化： 

                        动态初始化 ：先创建对象，然后赋值

                                数据类型 [ ] 数组名 = new 数据类型 [长度];

                                数据类型：任意类型（可以是自己定义的引用数据类型）

                                                  数组中存放的数据类型必须一致

                                不同类型的数组的默认值：     

                                        整数：0         小数：0.0        布尔：false        字符型：空字符        引用数据类型：null     

                        静态初始化：创建数组对象的同时赋值

                                数据类型 [ ]  数组名 = new 数据类型 [ ] { 值1，值2，........值n}

                                数据类型 [ ]  数组名 = { 值1，值2，........值n}

                        在数组数据操作的时候索引容易出现的异常:

                                ArrayIndexOutOfBoundsException 数组索引越界异常

        数组的遍历

                1. 使用普通的for循环 

                2. 使用增强for循环

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

                 普通循环遍历操作的时索引，索引控制变化情况

                 增强for循环遍历数组，只能从前到后遍历

public class Test {
    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);
        }
    }
}

  1.将一个整型数组中的0去掉后但会一个新数组.
            例如: int[] arr={1,26,0,8,10,50,8,0,7,35,0,4,3,20,0,17};
            要求:将以上数组中的0去掉,将不为0的值存入一个新数组,生成新的数组作为返回值.
            int newArr={1,26,8,10,50,8,7,35,4,3,20,17};

 

public class Class005_ArrayPractice {
	public static void main(String[] args){
		int[] arr={1,26,0,8,10,50,8,0,7,35,0,4,3,20,0,17};

		print(checkZero(arr));

		System.out.println(find(arr,18));

	}


	public static int[] checkZero(int[] arr){
		//先找到不为0数据的的个数
		int count = 0;
		for(int i:arr){
			if(i!=0){
				count++;
			}
		}
		//当原数组中不存在0,直接返回值原数组
		if(count==arr.length){
			return arr;
		}

		//创建新数组
		int[] newArr = new int[count];

		//数组数据的拷贝
		int j = 0; //j为新数组的索引
		for(int i : arr){
			if(i!=0){
				newArr[j++] = i;
			}
		}

		//返回新数组
		return newArr;
	}

	/*2.数组元素查找(查找指定元素第一次在数组中出现的索引)
	 * 若存在:返回这个元素的下标
	 * 若不存在:返回-1
	 */
	public static int find(int[] arr,int value){
		for(int i=0;i<arr.length;i++){
			if(arr[i]==value){
				return i;
			}
		}
		return -1;
	}

	//遍历int类型数据的方法
	public static void print(int[] arr){
		for(int i:arr){
			System.out.println(i);
		}
	}

二维数组（了解）

        所谓二维数组就是在数组中存放数组 

 

 

        二维数组的声明：

                数据类型 [ ] [ ] 数组名           或者           数据类型   数组名  [ ] [ ]

                数据类型 [ ]  数组名 [ ]          或者           数据类型 [ ] [ ] 数组名

        二维数组的初始化：跟一维数组差不多，都分为动态初始化和静态初始化

                动态初始化： 先创建数组然后赋值

                        数据类型 [ ] [ ] 数组名 =  new 数据类型 [ 外层的二维长度] [ 内层的一维长度]

                                特点 ： 内层的每一个一维数组长度相同 

                         数据类型 [ ] [ ] 数组名 =  new 数据类型 [ 外层的二维长度] [  ]

                                特点 ：内层的每一个一维数组都没构建，长度有构建的时候指定，所以，内层的一维数组在构建的时候的创建方式就可以是一维数组的动态初始化或者静态初始化。

                静态初始化：创建的数组同时赋值

                        数据类型 [ ] [ ] 数组名 = new 数据类型 [ ] [ ]{{值1,值2,值...},{值1,值2,值...},{值1,值2,值...}....};

                         数据类型 [ ] [ ] 数组名 = {{值1,值2,值...},{值1,值2,值...},{值1,值2,值...}....};

       int[][] b={{11},{21,22},{31,32,33}};

        二维数组的遍历方式：

                        1. 普通嵌套普通
                        2. 普通嵌套增强
                        3. 增强嵌套增强
                        4. 增强嵌套普通

public class Class002_Array {
    public static void main(String[] args) {
        //静态初始化
        char[][] arr = new char[][]{{'a'},{'b','c'},{'d','e','f'}};


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

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

    }
}