数组

数组

1.数组的概念

数组可以看作是一个固定长度的容器，可以存储同种数据类型的多个值

• 创建了一个int类型的数组容器, 这个容器就只能存储int类型的数据

• 创建了一个double类型的数组容器, 这个容器就只能存储double类型的数据

  不可能出现的事 : 容器中同时存在, 小数和字符串.

2.数组的声明

2.1数组动态初始化

Java中的数组必须先初始化,然后才能使用

所谓初始化：就是在内存中，为数组容器开辟空间，并将数据存入容器中的过程。

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

示例：

int[] arr = new int[5];

等号左边：

• int:数组的数据类型

• []:代表这是一个数组

• arr:代表数组的名称

等号右边：

• new:为数组开辟内存空间

• int:数组的数据类型

• []:代表这是一个数组

• 5:代表数组的长度

注意 :

​ 打印数组名 , 出现的是数组在内存中的 【内存地址】

​ 例如：[I@10f87f48

2.2数组的静态初始化

静态初始化：初始化时，就可以指定数组要存储的元素，系统还会自动计算出该数组长度

静态初始化格式：

完整格式:

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

正确范例 :

 int[] arr = new int[]{11,22,33};

简化格式:

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

范例 :

int[] arr = {11,22,33};

注意 : 静态初始化的简化写法，一样会在堆内存中开辟空间并产生地址值.

2.3两种初始化的区别

• 动态初始化 : 手动指定长度, 由系统给出默认初始化值.
• 静态初始化 : 手动指定元素, 由系统计算出数组的长度.

动态初始化的应用场景：

[明确了数据的个数], 但是 [不明确数据具体的值], 就需要使用动态初始化.

 例：使用数组容器来存储键盘录入的5个整数
 int[] arr = {？？？？？};
 int[] arr = new int[5];

静态初始化的应用场景：

如果要操作的数值已经非常清楚了, 就使用静态初始化

例：将一班的学生成绩存入数组中  11，22，33
int[] arr = {11, 22, 33};

3.数组的元素访问

3.1什么是索引

每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。

这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。

3.2访问数组的元素格式

数组名[索引];

3.3示例代码

public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr = new int[3];

        //输出数组名
        System.out.println(arr); //[I@880ec60

        //输出数组中的元素
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

3.4默认化初始化值

• 整数类型 : 0
• 小数类型 : 0.0
• 字符类型 : ‘\u0000’ (空字符)
• 布尔类型 : false
• 引用数据类型 : null

4.数组常见问题

• 数组索引越界异常
  ArrayIndexOutofBoundsException :
  当访问了不存在的索引时 空指针异常 :
  NullPointerException :
  当一个变量不再记录地址值的时候, 还想去访问堆内存的数据.
  null：空值，引用数据类型的默认值，表示不指向任何有效对象

5.数组常见的操作

5.1数组的遍历

• 数组遍历：将数组中所有的内容取出来，取出来之后可以（打印，求和，判断…）

• 注意：遍历指的是取出数据的过程，不要局限的理解为，遍历就是打印！

• 获取数组长度的属性 : 数组名.length

• 遍历数组的通用格式 :

  int[] arr = {……};
  for(int i=0; i<arr.length; x++) {
  	arr[i]	 //对arr[i]进行操作
  }
  

5.2数组中获取最大值

• 需求: 从数组中查找最大值

  int[] arr = {12,45,98,73,60};
  

• 实现步骤:

  1. 假设数组中的第一个元素为最大值
  2. 遍历数组, 获取每一个元素, 准备进行比较
  3. 如果比较的过程中, 出现了比max更大的, 让max记录更大的值
  4. 循环结束后, 打印最大值.

• 代码实现:

  	public static void main(String[] args) {
          int[] arr = {12,45,98,73,60};
          // 1. 假设数组中的第一个元素为最大值
          int max = arr[0];
          // 2. 遍历数组, 获取每一个元素, 准备进行比较
          for(int i = 1; i < arr.length; i++){
          // 3. 如果比较的过程中, 出现了比max更大的, 让max记录更大的值
              if(arr[i] > max){
                  max = arr[i];
              }
          }
          //  4. 循环结束后, 打印最大值.
          System.out.println("max:" + max);
      }
  

5.3数组以[元素1，元素2，… ]形式输出打印

public static String printArrays(int[] arr){
    String str="[";  //字符串的开头
    for (int i = 0; i <arr.length ; i++) {
        if(i==arr.length-1){
            str+=arr[i]+"]";
        }else{
            str+=arr[i]+",";
        }
    }
   			 return str;
}

5.4数组元素排序（快速排序）

public class ArrayDemo06 {

public static void main(String[] args) {
    // 需求：{3, 7, 6, 9, 2, 1, 8} 请按照从小到大排序返回
    /*
        0. 前置条件，假设索引为 0 的数字最小
        1. 找到最小数的索引
        2. 将最小数移动至数组第一个索引
     */
    int[] arrNum = {3, 7, 6, 9, 2, 1, 8};

    // 选择排序
    for (int j = 0; j < arrNum.length - 1; j++) {
        // 0. 前置条件，假设索引为 0 的数字最小
        int minIndex = j;// 假设最小数的索引
        // 1. 找到最小数的索引
        for (int i = j + 1; i < arrNum.length; i++) {
            if (arrNum[i] < arrNum[minIndex]) {
                minIndex = i;// 找到了最小数的索引
            }
        }
        // 2. 将最小数移动至数组第一个索引
        int temp = arrNum[j];
        arrNum[j] = arrNum[minIndex];
        arrNum[minIndex] = temp;
    }
  System.out.println(ArraysUtil.printArrays(arrNum));
}

5.5数组常用工具类

public static void main(String[] args) {
    int[] arrNum = {3, 7, 6, 9, 2, 1, 8};
    // sort 排序 从小到大
    Arrays.sort(arrNum);
    // 将数据中的数据返回字符串
    System.out.println(Arrays.toString(arrNum));

    // 替换全部
    // Arrays.fill(arrNum, 50);
    // System.out.println(Arrays.toString(arrNum));
    // 替换区间
    Arrays.fill(arrNum, 2, 4, 100);// 左闭右开
    System.out.println(Arrays.toString(arrNum));

    // 拷贝数组指定拷贝的索引从0开始到newLength结束
    int[] result = Arrays.copyOf(arrNum, 5);
    System.out.println(Arrays.toString(result));
    result = Arrays.copyOfRange(arrNum, 2, 5);
    System.out.println(Arrays.toString(result));
}
}

6、二维数组

二维数组即数组的数组，二维数组中的每一个元素是一个个一维数组

抽象的理解为一个大的[]，里面有很多小的[]。

 public static void main(String[] args) {
        // 格式：数据类型[][] 数组变量名 = new 数据类型[][];
        // 1. 如何创建数组
        //int[][] arrs = new int[3][4];
    int[][] arrs = {{1, 2}, {5, 6, 7}, {9, 0, 1, 2}};
    // 2. 如何获取数组中的数据
    // 格式：数组变量名[索引][索引];
    int num = arrs[1][2];
    System.out.println("num = " + num);

    // 3. 如何给数组中对应的索引赋值？
    arrs[1][2] = 555;
    System.out.println(arrs[1][2]);

    // 4. 如何更方便的获取数组中的数据？
    for (int i = 0; i < arrs.length; i++) {
        for (int j = 0; j < arrs[i].length; j++) {
            System.out.println("arrs[" + i + "][" + j + "] = " + arrs[i][j]);
        }
        System.out.println("二维数组中的第" + (i+1) + "的数组的长度为：" + arrs[i].length);
    }
    // 5. 数组有一个属性可以直接获取到它的长度
    System.out.println("二维数组外层数组的长度为：" + arrs.length);
}
}

6.1数组的累加

public class ArrayDemo09 {
public static void main(String[] args) {
    // 需求：将数组中的所有数字进行累加
    int[] arr = {10, 20, 30, 40, 50};
    // 临时变量 sum
    int sum = 0;
    // 循环遍历数组累加
    for (int i = 0; i < arr.length; i++) {
        sum += arr[i];
    }
    System.out.println("总和为：" + sum);

    // 二维数组累加
    int[][] arr2 = {{1, 2}, {3, 4, 5}, {6, 7, 8, 9, 10}};
    // 两个临时变量
    int singleTotal = 0;
    int allTotal = 0;
    // 循环遍历数组累加
    for (int i = 0; i < arr2.length; i++) {
        for (int j = 0; j < arr2[i].length; j++) {
            singleTotal += arr2[i][j];
        }
        System.out.println("二维数组的第 " + (i + 1) + " 个数组的累加为：" + singleTotal);
        allTotal += singleTotal;
        singleTotal = 0;// 重置为 0 方便计算下一个数组
    }
    System.out.println("二维数组累加总和为：" + allTotal);
}
}