• 【java基础系列】12- java的数组（二）

    数组的定义以及应用

    1、数组

    • 组就是指多个的意思，在之前我们的代码中使用的数据类型都是单个的，为了将多个相同类型的数据存储在一起，这时候就引出了组的概念
    • 数组是存储同一种数据类型是多个元素的集合，也可以看成是一个容器
    • 数组可以存储基本数据类型，也可以存储引用数据类型
    • 数组是java中的唯一底层容器，集合的底层也使用的是数组
    package com.goshawk.array;
/**
 * 1、数组的定义
 * 数组是一个容器，里面存放着相同数据类型的多个元素
 * 2、数组的创建方式
 * 1> 创建数组的格式
 * 创建一个指定容量的数组
 * 数据类型[] 数组名 = new 数据类型[容量];
 * 数据类型 数组名[] = new 数据类型[容量];
 * 2> 数组的静态初始化和动态初始化
 *
 * 3> 如何使用数组
 * 数组名[下标] 这种方式来使用数组
 * */
public class demo1 {
    public static void main(String[] args){
        int a = 10;
        int b = 20;
        // 数组
        int[] arr = {10, 20, 30, 50};

        // 创建一个容量为10的数组，可以存放10个元素的数组
        int[] arr1 = new int[10];

        // 向数组中添加一个元素
        arr1[0] = 100;
        // 从数组中取第一个元素
        System.out.println(arr1[0]);
    }
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    2、数组的初始化

    • 就是为数组开辟连续的内存空间，并为每个数组元素赋值
    • 静态初始化
      • 指定内容，数组的长度由jvm自动判断
      • 数组类型[] 数组名 = new 数组类型[ ] {元素1, 元素2, 元素3, 元素4…}
      • 数组类型[] 数组名 = {元素1, 元素2, 元素3, 元素4 …}
    • 动态初始化
      • 指定数组的长度，数组中的元素由jvm给出默认值
      • 数组类型[] 数组名 = new 数据类型[数组长度]
    package com.goshawk.array;
/**
 * 1 数组的静态初始化和动态初始化
 * 1> 静态初始化：
 * 在创建数组的同时，给数组赋值（存元素）
 * 1.1> 创建方式1
 * 数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, 元素3};
 * 1.2> 创建方式2
 * 数据类型[] 数组名 = 元素1, 元素2, 元素3};
 * 2> 动态初始化
 * 在创建数组的时候不存元素，但是一定要指明数组的容量，因为不指明容量，jvm无法知道要开辟多大的空间
 * 应用场景：
 * 只有在使用时才会向数组存元素，所以只能使用动态初始化来创建数组；
 * 动态初始化刚完成后，还没有存数据前，数组中数据是什么样----- 数组中的数据是该数据类型的默认值。
 *      整型：0
 *      浮点：0.0
 *      布尔值：false
 *      引用数据类型: null
 *

 * */
public class demo1 {
    public static void main(String[] args){

        // 静态初始化
        // 创建一个存放a,b,c三个字符串元素的数组
        String[] arr1 = new String [] {"a","b", "c"}; // 可拆分，如arr3;
        String[] arr2 = {"a","b", "c"}; // 不可拆分
        String[] arr3;
        arr3 = new String[] {"a","b", "c"};

        // 动态初始化
        String[] arr4 = new String[5];
        System.out.println(arr4[0]);
    }
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38

    3、存储逻辑

    在这里插入图片描述

    int arr1[] = nwe int[10]; // 连续的空间：32位*10


    • 1
    • 2
    • 程序执行流程
      • main方法进入方法栈执行
      • 创建数组，JVM会在堆内存中开辟一块连续的内存空间，来存储数组；该内存空间的大小跟数组的数据类型和元素个数相关。
      • 数组在内存中会有自己的内存地址，以十六进制数表示（0X1AB）
      • 数组中有10个元素，默认值0；这10个空间会有一个首地址（例如：0X1AB），也就是说我只要找到这个刚开始的地址，那么这个连续空间的其它地址也能找到；
      • JVM将数组的内存地址赋值给引用类型变量arr1；（将首地址0X1AB赋值给arr1，也就是说arr1这个变量指向的空间里面存储0X1AB）
      • 变量arr1保存的是数组内存中的地址，而不是一个具体是数值，因此称为引用数据类型。
      • 可以通过数组的下标（索引：从0开始）来选择操作数组这片连续空间中的每一个位置。

    4、注意事项

    • 数组的长度在创建的时候就固定，中途无法被改变
    • 数组是靠角标定位元素，角标值从0开始
    • 数组属于引用数据类型
    • 数组中元素必须是同一种数据类型

