JavaSE——01数组

数组：

数组就是用来存储一批同种类型数据的内存区域（可以理解成容器）。
例子

20, 10, 80, 60, 90
int[] arr = {20, 10, 80, 60, 90};

牛二, 西门, 全蛋
String[] names = {"牛二", "西门", "全蛋"}

一、静态初始化数组

数据类型【】 数组名=new 数据类型【】{元素1，元素2，元素3-----}
double[]  scores=new double[]{92,32,32,32,12,54,88};
int []  ages=new int[]{12,24,36}

数组的访问

数组名称【索引】
//取值
System.out.println(arr[0]);

//赋值
arr[2]=100;
System.out.println(arr[2]);

数组的长度属性：length

//获取数组的长度（就是数组元素的个数）
System.out.println(arr.length);//3

二、数组的动态初始化

定义数组的时候只确定元素的类型和数组的长度，之后再
存入具体数据

数组的动态初始化格式

数据类型[]  数组名=new 数据类型[长度]；
int[]  arr=new int[3];
//后赋值
arr[0]=10;
System.out.println(arr[0]);//10

两种数组的特点和场景使用
1 当前已知的元素值，用静态初始化
2 当前还不清楚要存入那些数据，用动态初始化

案例1：

package Day4;

import java.util.Random;
import java.util.Scanner;

public class ArrayDemo10 {
    public static void main(String[] args) {
//        动态数组存储数据
        int[] codes=new int[5];
//        定义一个循环，循环依次录入一个工号存入对应的位置
        Scanner sc=new Scanner(System.in);
        for (int i = 0; i < codes.length; i++) {
            System.out.println("请输入第"+(i+1)+"个员工的工号");
            int code=sc.nextInt();
//            存入数组中去
            codes[i]=code;
        }
//        遍历每个数组中的元素，然后随机一个索引出来，让该元素与随机索引位置处的元素值进行互换
        //codes=[12,24,46,34,23]
        Random r=new Random();
        for (int i = 0; i < codes.length; i++) {
            //当前遍历的元素值：codes[i]
            int index=r.nextInt(codes.length);
//            引入一个中间变量存储index位置处的值
            int temp=codes[index];
            codes[index]=codes[i];
            codes[i]=temp;
        }
        //遍历数组元素输出随机排名的结果
        for (int i = 0; i < codes.length; i++) {
            System.out.print(codes[i]+"\t");
        }
    }
}

冒泡排序：

每次从数组中找出最大值放在数组的后面去。
实现冒泡排序的关键步骤：

1. 确定总共需要做几轮：数组的长度-1
2. 每轮比较几次
   i(轮数) 次数 次数规律: 数组的长度 - i
   1 3
   2 2
   3 1
3. 当前位置大于后一个位置则交换数据
   

案例2：

package Day4;

public class Test5 {
    public static void main(String[] args) {
        // 1、定义一个数组，存储一些数据啊
        int[] arr = {5, 2, 3, 1};
        //           0  1  2  3

        // 2、定义一个循环控制比较的轮数
        for (int i = 0; i < arr.length - 1; i++) {
            // i == 0  比较的次数 3  j = 0 1 2
            // i == 1  比较的次数 2  j = 0 1
            // i == 2  比较的次数 1  j = 0
            // 3、定义一个循环控制每轮比较的次数，占位
            for (int j = 0; j < arr.length - i - 1; j++) {
                // 判断j当前位置的元素值 是否 大于后一个位置 若较大 则交换
                if(arr[j] > arr[j+1]) {
                    int temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                }
            }
        }

        // 遍历数组内容输出
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
    }
}

数组的异常问题：

package Day4;
//数组使用常见问题

public class ArrayDemo13 {
    public static void main(String[] args) {
        int[] arr={11,22,33};
        System.out.println(arr[2]);
        //问题1：访问元素位置超过最大索引，执行时会提示ArrayIndexOutOfBoundsException（数组越界异常）
//        System.out.println(arr[3]);
        //问题2，数组中没有存储数组的地址，而是null，访问数组信息时会出现

        //空指针异常NullPointerException
//        arr=null;
//        System.out.println(arr[1]);
        
    }
}