数组篇(最新版总结)

程序员就是阿欣

已于 2022-03-23 02:47:48 修改

阅读量949

点赞数

分类专栏： java 文章标签： java 后端开发语言

于 2022-03-23 02:47:19 首次发布

本文链接：https://blog.csdn.net/weartheword/article/details/123676115

版权

java 专栏收录该内容

18 篇文章 1 订阅

订阅专栏

本文详细介绍了Java中的数组，包括静态和动态初始化、数组访问、遍历、常见问题等。通过实例展示了如何进行数组操作，如求和、求最值、猜数字游戏等，还涉及到了数组排序的基础概念。此外，讨论了两个变量指向同一数组时的注意事项，并列举了数组使用中可能遇到的异常情况。

摘要由CSDN通过智能技术生成

数组篇(最新版总结)

一：数组的概述
二：静态初始化
三：数组的访问
①数组名称[索引]
②数组的长度属性：length
③数组的最大索引可以怎么表示？
四：动态初始化
①动态初始化格式
②两种数组定义时的特点和场景有什么区别？
③动态初始化数组元素的默认值
④两种初始化的使用场景总结、注意事项说明
五：数组的遍历
六：数组练习案例
七：两个变量指向同一个数组
八：数组使用的常见问题

一、数组的概述

数组的概述：数组就是用来存储一批同种类型数据的内存区域。(可以理解成容器)

例子：10,20,80,60,90

10,20,80,60,90   
    int [] arr = {10,20,80,60,90};
张三,李四,王五,老王
    String[]  name = {"张三","李四","王五","老王"};

假如用变量存储这些名字，然后完成随机点名功能，怎么实现？存在有什么问题？

张誉，刘疏桐，田启峰，尹成元，赵志刚，解天野，高续升，王世举，周宇怜，刘帅，陈小伟，陈伟鸿，高明，毕振宇，王乾麟，丁佳峰，李鑫宇，孙孟想，陈耀，尹于林，聂定廉，马煜，林圣凯，林圣凯，范洪庆.，黄豪龙，罗磊，金胜锋，孙胜贤…等等等等…

  //如果这样子存储的话需要非常多的变量
   String name1 = "张誉";
   String name2 = "刘疏桐";
   String name3 = "田启峰";
        ...
        ...
     String name68 = "尹成元";
     String name69 = "赵志刚";
     String name70 = "解天野";



//所以java提供了数组   使用数组来完成

   String[] names = {"张三","李四"..."王五","老王"};

二、静态初始化

静态初始化数组：定义数组的时候直接给数组赋值。

静态初始化数组格式：

//完整格式
//数据类型 数组名= new  数据类型[]{元素1，元素2，元素3,...}
double[] scores = new double[]{88.9,99.5,59.6,66.3};
    int[] args = new int[]{12,34,60};

//简化格式
// 数据类型[]  数组名  = {元素1,元素2,元素3,...}
        int[]  ages    =  {12,23,14,15};

注意：数组变量名中存储的是数组在内存中的地址，数组是引用类型。

三、数组的访问

1、数组名称[索引]

 int[]  ages    =  {12,23,14,15};
        //取值  
        System.out.println(ages[0]);  //12

       //赋值
        ages[2] = 100;
        System.out.println(ages[2]); //把14改成100

2、数组的长度属性：length

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

3、数组的最大索引可以怎么表示？

答：数组名.length-1； //前提：元素个数大于0,因为下标是从0开始所以要 -1、

四、动态初始化

1、动态初始化格式

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

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

2、两种数组定义时的特点和场景有什么区别？

当前已经知道存入的元素值，用静态初始化。
当前还不清楚要存入哪些数据。用动态初始化。

3、动态初始化数组元素的默认值

   //基本类型                //默认
byte,short,char,int,long    // 0
    float,double           //  0.0
    boolean                // false
    
    //引用类型
  类 接口  数组  String         null

4、两种初始化的使用场景总结、注意事项说明：

动态初始化：只指定数组的长度，后期赋值，适合开始知道数据的数量，但是不确定具体元素值的业务场景。
静态初始化：开始就存入元素值，适合一开始就能确定元素值的业务场景。
两种格式的写法是独立的严，不可以混用。

int[] arrs = new int [3]{30,40,50};  //这种写法严重错误！！！

五、数组的遍历

