数组以及应用

最新推荐文章于 2022-04-17 16:35:55 发布

akiaug

最新推荐文章于 2022-04-17 16:35:55 发布

阅读量135

点赞数

分类专栏：拉勾教育 JavaSE 文章标签： java

本文链接：https://blog.csdn.net/Guai_Ka/article/details/110949855

版权

拉勾教育同时被 2 个专栏收录

62 篇文章 2 订阅

订阅专栏

JavaSE

32 篇文章 2 订阅

订阅专栏

前言

文章内容输出来源：拉勾教育JAVA就业训练营
总目录跳转链接：总目录
如有侵权请联系本人
邮箱:xiaogueika@tom.com

一维数组（掌握）

一维数组的基本概念

当需要在Java程序中记录单个数据内容时，则声明一个变量即可。
当需要在Java程序中记录多个类型相同的数据内容时，则声明一个一维数组即可，一维数组本质上就是在内存空间中申请一段连续的存储单元。
数组是相同数据类型的多个元素的容器，元素按线性顺序排列，在Java语言中体现为一种引用数据类型。

一维数组的声明方式

数据类型数组名称 = new 数据类型[数组的长度]；
调用数组的length属性可以获取数组的长度：
可以通过下标的方式访问数组中的每一个元素。需要注意的是：数组的下标从0开始，对于长度为n的数组，下标的范围是0～n-1。

package cn.cyh.array;
/**
 * 编程实现一维数组的声明和使用
 * @author cyh
 * @create 2020/12/10 11:56
 */
public class ArrayTest {
    public static void main(String[] args) {
        //1.声明一个长度为2元素类型为int类型的一维数组
        //数据类型[]数组名称=new数据类型[数组的长度]；
        //int arr1[]=new int[2];    //两种方式从结果上来说是一样的，不推荐使用
        //int num =2;               //声明一个初始值为2的变量
        int[] arr = new int[2];     //推荐该方式，更容易与变量的声明区分，提高了代码的可读性   动态方式
        //2.打印一维数组的长度以及每个元素的数值
        System.out.println("数组的长度是：" + arr.length); //2 下标0~1
        System.out.println("下标为0的元素是:" + arr[0]);   //默认0
        System.out.println("下标为1的元素是:" + arr[1]);   //0
        //System.out.println("下标为2的元素是:" + arr[2]);//错误:java.lang.ArrayIndexOutOfBoundsException(数组下标越界异常): 2
        System.out.println("--------------------------------------");
        //3.使用for循环打印数组中的所有元素
        for (int i = 0; i < arr.length; i++){
            System.out.println("下标为" + i + "的元素是：" + arr[i]);
        }
    }
}

一维数组的初始化方式

基本类型的数组（数据元素为基本类型）创建后，其元素的初始值：
byte short char int long为 0；
float和double为 0.0；
boolean为false。
可以在数组声明的同时进行初始化，具体如下：数据类型数组名称={初始值1，初始值2，…}；

		//4.声明一个长度为5元素类型为double类型的一维数组
        double[] arr1 =new double[5];
        for (int i = 0; i < arr1.length; i++){
            System.out.println("下标为" + i + "的元素是：" + arr1[i]);
        }
        System.out.println("-----------------------------------");
        //5.声明数组的同事就对数组中的元素进行初始化    静态方式
        char[] arr2 ={'a','b','c','d'};
        for (int i = 0; i < arr2.length; i++){
            System.out.println("下标为" + i + "的元素是：" + arr2[i]);
        }
        System.out.println("-----------------------------------");
        //6.特殊的写法
        boolean[] arr3 = new boolean[]{true,true,false,false};
        for (int i = 0; i < arr3.length; i++){
            System.out.println("下标为" + i + "的元素是：" + arr3[i]);
        }

内存结构之栈区

栈用于存放程序运行过程当中所有的局部变量。一个运行的Java程序从开始到结束会有多次变量的声明。

