数组

最新推荐文章于 2024-10-10 09:56:47 发布
最新推荐文章于 2024-10-10 09:56:47 发布
阅读量61 收藏
点赞数
分类专栏： Java 文章标签： java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50228967/article/details/116137607
版权

数组

数组概述

数组的声明与创建

package com.YuZhang.array;

public class ArrayDemo01 {
    public static void main(String[] args) {
        //变量的类型 变量名字 = 变量的值
        int[] nums;//定义 java     //声明一个数组
        int nums2;//定义 c++

        nums = new int[10];//这里可以存10个int类型的数字    // 创建一个数组

       // int nums = new int [10];     //声明+创建
        //给数组元素中赋值
        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;
        nums[5] = 6;
        nums[6] = 7;
        nums[7] = 8;
        nums[8] = 9;
        nums[9] = 10;

        //计算所有元素的和
        int sum = 0;
        for (int i = 0;i<nums.length;i++)
        {
            sum = sum + nums[i];
        }

        System.out.println("总和为："+ sum);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hOTl28YP-1619354000550)(D:\未命名文件.jpg)]

数组的四个基本特点

  • 长度确定 一旦被创建 大小不可改变
  • 其元素必须是相同类型
  • 数组中的元素可以是任何数据类型 包括基本类型和引用类型
  • 数组变量属于引用类型 数组也可看成是对象 数组中的每个元素相当于该对象的成员变量 Java中对象是在堆中的

三种初始化

package com.YuZhang.array;

public class ArrayDemo02 {
    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]);
        System.out.println(b[1]);
        System.out.println(b[2]);
        System.out.println(b[3]);
    }
}

数组边界

  • 越界就会报错 ArrayIndexOutOfBoundsException:数组下标越界异常

  • package com.YuZhang.array;

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

        for (int i = 0; i < a.length; i++) {
        //for (int i = 0; i <= a.length; i++) {
            //等于时会越界
            System.out.println(a[i]);

        }

        //动态初始化：包含默认初始化
//        int[] b = new int[10];
//        b[0] = 10;
//        System.out.println(b[0]);
//        System.out.println(b[1]);
//        System.out.println(b[2]);
//        System.out.println(b[3]);
        //一次注好多行 ctrl+/
    }
}

数组使用

普通for循环

for-each

  • arrays.for

数组做方法参数

package com.YuZhang.array;

public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5};
        //printArray(arrays);
        int[] reverse = reverse(arrays);
        printArray(reverse);
    }

    //打印数组元素
    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
        }
    }
    //反转数组
    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[j] = arrays[i];
        }
        return result;
    }
}

数组做返回值

  • 上例的反转操作

多维数组

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

package com.YuZhang.array;

public class ArrayDemo05 {
    public static void main(String[] args) {
        //[4][2]
        /*
        1,2 array[0]
        2,3 array[1]
        3,4 array[2]
        4,5 array[3]
         */
        int[][] array = {{1,2},{2,3},{3,4},{4,5}};
//        printArray(array[0]);
//        System.out.println(array[0][0]);
//        System.out.println(array.length);
//        System.out.println(array[0].length);
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j]+" ");

            }
        }


    }
    //打印数组元素
    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
        }
    }
}

Arrays类

package com.YuZhang.array;

import java.util.Arrays;

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

        int[] a = {1, 2, 3, 4, 999, 43, 5646, 67, 78, 89};

        System.out.println(a);//[I@4554617c

        //打印数组元素Arrays.toString
        //System.out.println(Arrays.toString(a));
        //printArray(a);
        Arrays.sort(a);//数组进行排序   升序
        System.out.println(Arrays.toString(a));

        Arrays.fill(a,0);//数组填充
        System.out.println(Arrays.toString(a));
    }

//    public static void printArray(int[] a) {
//        for (int i = 0; i < a.length; i++) {
//            if (i == 0) {
//                System.out.print("[");
//            }
//            if (i == a.length-1) {
//                System.out.print(a[i] + "]");
//            } else {
//                System.out.print(a[i] + ",");
//            }
//
//        }
//    }
}

冒泡排序（共8种排序方法）

  • 两层循环 外层表示冒泡轮数 里层依次比较
package com.YuZhang.array;

import java.util.Arrays;

