Javaj基础——数组

最新推荐文章于 2024-07-14 22:18:32 发布
最新推荐文章于 2024-07-14 22:18:32 发布
阅读量145 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53605652/article/details/131794379
版权

1 一维数组

1.1 概念

  数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的 方式对这些数据进行统一管理。

  • 变量：在内存开辟一块空间。
  • 数组：也是变量，在内存中开辟一串连续的空间。数组长度一旦确定，就不能修改。

数组的常见概念

  • 数组名
  • 下标(或索引)
  • 元素
  • 数组的长度

1.2 基本用法

1. 格式

  • 格式 1. 数据类型[] 数组名，属于只创建了数组引用名， 并未在内存创建数组空间
  • 格式 2. 数据类型[] 数组名称 = new 数据类型[数组长度];
  • 格式 3. 数据类型[] 数组名称 = {数组内容 1,数组内容 2,数组内容 3...数组内容 n};
  • 格式 4. 数据类型[] 数组名称 = new 数据类型[]{内容 1,内容 2,内容 3...内容 n}

2. 代码

public static void main(String[] args) {
        // 1、声明数组
        //1.1 先声明，后开辟空间：数据类型[] 数组名称;
        int[] arr1;//声明
        arr1 = new int[4];//开辟空间：数组名称=new 数据类型[数组长度]; 数组的长度一旦确定，不可以改变
        //1.2 声明数组的同时开辟空间
        double[] arr2 = new double[5];
        System.out.println(arr1);
        System.out.println(arr2);
        //1.3 声明数组
        String[] arr3;//只是声明，没有在内存中开辟数组空间
        //System.out.println(arr3);
        //1.4 声明数组的同时赋值 数据类型[] 数组名称=new 数据类型[]{数组值1,数组值2,数组值3,数组值4......数组值n};
        //此时数组的长度由赋值的个数决定
        int[] arr4 = new int[]{1, 2, 3, 4, 5};
        System.out.println(arr4);
        //1.5 声明数组的同时赋值 数据类型[] 数组名称={数组值1,数组值2,数组值3,数组值4......数组值n};
        //此时数组的长度由赋值的个数决定
        double[] arr5 = {1.5, 3.6, 5.8, 4.0};
    }

1.3 内存结构

JMM、JVM的内存结构

第四行代码内存状态

 第5行代码内存状态

 

 1.4 数组实战

1. 读取数组

取出数组中的值：数组名称[下标索引]

public static void main(String[] args) {
        //1、声明数组并开辟空间
        int[] arr1 = new int[4];
        //2、给数组赋值：数组名称[下标索引]=值；下标索引从0开始，最大比数组长度小1
        //数组长度:数组名称.length获取
        //原始赋值方式：
        /*
         * arr1[0]=2;
         * arr1[1]=4;
         * arr1[2]=6;
         * arr1[3]=8;
         */
        //推荐使用循环的方式数组
        for (int i = 0; i < arr1.length; i++) {
            arr1[i] = i + 1;
        }
        //3、使用数组
        for (int i = 0; i < arr1.length; i++) {
            System.out.println(arr1[i]);
        }
    }

2. 数组的默认值

public static void main(String[] args) {
        //int类型数组元素的默认值是0
        int[] arr1 = new int[4];
        for (int i = 0; i < arr1.length; i++) {
            System.out.println(arr1[i]);
        }
        //double类型数组元素的默认值是0.0
        double[] arr2 = new double[4];
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }
        //String类型数组元素的默认值是null
        String[] names = new String[5];
        for (int i = 0; i < names.length; i++) {
            System.out.println(names[i]);
        }
        //char类型数组元素的默认值是0
        char[] genders = new char[5];
        for (int i = 0; i < genders.length; i++) {
            System.out.println((int)genders[i]);
        }
        //boolean类型数组元素的默认值是false
        System.out.println("over");
    }

3. 求极值问题

public static void main(String[] args) {
        //找出指定数组{12,43,-45,567,13}中的最大值和最小值
        int[] arr = {12, 43, -45, 567, 13};
        //定义极值：一定数组元素，一般把第一个元素作为最大值的初始值
        int max = arr[0];//12
        int min = arr[0];
        //循环比对
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
            if (arr[i] < min) {
                min = arr[i];
            }
        }
        System.out.println("最大值是:" + max);
        System.out.println("最小值是:" + min);
    }