内存结构之堆区

JVM会在其内存空间中开辟一个称为“堆”的存储空间，这部分空间用于存储使用new关键字创建的数组和对象。

案例题目

声明一个长度为5元素类型为int类型的一维数组，打印数组中所有元素值；
使用元素11、22、33、44分别对数组中前四个元素赋值后再次打印；
将元素55插入到下标为0的位置，原有元素向后移动，再打印所有元素值；
将元素55从数组中删除，删除方式为后续元素向前移动，最后位置置为0 并打印；
查找数组中是否存在元素22，若存在则修改为220后再次打印所有元素；

package cn.cyh.array;

/**
 * 编程实现一维数组的增删改查操作
 * @author cyh
 * @create 2020/12/10 14:18
 */
public class ArrayOpTest {
    public static void main(String[] args) {
        /**
         *  - 声明一个长度为5元素类型为int类型的一维数组，打印数组中所有元素值；
         *  - 使用元素11、22、33、44分别对数组中前四个元素赋值后再次打印；
         *  - 将元素55插入到下标为0的位置，原有元素向后移动，再打印所有元素值；
         *  - 将元素55从数组中删除，删除方式为后续元素向前移动，最后位置置为0 并打印；
         *  - 查找数组中是否存在元素22，若存在则修改为220后再次打印所有元素；
         */
        //声明一个长度为5元素类型为int类型的一维数组，打印数组中所有元素值；
        int[] arr =new int[5];
        System.out.println("数组中所有元素值：");
        for (int i = 0; i < arr.length; i++){
            System.out.print(arr[i] + "\t");
        }
        System.out.println();
        System.out.println("------------------------");
        //使用元素11、22、33、44分别对数组中前四个元素赋值后再次打印；
//        arr[0] = 11;
//        arr[1] = 22;
//        arr[2] = 33;
//        arr[3] = 44;
        for (int i = 0; i < arr.length-1; i++){
            arr[i] = (i+1)*11;
        }
        System.out.println("数组中所有元素值：");
        for (int i = 0; i < arr.length; i++){
            System.out.print(arr[i] + "\t");
        }
        System.out.println();
        System.out.println("------------------------");
        //将元素55插入到下标为0的位置，原有元素向后移动，再打印所有元素值；
        for (int i = arr.length-1; i > 0; i--){
            arr[i] = arr[i-1];
        }
        arr[0] = 55;
        System.out.println("数组中所有元素值：");
        for (int i = 0; i < arr.length; i++){
            System.out.print(arr[i] + "\t");
        }
        System.out.println();
        System.out.println("------------------------");
        //将元素55从数组中删除，删除方式为后续元素向前移动，最后位置置为0 并打印；
        for (int i = 0; i < arr.length-1; i++){
            arr[i] = arr[i+1];
        }
        arr[4] = 0;
        System.out.println("数组中所有元素值：");
        for (int i = 0; i < arr.length; i++){
            System.out.print(arr[i] + "\t");
        }
        System.out.println();
        System.out.println("------------------------");
        //查找数组中是否存在元素22，若存在则修改为220后再次打印所有元素；
        for (int i = 0; i < arr.length; i++){
            if(22 == arr[i]){
                arr[i] = 220;
            }
        }
        System.out.println("数组中所有元素值：");
        for (int i = 0; i < arr.length; i++){
            System.out.print(arr[i] + "\t");
        }
        System.out.println();
    }
}

数组的优缺点

可以直接通过下标(或索引)的方式访问指定位置的元素，速度很快。
数组要求所有元素的类型相同。
数组要求内存空间连续，并且长度一旦确定就不能修改。
增加和删除元素时可能移动大量元素，效率低。

案例题目1.

声明一个初始值为11 22 33 44 55的一维数组并打印所有元素
声明一个长度为3元素类型为int类型的一维数组并打印所有元素
实现将第一个数组中间3个元素赋值到第二个数组中
再次打印第二个数组中的所有元素

