03-java数组的使用

概念

数组就是存储数据长度固定的容器，存储多个数据的数据类型要一致。

数组的定义格式

// 第一种格式
// 数据类型[] 数组名
int[] arr;        
double[] arr;      
char[] arr;

// 第二种格式
// 数据类型 数组名[]
int arr[];
double arr[];
char arr[];

数组的动态初始化

什么是动态初始化

数组动态初始化就是只给定数组的长度，由系统给出默认初始化值

动态初始化格式

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

动态初始化格式详解

• 等号左边：

  • int:数组的数据类型

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

  • arr:代表数组的名称

• 等号右边：

  • new:为数组开辟内存空间
  • int:数组的数据类型
  • []:代表这是一个数组
  • 5:代表数组的长度

代码 :

package com.itheima.array;

public class Demo2Array {
    
    
    /*
        数组的动态初始化:
            在初始化的时候, 需要手动指定数组的长度, 系统会为数组容器分配初始值.

        动态初始化格式:
            数据类型[] 数组名 = new 数据类型[数组的长度];

        注意:
            打印数组变量的时候, 会打印出数组的内存地址

        [I@10f87f48 :
                        @ : 分隔符
                        [ : 当前的空间是一个数组类型
                        I : 当前数组容器中所存储的数据类型
                        10f87f48 : 十六进制内存地址
                                0 1 2 3 4 5 6 7 8 9 a b c d e f
     */
    public static void main(String[] args) {
    
    
        // 数据类型[] 数组名 = new 数据类型[数组的长度];
        // 通过new关键字创建了一个int类型的数组容器, 该容器可以存储5个int类型的整数, 该容器被arr数组变量所记录
        int[] arr = new int[5];
        // [I@10f87f48
        System.out.println(arr);

        byte[] bArr = new byte[3];
        // [B@b4c966a
        System.out.println(bArr);

    }
}

数组的静态初始化

什么是静态初始化

在创建数组时，直接将元素确定

静态初始化格式

完整版格式  
数据类型[] 数组名 = new 数据类型[]{
    
    元素1,元素2,...};

简化版格式  
数据类型[] 数组名 = {
    
    元素1,元素2,...};

数组元素访问

什么是索引

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

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

访问数组元素格式

数组名[索引];

内存概述

内存是计算机中的重要原件，临时存储区域，作用是运行程序。

我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的。

必须放进内存中才能运行，运行完毕后会清空内存。

Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。

数组操作的两个常见问题

索引越界异常

• 出现原因
  数组长度为3，索引范围是0~2，但是我们却访问了一个3的索引。
  程序运行后，将会抛出ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。

public class ArrayDemo {
    
    
    public static void main(String[] args) {
    
    
        int[] arr = new int[3];
        System.out.println(arr[3]);
    }
}

• 解决方案
  将错误的索引修改为正确的索引范围即可！

空指针异常

• 出现原因
  arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出 NullPointerException 空指针异常。在开发中，空指针异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。

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

        //把null赋值给数组
        arr = null;
        System.out.println(arr[0]);
    }
}

• 解决方案
  给数组一个真正的堆内存空间引用即可！

数组常用操作

数组遍历

• 数组遍历：就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。
• 其实遍历的就两种,对象和数组.只是哪个遍历适用于哪个而已，后面会总结一下

package com.demo;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;