1.5 练习

  从键盘读入学生成绩，找出最高分，并输出学生成绩等级。

  • 成绩>=最高分-10 等级为’A’
  • 成绩>=最高分-20 等级为’B’
  • 成绩>=最高分-30 等级为’C’
  • 其余 等级为’D’

  提示：先读入学生人数，根据人数创建int数组，存放学生成绩

 public static void main(String[] args) {
        //1.使用Scanner，读取学生个数
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入学生人数：");
        int number = scanner.nextInt();
        //2.创建数组，存储学生成绩：动态初始化
        int[] scores = new int[number];
        //3.给数组中的元素赋值
        System.out.println("请输入" + number + "个学生成绩：");
        int maxScore = 0;
        for (int i = 0; i < scores.length; i++) {
            scores[i] = scanner.nextInt();
            //4.获取数组中的元素的最大值:最高分
            if (maxScore < scores[i]) {
                maxScore = scores[i];
            }
        }
        //5.根据每个学生成绩与最高分的差值，得到每个学生的等级，并输出等级和成绩
        char level;
        for (int i = 0; i < scores.length; i++) {
            if (maxScore - scores[i] <= 10) {
                level = 'A';
            } else if (maxScore - scores[i] <= 20) {
                level = 'B';
            } else if (maxScore - scores[i] <= 30) {
                level = 'C';
            } else {
                level = 'D';
            }
            System.out.println("student " + i +
                    " score is " + scores[i] + ",grade is " + level);
        }

    }

2 二维数组

2.1 概念

  对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存 在。其实，从数组底层的运行机制来看，其实没有多维数组

1. 语法格式

格式1：

int[][] arr = new int[3][2]
  • 定义了名称为arr的二维数组
  • 二维数组中有3个一维数组
  • 每一个一维数组中有2个元素
  • 一维数组的名称分别为arr[0], arr[1], arr[2]
  • 给第一个一维数组1脚标位赋值为78写法是： arr[0][1] = 78

格式2：

int[][] arr = new int[3][];
  • 二维数组中有3个一维数组个一维数组都是。
  • 每默认初始化值null (注意：区别于格式1）
  • 可以对这个三个一维数组分别进行初始化 arr[0] = new int[3]; arr[1] = new int[1]; arr[2] = new int[2];

注： int[][] arr = new int[][3] 非法

格式3：

int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};
  • 定义一个名称为arr的二维数组，二维数组中有三个一维数组
  • 每一个一维数组中具体元素也都已初始化 第一个一维数组 arr[0] = {3,8,2};
  • 第二个一维数组 arr[1] = {2,7};
  • 第三个一维数组 arr[2] = {9,0,1,6};
  • 第三个一维数组的长度表示方式：arr[2].length;

2.2 二维数组的使用

1. 方式1：

int[][] arr1 = new int[3][2];        
arr1[0][1] = 3;

 2. 方式2：

//方式2

        int[][] arr2 = new int[3][];
        arr2[0] = new int[3];
        arr2[1] = new int[4];
        arr2[0][1] = 3;

 3. 方式3：

public static void main(String[] args) {
        //方式3
        int[][] arr2 = new int[][]{{3,8,2},{2,7}, {9,0,1,6}};
        //取值
        for (int i = 0; i < arr2.length; i++) {
            for (int j = 0; j < arr2[i].length; j++) {
                System.out.println(arr2[i][j]);
           }
            System.out.println("------------------");
       }
   }

 2.3 内存结构

 

 

2.4 练习

  • 基本都跟循环打交道；一维数组数组一重循环；2维数组数组2重循环；
  • 基本离不开坐标问题；一维数组一个下标索引；二维数组一定就是两个坐标（横纵坐标）
public static void main(String[] args) {

        Scanner input = new Scanner(System.in);
        //1、计算3个班级所有学生的平均分：每个班级有n个人，要求先输出各个班级的自己的平均分

        double[][] score = new double[3][];//列数省略，需要自己去开辟空间

        for (int i = 0; i < score.length; i++) {
            double sum = 0;
            System.out.print("请输入第" + (i + 1) + "个班级的学生人数:");
            int num = input.nextInt();
            score[i] = new double[num];//不开空间默认null,会报出NullPointerException异常

            //System.out.println(score[i]);

            for (int j = 0; j < num; j++) {
                System.out.print("请输入第" + (j + 1) + "个同学的成绩：");
                score[i][j] = input.nextDouble();
                sum += score[i][j];
            }
            System.out.println("第"+ (i + 1) +"个班级的平均分是：" + sum / num);
        }


    }

3 数组中常见算法

3.1 二分查找

  数组的复制、反转、查找(线性查找、二分法查找)

