数组基础知识：数组的声明与创建、二维数组、冒泡排序、稀疏数组

最新推荐文章于 2023-07-12 11:38:13 发布
最新推荐文章于 2023-07-12 11:38:13 发布
阅读量281 收藏 1
点赞数
分类专栏： Java 基础知识笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ai_Answer_zr/article/details/118224410
版权

数组

数组是相同类型数据的有序集合。描述的是相同类型的若干个数据，按照一定的先后顺序排列。数组中的每一个数据称为元素，数组元素是根据索引来访问的，数组索引从0开始，所以数组的第一个元素的下标为0。

数组的特点：

1、数组在创建的时候，长度就固定了，不能改变。

2、数组的元素必须为相同类型，不能出现混合类型。

3、数组的元素可以是任何的数据类型，基本数据类型或者引用数据类型都可以。

4、数组变量属于引用类型，数组也可以看成是对象，数组中的每一个元素相当于对象的成员变量。Java中对象是存放在堆中的，而数组本身就在堆中，因此数组无论存放的数据是基本数据类型还是其他对象类型，都存储在堆中。

java内存分析

  • 堆：存放new的对象和数组。（可以被所有线程共享，不会存放别的对象引用）

  • 栈：存放基本变量类型，包含这个基本类型的具体数值。（如果存放的是引用对象变量，会存放这个引用对象变量在堆里的具体地址）

  • 方法区：可以被所有的线程共享，包含了所有的class和static变量。

数组的声明与创建

  • 声明：声明的时候数组并不存在，没有在堆中分配内存空间。
//声明数组。
dataType[] variableName;
  • 创建：用new来创建数组，并在堆中分配内存中间
//创建数组
variableName = new dataType[size]; 
//声明并创建
dataType[] variableName = new dataType[size];
  • 获取数组的长度
数组名.length
  • 初始化：静态初始化、动态初始化

默认初始化：数组是引用类型，其元素相当于类的实例变量，因此数组一旦分配空间，每个元素也被按照实例变量同样的方式被隐士初始化。

//静态初始化,创建数组并赋值
int[] a = {1,2,4,5,6,7,8};
//动态初始化，创建，规定了数组长度，但是并不赋值，元素的值根据数据类型默认为0或者null。
int[] a = new int[10];
a[0] = 1;

数组的使用

注意数组不能直接用System.out.print(变量名)打印出来，会打印出来哈希值。可以使用Arrays类的toString()方法。

  • 循环打印数组元素

示例一：输出一下看看动态初始化的默认值

public class ArrayDemo01 {
    public static void main(String[] args) {
        //静态初始化
        int[] b = {1,2,3,4,5,6,7,8,9,10};
        System.out.println(Arrays.toString(b));

        //动态初始化，int类型的默认值为0
        int[] a = new int[10];
        System.out.println(Arrays.toString(a));
    }
}

在这里插入图片描述

示例二：增强for循环遍历数组元素。

public class ForEachPrintArray {
    public static void main(String[] args) {
        int[] aArray = {2,5,6,3,4,8,5,6};
        //JDK1.5后可用增强for循环打印，没有下标
        for (int i : aArray) {
            System.out.println(i);
        }
    }
}

示例三：for语句遍历数组元素。

public class ForPrintArray {
    public static void main(String[] args) {
        int[] a = {2,6,4,51,61,81,61};
        for (int i = 0;i < a.length;i++){
            System.out.println(a[i]);
        }
    }
}

示例三：计算数组内所有元素的和。知道如何打印后，只需要一个变量在打印前，把元素一个一个加起来即可。

public class ArraySum {
    public static void main(String[] args) {
        int[] arr = new int[5];
        arr[0] = 1;
        arr[1] = 8;
        arr[2] = 12;
        arr[3] = 46;
        arr[4] = 23;
        //sum用于计算数组元素的和
        int sum = 0;
        for (int i = 0;i <arr.length;i++){
            sum+=arr[i];
        }
        System.out.println(sum);
    }
}

示例四：查找数组内最大的元素

public class MaxElement {
    public static void main(String[] args) {
        int[] array = {0,3,5,9,88,444,5,1,6};
        //result用于存放最大元素。
        int result = 0;
        for (int i = 0; i < array.length; i++) {
            if (result < array[i]){
                result = array[i];
            }
        }
        System.out.println(result);
    }
}
  • 数组作方法入参
