java快速入门--数组，二维数组

已于 2022-03-27 15:58:09 修改
阅读量372 收藏
点赞数
文章标签： java 开发语言 后端
于 2021-11-28 18:42:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46435451/article/details/121595396
版权

数组

介绍：可以存放多个同一类型的数据，数组也是一种数据类型，是引用类型，即：数组就是一组数据

package com.company.hello;

import java.util.Scanner;

/**
 * 数组快速入门
 *
 * @author L.yn
 * @version 1.0
 * @date 2021/11/21 9:21
 */
public class ArrayTest {
    public static void main(String[] args) {
        //定义一个数组
        /**
         * 1、double[] 表示 是double类型的数组，数组名 hens
         * 2、{3, 5, 1, 3.4, 2, 50}表示数组的值/元素
         */
        double[] hens = {3, 5, 1, 3.4, 2, 50};

        //遍历数组得到数组的所有元素的和
        /**
         * 可以通过hens[下标]来访问数组的元素，下标是从0开始编号的比如第一个元素就是hens[0]
         * 通过循环访问
         */
        for (double hen : hens) {
            System.out.println(hen);
        }
        for (int i = 0; i < hens.length; i++) {
            System.out.println(hens[i]);
        }

        //演示 循环输入五个成绩，保存到double数组，并输出
        //1、创建一个double数组，大小5
        double[] score = new double[5];
        //2、循环输入
        for (int i = 0; i < score.length; i++) {
            System.out.println("请输入元素的值");
            double aDouble = new Scanner(System.in).nextDouble();
            score[i] = aDouble;
        }
        //输出，遍历数组
        for (double v : score) {
            System.out.println(v);
        }
    }
}

数组的使用

  1. 使用方式1-动态初始化

    1. 数组的定义
      数据类型[] 数组名 = new 数据类型[大小]
      int[] arr = new int[5];//创建了一个数组，名字为arr，存放五个int
      说明：这是定义数组的一种方法
      在这里插入图片描述

    2. 数组的引用（使用）

      1. 数组名[下标/索引]，比如：你要使用A数组的第三个数 A[2]
  2. 使用方式2-动态初始化
    1. 先声明数组
      语法：数据类型[] 数组名
      int[] arr;
    2. 创建数组
      语法：数组名 = new 数据类型[大小]
      arr = new int[10]
  3. 使用方式3-静态初始化
    1. 初始化数组
      语法：数据类型[] 数组名 = {元素值，元素值…}
      int[] arr = {1,2,3,4,5,…}

数组使用注意事项和细节

  1. 数组是多个相同类型数据的组合，实现对这些数据的统一管理
  2. 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用
  3. 数组创建后，如果没有赋值，有默认值
  4. 使用数组的步骤
    1. 声明数组并开辟空间
    2. 给数组各个元素赋值
    3. 使用数组
  5. 数组的下标是从0开始的
  6. 数组下标必须在指定范围内使用，否则报：下标越界异常
  7. 数组属于引用类型，数组型数据是对象（object）

数组赋值机制

  1. 基本数据类型赋值，这个值就是具体的数据，而且相互不影响
    int n1 = 2; int n2 = n1;
  2. 数组在默认情况下是引用传递，赋的值是地址

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jD63RT2P-1638096009413)(C:\Users\MSI-NB\AppData\Roaming\Typora\typora-user-images\image-20211121151250641.png)]

排序

排序的介绍

排序是将一群数据，依指定的顺序进行排列的过程

排序的分类

  • 内部排序：
    指将需要处理的所有数据都加载到内部存储器中进行排序。包括（交换式排序法、选择式排序法和插入式排序法）

  • 外部排序法：
    数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。包括（合并排序法和直接合并排序法）

  • 冒泡排序
    通过对待排序序列从后向前（从下标较大的元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移到后，就像水底下的气泡一样逐渐向上冒

    package com.company.hello;

/**
 * 冒泡排序
 *
 * @author L.yn
 * @version 1.0
 * @date 2021/11/28 16:02
 */
