韩顺平零基础30天学会Java笔记（五）——数组

数组介绍

数组可以存放多个同一类型的数据。
数组也是一种数据类型，是引用类型。

数组的使用

double[] hens = {3, 5, 1, 3.4, 2, 50};
//double[] 表示这是一个double类型的数组

double sum = 0;
//遍历数组得到所有元素的和
for (int i=0; i<hens.length; i++){   //hens.length是数组的长度
	//下标从0开始编号,第一个元素是hens[0]
	System.out.println("第" + (i+1) + "个元素的值是" + hens[i]);
	sum += hems[i];
	System.out.println("总重量为" + sum + "，平均重量为" + (sum / hens.length));
}

使用方式1：动态初始化

1.数组的定义
数据类型 数组名[] = new 数据类型[大小]

int a[] = new int[5];  
//创建一个名字为a的数组，存放5个int类型元素

2.数组的引用（使用/访问/获取元素）
数组名[下标/索引]
a[2]表示使用a数组的第三个数

public static void main(String[] args) {
        double scores[] = new double[5];

        //输入
        Scanner sc = new Scanner(System.in);
        for (int i=0; i<scores.length; i++){
            System.out.print("请输入第" + (i+1) + "个元素的值:");
            scores[i] = sc.nextDouble();
        }

        //输出
        System.out.println("数组的元素为：");
        for (int j = 0; j<scores.length; j++){
            System.out.println("第" + (j+1) + "个元素的值为" + scores[j]);
        }
    }

使用方式2：动态初始化

1.声明数组
数据类型 数组名[];
或 数据类型[] 数组名；
2.创建数组
数组名 = new 数据类型[大小];

double scores[];  //声明数组，这时scores是NULL
scores = new double[5];  //分配内存空间

使用方式3：静态初始化

1.初始化数组
已知数组元素数量和具体值。
数据类型 数组名[] = {元素值，元素值…}
2.用法

int a[] = {1,2,3,4,5};
//相当于
//int a[] = new int[5];
//a[0] = 1;
//a[1] = 2;
//a[2] = 3;
//a[3] = 4;
//a[4] = 5;

数组的使用细节

1.数组是多个相同类型数据（或可以自动类型转换）的组合，实现对这些数据的统一管理。
2.数组的下标从0开始。
3.数组属于引用类型，数组型数据是对象（object）。
4.数组创建后如果没有赋值，会赋默认值：
int 0 | short 0
byte 0 | long 0
float 0 | double 0.0
char \u0000 | boolean false
String null

两个基础练习

1.创建一个char类型的26个元素的数组，分别放置A-Z，使用for循环访问所有元素并打印出来。

    public static void main(String[] args) {
        //创建一个数组放置A-Z并打印
        char[] chars = new char[26];
        for (int i=0; i<chars.length; i++){
            chars[i] = (char)('A' + i);
        }

        for (int i=0; i<chars.length; i++){
            System.out.print(chars);
        }
    }

2.求出一个数组int[]的最大值{4，-1，9，10，23}，并得到对应的下标。

    public static void main(String[] args) {
        //求出一个数组的最大值{4，-1，9，10，23}和对应的下标
        int[] arr = {4, -1, 9, 10, 23};
        int temp = 0;
        int index = 0;
        for (int i=0; i<arr.length; i++){
            if (arr[i] > temp){
                temp = arr[i];
                index = i;
            }
        }
        System.out.println("最大值为："+temp);
        System.out.println("最大值的下标为："+index);
    }

数组赋值机制

1.基本数据类型赋值，这个值就是具体的数据，而且相互不影响，赋值方式为值拷贝。
2.数组赋值在默认情况下是引用传递，赋的值是地址。

int n1 = 10;
        int n2 = n1;
        n2 = 80;
        System.out.println("n1:"+n1);  //10
        System.out.println("n2:"+n2);  //80

        int[] arr1 = {1, 2, 3};
        int[] arr2 = arr1;
        arr2[0] = 10;

        System.out.println("arr1:");
        for (int i=0; i<arr1.length; i++){
            System.out.println(arr1[i]);  //10  2  3
        }

3.对数组进行值拷贝，需要新创建一个数组，开辟新的数据空间

int[] arr1 = {1, 2, 3};
        int[] arr2 = new int[3];

        for (int i=0; i<arr2.length; i++){
            arr2[i] = arr1[i];
        }
        arr1[0] = 100;

        System.out.println("arr1为：");
        for (int i=0; i<arr1.length; i++){
            System.out.println(arr1[i]);  //100  2  3
        }

        System.out.println("arr2为：");
        for (int i=0; i<arr2.length; i++){
            System.out.println(arr2[i]);  //1  2  3
        }

数组反转

		int[] arr = {1, 2, 3, 4, 5, 6};
        int[] rearr = new int[6];

        //方法一
        for (int i=0; i<rearr.length; i++){
            rearr[i] = arr[(rearr.length-1)-i];
            System.out.println(rearr[i]);
        }


        //方法二
        for (int i=0; i<arr.length/2; i++){
            int temp = arr[arr.length-1-i];
            arr[arr.length-1-i] = arr[i];
            arr[i] = temp;
        }
        for (int i=0; i<arr.length; i++){
            System.out.println(arr[i]);
        }


		//方法三
        for (int i=arr.length-1, j=0; i>=0; i--, j++){
            //逆序遍历
            rearr[j] = arr[i];
        }
        arr = rearr;
        //让arr指向rearr数据空间
        // 此时arr原来的数据空间就没有变量引用了，会被销毁
        for (int i=0; i<arr.length; i++){
            System.out.println(arr[i]);
        }

数组扩容

实现动态地给数组添加元素，原始数组静态分配。

public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        Scanner sc = new Scanner(System.in);

        do{
            int[] newarr = new int[arr.length + 1];
            for (int i=0; i<arr.length; i++){
                newarr[i] = arr[i];
            }

            System.out.print("请输入你要添加进数组的数字：");
            int newint = sc.nextInt();
            newarr[newarr.length-1] = newint;
            arr = newarr;

            System.out.println("当前数组元素有：");
            for (int i=0; i<newarr.length; i++){
                System.out.print(newarr[i] + " ");
            }

            System.out.print("\n是否继续添加？(y/n)：");
            char yesno = sc.next().charAt(0);
            if (yesno == 'n'){
                System.out.println("退出程序。");
                break;
            }
        }while (true);

    }

数组缩减

将数组进行缩减，每次缩减最后一个元素，当只剩下一个元素时提示不能缩减。

public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        Scanner sc = new Scanner(System.in);

        System.out.println("当前数组元素有：");
        for (int i=0; i<arr.length; i++){
            System.out.print(arr[i]+" ");
        }

        do{
            System.out.println("\n正在删除最后一个元素......");
            int[] newarr = new int[arr.length-1];
            for (int i=0; i<newarr.length; i++){
                newarr[i] = arr[i];
            }
            arr = newarr;

            System.out.println("删除成功，当前数组元素有：");
            for (int i=0; i<newarr.length; i++){
                System.out.print(newarr[i]+" ");
            }

            System.out.print("\n是否继续删除？(y/n)：");
            char yesno = sc.next().charAt(0);
            if (yesno == 'n'){
                System.out.println("退出程序。");
                break;
            }else if (newarr.length == 1){
                System.out.println("数组只剩下最后一个元素，无法继续缩减。");
                break;
            }

        }while (true);
    }