遍历：就是一个一个数据的访问。

为什么要遍历？搜索、数据统计等等都需要用到遍历。

int[] ages = {20,30,40,50};
//            0   1  2  3
        for (int i = 0; i < ages.length; i++) {
            System.out.println(ages[i]);  
        }          //终极数组遍历形式

六、数组练习案例

1、数组遍历–求和

需求：某部门5名员工的销售额分别是：16,26,36,6,100，请计算出他们部门的总销售额。

//分析：把这5个元素拿到数据中去---->使用数组
int[] money = {16,26,36,6,100};
//遍历数组中的每个数据，然后在外面定义求和变量把它们累加起来。
 int Sum = 0;
        for (int i = 0; i < money.length; i++) {
           Sum+=money[i];
            //再输出总数就可以
        
            
            
   int Sum = 0;
        int[] money = {16,26,36,6,100};
        for (int i = 0; i < money.length; i++) {
            Sum+=money[i];  //Sum = Sum+money
        }
        System.out.println(Sum);

2、数组求最值

一个班级的有10个同学，分数分别是66,90,68,78,88,64,87,56,87,42请用程序找出这次考试成绩的最高分。

//分析：把数据拿到程序中去，用数组封装起来。
int [] = score{66,90,68,78,88,64,87,56,87,42};
//定义一个变量用于存放最大值，这个变量建议默认存储第一个元素值最为参照。
 int max = score[0];
//遍历数组的元素，如果改元素大于变量存储的元素，则替换变量存储的值为该元素。


public class Demo01 {
    public static void main(String[] args) {

        int[] score = {66,90,68,78,88,64,87,56,87,42};

        int max = score[0];

        for (int i = 0; i < score.length; i++) {

            if(score [i] > max  ){
                max=score [i];
            }
        }
        System.out.println("班级成绩的最高分是："+max+"分");
    }
}

3、猜数字游戏

需求：开发一个幸运小游戏，游戏规则是：游戏后台随机生成无所谓是否重复),然后让大家来猜数字：

未猜中提示：“未命中”，并继续猜测
猜中提示：“运气不错，猜中了”，并输出该数据第一次出现的位置，且输出全部五个数据，最终结束本游戏。

//分析：随机生成5个1-20之间的数据存储起来--->使用数组
//定义一个死循环，输入数据猜测，遍历数组，判断依据是否在数组中，如果在，进行对应提示并结束死循环，如果没有猜中，提示继续猜测直到猜中为止。

package com.zongxin.huang.Demo01;

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

public class Demo02 {
    public static void main(String[] args) {
        //需求：5个1-20之间的随机数，让用户猜测，猜中要提示猜中，还要输出该数据在数组中第一次出现的索引，并打印数组的内容出来。
        //没有猜中继续

        //1、定义一个动态初始化的数组存储5个1-20之间的数据
        int[] date = new int[5];

        //动态生成5个1-20之间的随机数并存储到数组中去。
        Random r = new Random();  //随机函数     System.out.println(Math.random());  这个代码运行就会生成一个随机数  Random是随机数字函数

        for (int i = 0; i < date.length; i++) {
            //i = 0 1 2 3 4
            date[i] = r.nextInt(20)+1;  //生成一个在区间[0-19)之间的数字；加1相当于区间变成[0,20]
        }

        //3、使用一个死循环让用户猜测
        Scanner sc = new Scanner(System.in);
        OUT:
        while(true){
            System.out.println("请您输入一个1-20之间的整数进行猜测：");
            int guessDate = sc.nextInt();

            //4、遍历数组中的每个数据，看是否有数据与猜测的数据相同，相同代表猜中了，给出提示
            for (int i = 0; i < date.length; i++) {
                if (guessDate==date[i]){
                    System.out.println("运气不错，猜中啦，您猜中的数据索引在"+i);
                    break OUT;//结束了整个死循环,代表游戏结束！
                }
            }
            System.out.println("当前猜测的数据在数组中不存在，请重新猜测！");
        }
        //5、输出数组的全部元素，让用户看到自己确实是猜中了某个数据
        for (int i = 0; i < date.length; i++) {
            System.out.print(date[i]+"  \t");
        }
    }
}

4、随机排名

需求：某公司开发部5名开发人员；要进行项目进展汇报演讲，现在采取随机排名后进行汇报。请先依次录入5名员工的工号，然后展示一组随机的排名顺序。
22,33,35,13,88----->13,35,88, 33,22