public class BubbleSort {
    public static void main(String[] args) {
        /**
         * 将五个无序：24，69，80，57，13使用冒泡排序将其排成一个从小到大的有序数列
         * 思路
         * 第一轮排序：目标把最大数放在最后
         * 第一次比较：[24,69,80,57,13]
         * 第二次比较：[24,69,80,57,13]
         * 第三次比较：[24,69,57,80,13]
         * 第四次比较：[24,69,57,13,80]
         *
         * 第二轮排序：目标把第二大数放在倒数第二位置
         * 第一次比较：[24,69,57,13,80]
         * 第二次比较：[24,57,69,13,80]
         * 第三次比较：[24,57,13,69,80]
         *
         * 第三轮排序：目标把第三大数放在倒数第三位置
         * 第一次比较：[24,57,13,69,80]
         * 第二次比较：[24,13,57,69,80]
         *
         * 第四轮排序：目标把第四大数放在倒数第四位置
         * 第一次比较：[13,24,57,69,80]
         *
         * 总结冒泡排序特点
         * 一：一共有五个元素
         * 二：一共进行了四轮排序，可以看成是外层循环
         * 三：每一轮排序可以确定一个数的位置，比如第一轮排序确定最大数...
         * 四：当进行比较时，如果前面的数小于后面的数，就交换
         * 五：每轮比较在减少 4->3->2->1
         */
        int[] arr = {24, 69, 80, 57, 13};
        int temp = 0;//用于辅助交换的变量
        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]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            /**
             * 第1轮
             * 24	69	57	13	80	
             * 第2轮
             * 24	57	13	69	80	
             * 第3轮
             * 24	13	57	69	80	
             * 第4轮
             * 13	24	57	69	80	
             */
            System.out.println("\n第" + (i + 1) + "轮");
            for (int ae : arr) {
                System.out.print(ae + "\t");
            }
        }

    }
}

查找

介绍

在java中，我们常用的查找有两种

  • 顺序查找

    package com.company.hello;

import java.util.Scanner;

/**
 * 顺序查找
 *
 * @author L.yn
 * @version 1.0
 * @date 2021/11/28 16:41
 */
public class SeqSearch {
    public static void main(String[] args) {
        /**
         * 有一个数列：白眉鹰王，金毛狮王，紫衫龙王，青翼蝠王猜数游戏：
         * 从键盘中任意输入一个名称，判断数列中是否包含此名称【顺序查找】
         * 要求：如果找到了，就提示找到，并给出下标
         *
         * 思路
         * 一、定义一个字符串数组
         * 二、接收用户输入，遍历数组，逐一比较，如果有，则提示信息，并退出
         */

        //定义一个字符串数组
        String[] name = {"白眉鹰王", "金毛狮王", "紫衫龙王", "青翼蝠王"};
        System.out.println("请输入名字");
        String findName = new Scanner(System.in).nextLine();
        boolean deflag = true;
        for (int i = 0; i < name.length; i++) {
            //比较字符串 equals，如果要找到名字就是当前元素
            if (findName.equals(name[i])) {
                System.out.println("恭喜你找到:" + findName);
                System.out.println("下标=" + i);
                deflag = false;
                break;
            }
        }
        if (deflag){
            //没有找到
            System.out.println("没有找到...");
        }
    }
}

  • 二分法查找

多维数组–二维数组

package com.company.hello;

/**
 * 二维数组快速入门
 *
 * @author L.yn
 * @version 1.0
 * @date 2021/11/28 16:54
 */
public class TwoDimensionalArray {
    public static void main(String[] args) {
        /**
         * 快速入门案例：
         * 请用二维数组输出如下图形
         * 0 0 0 0 0 0
         * 0 0 1 0 0 0
         * 0 2 0 3 0 0
         * 0 0 0 0 0 0
         *
         * 什么是二维数组
         * 一：从定义上看 int[][]
         * 二：可以这样理解，原来的一维数组的每个元素是一维数组，就构成二维数组
         */
        int[][] arr = {
                {0, 0, 0, 0, 0, 0},
                {0, 0, 1, 0, 0, 0},
                {0, 2, 0, 3, 0, 0},
                {0, 0, 0, 0, 0, 0}
        };
        //关于二位数组的关键概念
        //1、获取二位数组的元素个数
        System.out.println("二位数组的元素个数：" + arr.length);
        //2、二维数组的每个元素都是一维数组，所以如果需要得到每个一维数组的值，还需要再次遍历
        //3、如果我们要访问第i+1个一维数组的第j个值 arr[i][j]


        //输出二维图形
        for (int i = 0; i < arr.length; i++) {
            //遍历二维数组的每个元素（数组）
            /**
             * arr[i]表示二维数组的第i+1个元素，比如arr[0]:二维数组的第一个元素
             * arr[i].length 得到对应的每一个一维数组的长度
             *
             * 0	0	0	0	0	0
             * 0	0	1	0	0	0
             * 0	2	0	3	0	0
             * 0	0	0	0	0	0
             */
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + "\t");//输出一维数组
            }
            System.out.println();//换行
        }
    }
}