public class ArrayDemo07 {
    public static void main(String[] args) {
        int[] a = {1, 2, 3, 5, 656, 7, 68, 789, 8998};

        int[] sort = sort(a);//调用我们自己写的排序方法后  返回一个排序后的数组
        System.out.println(Arrays.toString(a));

    }


    //冒泡排序
    //1.比较数组中 两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
    //2.每一次比较都会产生出一个最大 或者最小的数字
    //3.下一轮可以少一次排序
    //4.依次循环，直至结束。

    public static int[] sort(int[] array) {
        //临时变量
        int temp = 0;

        //外层循环  判断我们要走多少次
        for (int i = 0; i < array.length - 1; 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 == false){
                break;
            }
        }
        return array;
    }
}
  • 时间复杂度为O（n*n）

稀疏数组

  • 记录数组一共几行几列 有多少不同值
  • 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小规模
package com.YuZhang.array;

public class ArrayDemo08 {
    public static void main(String[] args) {
        //1.创建一个二维数组11*11 0：没有棋子  1：黑棋   2：白棋

        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 1;
        //输出原始数组
        System.out.println("输出原始数组");

        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        System.out.println("==================");
        //转换为稀疏数组保存
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(array1[i][j]!=0){
                    sum++;
                }

            }

        }
        System.out.println("有效值的个数："+sum);

        //2.创建一个稀疏数组的数组
        int[][] array2 = new int[sum+1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        //遍历二维数组  将非零的值存放到稀疏数组中
        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++) {
            System.out.println(array2[i][0]+"\t"+array2[i][1]+"\t"+array2[i][2]+"\t");

        }

        System.out.println("================");
        System.out.println("还原");
        // 读取稀疏数组的值
        int[][] array3 = new int[array2[0][0]][array2[0][1]];

        // 给其中的元素还原他的值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];

        }

        //3.打印
        System.out.println("还原数组");

        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

    }
}
我永远明天最好看
关注
专栏目录
C++ 数组
NuYoaH502329的博客
08-03 2345
*数组是具有一定顺序关系的若干对象的集合体，组成数组的对象称为该数组的元素。**数组元素用数组名与带方括号的下标表示，同一数组的各个元素具有相同的类型。数组可以由除void型以外的任何一种类型构成，构成数组的类型和数组之间的关系，可以类比为数学上数与向量或矩阵的关系。每个元素有n个下标的数组称为n维数组。如果用array来命名一个数组，且其下标为从0到N的整数，则数组各元素为array[0]，array[1]，…，array[N]。
C++数组
m0_58233509的博客
12-05 6566
数组的特点： 1. 放在一块连续的内存空间中 2. 数组中每个元素都是相同的数据类型 我们可以通过下标访问数组中的元素 一维数组名称的用途： 1. 可以统计整个数组在内存中的长度 2. 可以获取数组在内存中的首地址 数组名是一个常量，不可以进行赋值的操作练习案例：五只小猪称重 案例描述： 在一个数组中记录了五只小猪的体重，如：int array[5] = {300,20,120,320,21}; 找出并打印最重的小猪。 练习案例：数据元素逆置 案例描述： 请声名一个5个元素的数组
JavaScript 多维数组
zsx0728的博客
04-21 7776
文章目录创建多维数组访问数组的元素将元素添加到多维数组将元素添加到外部数组将元素添加到内部数组从多维数组中删除元素从外部数组中删除元素从内部数组中删除元素迭代多维数组参考文档     在本教程中，您将借助示例了解 JavaScript 多维数组。     多维数组是包含另一个数组的数组。例如， // multidimensional array const data = [[1, 2, 3], [1, 3, 4], [4, 5, 6]]; 创建多维数组     这是在 JavaScript 中创建多维数组
Java数组
xinhang10的博客
10-22 7202
此文章对Java中的数组进行了详细的讲解，从数组的定义、创建到使用，以后数组如何传参，数组作为方法返回值应该怎么做。为了防止大家看不懂，我们特地的为大家准备了一些例题，如数组转字符串、数组拷贝、找数组中的最大元素、找数组的平均值、查找数组中的指定元素(二分法和顺序查找)、检索数组的优秀给你、数组排序、数组逆序、以及数组数字排列。在文章的最后，我们为大家讲解了二位数组是什么它怎么遍历，等……
Java对象数组
zhangyan_1010的专栏
05-22 1372
在Java中，对象数组是指由对象类型的元素组成的数组。与基本类型数组不同，对象数组可以存储对象的引用。对象数组的声明和初始化方式与基本类型数组类似。其中，ClassName 是指对象类型的类名，arrayName 是对象数组的名称，arrayLength 是数组的长度。对象数组在Java中具有广泛的用途。它们允许存储和操作多个对象的引用，使代码更加灵活和可扩展。无论是存储对象集合、实现数据结构还是进行排序和搜索，对象数组都是一个重要的数据结构。
动态数组、关联数组、队列——SV，SystemVerilog
热门推荐
SummerXRT的博客
05-22 1万+
1.定宽数组 声明： int lo [0:15]; int lo [16]; //16个整数[0]...[15] int arr[0:7] [0:3]; // 等效与 int arr[8] [4]; 8行4列的数组 arr[8] [4]=1;// 设置数组的最后一个元素为1 知识1 – for 和 foreach 的使用 对于f[0:4
【IEEE_SV-7.8】关联数组用法
Alfred的博客
04-05 3401
7.8 Associative arrays 动态数组对于处理数量动态变化的连续变量集合很有用。当集合的大小未知或数据空间稀疏时，关联数组是更好的选择。关联数组在被使用之前不会分配任何存储空间，并且索引表达式不限于整数表达式，而可以是任何类型。 关联数组实现其声明类型的元素的查询表。要用作索引的数据类型用作查找键并强制排序。 明关联数组的语法如下: data_type array_id [ index_type ]; 这里 data_type是数组元素的数据类型。可以是适用于固定大小数组的任何类型 arra
c语言柔性数组
qq_51950769的博客
02-01 1188
1.柔性数组 柔性数组, 也叫0长度数组 struct S { int data; int arr[0]; //0长数组 }; 2.柔性数组的特点 结构体中的柔性数组前必须至少有一个成员 sizedof这种结构不包括柔性数组的大小 包含柔性数组的结构开辟空间时需要用 malloc()函数 动态开辟 3.柔性数组与传统动态增加大小区别 3.1传统动态分配 定义： struct S2 { int data; int* point; }; S1*...
byte数组拼接
笑看人生
06-17 4737
/** * 拼接byte数组 * @param data1 * @param data2 * @return 拼接后数组 */ public static byte[] addBytes(byte[] data1, byte[] data2) { byte[] data3 = new byte[data1.length + data2.length]; System.arraycopy(data1, 0, data3, 0, data1.length)..
三维数组操作_labview三维数组_labview_三维数组_
10-02
在LabVIEW编程环境中，三维数组是一种非常重要的数据结构，它能够有效地存储和处理大量多维数据。本篇文章将深入探讨如何在LabVIEW中创建、操作和应用三维数组，以实现如标题和描述所述的功能。 首先，让我们理解...
读取二维数组所有数据_labview读取数组_
09-29
在LabVIEW编程环境中，二维数组是一种常见的数据结构，用于存储多行多列的数据。本教程将深入探讨如何在LabVIEW中有效地读取二维数组的所有数据，这对于数据分析、处理和可视化至关重要。 首先，让我们理解二维数组...
C语言数组入门之数组的声明与二维数组的模拟
07-31
C语言数组入门之数组的声明与二维数组的模拟 在C语言中，数组是一个非常基本的数据结构，它的声明和使用对程序员来说非常重要。数组的声明是指在C语言中定义一个数组的过程，这个过程包括指定数组的名称、类型和维...
js数组相减简单示例【删除a数组所有与b数组相同元素】
10-15
本文详细讲解了如何使用JavaScript进行数组相减的操作，即删除数组a中所有与数组b相同的元素。这涉及到JavaScript中的数组遍历、元素比较以及数组的删除操作等核心知识。通过具体示例，我们学习了如何编写一个函数来...
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
最新发布
杨荧的CSDN博客
10-10 998
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1266
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JDK1.0主要特性
FoolRabbit的专栏
10-06 373
JDK1.0主要特性。
Netty 相比原生IO模型的优势
lssffy的博客
10-09 601
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
C语言指针数组与数组指针详解
"数组指针和指针数组是C语言中两个重要的概念，它们在内存布局和使用上有显著差异。理解这两个概念对于深入学习C语言至关重要。本文将详细讲解它们的区别。 一、指针数组和数组指针的内存布局 1. 指针数组：指针...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值