自学java的第五天

数组

一维数组

又偷懒一天服了，完全静不下心。

今天学习了一维数组的初始化：静态初始化和的动态初始化

例如：

public class index {
    public static void main(String[] args) {
        //静态初始化
        int[] arr = {11,22,33};
        //动态初始化
        int[] arr1 = new int[10];
    }
}

 数组是引用数据类型，创建数组时会在堆空间开辟空间用来存储数据。

注意：数组初始化时，数组里面的数据类型要一致，可以进行自动类型提升的会自动提升数据类型。

一维数组的遍历：

public class index {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

数据的数据的取出是根据索引，数据的索引是从0开始的有序的。

0	1	2	3	4	5
11	22	33	44	55	66

表格第一行表示索引，对应的第二行是存储的数据，通过：数组名[索引]来得到对应的数据

数组动态初始化例如：int[] arr1 = new int[6]

0	1	2	3	4	5
0	0	0	0	0	0

如上图所示：动态初始化就是开辟了6个空间，对应的默认值为0,可以通过数组名[索引] = 数值来进行赋值。

例如：

public class index {
    public static void main(String[] args) {
        int[] arr = new int[6];
        arr[1] = 12;
        arr[4] = 23;
        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        //结果为0 12 0 0 23 0 
    }
}

数组默认值：整数类型和char都为0.0，浮点类型为0.0，boolean类型为false,String类型为null

练习：数组的求和，反转，扩容，缩容。

import java.util.Scanner;

public class index {
    public static void main(String[] args) {
        //动态初始化数据
        int[] arr = new int[6];
        //键盘录入数据
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你要求和的数据");
        //遍历赋值
        for (int i = 0; i < arr.length; i++) {
            int count = sc.nextInt();
            arr[i] = count;
        }
        //求和
        //定义求和变量
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        //输出求和
        System.out.println("求和为:" + sum);

        System.out.println("*********************");
        //数组的反转
        //静态初始化数组
        int[] arr1 = {11,22,33,44,55,66};
        for (int i = 0; i < arr1.length / 2; i++) {
            int temp = arr1[i];
            arr1[i] = arr1[arr1.length - 1 - i];
            arr1[arr1.length - 1 - i] = temp;
        }
        //遍历输出
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i] + " ");
        }

        System.out.println("*********************");
        //扩容
        int[] arr2 = new int[arr1.length + 1];
        //缩容
        int[] arr3 = new int[arr1.length - 1];
    }
}

 练习：数组{11,22,33,44,55,66}，找到33，并且删除

方法一：

public class index {
    public static void main(String[] args) {
//        数组{11,22,33,44,55,66}，找到33，并且删除
        //方法一：不创建额外数组
        int[] arr = {11,22,33,44,55,66};
        //查找得到33对应的索引,并复制为0
        int index = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == 33){
                arr[i] = 0;
                index = i;
            }
        }
        //从当前索引开始，数据全部向前移动一位,不用判断最后一位，因为删除后多一位
        for (int i = index; i < arr.length - 1; i++) {
            arr[i] = arr[i + 1];
        }
        //最后一位赋值为0
        arr[arr.length - 1] = 0;
        //遍历输出,结果为11 22 44 55 66 0 
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

方法二：

public class index {
    public static void main(String[] args) {
//        数组{11,22,33,44,55,66}，找到33，并且删除
        //方法二：创建额外数组
        int[] arr = {11,22,33,44,55,66};
        //查找得到33对应的索引,并复制为0
        int index = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == 33){
                index = i;
            }
        }
        //创建缩容数组
        int[] arr1 = new int[arr.length - 1];
        //前半部分先赋值，从0到33对应的索引（不包括该索引）
        for (int i = 0; i < index; i++) {
            arr1[i] = arr[i];
        }
        //遍历后半部分，注意删除了33索引，就不用截取33了
        for (int i = index + 1; i < arr.length; i++) {
            //新数组还是从index开始的
            arr1[i - 1] = arr[i];
        }
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i] + " ");
        }
        //输出结果为11 22 44 55 66
    }
}