Java入门Day6：数组

1. 数组的定义

• 数组是具有相同数据类型的数据的集合。
• 它们按照一定的顺序排列。
• 每个数据称作数组的一个元素，可以通过下标来访问它们。
• 下标从0开始，而不是从1开始。

2. 建立数组

• 1.声明一个数组，即告诉编译器，要建立一个数组，保证后续能进行内存调用。
• 2.创建一个实例数组，利用new运算符，调用内存来建立一个数组。

    public static void main(String[] args) {
        int[] nums; //声明，不提供内存
        int nums2[];//C和C++中的用法
        nums = new int[10];//可以存放10个int类型的数字
        nums[0]=1; //给数组中的元素赋值
        nums[1]=2;
        nums[2]=3;
        nums[3]=4;
        nums[4]=5;
        nums[5]=6;
        nums[6]=7;
        nums[7]=8;
        nums[8]=9;
        System.out.println(nums[0]);  //查询第0个元素
        System.out.println(nums[9]);  //没有赋值的元素，返回默认值
        System.out.println(nums.length);  //获取数组的长度
        int sum = 0;
        for (int i=0;i<nums.length;i++) {
            sum+=i;
        } //遍历数组中的元素并求和
        System.out.println(sum);
    }
}

• 通过下标，我们可以对数组中的元素赋值，也可以查询元素的值。
• 没有赋值的元素，会返回默认值，数字类型的默认值为0，字符类型为空，布尔值的默认值是false。

3.数组的三种初始化

3.1 静态初始化

• 在创建数组时，直接为数组中的元素赋值。

    public static void main(String[] args) {
        int[] nums = {1,2,3,4,5,6,7,8,9}; //数组的静态初始化
        System.out.println(nums[0]);
    }
}

3.2 动态初始化与默认初始化

• 创建数组时，不为元素赋值，只是指向一片内存空间，作为数组的内存，再单独为元素赋值。

    public static void main(String[] args) {
        int[] nums2 = new int[10]; //动态初始化
        nums[0]=6;//给0号元素赋值
        System.out.println(nums[0]);
    }

• 默认初始化，就是在创建数组时，没有赋值的元素，保持它数据类型的默认值。

没有赋值的元素，会返回默认值，数字类型的默认值为0，字符类型为空，布尔值的默认值是false。

4.数组的基本特点

• 数组的元素类型必须相同。
• 数组中的元素可以是任何类型。
• 数组的长度是确定的，一旦被创建，那么它的大小不可修改。
• 数组变量属于引用类型，数组本身就是对象，每个元素想到于对象的成员变量。
• 数组和所有的对象一样，存放在堆内存中。

5.数组的下标越界

我们知道数组的长度是确定的，一旦被创建，它的大小就不可修改了。那么当我们查询一个下标超过数组长度的元素，会发生下标越界。

public class Demo03 {
    public static void main(String[] args) {
        int nums[] = new int[9];
        System.out.println(nums[10]);
    }
}

可以发现，出现了下标越界的报错。

6.数组的使用

int[] arrs = {1,2,3,4,5};

• 打印数组中的元素

//打印全部元素
        for (int i = 0; i < arrs.length; i++) {
            System.out.println(arrs[i]);
        }

• 计算所有元素的和

//计算元素的和
		int sum = 0;
        for (int i = 0; i < arrs.length; i++) {
            sum+=arrs[i];
        }
        System.out.println(sum);

• 查找最大的元素

 //查找最大元素
        int max = 0;
        for (int i = 0; i <arrs.length ; i++) {
            if (arrs[i]>max){
                max = arrs[i];
            }
        }
        System.out.println(max);

• 增强型for循环-foreach循环

        for (int arr: arrs) {
            System.out.println(arr);
        }

可以用简单代码遍历整个数组，但是由于没有对下标进行标记，不能很好的利用下标操作数组。

• 作为方法的参数

 public static void main(String[] args) {
        int[] arrs = {1,2,3,4,5};
        test(arrs);
    }

    //数组作为方法的参数
    public static void test(int[] arrs){
        for (int arr:arrs) {
            System.out.println(arr);
        }
    }

• 作为方法的返回值

public static void main(String[] args) {
        int[] arrs = {1,2,3,4,5};
        test(arrs);
        test2(arrs);
    }

    //数组作为方法的参数
    public static void test(int[] arrs){
        for (int arr:arrs) {
            System.out.println(arr);
        }
    }
    //数组作为方法的返回值
    //反转数组
    public static void test2(int[] arrs){
        int[] abc= new int[5];
        for (int i = 0; i < arrs.length; i++) {
            abc[abc.length-i-1] = arrs[i];
        }
        test(abc);
    }

7.二维数组

• 数组中的元素本身也可以是一个数组。

 public static void main(String[] args) {
        int[][] arrs = {{1,2,3},{4,5,6},{7,8,9}};
        //输出二维数组
        for (int i = 0; i < arrs.length; i++) {
            System.out.println();
            for (int j = 0; j < arrs[i].length; j++) {
                System.out.print(arrs[i][j]);
            }
        }
    }

8.Arrays类讲解

• Arrays类似Java提供的一个工具类，他可以帮助我们快速对数组进行一些操作。
  打印数组并排序后再次打印``

 public static void main(String[] args) {
        int[] arrs = {1, 8, 98, 6, 7, 2, 76, 9, 2};
        System.out.println(Arrays.toString(arrs));  //Arrays类打印数组

        Arrays.sort(arrs);      //对数组进行排序

        System.out.println(Arrays.toString(arrs));
    }

我们通过Arrays.toString（）将数组以字符串的形式打印，又通过Arrays.sort()将数组进行排序。

9.冒泡排序

 public static void main(String[] args) {
        int[] arrs = {9,5,47,9,3,18,2,7,1,8};
        test(arrs);
    }

    public static void test(int[] arrs) {
        //交换中间变量
        int n = 0;
        for (int i = 0; i < arrs.length-1; i++) {
            for (int j = 0; j < arrs.length-1-i; j++) {
                if (arrs[j]>arrs[j+1]){
                    n = arrs[j+1];
                    arrs[j+1] = arrs[j];
                    arrs[j] = n;
                }
            }
        }
        System.out.println(Arrays.toString(arrs));
    }

冒泡排序是通过循环的嵌套，实现通过外部循环控制内部循环的次数；通过内部循环控制排序的结果，每一次内部循环完成，都将有一个最大数被确认。那么内部循环的次数等于数组的元素个数减一，就能完成排序，而这个次数正好是外部循环的次数。

今天学习时间有点长，也没有被打扰，效率很高，但是有点头晕眼花，休息，休息一下。