    5、数组的基本操作

    • 使用数组的角标对数组进行操作，我们可以将数组的一个角标为看作是一个变量

    • 获取数组的某个角标为：arr[角标位3]

      • 获取到数组中的某个角标之后，就可以获取值和赋值了

    • 获取数组的长度（元素的个数）：arr.length

    • 遍历数组

      • 循环查看数组中每一个元素

        public static void print(){
  for (int i=0;i<arr.length;i++){
  	System.out.println(arr[i]+" ");
  }
}

        • 1
        • 2
        • 3
        • 4
        • 5

    • 获取数组中的最大值

      • 遍历数组，查找最大的值，注意，这个最大值一定是数组的，所以我们不能随便给最大值变量赋予一个默认值

        public static void getMax(){
  int[] arr = {10,20,30,1,5,16,33,90}
  // 定义存储最大值的变量
  
  int max = arr[0]; // int max = 0;
 
  for (int i=1;i<arr.length;i++){
    if(arr[i]>max){
      max = arr[i];
    }
  }
  System.out.println(max);
  return max;
}

        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14

    • 反转数组

      • 将数组中的元素按照排列顺序反转，例如角标0和最后一个角标位上的元素交换

        package com.goshawk.array;

import java.util.Arrays;

/**
 * 反转数组
 * 思路：取数组中的一半位置，让尾部向前，头部向后，两个数逐一的互换
 * */
public class reversal {
    public static void main(String[] args) {
        int arr[] = {1,10,5,3,4,12,6,21,8,3};
        for (int i=0;i<arr.length/2;i++){
            // 两数互换的中间值
            int swap = arr[i];
            arr[i] = arr[arr.length-i-1];
            arr[arr.length-i-1] = swap;
        }
        System.out.println(Arrays.toString(arr));
    }
}


        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14
        • 15
        • 16
        • 17
        • 18
        • 19
        • 20
        • 21

    • 查找数组中某个值第一次出现的位置

      • 对比数组中每个元素，知道匹配成功，返回当前的角标，如果没有查找到，返回一个负数

        package com.goshawk.array;

import java.util.Scanner;

/**
 * 通过方法，实现查找数组中某个元素第一次出现的位置
 * 数组中的元素前后交换，遍历的次数只能是数组长度的一半；
 * */
public class first_to_element {
    public static void main(String[] args) {
        int arr[] = {1,10,5,3,4,12,6,21,8,3};

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要查找的数值：");
        int value = scanner.nextInt();
        // 遍历数组
        // 记录该位置。并返回
        int index = indexValue(arr, value);
        if (index==-1){
            System.out.println("很遗憾。没找到你要找的数值");
        }else {
            System.out.println("要查找的是21，第一次出现的索引是："+index);
            }

        }

    /**
     * 返回数组中某个元素第一次出现的索引位置
     * @param array 数组
     * @param value 要查找的元素
     * @return 第一次出现的该元素的索引位置
     */
    public static int indexValue(int[] array, int value){
        for (int i=0;i<array.length;i++){
            if (value == array[i]){
                return i;
            }
        }
        return -1;
    }
}


        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14
        • 15
        • 16
        • 17
        • 18
        • 19
        • 20
        • 21
        • 22
        • 23
        • 24
        • 25
        • 26
        • 27
        • 28
        • 29
        • 30
        • 31
        • 32
        • 33
        • 34
        • 35
        • 36
        • 37
        • 38
        • 39
        • 40
        • 41
        • 42

    举个例子：

    package com.goshawk.array;
/**
 * 数组的使用
 * 1、通过下标来找到数组中某一个具体的元素，下标从0开始，最多只能达到数组的长度-1
 * 2、数组的长度
 * 数组内元素的个数；注意数组的长度是不可变的。
 * 任何一个数组都有一个length属性
 * 3、数组的遍历：将数组中每个元素都过一遍；
 * 通过循环语句来遍历数组，循环的次数就是数组的长度，通过把循环变量作为数组的下标来遍历数组
 *

 * */
public class demo2 {
    public static void main(String[] args){

        // 创建一个存放a,b,c三个字符串元素的数组
        String[] arr1 = new String [] {"a","b", "c"};
        System.out.println(arr1[0]);
        // 获取数组的长度
        int len = arr1.length;
        System.out.println(len);

        // 遍历数组
        for (int i=0;i<arr1.length;i++){
            System.out.println(arr1[i]);
        }


    }
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    举个例子：