public class PrintArray {
    public static void main(String[] args) {
        int[] array = {1,3,7,2,4,6};
        printArray(array);
    }
    //数组作为方法的形式参数
    public static void printArray(int[] a) {
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
    }
}
  • 数组作返回值：看反转数组

反转数组

反转数组元素，其实就是把目标数组的值按照相反的顺序存入到另一个数组中。所以需要重新创建一个数组，长度跟目标数组一样，数组的第一个元素是目标数组的最后一个元素，然后目标数组下标增加，结果数组的下标减少，把目标数组的值对应赋值给结果数组即可。

public class ReversalArray {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

        System.out.println(Arrays.toString(reversalArray(array)));
    }
	//反转方法
    public static int[] reversalArray(int[] array){
        //定义一个数组,按顺序存放翻转后的元素,长度跟目标数组一样
        int[] result = new int[array.length];
        //结果数组的第一个元素是目标数组的最后一个元素，即目标数组的长度-1
        for (int i = 0, j = array.length-1;i <array.length;i++,j--){
            result[j] = array[i];
        }
        //数组作为返回值返回
        return result;
    }
}

在这里插入图片描述

多维数组（二维数组为例）

多维数组可以看成是数组的数组（二维数组用矩阵来理解比较容易）。

二维数组的声明跟创建跟一维数组基本一样。

//创建一个size1行size2列的二维数组
int[][] array = new int[size1][size2];
//创建一个两行两列的数组,并给每一个元素赋值
int[][] array = new int[2][2];
array[0][0] = 11;
array[0][1] = 12;
array[1][0] = 21;
array[1][1] = 22;

在这里插入图片描述

  • 打印二维数组：
public class ArrayDemo02 {
    public static void main(String[] args) {
        int[][] array = new int[2][2];
        array[0][0] = 11;
        array[0][1] = 12;
        array[1][0] = 21;
        array[1][1] = 22;
        System.out.println(array[0][0]);
        //array.length是指行的长度
        for (int i = 0;i <array.length;i++){
            //array[i].length是指列的长度
            for (int j = 0;j <array[i].length;j++){
                System.out.println(array[i][j]);
            }
        }
    }
}

Arrays类

数组的工具类：java.util.Arrays

JDK帮助文档：Overview (Java Platform SE 8 ) (oracle.com)

Arrays类中的方法都是static修饰的静态方法，可以直接使用类名调用，不用new一个Arrays类的对象（new也可以）。

常用方法：

  • toString()：打印，返回特定的值，一般的toString()方法，返回哈希值，Arrays类的toString()方法已经进行了重写，可以输出不同类型的数组元素的值。
  • equals()：比较数组中的元素是否相等。

等。

★★★冒泡排序

冒泡排序：八大基本排序算法之一，时间复杂度为n的平方：O(n²)。

代码：两层循环，外层冒泡轮数，内层比较。冒泡的轮数为数组长度-1，两个数比较后交换值的时候，需要一个临时变量temp来过度。排序完一次之后就确定了一个最大值或者最小值，看排列的顺序，所以每比较完一轮就少了一轮的比较，即比较i轮就减少i轮。