package cn.cyh.array;

/**
 * 编程实现数组之间元素的拷贝
 * @author cyh
 * @create 2020/12/10 14:51
 */
public class ArrayCopyTest {
    public static void main(String[] args) {
        /**
         * > 声明一个初始值为11 22 33 44 55的一维数组并打印所有元素
         * > 声明一个长度为3元素类型为int类型的一维数组并打印所有元素
         * > 实现将第一个数组中间3个元素赋值到第二个数组中
         * > 再次打印第二个数组中的所有元素
         */
        //声明一个初始值为11 22 33 44 55的一维数组并打印所有元素
        int[] arr = {11,22,33,44,55};
        System.out.println("打印数组所有元素");
        for (int i = 0; i < arr.length; i++){
            System.out.print(arr[i] + "\t");
        }
        System.out.println();
        System.out.println("--------------------------------------------------");
        //声明一个长度为3元素类型为int类型的一维数组并打印所有元素
        int[] arr1 =new int[3];
        System.out.println("打印数组所有元素");
        for (int i = 0; i < arr1.length; i++){
            System.out.print(arr1[i] + "\t");
        }
        System.out.println();
        System.out.println("--------------------------------------------------");
        //实现将第一个数组中间3个元素赋值到第二个数组中
//        for (int i = 0; i < arr1.length; i++){
//            arr1[i] =arr[i+1];
//        }
        //优化:
        //可以直接使用Java官方提供的拷贝功能
        //表示将数组arr中下标从1开始的3个元素拷贝到数组brr中下标从0开始的位置
        System.arraycopy(arr,1,arr1,0,3);
        //再次打印第二个数组中的所有元素
        System.out.println("打印数组所有元素");
        for (int i = 0; i < arr1.length; i++){
            System.out.print(arr1[i] + "\t");
        }
        System.out.println();
    }
}

笔试考点

		//笔试考点
        //表示将变量arr的数值赋值给变量arr1，覆盖变量arr1中原来的数值
        //数组名arr的内存空间中存放的是数据在堆区中的内存地址信息，赋值后让arr1变量中存放了arr所指向堆区的内存地址
        //也就是让arr1和arr指问了同一块堆区空间
        arr1 = arr;
        System.out.println("打印数组所有元素");
        for (int i = 0; i < arr1.length; i++){
            System.out.print(arr1[i] + "\t");
        }
        System.out.println();

在这里插入图片描述

案例题目2.

编程统计用户输入任意一个正整数中每个数字出现次数的统计并打印。
如：123123 => 1出现2次，2出现2次，3出现2次

package cn.cyh.array;

import java.util.Scanner;

/**
 * 编程使用数组实现正整数中每个数字出现次数的统计
 * @author cyh
 * @create 2020/12/10 15:20
 */
public class ArrayCountTest {
    public static void main(String[] args) {
        //1.提示用户输入一个正整数并使用变量记录
        System.out.println("请输入一个正整数:");
        Scanner scanner =new Scanner(System.in);
        int num =scanner.nextInt();
        //2.准备一个长度为10元素类型int类型的一维数组
        int[] arr = new int[10];
        //3.拆分正整数中的每个数字并统计到一维数组中
        int temp =num;
        while (temp > 0){
            arr[temp%10]++;
            temp/=10;
        }
        //4.打印最终结果
        for (int i = 0; i < arr.length; i++){
            if(arr[i] > 0){
                System.out.println("数字" + i + "出现了" + arr[i] + "次");
            }
        }
    }
}

案例题目3

提示用户输入学生的人数以及每个学生的考试成绩并打印出来。
计算该班级的总分和平均分并打印出来。

package cn.cyh.array;

import java.util.Scanner;

/**
 * 编写使用数组来记录学生的考试成绩并打印
 * @author cyh
 * @create 2020/12/10 15:32
 */