public static void main(String[] args) {

        String[] arr = new String[]{"JJ", "DD", "MM", "BB", "GG", "AA"};

        //数组的复制(区别于数组变量的赋值：arr1 = arr)
        String[] arr1 = new String[arr.length];
        for (int i = 0; i < arr1.length; i++) {
            arr1[i] = arr[i];
        }

        //数组的反转
        // for(int i = 0,j = arr.length - 1;i < j;i++,j--){
        // String temp = arr[i];
        // arr[i] = arr[j];
        // arr[j] = temp;
        // }

        //遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
        System.out.println();

  

//查找（或搜索）
        //线性查找：
        String dest = "BB";
        dest = "CC";
        boolean isFlag = true;
        for (int i = 0; i < arr.length; i++) {
            if (dest.equals(arr[i])) {
                System.out.println("找到了指定的元素，位置为：" + i);
                isFlag = false;
                break;
            }
        }
        if (isFlag) {
            System.out.println("很遗憾，没有找到的啦！");
        }

        //二分法查找：(熟悉)
        //前提：所要查找的数组必须有序。
        int[] arr2 = new int[]{-98, -34, 2, 34, 54, 66, 79, 105, 210, 333};
        int dest1 = -34;
        dest1 = 35;
        int head = 0;//初始的首索引
        int end = arr2.length - 1;//初始的末索引
        boolean isFlag1 = true;
        while (head <= end) {
            int middle = (head + end) / 2;
            if (dest1 == arr2[middle]) {
                System.out.println("找到了指定的元素，位置为：" + middle);
                isFlag1 = false;
                break;
            } else if (arr2[middle] > dest1) {
                end = middle - 1;
            } else {//arr2[middle] < dest1

                head = middle + 1;
            }
        }

        if (isFlag1) {
            System.out.println("很遗憾，没有找到的啦！");
        }
  }

 3.2 排序算法

衡量排序算法的优劣：

  • 时间复杂度：分析关键字的比较次数和记录的移动次数
  • 空间复杂度：分析排序算法中需要多少辅助内存
  • 稳定性：若两个记录A和B的关键字值相等，但排序后A、B的先后次序保持不变，则称这种排序算 法是稳定的。

3.3 冒泡排序

  重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

 public static void main(String[] args) {

            int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};

            //冒泡排序
            for (int i = 0; i < arr.length - 1; i++) {
                for (int j = 0; j < arr.length - 1 -i; j++) {
                    if (arr[j] > arr[j + 1]){
                        int temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }

            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + "\t");
            }

        }

3.4 Arrys工具类

public static void main(String[] args) {
        //1.boolean equals(int[] a,int[] b):判断两个数组是否相等。
        int[] arr1 = new int[]{1, 2, 3, 4};
        int[] arr2 = new int[]{1, 2, 3, 4};
        boolean isEquals = Arrays.equals(arr1, arr2);
        System.out.println(isEquals);

        //2.String toString(int[] a):输出数组信息。
        System.out.println(Arrays.toString(arr1));

        //3.void fill(int[] a,int val):将指定值填充到数组之中。
        Arrays.fill(arr1, 10);
        System.out.println(Arrays.toString(arr1));

        //4.void sort(int[] a):对数组进行排序。
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2));

        //5.int binarySearch(int[] a,int key)
        int[] arr3 = new int[]{-98, -34, 2, 34, 54, 66, 79, 105, 210, 333};
        int index = Arrays.binarySearch(arr3, 210);
        if (index >= 0) {
            System.out.println(index);
        } else {
            System.out.println("未找到");
        }
    }