public class BubbleSort {
    public static void main(String[] args) {
        int[] array = {2,1,5,6,4,8,5,6,3,9};
        bubbleSort(array);
    }
    public static void bubbleSort(int[] array){
        int temp = 0;
        for (int i = 0;i <array.length-1;i++){
            for (int j = 0;j <array.length-1-i;j++){
                if (array[j]>array[j+1]){
                    //注意这里数组的下标，是j不是i，如果是外层循环的i的话，那么就第一个元素一直与下一个元素比较。
                    temp = array[j+1];
                    array[j+1] = array[j];
                    array[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(array));
    }
}

在这里插入图片描述

稀疏数组

数据结构的一种，可以用来压缩数组空间。适用于：当一个数组中大部分元素为0或者为同一个值的时候，可以用稀疏数组来保存该数组。

稀疏数组：i行3列。第0行记录原数组有几行几列几个不同的值。第i行用来记录不同值所在的行和列和具体的值。

在这里插入图片描述

  • 普通数组转成稀疏数组：
  1. 定义一个变量sum，用于计算有效值的个数。当数组的元素不等于其他大部分相同元素时，即为有效值。
  2. 创建稀疏数组（sum+1行，3列），第0行为原数组的行数、列数、有效值个数（sum）。
  3. 把原数组的有效值按所在的行和列存入稀疏数组，并在稀疏数组的第2列存入该有效值。
    /**
     * 普通数组转变为稀疏数组
     * @param array
     */
    public static void transformArray(int[][] array){
        //获取有效值的个数
        int sum = 0;    //变量sum计算有效值。
        for (int i = 0;i <array.length;i++){
            for (int j = 0;j <array[i].length;j++){
                if (array[i][j]!=0){
                    sum++;
                }
            }
        }

        //创建一个数组，稀疏数组
        int[][] result = new int[sum+1][3];
        //稀疏数组的第一行的元素为元素组的行数、列数、有效值个数
        result[0][0] = array.length;
        result[0][1] = array[0].length;
        result[0][2] = sum;

        //把原数组的有效值存入稀疏数组
        int count = 0;
        for (int i = 0;i <array.length;i++){
            for (int j = 0;j <array[i].length;j++){
                if (array[i][j]!=0){
                    count++;
                    result[count][0] = i;
                    result[count][1] = j;
                    result[count][2] = array[i][j];
                }
            }
        }

        //打印稀疏数组
        for (int i = 0;i <result.length;i++){
            for (int j = 0;j <result[i].length;j++){
                System.out.print(result[i][j]+"\t");
            }
            System.out.println();
        }
    }
  • 稀疏数组转成普通数组：
  1. 读取稀疏数组，第一个元素为原数组的行数，第二个元素为原数组的列数。
  2. 提取稀疏数组的有效值以及其所在的行和列。
    /**
     * 稀疏数组还原
     * @param array
     */
    public static void restoreArray(int[][] array){
        //读取稀疏数组的，第一个元素为原数组的行数，第二个元素为原数组的列数
        int[][] oldArray = new int[array[0][0]][array[0][1]];
        //注意稀疏数组的第一行并没有记录原数组具体的值，所以i从1开始。
        for (int i = 1;i <array.length;i++){
            oldArray[array[i][0]][array[i][1]] = array[i][2];
        }
        //打印还原了的数组
        for (int i = 0;i <oldArray.length;i++){
            for (int j = 0;j <oldArray[i].length;j++){
                System.out.print(oldArray[i][j]+"\t");
            }
            System.out.println();
        }
    }

示例：普通数组转变为稀疏数组，稀疏数组转变为普通数组，并打印。

public class SparseArray {
    public static void main(String[] args) {
        //普通数组
        int[][] array = new int[5][12];
        array[0][6] = 1;
        array[0][8] = 3;
        array[1][1] = 1;
        array[1][10] = 2;
        array[2][1] = 9;
        array[4][0] = 9;
        array[4][1] = 8;
        array[4][2] = 7;
        transformArray(array);
        System.out.println("===============================================================");
        //稀疏数组 原数组10行10列，两个有效值：1，2
        int[][] sparse = new int[3][3];
        sparse[0][0] = 10;
        sparse[0][1] = 10;
        sparse[0][2] = 2;
        sparse[1][0] = 5;
        sparse[1][1] = 6;
        sparse[1][2] = 1;
        sparse[2][0] = 7;
        sparse[2][1] = 8;
        sparse[2][2] = 2;

        restoreArray(sparse);
    }

    /**
     * 打印二维数组
     * @param array
     */
    public static void printArray(int[][] array){
        for (int i = 0;i <array.length;i++){
            for(int j = 0;j <array[i].length;j++){
                System.out.print(array[i][j]);
            }
            System.out.println();
        }
    }

    /**
     * 普通数组转变为稀疏数组
     * @param array
     */
    public static void transformArray(int[][] array){
        //获取有效值的个数
        int sum = 0;    //变量sum计算有效值。
        for (int i = 0;i <array.length;i++){
            for (int j = 0;j <array[i].length;j++){
                if (array[i][j]!=0){
                    sum++;
                }
            }
        }

        //创建一个数组，稀疏数组
        int[][] result = new int[sum+1][3];
        //稀疏数组的第一行的元素为元素组的行数、列数、有效值个数
        result[0][0] = array.length;
        result[0][1] = array[0].length;
        result[0][2] = sum;

        //把原数组的有效值存入稀疏数组
        int count = 0;
        for (int i = 0;i <array.length;i++){
            for (int j = 0;j <array[i].length;j++){
                if (array[i][j]!=0){
                    count++;
                    result[count][0] = i;
                    result[count][1] = j;
                    result[count][2] = array[i][j];
                }
            }
        }

        //打印稀疏数组
        for (int i = 0;i <result.length;i++){
            for (int j = 0;j <result[i].length;j++){
                System.out.print(result[i][j]+"\t");
            }
            System.out.println();
        }
    }

    /**
     * 稀疏数组还原
     * @param array
     */
    public static void restoreArray(int[][] array){
        //读取稀疏数组的，第一个元素为原数组的行数，第二个元素为原数组的列数
        int[][] oldArray = new int[array[0][0]][array[0][1]];
        //注意稀疏数组的第一行并没有记录原数组具体的值，所以i从1开始。
        for (int i = 1;i <array.length;i++){
            oldArray[array[i][0]][array[i][1]] = array[i][2];
        }
        //打印还原了的数组
        for (int i = 0;i <oldArray.length;i++){
            for (int j = 0;j <oldArray[i].length;j++){
                System.out.print(oldArray[i][j]+"\t");
            }
            System.out.println();
        }
    }
    
}

在这里插入图片描述

moonlight_Answer
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java数组01：数组的概述、声明和创建、数组的优缺点
耳东er的博客
04-25 494
一、数组概述 ——数组的定义 数组是相同类型数据的有序集合。 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们。 二、数组声明创建 ——数组声明创建 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法： dataType[] arrayRefVar; //首选的方法 或 dataType arrayRefVar[]; //效果相同，但不是首选方法 例如： --int[] nums2; //
Data-Structures-Algorithms:此仓库包含我在多个平台上解决的所有与数据结构和算法相关的问题
03-13
- **二维数组**：也称为矩阵，是多个一维数组的组合，用于处理二维或更高维度的数据，如图像处理或棋盘游戏。 - **动态数组**：如C++中的`std::vector`，它允许在运行时改变数组大小。相比于静态数组，动态数组...
数组的声明和创建
qq_45525100的博客
04-25 338
数组 定义： 数组是相同类型数据的有序集合 数据描述的是相同类型的若干个数据，按照一定的先后顺序排列组合而成。 每一个数据都称为一个数据元素，可以通过下标来访问他们 数组声明创建 首先必须声明数组变量，才能在程序中使用数组 dataType[] arrayRefVar; //首选的方法 dataType arrayRefVar[]; //效果相同，但不是首选方法 Java使用new操作...
Java编程基础:一维数组与二维数组的声明、创建、初始化（静态、动态）
m0_70900812的博客
03-10 1187
Java编程基础:一维数组与二维数组的声明、创建、初始化（静态、动态）
数组的创建方法及二维数组
杨欢博的博客
05-08 679
数组 所谓的数组就是说用变量名来保存一系列的值，一般都是相同的数据类型 数组的创建方法 方法一 通过new关键字声明数组 用数组索引的方式来给对应的下标赋值 语法： 数组名称[索引] 数组的索引从零开始 var arr1=new Array(); arr1[0]="a"; arr1[1]="b"; arr1[2]="c"; document.write("arr1:" + arr1+"<br />"); //arr1:a,b,c 方法二 通过指定数组的长度来创建 var arr2=ne
二维数组的声明与使用
进步、每天①点点↗的博客
09-05 1239
二维数组的声明与使用 1、二维数组的本质就是指由一维数组组成的数组，也就是说二维数组中的元素都是一维数组。 2、数组的声明与使用 （1）格式：    数据类型[ ][ ]    数组名称    =    new    数据类型[行数][列数]          例如：    int[ ][ ]    arr    =   new    int[2][3]     2行3列的数组 （2）分...
实验四 二维数组基本操作的编程实现
02-09
【二维数组基本操作】在本实验中，二维数组被用于实现一些基本的计算任务，如求阶乘和稀疏数组的压缩。二维数组是线性代数中的基本元素，尤其在处理矩阵运算时非常常见。它是一种数据结构，用于存储具有固定大小的...
CH4-数组18.zip_数据结构
09-21
5. **多维数组**：数组可以扩展到多维，例如二维数组（矩阵）和三维数组，用于表示更复杂的数据结构。 在数据结构的课程中，数组常常被用来作为基础，以便引入更高级的数据结构，如链表、栈、队列和树等。数组在...
软件技术基础复习提纲
10-08
#### 二维数组 - **特殊数组（对称、三角）的元素定位**：通过对角线划分来优化存储空间。 - **数组的压缩存储**：通过特定的规则存储对称或三角数组，以节省空间。 #### 串 - **串的各种操作及应用**：包括字符...
2019宁波大学917数据结构与程序设计(计算机技术)考试大纲.docx
11-05
3. **数组**：讲解一维和二维数组的定义、初始化和操作，强调数组元素的引用。 4. **函数**：涵盖函数的定义、参数传递（传值与传址）、函数原型声明、递归函数的使用，以及局部变量、静态变量、全局变量的概念和...
二维数组的定义、声明、创建、遍历（打印）
最新发布
2303_77522514的博客
07-12 1969
数组的数组,二维数组的每一个元素是一个一维数组例 int a = {{1,2,3},{1,2,3},{1,2,3}};说明：a中有三个一维数组。
二维数组的创建及使用
chuojiandi3387的博客
04-17 738
Java 中的二维数组 所谓二维数组，可以简单的理解为是一种“特殊”的一维数组，它的每个数组空间中保存的是一个一维数组。 那么如何使用二维数组呢，步骤如下： 1、 声明数组并分配空间 或者 如： 2、 赋值 二维数组的赋值，和一维数组类似，可以通过下标来逐个赋值，注意索引...
读书笔记——声明和创建数组
weixin_34055787的博客
06-12 85
数组是相同类型的变量按顺序组成的一种复合数据类型，这些相同类型的变量称为数组的元素或单元。 也就是说，数组是用来存储固定大小的同类型元素。 数组也是Object对象。 数组通过数组名加索引来使用数组的元素，索引从0开始。 声明数组 声明数组有两种格式： float boy[]; char[] girl; int cat[][]; double[][] pig; 那么数组b...
二维数组
weixin_45517802的博客
05-05 760
声明和创建二维数组 1.声明二维数组 二维数组中的每个元素是一个一维数组，其声明格式为： 类型[] [] 数组名； 两对方括号决定了数组是二维的。 2.创建二维数组 创建二维数组的常规语法格式为： 数组名 =new 类型[行数][列数]; 类型 [] [] 数组名 =new 类型 [行数][列数]； 二维数组经常用于表示数学上由若干行和若干列构成的矩阵 也可以在声明数组的同时为各元素指定初值，其语法格式为； 类型[][] 数组名 ={{第1行初值}，{第2行初值}} 内层花括号必不可少，花括号的对数即
Java数组01、02:什么是数组、数组的声明和创建
tianyi520jx的博客
07-09 93
Java数组01、02:什么是数组、数组的声明和创建
使用Array和[]创建数组的区别
weixin_30421525的博客
07-08 181
原文 　　简书原文：https://www.jianshu.com/p/57a337d20aea 大纲 　　前言　　对使用Array和[]创建数组的区别的解释　　个人理解 前言 　　JS定义数组变量时，在不需要给定数组的维度和长度的情况下，通常有两种方法： 1、var arrTest=new Array(); 2、var arrTest=[]; 　　两者效果一样。但是经...
c中数组的创建和java不同_Java创建数组的几种方式及区别
weixin_35716518的博客
02-13 254
Java创建数组的几种方式1、一维数组的声明方式：type［］ arrayName; 或 type arrayName［］;附：推荐使用第一种格式，因为第一种格式具有更好的可读性，表示type［］是一种引用类型(数组)而不是type类型。建议不要使用第二种方式下面是典型的声明数组的方式：// 声明整型数组int［］ intArray0 ;int intArray1 ［］;// 声明浮点型数组flo...
52_数组_数组基本概念_内存分析
werdzs的博客
06-09 397
数组概述和特点 数组的定义：数组是相同类型数据的有序集合. 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们. 数组的四个基本特点： 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。 其元素必须是相同类型,不允许出现混合类型。 数组中的元素可以是任何数据类型，包括基本类型和引用类型。 数组变量
数组概述以及数组的声明和创建
Fat_peach的博客
05-16 273
什么是数组？数组这两个字，可以理解为一组数； 就像平时定义的 int a=0，a 是一个数字，一组数的意思就是定义了一个数组，里面可以存放很多个数字；
MATLAB中数组创建详解：从一维到二维示例操作
在MATLAB中创建数组是编程和数据分析的基础，本文将详细介绍如何通过示例操作来构建各种类型的数组。首先，让我们理解什么是数组。数组是数学中的一个概念，它是一系列数值按照行和/或列进行排列的结构，可以是一维...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

moonlight_Answer

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

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

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

打赏作者

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

抵扣说明：

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

余额充值