public class ArrayScoreTest {
    public static void main(String[] args) {
        /**
         * > 提示用户输入学生的人数以及每个学生的考试成绩并打印出来。
         * > 计算该班级的总分和平均分并打印出来。
         */
        //提示用户输入学生的人数以及每个学生的考试成绩并打印出来。
        System.out.println("请输入学生的人数");
        Scanner scanner =new Scanner(System.in);
        int num =scanner.nextInt();
        int[] score =new int[num];
        for (int i = 0; i < score.length; i++) {
            System.out.println("请输入第" + (i+1) + "学生的成绩");
            score[i] = scanner.nextInt();
        }
        for (int i = 0; i < score.length; i++) {
            System.out.println("第" + (i+1) + "学生的成绩为:" + score[i]);
        }
        //计算该班级的总分和平均分并打印出来。
        int sum = 0;
        for (int i = 0; i < score.length; i++) {
            sum += score[i];
        }
        System.out.println("该班级的总分:" + sum);
        System.out.println("该班级的平均分:"+ sum * 1.0 / num );
    }
}

数组工具类的概念

java.util.Arrays类可以实现对数组中元素的遍历、查找、排序等操作。
数组工具类的常用方法

Arrays常用方法	注解
static String toString(int[] a)	输出数组中的内容
static void fill(int[] a, int val)	将参数指定元素赋值给数组中所有元素
static boolean equals(boolean[] a,boolean[] a2)	判断两个数组元素内容和次序是否相同
static void sort(int[] a)	对数组中的元素进行从小到大排序
static int binarySearch(int[] a, int key)	从数组中查找参数指定元素所在的位置

package cn.cyh.array;

import java.util.Arrays;

/**
 * 编程实现数组工具类的使用
 * @author cyh
 * @create 2020/12/10 15:45
 */
public class ArraysTest {
    public static void main(String[] args) {
        //1.声明一个初始值为10、20、30、40、50的一维数组
        int[] arr = {10,20,30,40,50};
        //2.使用原始方式打印数组中的所有元素，要求打印格式为：[10，20，30，40，50]
//        System.out.print("第一个数组中的元素有:[");
//        for (int i = 0; i < arr.length; i++) {
//            if(arr.length-1 ==i){
//                //当打印的元素是最后一个元素时，则直接打印元素本身即可
//                System.out.print(arr[i]);
//            }else{
//                //否则打印元素后打印逗号加空格
//                System.out.print(arr[i] + ", ");
//            }
//        }
//        System.out.print("]");
        System.out.println();
        //3.使用数组工具类实现数组中所有元素的打印 toString
        System.out.println("第一个数组中的元素有:" + Arrays.toString(arr));
        System.out.println("------------------------------------------------");
        //4.声明一个长度为5元素类型为int类型的一维数组
        int[] arr1 =new int[5];
        System.out.println("第二个数组中的元素有:" + Arrays.toString(arr1));

        //表示使用10来填充数组arr中的每个元素，也就是给数组中每个元素赋值为10
        Arrays.fill(arr1,10);
        System.out.println("第二个数组中的元素有:" + Arrays.toString(arr1));
        System.out.println("------------------------------------------------");
        //5.声明一个长度为5元素类型为int类型的一维数组并初始化
        int[] arr2 =new int[5];
        Arrays.fill(arr2,10);
        System.out.println(Arrays.equals(arr1,arr2));
        arr2[4] = 20;
        System.out.println("第三个数组中的元素有:" + Arrays.toString(arr2));
        System.out.println(Arrays.equals(arr1,arr2));
        arr1[3] = 20;
        System.out.println("第三个数组中的元素有:" + Arrays.toString(arr1));
        System.out.println(Arrays.equals(arr1,arr2));
        //6.声明一个初始值乱序的一维数组
        int[] arr3 = {35,26,6,38,23,29};
        System.out.println(Arrays.toString(arr3));
        Arrays.sort(arr3);
        System.out.println(Arrays.toString(arr3));
        //从数组中查找指定元素所在小标的位置
        System.out.println(Arrays.binarySearch(arr3,35)+1);
    }
}