public class demo {
    
    
    public static void main(String[] args) {
    
    
       // 数组遍历方式
        String[] arrs = {
    
    "a", "b", "c"};

        // for
        for (int i = 0; i < arrs.length; i++) {
    
    
            System.out.println(arrs[i]);
        }
        System.out.println("================");

        // for增强
        for (String str : arrs) {
    
    
            System.out.println(str);
        }
        System.out.println("================");

        // Iterator（迭代器）
        Iterator<String> iterator = Arrays.stream(arrs).iterator();
        while (iterator.hasNext()){
    
    
            String next = iterator.next();
            System.out.println(next);
        }
        System.out.println("================");

        //stream
        Arrays.stream(arrs).forEach(System.out::println);

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

数组过滤/查找

常见过滤

代码实现：

public static void main(String[] args) {
    
    
    String[] arrs = {
    
    "a", "b", "c"};
    for (String arr : arrs) {
    
    
        if(!"a".equals(arr)){
    
    
            System.out.println("打印出不是a的值："+ arr);
        }
    }
}

二分查找 (理解)

注意事项:有一个前提条件，数组内的元素一定要按照大小顺序排列，如果没有大小顺序，是不能使用二分查找法的

二分查找概述

• 查找指定元素在数组中的位置时,以前的方式是通过遍历,逐个获取每个元素,看是否是要查找的元素,这种方式当数组元素较多时,查找的效率很低
• 二分查找也叫折半查找,每次可以去掉一半的查找范围,从而提高查找的效率

需求

• 在数组{1,2,3,4,5,6,7,8,9,10}中,查找某个元素的位置

实现步骤

1. 定义两个变量，表示要查找的范围。默认min = 0 ，max = 最大索引
2. 循环查找，但是min <= max
3. 计算出mid的值
4. 判断mid位置的元素是否为要查找的元素，如果是直接返回对应索引
5. 如果要查找的值在mid的左半边，那么min值不变，max = mid -1.继续下次循环查找
6. 如果要查找的值在mid的右半边，那么max值不变，min = mid + 1.继续下次循环查找
7. 当min > max 时，表示要查找的元素在数组中不存在，返回-1.

代码实现

public class MyBinarySearchDemo {
    
    
    public static void main(String[] args) {
    
    
        int [] arr = {
    
    1,2,3,4,5,6,7,8,9,10};
        int number = 11;

        //1,我现在要干嘛? --- 二分查找
        //2.我干这件事情需要什么? --- 数组 元素
        //3,我干完了,要不要把结果返回调用者 --- 把索引返回给调用者
        int index = binarySearchForIndex(arr,number);
        System.out.println(index);
    }

    private static int binarySearchForIndex(int[] arr, int number) {
    
    
        //1,定义查找的范围
        int min = 0;
        int max = arr.length - 1;
        //2.循环查找 min <= max
        while(min <= max){
    
    
            //3.计算出中间位置 mid
            int mid = (min + max) >> 1;
            //mid指向的元素 > number
            if(arr[mid] > number){
    
    
                //表示要查找的元素在左边.
                max = mid -1;
            }else if(arr[mid] < number){
    
    
                //mid指向的元素 < number
                //表示要查找的元素在右边.
                min = mid + 1;
            }else{
    
    
                //mid指向的元素 == number
                return mid;
            }
        }
        //如果min大于了max就表示元素不存在,返回-1.
        return -1;
    }
  
}

数据排序

冒泡排序

步骤

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

动图演示

代码实现

public class Demo01 {
    
    
    public static void main(String[] args) {
    
    
        int[] arr = {
    
    3,4,1,2};
        int[] ints = bubbleSort(arr);
        Arrays.stream(ints).forEach(System.out::println);
        
        System.out.println(Arrays.toString(bubbleSort(arr)));
    }


    // 返回一个对原数组没有影响的排好序的新数组
    public static int[] bubbleSort(int[] sourceArray)   {
    
    
        // 对 arr 进行拷贝，不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        for (int i = 1; i < arr.length; i++) {
    
    
            for (int j = 0; j < arr.length - i; j++) {
    
    
                if (arr[j] > arr[j + 1]) {
    
    
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;
                }
            }
        }
        return arr;
    }
}

选择排序

步骤

1. 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
2. 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

动图演示

代码实现

public class Demo01 {
    
    
    public static void main(String[] args) {
    
    
        int[] arr = {
    
    3,4,1,2};
        int[] ints = selectSort(arr);
        Arrays.stream(ints).forEach(System.out::println);
    }

    public static int[] selectSort(int[] arrs){
    
    
        int minIndex,temp;
        for (int i = 0; i < arrs.length-1; i++) {
    
      // 注意，这里需要减一
            minIndex = i; // 默认最小值元素的索引
            for (int j = i+1; j < arrs.length; j++) {
    
    
                if(arrs[minIndex] > arrs[j]){
    
      // 依次查找最小值的索引
                    minIndex = j;
                }
            }
            if(minIndex != i){
    
       // 如果最小值的索引不一样，交换位置
                temp = arrs[minIndex];
                arrs[minIndex] = arrs[i];
                arrs[i] = temp;
            }
        }
        return arrs;
    }
}

插入排序

步骤

将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。

从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。

说真的，说的有点迷糊，按照我的理解来说，举个例子, 玩牌，我们玩牌的时候怎么对牌进行排序

1. 从所有牌中拿一个牌
2. 第二次拿牌，比较和第一章那个大，然后排序
3. 第三次，和前面那的两张牌比较，插入指定位置。。。
4. 最后一次，拿到最后一张牌，和你手里的牌对比，插入指定位置

动图演示

代码实现

public class Demo01 {
    
    
    public static void main(String[] args) {
    
    
        int[] arr = {
    
    3,4,1,2};
        int[] ints = insertSort(arr);
        Arrays.stream(ints).forEach(System.out::println);
    }

