数组

最新推荐文章于 2024-10-25 22:04:23 发布
最新推荐文章于 2024-10-25 22:04:23 发布
阅读量137 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40511698/article/details/114363533
版权

数组定义

数组是相同类型数据的有序集合。它描述的是相同类型的若干个数据，按照一定的先后顺序排列组合的。

数组的声明和创建

  1. 首先必须声明数组变量，才能在程序中使用数组。
dataType[] arraryReFVar; //首选方法   int[] =num;
dataType   arraryReFVar[]; //也可以
  1. 声明好以后，使用new操作符来创建数组，也就是为其分配内存。
dataType[] arraryReFVar  = new  dataType[arrarySize];//大小
//int[] num =new int[10];
数组

  1. 给数组元素赋值

  2. 就可以访问数组了，数组的元素是通过索引访问的，数组索引从0开始。

​ arrays.length 获取数组长度

public class ArrayDemo1 {
    //变量(数组)的类型  变量的名字 = 变量的值

    public static void main(String[] args) {
        //1.声明一个数组
        int[] num1;

        //2.创建一个数组（分配了空间）
        num1=new int[10];//这里可以存放10个int类型数字
        //3.给数组元素赋值
        num1[0]=1;
        num1[1]=2;
        num1[2]=3;
        num1[3]=4;
        num1[4]=5;
        num1[5]=6;
        num1[6]=7;
        num1[7]=8;
        num1[8]=9;
        num1[9]=10;
        System.out.println(num1[9]);
        
        //计算所有元素的和
        int sum=0;
        for(int i=0; i<num1.length; i++){
            sum=sum+num1[i];
        }
        System.out.println("总和是:"+sum);
   }

Java内存分析

堆

  1. 存放new的对象和数组
  2. 可以被所有线程共享，不会存放别的对象引用

栈

  1. 存放基本类型（会包含这个基本类型的具体数值）
  2. 引用对象的变量（会存放这个引用在堆里的具体地址）

方法区

  1. 可以被所有线程共享
  2. 包含了所有的class和static变量

在这里插入图片描述

三种初始化

public class ArrayDemo2 {
    public static void main(String[] args) {
        //静态初始化   同时进行创建和赋值
        int [] a= {1,2,3,4,5,6,7,8};
        System.out.println(a[0]);

        //动态初始化(包含默认初始化)
        int [] b=new  int[10];
        b[0]=10;
        System.out.println(b[0]);//10
        System.out.println(b[1]);//0
    }
}

数组的默认初始化：

​ 数组是引用类型，他的元素相当于类的实例变量，所以数组一旦分配空间，其中每个元素也是按照实例变量同样方式被隐式初始化。

数组的基本特点

  1. 长度是确定的。数组一旦被创建，他的大小不可改变。若越界，报：ArrayLndexOutofBounds(数组下标越界异常)
  2. 元素必须是相同类型。
  3. 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
  4. 数组本身就是对象，对象在堆中。数组元素就是对象的成员变量。

数组的使用

普通的for循环

For-Each循环

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

        int[] arrays={1,2,3,4,5};
        //打印全部数组元素
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
        }
        System.out.println("====================");
        //计算所有元素的和
        int sum=0;
        for (int i = 0; i < arrays.length; i++) {
            sum += arrays[i];
        }
            System.out.println("sum="+sum);
        //查找最大元素
        int max=arrays[0];
        for (int i = 0; i <arrays.length ; i++) {
            if(arrays[i]>max){
                max=arrays[i];
            }
        }
        System.out.println("max="+max);
    }
}

public class ArrayDemo4 {
    public static void main(String[] args) {
        int [] arrays={1,2,3,4,5};
        //增强型for循环
        for (int array : arrays) {
            System.out.println(arrays);
        }

数组做方法入参

public class ArrayDemo5 {
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5};
        printArray(arrays);
    }
    //打印数组元素
    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
        }
    }

数组做返回值

public class ArrayDemo5 {
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5};
        int[] reverse = reverse(arrays);
        printArray(reverse );
    }
    //反转数组
    public static int[] reverse(int[] arrays){
        int [] result =new int[arrays.length];
        //反转操作
        for (int i = 0,j=result.length-1; i <arrays.length ; i++,j--) {//result.length-1为了防止下标越界
            result[j]=arrays[i];
        }
        return  result;
    }

多维数组

数组的套娃在套娃… num[i][j]

多维数组 
public class ArrayDemo6 {
    public static void main(String[] args) {
        int[][] array= {{1,2},{2,3},{3,4}};
        /*
        1,2   array[0]
        2,3   array[1]
        3,4   array[2]
         */
        for (int i = 0; i <array.length ; i++) {
            for (int j = 0; j <array[i].length ; j++) {
                System.out.println(array[i][j]);
            }
        }

Arrays类

  1. 数组的工具类 Java.util.Arrays;

该类包含用于操作数组的各种方法（排序、搜索）

  1. Arrays类中的方法都是static修饰的静态方法，在使用时可以直接使用类名进行调用。

冒泡排序

两层循环，外层冒泡轮数，里层依次比较。

时间复杂度是 O（n^2）

public class ArrayDemo7 {
    public static void main(String[] args) {
        int[] a = {1, 5, 85, 8454, 44, 3, 2};
        int[] sort = sort(a);//调用完我们自己写的排序方法后，返回到一个排序的数组
        System.out.println(Arrays.toString(sort));
    }  

    public static int[] sort(int[] array) {
        //临时变量
        int temp = 0;//相当于过度的容器

        //外层循环，判断我们这个要走多少步
        for (int i = 0; i < array.length; i++) {
            //内层循环，比较两个数，交换位置
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j + 1] > array[j]) {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;  //实现交换
                }
            }
        }
        return array;
    }
}