二维数组的使用

  • 使用方式一

    • 语法：类型[][] 数组名 = new 类型[大小][大小]
比如：int[][] arr = new int[3][5]
    package com.company.hello;

/**
 * @author L.yn
 * @version 1.0
 * @date 2021/11/28 17:15
 */
public class TwoDimensionalArray01 {
    public static void main(String[] args) {

        int[][] arr = new int[2][3];
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                /**
                 * 0  0  0
                 * 0  0  0 
                 */
                System.out.print(arr[i][j] + "  ");
            }
            System.out.println();
        }
    }
}

  • 使用方式二

    • 先声明  类型[][] 数组名;
在定义（开辟空间） 数组名 = new 类型[大小][大小]
赋值（有默认值，比如int类型的就是0）

  • 使用方式三

    • 看一个需求：动态创建下面的二位数组，并输出

      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GQzsRale-1638096009414)(C:\Users\MSI-NB\AppData\Roaming\Typora\typora-user-images\image-20211128173347617.png)]

      package com.company.hello;

/**
 * @author L.yn
 * @version 1.0
 * @date 2021/11/28 17:34
 */
public class TwoDimensionalArray02 {
    public static void main(String[] args) {
        //动态创建二位数组，并输出
        int[][] arr = new int[3][];
        for (int i = 0; i < arr.length; i++) {
            //给每个一维数组开辟空间
            //如果没有给一维数组 new，那么arr[i]就是null
            arr[i] = new int[i + 1];

            //遍历一维数组，并给一维数组赋值
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = i + 1;
            }

            /**
             * 1
             * 2	2
             * 3	3	3
             */
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

  • 使用方式4：静态初始化

    • 定义：类型[][] 数组名 = {{值1，值2,...},{值1,....},...}
比如：
    int[][] arr = {{1,2,3,4},{1,2,3},{1}};
解读：
    一、定义了一个二维数组 arr
    二、arr有三个元素（每个元素都是一维数组）
    三、第一个一维数组有四个元素，第二个一维数组有三个元素，第三个一维数组有一个元素

  • 二位数组的遍历

    • package com.company.hello;

/**
 * 二维数组的遍历
 *
 * @author L.yn
 * @version 1.0
 * @date 2021/11/28 18:12
 */
public class TwoDimensionalArray03 {
    public static void main(String[] args) {
        int[][] arr = {{1, 2}, {3, 2, 1}, {-2}};
        /**
         * 遍历该二维数组，并得到和
         *
         * 思路
         * 一、遍历二维数组，并将各个值累计到int sum
         */
        int sum = 0;
        /**
         * 输出二位数组的值....
         * 1	2	
         * 3	2	1	
         * -2	
         * 和：7
         */
        System.out.println("输出二位数组的值....");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                sum += arr[i][j];
            }

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

  • 二位数组使用细节和注意事项

    • 一维数组的声明方式有：int[] x 或者 int x[]

    • 二维数组的声明方式有

      int[][] x 或者 int[] x[] 或者 int x[][]

    • 二维数组实际上是多个一维数组组成的，它的各个一维数组的长度可以相同，也可以不同，比如:map[][] 是一个二维数组
      map[][] = {{1,2},{3,4,5}}由map[0]是一个含有两个元素的一维数组，map[1]是一个含有三个元素的一维数组构成，我们也成为列数不等的二维数组

北木楠-
关注
数组
Chen_anan的博客
07-09 1080
数组的定义（三种）double [] a = new double[5];申请一个连续的内存单元，储存一批数据。String [] b = {"数组0","数组1","数组2","数组3","数组4"};int [] c = new int[]{1,2,3,4,5};访问数组元素：数组名+下标。但是注意数组的第一个下标是从0开始的，比如：数组中存5个数，那么他们的下标是[0,4];数组的本质：一组...
JAVA基础知识----数组
weixin_63156135的博客
05-11 239
一 数组概念： 数组是存储同一种数据类型多个元素的容器。 数组既可以存储基本数据类型，也可以存储引用数据类型。 数组的定义格式： 格式1：数据类型[] 数组名;（推荐的方式） 格式2：数据类型 数组名[]; 举例：int[] arr;定义了一个int类型的数组，数组名是arr int arr[];定义了一个int类型的变量，变量名是arr数组 注意：这两种定义做完了，数组中是没有元素值的。 数组初始化概述 Java中的数组必须先初始化,然后才能使用。 ...
快速入门java数组
weixin_44964082的博客
11-20 146
Java数组 什么是数组？ 在内存中是一块连续的空间存放相同的数据类型，且一旦创建长度不可改变。 特点： 是一种引用数据类型。 数组中的多个数据，类型必须统一。 数组的长度在运行期间不能改变。 数组的初始化 数组的初始化有两种方式： 动态初始化 初始化数组的时候，指定数组的长度，并且赋默认值。 格式 ：数据类型[] 数组名 = new 数据类型[数组长度]; 静态初始化 初始化数组的同时，给数组赋值。（底层是先指定长度，确定默认值，然后在给数组赋值） 格式：数据类型[] 数组名 = new 数据类型[
java教程——java快速入门（数组操作）
我想月薪过万的博客
04-24 308
遍历数组 我们在java程序基础里介绍了数组这种数据类型，有了数组，我们还需要来操作他。而数组最常见的一个操作就是遍历。 遇到 for 循环就可以遍历数组。因为数组的每个元素都可以通过索引来访问，因此，使用标准的 for 循环可以完成一个数组的遍历： public static void main(String[] args){ /*** Description:遍历数组 * @author: yiqi * @date: 2021/4/24 15:25
java数组的“快捷方式”与复制
m0_47169588的博客
07-20 141
二维数组小笔记 此种情况 array2=array1后 两个一维数组变量指向了同一地址 所以改变任何一个的值 另一个也会变。 import java.util.Arrays; public class Note05_ArrayTest3 { public static void main(String[] args){ int[] array1,array2; array1 = new int[]{1,2,3,4,5}; System.out.println(Arrays.toString(
DAY3数组
weixin_44872327的博客
09-22 824
第六章*** 数组 array数组 数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型：即数组就是一组数据。 定义一个数组 ***double【】 数组名{数据，数据，……，数据}； 例如 double [] hens ={1,2,4,6,4,5};[]也可以写在hens后 //double【】表示double类型的数组 里面的值表示数组的值或者叫元素 用for循环遍历数组可以得到数组所有元素的和 1可以通过hens【下标】来访问数组的元素，下标是从0开始编号。 .
黑马程序员 - Java基础教学 - 04 - 数组、进制转换、二维数组
04-10
Java基础教学 - 数组、进制转换、二维数组 在Java基础教学中，数组是一个非常重要的概念。数组是多个相同类型的变量组成的集合，每个变量被称为一个元素，数组中的每个元素都有自己的下标或索引。下面将详细讲解...
JAVA入门基础--数组
qq_46079450的博客
02-24 1098
文章目录前言一、JVM内存模型（掌握概念）二、数组定义（重点）1.引入库2.读入数据三、数组定义（重点）总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、JVM内存模型（掌握概念） 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、数组定义（重点） 1.引入库 代码如下（示例）： i
Java基础学习-------数组练习题
weixin_46936639的博客
03-09 542
冒泡排序： int arr[]= {3,3,6,7,2,5,8}; int c=0; for (int i = 1; i < arr.length; i++) { for (int j = 0; j < arr.length-1; j++) { if(arr[i]<arr[j]) { c=arr[i]; arr[i]=arr[j]; arr[j]=c; } } } for(int x:arr) {
12、JAVA入门——二维数组
zl5186888的博客
09-11 593
码文不易，本篇文章就介绍到这里，如果想要学习更多Java系列知识，请关注博主，博主带你零基础学习Java知识。与此同时，对于日常生活有困扰的朋友，欢迎阅读我的第四栏目：《国学周更—心性养成之路》，学习技术的同时，我们也注重了心性的养成。//二维数组声明、分配空间合并写： 数据类型[][] 数组名 = new 数据类型[长度][长度];或 数据类型[][] 数组名 = new 数据类型[长度][];（1）Java中操作多位数组的语法与一维数组类似。在实际应用中，三维以上的数组很少使用，主要使用二维数组。
3-数组的概述
sinat_37106527的博客
03-15 271
一、数组的概述 1.数组的理解：数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名， 并通过编号的方式对这些数据进行统一管理。 2.数组相关的概念： 数组名 元素 角标、下标、索引 数组的长度：元素的个数 3.数组的特点： 1）数组是有序排列的 2）数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型 3）创建数组对象会在内存中开辟一整块连续的空间 4）数组的长度一旦确定，就不能修改。 4.数组的分类： ① 按照维数：一维数组、二维数
java 快速初始化，填充一个数组， Arrays.fill
天天向上的专栏
01-24 3万+
java 中的数组初始值都为零，若快速填充一个其他值的数组，可以用 Arrays.fill 方法，但只能填充一个一维数组，多维数组还得用循环。 举例： import java.util.Arrays; public class HelloWorld { public static void main(String[] args) { int[] a
JAVA范例　五）数组---数组的排序
A+
07-21 307
数组的排序 实例74 冒泡排序法 public class SortArray_01 { public static void main(String args[]) { int[] array = { 14, 5, 86, 4, 12, 3, 21, 13, 11, 2, 55 }; // 创建一个初始化的一维数组array System.out.println("未排序的...
java中数组快速转成List集合
NasubiZW
12-12 1万+
java中，如果想把一个数组转换成为List集合，我们一般会使用Arrays.asList()方法，代码如下： public class ArrayTest1 { public static void main(String[] args) { String[] arr = {"aa","bb","cc"}; List&lt;String&gt; list = Arrays.asList(arr...
java数组比较 快速_Java中的数组或列表。哪个更快？
weixin_42548752的博客
02-27 447
小编典典我写了一个基准测试来比较ArrayLists和Arrays。在我的老式笔记本电脑上，遍历5000个元素的数组列表的时间为1000次，比同等的数组代码慢大约10毫秒。所以，如果你在做什么，但迭代的列表，你做了很多，那么也许它的价值的最优化。否则，我会使用列表中，因为它会更容易，当你这样做需要优化的代码。我确实注意到使用for String s: stringsList它比使用老式的for循环...
韩顺平 零基础30天学会Java第六章
暂未入门程序猿的博客
01-07 311
数组 为什么需要数组 一个养鸡场有6只鸡，它们的体重分别是3kg,5kg,1kg,3.4kg,2kg,50kg。请问这六只鸡的总体重是多少?平均体重是多少?请你编一个程序。 //思路分析 //1.定义六个变量double ，求和得到总体重 //2．平均体重=总体重/6 //3。分析传统实现的方式问题.6->600->566 //4。引出新的技术->使用数组来解决. double hen1 = 3; double hen2 = 5; double hen3 = 1; double hen4
java初始化二维数组的三种方式
热门推荐
Code_lr的专栏
11-15 11万+
//第一种方式： int a[][]={{1,2,3},{4,5,6}}; //第二种方式； int[][] ints = new int[4][2]; ints[i][j] =__; //分别赋值 //第三种方式：第二维的长度可以动态申请 int[][] arr3 = new int[5][];//五
java入门：数组、二维数组、字符与字符串、函数
m0_63346293的博客
08-09 1047
java入门：数组、二维数组、字符与字符串、函数
Java一维数组与二维数组基础入门
在Java编程中，多维数组，特别是二维数组（也称为矩阵）是一个重要的概念。它们允许我们存储和处理具有多个维度的数据，比如表格或矩阵数据结构。二维数组的特性包括： 1. **起点和终点**： - 与一维数组类似，二...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

北木楠-

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值