    public static int[] insertSort(int[] sourceArray) {
    
    
        // 对 arr 进行拷贝，不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        // 从下标为1的元素开始选择合适的位置插入，因为下标为0的只有一个元素，默认是有序的
        for (int i = 1; i < arr.length; i++) {
    
    

            // 记录要插入的数据
            int tmp = arr[i];

            // 从已经排序的序列最右边的开始比较，找到比其小的数
            int j = i;
            while (j > 0 && tmp < arr[j - 1]) {
    
    
                arr[j] = arr[j - 1];
                j--;
            }

            // 存在比其小的数，插入
            if (j != i) {
    
    
                arr[j] = tmp;
            }

        }
        return arr;
    }
}

数组元素求和/字符串拼接

    public static void main(String[] args) {
    
    
        // 求和
        int[] arr = {
    
    1,2,3,4};
        int total = 0;
        for (int i : arr) {
    
    
            total += i;
        }
        System.out.println("合为："+total);

        String[] strs = {
    
    "a","b","c","d"};
        String str = "";
        for (String s : strs) {
    
    
            str += s;
        }
        System.out.println("拼接后的字符串为："+str);
    }

数组获取最大值

• 最大值获取：从数组的所有元素中找出最大值。

• 实现思路：

• • 定义变量，保存数组0索引上的元素
  • 遍历数组，获取出数组中的每个元素
  • 将遍历到的元素和保存数组0索引上值的变量进行比较
  • 如果数组元素的值大于了变量的值，变量记录住新的值
  • 数组循环遍历结束，变量保存的就是数组中的最大值

• 代码实现：

package com.itheima.test;

import java.util.Scanner;

public class Test2Array {
    
    
    /*
        需求: 从数组中查找最大值

                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);
    }
}

Arrays (应用)

Arrays的常用方法

方法名	说明
public static String toString(int[] a)	返回指定数组的内容的字符串表示形式
public static void sort(int[] a)	按照数字顺序排列指定的数组
public static int binarySearch(int[] a, int key)	利用二分查找返回指定元素的索引

示例代码

public class MyArraysDemo {
    
    
      public static void main(String[] args) {
    
    
  //        public static String toString(int[] a)    返回指定数组的内容的字符串表示形式
  //        int [] arr = {3,2,4,6,7};
  //        System.out.println(Arrays.toString(arr));

  //        public static void sort(int[] a)      按照数字顺序排列指定的数组
  //        int [] arr = {3,2,4,6,7};
  //        Arrays.sort(arr);
  //        System.out.println(Arrays.toString(arr));

  //        public static int binarySearch(int[] a, int key) 利用二分查找返回指定元素的索引
          int [] arr = {
    
    1,2,3,4,5,6,7,8,9,10};
          int index = Arrays.binarySearch(arr, 0);
          System.out.println(index);
          //1,数组必须有序
          //2.如果要查找的元素存在,那么返回的是这个元素实际的索引
          //3.如果要查找的元素不存在,那么返回的是 (-插入点-1)
              //插入点:如果这个元素在数组中,他应该在哪个索引上.
      }
  }

• 工具类设计思想

1. 1. 构造方法用 private 修饰
   2. 成员用 public static 修饰

二维数组概述

概述 : 二维数组也是一种容器，不同于一维数组，该容器存储的都是一维数组容器

二维数组动态初始化

动态初始化格式：

数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组，可以存放多少个一维数组
n表示每一个一维数组，可以存放多少个元素

package com.itheima.demo;

public class Demo1Array {
    
    
    /*
        动态初始化格式：

            数据类型[][] 变量名 = new 数据类型[m][n];
            m表示这个二维数组，可以存放多少个一维数组
            n表示每一个一维数组，可以存放多少个元素
     */
    public static void main(String[] args) {
    
    
        // 数据类型[][] 变量名 = new 数据类型[m][n];
        int[][] arr = new int[3][3];
        /*
            [[I@10f87f48

            @ : 分隔符
            10f87f48 : 十六进制内存地址
            I : 数组中存储的数据类型
            [[ : 几个中括号就代表的是几维数组
         */
        System.out.println(arr);

        /*
            二维数组存储一维数组的时候, 存储的是一维数组的内存地址
         */
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        System.out.println(arr[0][0]);
        System.out.println(arr[1][1]);
        System.out.println(arr[2][2]);

        // 向二维数组中存储元素
        arr[0][0] = 11;
        arr[0][1] = 22;
        arr[0][2] = 33;

        arr[1][0] = 11;
        arr[1][1] = 22;
        arr[1][2] = 33;

        arr[2][0] = 11;
        arr[2][1] = 22;
        arr[2][2] = 33;

        // 从二维数组中取出元素并打印
        System.out.println(arr[0][0]);
        System.out.println(arr[0][1]);
        System.out.println(arr[0][2]);
        System.out.println(arr[1][0]);
        System.out.println(arr[1][1]);
        System.out.println(arr[1][2]);
        System.out.println(arr[2][0]);
        System.out.println(arr[2][1]);
        System.out.println(arr[2][2]);
    }
}

二维数组静态初始化

代码实现 :

package com.itheima.demo;

public class Demo3Array {
    
    
    /*
        完整格式：数据类型[][] 变量名 = new 数据类型[][]{ {元素1, 元素2...} , {元素1, 元素2...} ...};

        简化格式: 数据类型[][] 变量名 = { {元素1, 元素2...} , {元素1, 元素2...} ...};
     */
    public static void main(String[] args) {
    
    
        int[] arr1 = {
    
    11,22,33};
        int[] arr2 = {
    
    44,55,66};

        int[][] arr = {
    
    {
    
    11,22,33}, {
    
    44,55,66}};
        System.out.println(arr[0][2]);

        int[][] array = {
    
    arr1,arr2};
        System.out.println(array[0][2]);
    }
}

二维数组遍历

需求 :

已知一个二维数组 arr = { {11, 22, 33}, {33, 44, 55}};

遍历该数组，取出所有元素并打印

步骤 :

1. 遍历二维数组，取出里面每一个一维数组

2. 在遍历的过程中，对每一个一维数组继续完成遍历，获取内部存储的每一个元素

代码实现 :

package com.itheima.test;

public class Test1 {
    
    
    /*
        需求:

            已知一个二维数组 arr = {
    
    {11, 22, 33}, {33, 44, 55}};
            遍历该数组，取出所有元素并打印

        步骤:
            1. 遍历二维数组，取出里面每一个一维数组
            2. 在遍历的过程中，对每一个一维数组继续完成遍历，获取内部存储的每一个元素
     */
    public static void main(String[] args) {
    
    
        int[][] arr = {
    
    {
    
    11, 22, 33}, {
    
    33, 44, 55}};

        // 1. 遍历二维数组，取出里面每一个一维数组
        for (int i = 0; i < arr.length; i++) {
    
    
            //System.out.println(arr[i]);
            // 2. 在遍历的过程中，对每一个一维数组继续完成遍历，获取内部存储的每一个元素
            //int[] temp = arr[i];
            for (int j = 0; j < arr[i].length; j++) {
    
    
                System.out.println(arr[i][j]);
            }
        }
    }
}

二维数组求和

需求 :

某公司季度和月份统计的数据如下：单位(万元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99

步骤 :

1. 定义求和变量，准备记录最终累加结果
2. 使用二维数组来存储数据，每个季度是一个一维数组，再将4个一维数组装起来
3. 遍历二维数组，获取所有元素，累加求和
4. 输出最终结果

代码实现 :

package com.itheima.test;

public class Test2 {
    
    
    /*
        需求:
            某公司季度和月份统计的数据如下：单位(万元)
            第一季度：22,66,44
            第二季度：77,33,88
            第三季度：25,45,65
            第四季度：11,66,99

        步骤:
            1. 定义求和变量，准备记录最终累加结果
            2. 使用二维数组来存储数据，每个季度是一个一维数组，再将4个一维数组装起来
            3. 遍历二维数组，获取所有元素，累加求和
            4. 输出最终结果
     */
    public static void main(String[] args) {
    
    
        // 1. 定义求和变量，准备记录最终累加结果
        int sum = 0;
        // 2. 使用二维数组来存储数据，每个季度是一个一维数组，再将4个一维数组装起来
        int[][] arr = {
    
     {
    
    22,66,44} , {
    
    77,33,88} , {
    
    25,45,65} , {
    
    11,66,99}};
        // 3. 遍历二维数组，获取所有元素，累加求和
        for (int i = 0; i < arr.length; i++) {
    
    
            for(int j = 0; j < arr[i].length; j++){
    
    
                sum += arr[i][j];
            }
        }
        // 4. 输出最终结果
        System.out.println(sum);
    }
}