优化

通过flag标志位减少无意义的比较

public class ArrayDemo7 {
    public static void main(String[] args) {
        int[] a = {1, 5, 85, 8454, 44, 3, 2};
        int[] sort = sort(a);//调用完我们自己写的排序方法后，返回到一个排序的数组
        System.out.println(Arrays.toString(sort));
    }

    public static int[] sort(int[] array) {
        //临时变量
        int temp = 0;//相当于过度的容器

        //外层循环，判断我们这个要走多少步
        for (int i = 0; i < array.length; i++) {
            boolean flag=false;
            //通过flag标志位减少无意义的比较

            //内层循环，比较两个数，交换位置
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j + 1] > array[j]) {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;  //实现交换
                    flag=true;
                }
            }
            if(flag==true){
               break;
            }
        }
        return array;
    }
}

稀疏数组

  1. 当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。
  2. 稀疏数组处理方式
    • 记录数组一共有几行几列，有多少不同值
    • 把具有不同值的元素、行、列、值，记录在一个小规模的数组中，从而缩小程序的规模。

eg:在这里插入图片描述

public class ArrayDemo8 {
public static void main(String[] args) {
//创建一个二维数组11*11 0没有棋子 1黑棋 2白棋
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
System.out.println(“输出原始数组”);
for (int[] ints : array1) {//ForEach循环
for (int anInt : ints) {
System.out.print(anInt + “\t”);
}
System.out.println();
}
System.out.println("============================");

    //转换为稀疏数组来保存
    //1.获取有效值个数
    int num = 0;
    for (int i = 0; i < 11; i++) {
        for (int j = 0; j < 11; j++) {
            if (array1[i][j] != 0) {
                num++;
            }
        }
    }
    System.out.println("有效值的个数:" + num);
    //1.创建一个稀疏数组的数组
    int[][] array2 = new int[num + 1][3];//参照稀疏数组表
    array2[0][0] = 11;
    array2[0][1] = 11;
    array2[0][2] = num;//11行11列num个有效数字

    //遍历二维数组，将非零值存放在稀疏数组中
    int count = 0;
    for (int i = 0; i < array1.length; i++) {
        for (int j = 0; j < array1[i].length; j++) {
            if (array1[i][j] != 0) {
                count++;
                array2[count][0] = i;
                array2[count][1] = j;
                array2[count][2] = array1[i][j];
            }
        }
    }
    //输出稀疏数组
    System.out.println("稀疏数组");
    for (int i = 0; i < array2.length; i++) {
        for (int j = 0; j < array2.length; j++) {
            System.out.print(array2[i][j] + " ");
        }
        System.out.println("\t");
    }
    /*
    另一种输出方法
    for (int i = 0; i < array2.length; i++) {
         System.out.print(array2[i][0] + "\t"
                          +array2[i][1] + "\t"
                          +array2[i][2] + "\t");
    }
     */
    System.out.println("==============================")       
    System.out.println("还原");
    //1.先读取稀疏数组的值
    int[][] array3=new int[array2[0][0]][array2[0][1]];//[0][0]行 [0][1]列
    //2.给其中的元素还原值
    for (int i = 1; i <array2.length ; i++) {
        array3[array2[i][0]][array2[i][1]]= array2[i][2];
        //  数组3值【数组3的行          3的列】           数组2的值
    }
    //3.打印
    System.out.println("输出还原的数组");
    for (int[] ints : array3) {//ForEach循环
        for (int anInt : ints) {
            System.out.print(anInt + "\t");
        }
        System.out.println();
    }
}

}