    package com.goshawk.array;

import java.util.Scanner;

/**
 * 数组的创建和使用demo
 * 键盘录入5个学生的年龄，查找年龄为15的学生的录入位置（序号）；

 * */
public class demo3 {
    public static void main(String[] args){

        Scanner scanner = new Scanner(System.in);
        int[] ages = new int[5];
        for (int i=0;i<5;i++){
            System.out.println("请输入第"+(i+1)+"个学生的年龄");
            int age = scanner.nextInt();
            // 存入数组中
            ages[i] = age;

        }
        // 查找年龄为15的学生的录入位置（序号）
        for (int i=0;i<ages.length;i++){
            if (15 == ages[i]){
                System.out.println("找到年龄为15的学生位置："+(i+1));
                return;
            }

        }
        System.out.println("没有找到年龄为15的学生位置");

    }
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    6、数组常见的问题

    1、ArrayIndexOutOfBoundsException

    • 数组角标越界异常
    • 访问了不存在的角标

    2、NullPointerException

    • 空指针异常
    • 栈中的数组变量没有指向堆内存中的数组实体

    3、演示

    package com.goshawk.array;

/**
 * 数组操作常见的问题
 *

 * */
public class demo4 {
    public static void main(String[] args) {
      // ArrayIndexOutOfBoundsException
        int[] arr1 = new int[] {1,2,3};
        System.out.println(arr1[3]);
    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    7、数组的参数传递

    1、简单的通过变量来实现两数的互换

    package com.goshawk.array;

/**
 * 数组的参数传递
 * 实现两个数的互换
 *
 *

 * */
public class demo5 {
    public static void main(String[] args) {
        // 1、简单的通过变了来实现两数的互换
        int a = 10;
        int b = 20;

        int swap = b;
        b = a;
        a = swap;
      
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    2、通过数组来实现两值的互换

    package com.goshawk.array;

/**
 * 数组的参数传递
 * 实现两个数的互换
 *
 *

 * */
public class demo5 {
    public static void main(String[] args) {

        // 2、通过数组来实现两值的互换
        int a1 = 10;
        int b1 = 20;
        int[] arr = {a1, b1};
        swap_(arr[0], arr[1]);
        // 遍历数组并打印
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }

    }

    public static void swap_(int a, int b){
        int swap = b;
        b = a;
        a = swap;
    }
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    上述代码分析如下：

    在这里插入图片描述

    package com.goshawk.array;

/**
 * 数组的参数传递
 * 实现两个数的互换
 * 关于方法的参数传递：
 *      如果是基本数据类型，传的是值；
 *      如果是引用数据类型，传的是地址值；
 *
 *

 * */
public class demo5 {
    public static void main(String[] args) {

        // 2、通过数组来实现两值的互换
        int a1 = 10;
        int b1 = 20;
        int[] arr = {a1, b1};
        swapArray(arr);
        // 遍历数组并打印
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }

    public static void swapArray(int[] array){
        int swap = array[0];
        array[0] = array[1];
        array[1] = swap;
    }
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    上述代码分析如下图：

    在这里插入图片描述

    8、二分查找

    8.1 定义
    • 使用折半的形式，一次性剔除一般的无效元素，提高了查找的效率
    • 使用二分查找的数组必须是有序的
    8.2 演示
    package com.goshawk.array;

import java.util.Scanner;

/**
 * 二分查找
 * 要查找的数和中间位置上的数做一次比较，如果等于即找到；如果比中间位置上的数大，那么该数一定在中间位置的右边，反之在左边；
 * mid = (start + end)/2 mid==>中间值
 * 反复上述循环：start>end，就表示没有找到，即循环结束
 * */
public class binarySearch {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,12,23,45};
        // 定义有效元素开始的角标
        int start = 0;
        // 定义有效元素结束的角标
        int end = arr.length-1;
        // 要查找的数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要查找的值：");
        int input = scanner.nextInt();
        while (start<=end){
            // 计算中间的角标
            int mid = (start + end) / 2;
            if (input == arr[mid]){
                System.out.println("找到了，位置在："+mid);
                return;
            }
            if (input>arr[mid]){
                // 确定新的查找范围： start： 中间位置+1，end不变
                // 如果中间角标位上的值小于要查找的值，说明中间的值都不可能匹配上；
                start = mid + 1;
            }else {
                end = mid -1;
            }
        }
        System.out.println("很遗憾，没有找到数值："+input);
    }
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41

    9、Arrays工具类

    9.1 定义
    • 主要用于对数组进行排序、查找、填充、比较等操作
    9.2 演示
    package com.goshawk.array;

import java.util.Arrays;

/**
 * Arrays工具类：直接可以使用的类
 * */
public class arraysUtil {
    public static void main(String[] args) {

        int[] arr = {1,55,12,34,12,13,5,8,14};

        // Arrays数组的排序
        Arrays.sort(arr);
        // 把数组变成字符欻的方法
        String str = Arrays.toString(arr);
        System.out.println(str);

        // 查找 注意二分查找必须在有序的数组执行
        int index = Arrays.binarySearch(arr, 12);
        System.out.println("找到数据的位置：" + index);
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    10、可变参数

    10.1 定义
    • 在方法声明上使用…表示多个相同类型的参数
    10.2 注意事项
    • 在实际调用中，我们已经在方法内传入多个实参，虚拟机会自动帮我们填充到可变参数上，形成一个数组
    10.3 示例
    package com.goshawk.array;


/**
 * 可变参数
 * void method(数据类型... 数组名){}
 * 注意事项：
 * 1> 在方法的形参中使用
 * 2> 可变参数只能是形参列表中的最后一个参数
 * 3> 设计重载方法时不要出现重复
 * */
public class varParam {
    public static void main(String[] args) {
        method(10, 20);
        method1(10,20,30);
        method1(10);
        method2("a", "b");

    }

    public static void method(int... values){
        for (int i = 0; i< values.length;i++){
            System.out.println(values[i]+"");
        }
        System.out.println();
    }

    public static void method1(int a, int... values){
        for (int i = 0; i< values.length;i++){
            System.out.println(values[i]+"");
        }
        System.out.println();
    }
  
  // 这里注意，与method方法重复了
  // public static void method2(int a, int b, int... values){
  //     for (int i = 0; i< values.length;i++){
  //         System.out.println(values[i]+"");
  //    }
  //     System.out.println();
  //  }

    public static void method3(String... strs){
        for(int i=0;i<strs.length;i++){
            System.out.println(strs[i]);
        }
    }

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50

    11、二维数组（多维数组）

    11.1 演示

    在这里插入图片描述

    package com.goshawk.array;


/**
 * 二维数组（多维数组）
 * 1、定义
 * 外维数组中的元素，自身就是一个数组；
 * 举个例子：创建一个班级，描述班级的每位同学
 * 2、创建
 * 使用两对[] 来创建
 * 3、使用
 * 1> 存数据和取数据>>关键是如何定位你要找的数据
 * 2> 查数据：遍历（使用嵌套循环，如果是二维，就两层循环；如果是三维，就三层循环；
 * 外维控制行数，内维控制列数
 * 4、二维数组的使用细节
 * 1> 创建二维数组
 * 1.1> 静态初始化
 * 1.2> 动态初始化
 * 动态初始化需要指明几个维度的数组容量，关键是容量可以区别对待；
 * 2>
 *
 * */
public class multidimensional {
    public static void main(String[] args) {
        // 静态初始化
        int[][] arrs = new int[][]{{1, 2, 3}, {3, 4}, {5, 6, 7}};
        int[][] arrs1 = {{1, 2, 3}, {3, 4}, {5, 6, 7}};
        // 动态初始化
        // 动态初始化一，第二维真正存放数据，此时存放的是int类型的默认值0
        int[][] arrs2 = new int[3][4];
        // 动态初始化二，
        int[][] arrs3 = new int[3][];
        arrs3[0] = new int[4];
        arrs3[1] = new int[]{5, 6, 7};
        arrs3[2] = new int[]{8, 9, 10};
        // int[][] arrs4 = new int[][4]; 这种方式是不可行的，不知道外维需要开辟多少空间
        ergodic(arrs3);
    }

        public static void ergodic(int[][] arrs){
            // 遍历多维数组
            for (int i = 0;i<arrs.length;i++){
                for (int k = 0;k<arrs[i].length;k++){
                    System.out.println(arrs[i][k]);
                }
                // 换行
                System.out.println();
            }
        }
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
  • 相关阅读:
    激光雷达技术详解：MATLAB代码实践与遥感测距原理通俗解析
    系统篇： ubuntu 搭建 MFA+SSH 多重身份认证
    Linux--inode
    Spring 后置处理器【1】
    Day20_9 前端入门之CSS样式
    编辑距离问题
    MySQL读写分离技术及实现方案
    华为云排名仅为第二？市场占有率营收被阿里双碾压
    Ajax异步
    vscode 注释插件koroFileHeader
  • 原文地址：https://blog.csdn.net/weixin_40960688/article/details/127704578