数组

于 2020-07-24 10:38:14 发布
阅读量96 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zi599599/article/details/107555651
版权

数组的定义

  1. 数组是相同类型数据的有序集合.
  2. 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。
  3. 其中,每一个数据称作-个数组元素每个数组元素可以通过-个下标来访问们.

数组声明创建

  • 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量语法:
    • dateType[] arrayRefVar;
    • dateType arrayRefVar[] ;
  • Java语言使用new操作符来创建数组，语法如下:
    • dataType[] arrayRefVar = new dataType[ arraySize] ;
  • 数组的元素是通过索引访问的，数组索引从0开始。
  • 获取数组长度:arrays. length
package com.lzi.array;

public class Demo01 {
    public static void main(String[] args) {
        //int[] nums = new int[10];
        int[] nums;  //声明一个数组
        nums = new int[10]; //创建一个数组
        System.out.println(nums.length);//数组的长度

        //给数组赋值
        nums[0] = 1;  //数组下标从0-9，不给赋值默认值为0
        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);
    }
}

数组的三种初始化（动、静、默认）

  • 数组静态初始化：创建+复制
    • int[] a = {1,2,3,4,5,6}
  • 数组动态初始化：
    • int[] b = new int[10]；
    • b[0] = 1
  • 数组的默认初始化
    • 数组是引用类型，它的元素相当于类的实例变量，因此数组-经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
  1. 声明数组
    int] array = nul; 声明数组的时候在栈里面
  2. 创建数组
    array = new int[10]; 在堆里面，new出来都在堆中
  3. 给数组元素中赋值
    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;

数组的四个基本特点

  • 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。。
  • 其元素必须是相同类型,不允许出现混合类型。
  • 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
  • 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
  • 数组本身就是对象, Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型,
    数组对象本身是在堆中的。

数组边界

  • 下边的合法区间：[0，length-1],如果下标越界就会报错
    • ArrayIndexOutOfBoundsException：数组下标越界异常
  • 小结：
    • 数组是相同数据类型（数组类型可以为任意类型）的有序集合
    • 数组也是对象。数组元素相当于对象的成员变量
    • 数组长度确定的，不可以变的，如果越界，会报错。

数组的使用

package com.lzi.array;
//输出数组的1,2,3，4,5
public class Demo01 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        for (int array : arr) {
            System.out.println(array);
        }
    }
}




package com.lzi.array;

public class Demo01 {
    public static void main(String[] args) {
        Demo01 pr = new Demo01();
        int[] arr = {1,2,3,4,5};
        int[] rs={};
        pr.printArray(arr);

        rs=pr.reversePrint(arr);
        pr.printArray(rs);
    }
//打印数组
    public  void printArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"   ");
        }
    }
//反转数组
    public  int[] reversePrint(int[] arr) {
        int[] reverse = new int[arr.length];
        for (int i = 0,j=arr.length-1; i < arr.length; i++,j--) {
            reverse[j] = arr[i];
        }
        return reverse;
    }
}

多维数组

  • 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，气每个元素都是一个一维数组

  • 二维数组  int[][ ] a=new int [2][5];

    package com.lzi.array;
//反转数组
public class Demo01 {
    public static void main(String[] args) {
        int[][] array = {{1,2},{3,4},{4,5},{5,6}};
        printArray(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.println(array[i][j]);
            }
        }
    }
}

冒泡排序

package com.lzi.array;

import sun.java2d.pipe.AAShapePipe;

import java.util.Arrays;

public class Demo01 {
    public static void main(String[] args) {
        //冒泡排序
        //1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
        //2.每次比较，都会产生一个最大，或者最小的数
        //3.下一轮则可以少排一次排序
        //4.一次循环，直到结束
        int[] array = {5,1,8,7,3,4,2,9,6};
        int[] brray = arraySrot(array);
        System.out.println(Arrays.toString(brray));
    }