四两迷糊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java读取到数组_使用Java数组读取数组？
weixin_39696665的博客
02-25 1762
如果a = [[1,[],“ f”,3],[3,[4,“ x”]]]]和b = [1,1].我想像a [1] [1]一样读取a by b,以获得[4,“ x”].请注意,b是一个只能由整数组成的数组.您也可以执行eval(‘a [‘b.join(‘],[‘)’]’),但需要实际的变量名作为字符串,这很丑陋.这是我的一些功能：Array.prototype.readByArray = functio...
Java基础——数组
AlexTuringGong的博客
01-08 114
内存分析 创建一个数组后，存在栈里，他的第一个元素在堆空间里的地址也就是首地址，就是该数组的内存地址，用一个十六进制数表示。 一开始数组里的值都默认为null/0，添加元素后被替代。 一旦数组再次初始化，原有的数组就被垃圾回收器回收，内存地址也会发生变化。 当方法执行完后，所有的数组出栈，内容也会被垃圾回收器回收。 二维数组 初始化方式： 1) int[][] array1 = new int[2][]; array1[0] = new int[1]; array1[0][0
java 数组和字符串操作
蓝朽的小世界
04-11 1654
java 数组和字符串操作
java读写数组
m0_58166680的博客
05-01 1488
今天做作业时遇到一个要读写数组到文件的问题，即要把一个数组从文件读到内存，以及把一个数组从内存写到文件
Java数组类型
m0_63293142的博客
12-12 851
定义一个数组类型的变量，使用数组类型“数据类型[]”的语法，例如，int[]。和单个基本类型变量不同，数组变量初始化必须使用new int[5]或{... ...}表示创建一个可容纳5个int元素的数组内存空间。Java的数组有几个语法特点：●数组所有元素初始化为默认值，整型都是0，浮点型是0.0，布尔型是false；●数组一旦创建后，大小就不可改变，所以说数组长度固定；●访问数组中的某一个元素，需要使用索引。数组索引从0开始。例如，5个元素的数组，索引范围是0~4。
java读入整型数组的方式
weixin_43242420的博客
12-15 4888
平时习惯用c++写算法题，毕竟有STL可以用且输入耗时少，最近有几个作oj题要用java，且需要自己写输入输出，原先不太熟悉java的输入输出方法，于是去整理了一下 java的从输入读取两个整型数组 public static void main (String[] args) { Scanner sc = new Scanner(System.in); String str1 = sc.nextLine().toString();//读取第一行 String str2 = sc.nextLine(
Javaj基础企业应用实战
06-29
Javaj基础企业应用实战。请仔细阅读。。
JAVAJ2EE大作业——学生信息管理系统.pdf
11-14
《JAVA & J2EE大作业——学生信息管理系统》是一个基于JAVA和J2EE技术实现的项目，主要目标是设计和实现一个能够管理学生信息的系统。在这个系统中，`Find.java`类扮演了查找学生信息的关键角色。这个类使用了Java的...
Java基础总结
04-29
xmind文件，Java基础总结，包含数据类型、String、运算、Object通用方法、继承、关键字、反射、异常泛型、注解、特性方面
java库 读取文件内容并转换为数组
11-25
java库 读取文件内容并转换为String数组，以便进行进一步操作
Java基础面试题
11-15
java常见基础面试题
JAVAj将页面生成PDF
06-17
在Java开发中，将网页内容转化为PDF文档是一项常见的需求，比如用于报表打印、电子文档存储等。本篇文章将深入探讨如何使用Java技术实现这一功能，主要关注以下几个关键知识点： ... 2. **Flying Saucer库的使用**：...
Java中的数组
m0_67683346的博客
05-02 1816
初识Java中的数组
Java从输入中读取一个数组
No_Showbo的博客
05-13 1万+
最近在编程中遇到了如下问题：如何从输入中读取一个数组，一直调试出问题，后来查阅了一些资料终于解决了。这主要是关于scanner扫描器中的nextLine（）方法以及spilt（）方法的应用，代码如下所示：import java.util.Scanner; public class Main { public static void main(String[] args) { // TOD...
java获取数组的前3个字节_乐字节Java反射之三：方法、数组、类加载器
weixin_36024234的博客
02-24 869
继续讲述Java反射之三：方法、数组、类加载器一、方法获取所有方法(包括父类或接口)，使用Method即可。public static void test() throws Exception {Class> clz = Class.forName("com.shsxt.ref.simple.User ");//获取属性System.out.println("===============本...
Java：获取数组中的子数组的多种方法
个人博客
03-21 3万+
文章目录Java：从一个数组中创建子数组使用Arrays.copyOfRange函数使用subList Java：从一个数组中创建子数组 使用Arrays.copyOfRange函数 Arrays.copyOfRange支持：boolean[]， byte[] ，char[]，double[]，float[]，int[]，long[]以及泛型的 T[] 使用示例如下： import java.ut...
读取Java文件到byte数组的三种方式
热门推荐
z69183787的专栏
11-22 8万+
Java代码   import java.io.BufferedInputStream;   import java.io.ByteArrayOutputStream;   import java.io.File;   import java.io.FileInputStream;   import java.io.FileNotFoundException;   impo
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
最新发布
m0_73456341的博客
07-14 831
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
javaj对象数组list，转成map。key为一个属性，value为对象本身
05-27
可以使用 Java 8 的 Stream API 将对象数组转换成 Map，示例代码如下： 假设对象数组的类型为 `MyObject`，对象属性为 `id`，那么代码如下： ```java List<MyObject> list = new ArrayList<>(); // 添加对象到列表中 Map<Integer, MyObject> map = list.stream() .collect(Collectors.toMap(MyObject::getId, Function.identity())); ``` 上述代码中的 `MyObject::getId` 表示获取对象的 `id` 属性作为 Map 的键，`Function.identity()` 表示获取对象本身作为 Map 的值。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值