二维数组（熟悉）

二维数组的概念

二维数组本质上就是由多个一维数组摞在一起组成的数组，二维数组中
的每个元素都是一维数组，而一维数组中的每个元素才是数据内容。

二维数组的声明和初始化方式

数据类型[][] 数组名称 = new 数据类型[行数][列数];
数据类型[][] 数组名称 = {{元素1,元素2，…}, …};

package cn.cyh.array;
/**
 * 编程实现二维数组的声明和使用
 * @author Administrator
 * @create 2020/12/10 16:42
 */
public class ArrayArrayTest {
    public static void main(String[] args) {
        //1.声明一个具有2行2列元素类型为int类型的二维数组
        int[][] arr =new int[2][2];
        //打印数组中的每个元素
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }
        System.out.println("----------------------------------");
        //2.实现二维数组中元素的赋值    动态
        int index = 1;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] =index++;
            }
        }
        //打印数组中的每个元素
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }
        System.out.println("-------------------------------");
        //3.二维数组元素的初始化操作    静态
        int[][] drr ={{11,22,33,44},{12,23,34,45}};
        //打印数组中的每个元素
        for (int i = 0; i < drr.length; i++) {
            for (int j = 0; j < drr[i].length; j++) {
                System.out.print(drr[i][j]+"\t");
            }
            System.out.println();
        }
    }
}

笔试考点

		int[][] crr =new int[3][];
        crr[0] =new int[3];
        crr[1] =new int[4];
        crr[2] =new int[5];

案例题目

根据用户输入的行数n输出对应行数的杨辉三角，具体如下：

package cn.cyh.array;
import java.util.Scanner;
/**
 1. 编程使用二维数组来实现杨辉三角的生成和遍历
 2. @author cyh
 3. @create 2020/12/10 16:56
 */
public class ArrayArrayTriangleTest {
    public static void main(String[] args) {
        //1.提示用户输入一个行数并使用变量记录
        System.out.println("请输入一个行数:");
        Scanner scanner =new Scanner(System.in);
        int num = scanner.nextInt();
        //2.根据用户输入的行数来声明对应的二维数组
        int[][] arr =new int[num][];
        //3.针对二维数组中的每个元素进行初始化，使用双重for循环
        for (int i = 0; i < num; i++) {
            arr[i] =new int[i+1];
            for (int j = 0; j <= i; j++) {
                //当列下标为0或者列下标与当前行的行下标相等时，则对应位置的元素就是1
                if(0 == j || i == j){
                    arr[i][j] = 1;
                } else {
                    //否则对应位置的元素就是上一行当前列的元素加上上一行前一列的元素
                    arr[i][j] = arr[i-1][j] +arr[i-1][j-1];
                }
            }
        }
        //4.打印最终生成的结果
        for (int i = 0; i < num; i++) {
            for (int j = 0; j <= i; j++) {
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

知识总结

一维数组 (重点)
基本概念、两种声明方式、增删改查操作、优缺点、数组工具类等
二维数组
基本概念、两种声明方式等

akiaug

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
数组以及应用

一维数组的基本概念当需要在Java程序中记录单个数据内容时，则声明一个变量即可。当需要在Java程序中记录多个类型相同的数据内容时，则声明一个一维数组即可，一维数组本质上就是在内存空间中申请一段连续的存储单元。数组是相同数据类型的多个元素的容器，元素按线性顺序排列，在Java语言中体现为一种引用数据类型。一维数组的声明方式数据类型数组名称 = new 数据类型[数组的长度]；调用数组的length属性可以获取数组的长度：可以通过下标的方式访问数组中的每一个元素。需要注意的是：数组的
复制链接

扫一扫