    public static int[] arraySrot(int[] array) {
        int temp = 0;
        boolean flag = false;
        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]){
//                    temp = array[j+1];
//                    array[j+1] = array[j];
//                    array[j] = temp;
                //排序大到小
                  if(array[j]<array[j+1]){
                      temp = array[j+1];
                      array[j+1] = array[j];
                      array[j] = temp;
                      flag = true;
                }
            }
            if(flag==false){
                break;
            }
        }
        return array;
    }
}

Arrays类

  • arrays类包含用于操作数组的各种方法(排序和搜索)。该类还包含一个静态工厂，可以讲数组视为列表。
package com.lzi.array;

import sun.java2d.pipe.AAShapePipe;

import java.util.Arrays;

public class Demo01 {
    public static void main(String[] args) {
        int[] a={1,5,6,9,2,3,1000,8,10};
        System.out.println(a);//->[I@677327b6

        //打印数组元素Arrays.toString
        System.out.println(Arrays.toString(a));

        //对数组进行排序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));

        //fill数组填充
          Arrays.fill(a,0);
          System.out.println(Arrays.toString(a));  //->全部值为0

        Arrays.fill(a,2,4,0);
        System.out.println(Arrays.toString(a));  //->下标2,3为0
    }
}

稀疏数组

package com.lzi.array;

import sun.java2d.pipe.AAShapePipe;

import java.util.Arrays;

public class Demo01 {
    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] = 2;

        //输出原始数组
        System.out.println("输出原始数组");

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

        //转换为稀疏数组保存
        //获取有效值的个数

        int sum = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; 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 = 1,j=0; i < array1.length; i++) {
            for ( 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");
        }

        //1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //2.给其中的元素还原他的值
        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 : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}

package com.lzi.array;