//分析：在程序中录入5名员工的工号存储起来---->使用数组。
//依次遍历数组中的每个元素。随机一个索引数组。让当前元素与该索引位置处的元素进行交换。 

package com.zongxin.huang.Demo01;

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

public class Test2 {
    public static void main(String[] args) {
        //目标：键盘录入一组工号，最终要随机输出一组出来作为排名
        //1、动态初始化一个数组，存储5个工号
        int[] codes = new int[5];


        //2、定义一个循环，循环5次,依次录入一个工号存入对应的位置
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < codes.length; i++) {
            //正式录入工号
            System.out.println("请您输入第"+(i+1)+"员工的工号");  //这里i+1是因为索引是从0开始的
            int code = sc.nextInt();
            //存入到数组中去
            codes[i] = code;

        }
        // 3、遍历数组中的每个元素，然后随机一个索引出来，让该元素与随机索引位置处元素进行交换
        Random r =new Random();
        for (int i = 0; i < codes.length; i++) {
            //当前遍历元素值：codes[i]
            //随机一个索引位置出来 codes[index]

            //int index = r.nextInt(5);
            int index = r.nextInt(codes.length); //假如数组长度是5 那么随机索引范围就是0,1,2,3，4,边界值可以填5  真好是数组的长度

            //定义一个临时变量 存储index值
            int temp = codes[index];
            codes[index] = codes[i];
            codes[i] = temp;


        }
        //4、遍历数组元素输出就是随机排名的结果
        for (int i = 0; i < codes.length; i++) {
            System.out.print(codes[i]+    " \t");
        }

    }
}

5、数组的排序

就是对数组中的元素，进行升序(由大到小)或者降序(有小到大)的操作。

数组排序的技术：- 冒泡排序 - 选择排序 - 快速排序 - 插入排序 …

数组搜索相关的技术：- 二分搜索 - 分块查找 - 哈希表查找 …

冒泡排序思想：每次从数组中找出最大值放在数组的后面去。
实现冒泡排序的关键步骤分析：确定总共需要做几轮排序；数组的长度-1；因为如果是4个数的话；每一轮都会找出一个最大值，那么四个数中找出三个最大值了最后面一个一定是最小的。

每轮比较几次：

i(轮数)     次数     次数规律：数组长度-1
    1		3
    2		2
    3		1
    
   public class Test3 {
    public static void main(String[] args) {

        //1、定义一个数组，存储一些数据
        int[] arr = {5, 2, 3, 1};
        //   0 1 2 3

        //2、定义一个循环控制比较的轮数
        for (int i = 1; i <= arr.length - 1; i++) {

            //i == 1    比较的次数：3   j = 0 1 2
            //i == 2     比较的次数 2   j = 1 2
            //i == 3    比较的次数  1  j = 0
            //控制每轮比较的次数、站位
            for (int j = 0; j < arr.length - i; 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");
        }

    }
}                                                                    //冒泡排序是面试的一大问点

七、两个变量指向同一个数组

public class Test4 {
    public static void main(String[] args) {
        int[] arr1 = {11,22,33};
        //把数组arr1变量赋值给int类型的数组变量arr2

        int[] arr2 = arr1;

        System.out.println(arr1);                        //可以的
        System.out.println(arr2);


        arr2[1] = 99;
        System.out.println(arr1[1]);
        System.out.println(arr2[1]);

    }

八、数组使用的常见问题

问题1：如果访问的元素位置超过最大索引，执行时会出现 ArrayIndexOutOfBoundsException (数组索引越界异常)

public static void main(String[] args) {
        int[] arr =  new int[]{11,12,13};
        System.out.println(arr[2]);
  //    System.out.println(arr[3]);     出现ArrayIndexOutOfBoundsException异常
    }

问题2：如果数组变量中没有存储数组的地址，而是null，在访问数组信息时会出现NullPointerException（空指针异常）

public static void main(String[] args) {
        int[] arr =  new int[]{11,12,13};
        System.out.println(arr[2]);
  //    System.out.println(arr[3]);     出现ArrayIndexOutOfBoundsException异常
    } 
arr = null;
        System.out.println(arr);
        System.out.println(arr.length);  // 出现 NullPointerException 异常  (空指针异常)