q_6931
关注
js数组相减简单示例【删除a数组所有与b数组相同元素】
10-15
本文详细讲解了如何使用JavaScript进行数组相减的操作，即删除数组a中所有与数组b相同的元素。这涉及到JavaScript中的数组遍历、元素比较以及数组的删除操作等核心知识。通过具体示例，我们学习了如何编写一个函数来...
shell数组
shanjun12的博客
01-29 1310
shell数组
类数组
kiku
08-10 2194
类数组 1，由下标，有length，有push和splice，就是一个类数组 2，既可以当数组用，也可以当对象用 3，DOM 里面的数组都是类数组,因为DOM 还要当对象用，而原数组不能解决这个需求 比如这就是一个类数组 var arr = [1,2,3]; var obj = { "0":1, "1":2, "2":3, ...
多维数组
q20011的博客
08-27 6123
1.多维数组概述 数组是一个线性数据结构，用于储存一组相同数据类型的数据（长度一经定义就不能改了） 2.多维数组定义 3.多维数组的遍历 4.多维数组的使用 5.算法概述 6.排序算法 冒泡排序 选择排序 插入排序 7.引用数据类型 ...
C语言中的数组
zhangyuanhang123的博客
07-17 2042
1.在定义时规定数组元素的个数，并且不初始化。int a[100];2.在定义时确定数组的元素个数，并初始化，而且初始化的元素个数要小于等于确定的元素个数。int a[100] = {1,2,3,4,5}//{}里面的元素个数要小于等于1003.在定义时不确定数组的元素个数，并初始化。4.可变数组的定义：使用变量规定数组的元素的个数，并且在定义数组时不能初始化数组。int a[len];1.定义时确定数组的行数与列数，不初始化。
C语言——数组详解
2302_80141790的博客
08-18 1016
数组的概念，维数组的创建和初始化，⼀维数组的使⽤，⼆维数组的创建，数组练习
postgre 数组类型
lzh7917的博客
12-17 2019
前言 偶然发现 postgre 支持数组类型，闲着无聊整理了一些数组类型的用法。目前处于探索阶段。 1 创建表 CREATE TABLE test ( ID serial PRIMARY KEY, phone int4 [] ); 查看表结构显示phone字段type：integer[] postgres=# \d test Table "public.test" Column | Type | Collation | Nullable
结构体数组
changan
06-02 8895
结构体是一种集合，它里面包含多个变量和数组，他们类型形同，也可以不同，每个变量或数组都称为结构体成员 struct stu{   char *name; //姓名   int num; //学号   int age; //年龄   char group; //所在学习小组   float score; //成绩 }; 结构体成员定义与变量相同，只是不能初始化，}；不能少 struct stu{   char *n
Shell数组
zyy1020075955的博客
08-09 1188
数组是Shell的⼀种特殊变量，是⼀组数据的集合，⾥⾯的每个数据被称为⼀个数组元素。 当前Bash仅支持一维索引数组和关联数组，Bash对数组的大小没有限制。数组中可以存放多个值。初始化时不需要定义数组大小（与 PHP 类似）。与大部分编程语言类似，数组元素的下标由 0 开始。Shell 数组用括号来表示，元素用"空格"符号分割开。...
C语言新手入门--数组
2402_86630696的博客
10-25 1313
我将带领大家学习数组，初次接触C语言大家肯定有很多疑惑，也有急迫的心情恨不得把所有知识直接灌进自己的小脑瓜里面，但是学习是一件循序渐进的事情，保持耐心坚持下去一定会有结果。话不多说，带入大家切入正题。在未来的日子里，我将继续探索更多技术知识并把精彩内容分享在博客上面，敬请期待。如果您有任何问题或建议，欢迎在评论区留言，我们一起交流学习。
三维数组操作_labview三维数组_labview_三维数组_
10-02
在LabVIEW编程环境中，三维数组是一种非常重要的数据结构，它能够有效地存储和处理大量多维数据。本篇文章将深入探讨如何在LabVIEW中创建、操作和应用三维数组，以实现如标题和描述所述的功能。 首先，让我们理解...
读取二维数组所有数据_labview读取数组_
09-29
在LabVIEW编程环境中，二维数组是一种常见的数据结构，用于存储多行多列的数据。本教程将深入探讨如何在LabVIEW中有效地读取二维数组的所有数据，这对于数据分析、处理和可视化至关重要。 首先，让我们理解二维数组...
JavaScript实现一维数组转化为二维数组
09-20
在JavaScript中，将一维数组转换为二维数组是一项常见的操作，特别是在处理表格数据或者矩阵运算时。这个过程通常涉及到数组的分割和重组。以下是一个详细的解释和示例，展示如何实现这个功能。 首先，我们需要理解...
C语言数组入门之数组的声明与二维数组的模拟
12-31
语言中指针与数组这两个概念之间的联系是密不可分的，以至于如果不能理解一个概念，就无法彻底理解另一个概念。 C语言中的数组值得注意的地方有以下两点： C语言中只有一维数组，而且数组的大小必须在编译期就作为一...
Amazon S3：S3静态网站托管教程.docx
最新发布
11-12
Amazon S3：S3静态网站托管教程.docx
基于支持向量机SVM-Adaboost的风电场预测研究附Matlab代码.rar
11-12
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
基于花朵授粉优化算法FPA优化TCN-BiGRU-Attention实现光伏数据回归预测附Matlab代码.rar
11-12
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手
【粗糙面】基于matlab一维介质粗糙面双站散射系数计算【含Matlab源码 9130期】.mp4
11-12
Matlab领域上传的视频均有对应的完整代码，皆可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作
C语言指针数组与数组指针详解
"数组指针和指针数组是C语言中两个重要的概念，它们在内存布局和使用上有显著差异。理解这两个概念对于深入学习C语言至关重要。本文将详细讲解它们的区别。 一、指针数组和数组指针的内存布局 1. 指针数组：指针...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值