public class Demo02 {
    public static void main(String[] args) {
        int[][] array1 = new int[5][7];
        array1[2][5] = 1;
        array1[4][3] = 2;
        printArray(array1);
        int[][] array2 = xiShuArray(array1);
        readArray(array2);
    }
    //打印数组
    public static void printArray(int[][] array1) {
        System.out.println("输出原始数组");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
    //转换为稀疏数组
    public static int[][]  xiShuArray(int[][] array1) {
        int sum=0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if(array1[i][j]!=0){
                    sum++;
                }
            }
        }
        int[][] array2=new int[sum+1][3];
        array2[0][0]=5;
        array2[0][1]=7;
        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++) {
            for (int j = 0; j < array2[i].length; j++) {
                System.out.print(array2[i][j]+"\t");
            }
            System.out.println();
        }
        return array2;
    }
    //读取稀疏数组
    public static void readArray(int[][] array2) {
        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];
        }
        System.out.println("输出还原的数组");
        printArray(array3);
    }
}
Zi°
关注
专栏目录
数组_matlab数组_
10-02
在MATLAB中，数组是一种非常基础且重要的数据结构，它允许我们存储和处理大量数值数据。MATLAB数组的使用广泛，涵盖了科学计算、数据分析、图像处理等众多领域。本资料包着重介绍了MATLAB中的数组计算，包括数组的...
PHP 多维数组的排序问题 根据二维数组中某个项排序
10-28
该函数可以对多个数组或数组中的多个列进行排序，适用于需要根据多个标准对数组元素进行排序的场景。 首先，我们来详细说明array_multisort函数的用法。该函数允许开发者将一个或多个数组作为参数，并按照指定的...
初识JAVA数组
09-04
【初识JAVA数组】 在Java语言中，数组是一种基本的复合数据类型，它代表了有序数据的集合。数组的关键特性是其元素具有相同的类型，并且可以通过一个数组名称和下标来唯一地确定每个元素的位置。Java支持一维数组和...
js多维数组转一维数组
06-16
js基础代码实现
js合并两个数组生成合并后的key：value数组
10-18
在JavaScript中，合并两个数组以生成键值对（key:value）数组是一项常见的编程任务，尤其是在处理相关数据时。关键点在于如何将两个结构相同的数组（例如，一个是名称数组，另一个是对应的值数组）合并为一个对象...
php 判断数组是几维数组
10-27
1. **一维数组**：数组中的每个元素都是简单值（如整数、字符串等），没有嵌套数组。 2. **多维数组**：数组中的元素可以是另一个数组，即存在嵌套的情况。根据嵌套层数的不同，可以分为二维数组、三维数组等。 ###...
详解C++中的一维数组和二维数组
09-03
【C++一维数组】 C++中的一维数组是一种存储同类型数据的连续内存空间，可以看作是具有固定大小的线性集合。数组的定义通常遵循以下格式： ```cpp 类型标识符 数组名[常量表达式]; ``` 例如： ```cpp int a[10]; ...
易语言数组清零的方法
08-26
在编程中，数组是一种非常重要的数据结构，它用于存储同类型的数据集合。在易语言中，数组同样扮演着这样的角色，但如何对数组进行初始化或清零是许多初学者会遇到的问题。本文将详细讲解易语言中数组清零的方法。 ...
C#交错数组浅析
01-20
C#数组有很多值得学习的地方，这里我们主要介绍C#交错数组，包括介绍一维数组例、二维数组例、C#交错数组等方面。 数组是在我们编程当中经常用到的，想来大家对数组都有一定的概念，这部分内容将给大家详细讲解数组...
易语言合并数组的方法
08-26
在易语言编程中，处理数组是一项基础且重要的任务。数组是一种数据结构，它可以存储一系列相同类型的数据，并通过索引来访问这些数据。在某些情况下，我们需要将两个或多个数组合并成一个新的大数组，以便进行更复杂...
labview数组递增
11-23
labview小程序，将一个二维数组中的每一行都加一个递增的数
js数组相减简单示例【删除a数组所有与b数组相同元素】
10-15
本文详细讲解了如何使用JavaScript进行数组相减的操作，即删除数组a中所有与数组b相同的元素。这涉及到JavaScript中的数组遍历、元素比较以及数组的删除操作等核心知识。通过具体示例，我们学习了如何编写一个函数来...
将一个数组按照固定大小进行拆分成数组的方法
09-01
在编程中，有时我们需要将一个大的数组按照特定的大小拆分成多个小的数组。这个问题在处理大数据、分块计算或批量处理场景时尤为常见。本文将深入探讨如何使用Java实现这个功能，通过一个名为`ArraySplit`的示例类来...
javascript 伪数组实现方法
10-28
伪数组（array-like object）是JavaScript中一种特殊的对象，它看起来像数组，但实际上并不是真正的数组类型。伪数组可以有索引和length属性，却不能使用数组的方法，比如push、pop、shift等。不过，它可以通过一些...
C#各种数组的用法实例演示
09-04
本文将通过实例演示，详细讲解C#中的各种数组用法，包括一维数组、二维数组、锯齿型数组以及不同长度的数组组合。 首先，我们来看一维数组的用法。一维数组是最简单的数组形式，它类似于一个线性的列表。在示例中，...
一维数组题目8道题带答案
07-08
在IT领域，数组是一种基础且重要的数据结构，尤其在编程语言如C#中。一维数组是最简单形式的数组，它允许我们存储同一类型的数据集合。在这个“一维数组题目8道题带答案”资源中，我们可以期待找到一系列与一维数组...
GO语言数组的内存
01-20
在Go语言中，数组是一种基本的数据结构，它用于存储固定数量的同类型元素。数组的特点是它的元素在内存中是连续存储的，这使得数组访问速度快，因为可以通过索引来直接计算元素的内存地址。在本示例中，我们探讨了Go...
C语言指针数组与数组指针详解
"数组指针和指针数组是C语言中两个重要的概念，它们在内存布局和使用上有显著差异。理解这两个概念对于深入学习C语言至关重要。本文将详细讲解它们的区别。 一、指针数组和数组指针的内存布局 1. 指针数组：指针...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值