Java数组

本文主要是介绍Java数组，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

数组的定义

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

数组的声明与创建

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法:

dateType[] arrayRefVar;//首选方法
或
dateType arrayRefVar[];//效果相同，推荐使用第一种

Java语言使用new操作符来创建数组，语法如下：

arrayRefVar = new dateType[arraySize];
//声明与创建可以放一起
dateType[] arrayRefVar = new dateType[arraySize];

数组的元素是通过索引访问的，数组索引从0开始。
获取数组长度
```
arrays.length
```

实例

public class ArrayDemo01 {
    public static void main(String[] args) {
        int [] nums =new int[10];//1.数组的声明与创建，这里存储了10个数
        //数组的赋值
        for (int i = 0; i < 10; i++) {
            nums[i]=i+1;
        }

        // 计算数组的和
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum = sum + nums[i];
        }
        System.out.println(sum);
    }
}

内存四区

全局区

存放全局变量、static静态变量、常量
- 局部常量存储在栈中。

代码区

存放执行前的可执行程序。
- 双开同一程序，代码区只存储一份
- 保密性生成exe文件后，无法直接修改源代码。

栈区

自动申请和释放编译器管理占用内存极小且速度极快
- 存放局部变量函数中的参数（调用方法）

堆区

手动申请和释放编译器管理占用内存一般速度一般
- 存放对象和数组
- 可以被所有的线程共享，不会存放别的对象引用。

三种初始化

静态初始化

int[]a = {1,2,3,4,5,6,7,8};
Man[]mans = {new Man(1,1),new Man(2,2)};

动态初始化

int[]b =new int[10];
b[0]=10;
b[1]=20;

数组的默认初始化

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

数组的四个基本特点

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

数组边界

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

数组的使用

For-Each循环
for循环
数组做方法入参
数组作返回值

package com.Array;

public class ArrayDemo03 {
    public static void main(String[] args) {
        int[] arrays = {1, 3, 7, 5, 2};

        //打印所有的数组元素
        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);
        //查找最大元素
        int max = arrays[0];
        for (int i = 1; i < arrays.length; i++) {
            if (arrays[i] > max) {
                max = arrays[i];
            }
        }
        System.out.println(max);
    }
}

package com.Array;

import javax.xml.transform.Result;

public class ArrayDemo04 {
    public static void main(String[] args) {
        int[]arrays = {1,2,3,4,5};
        //JDK1.5 没有下标
//        for(int array : arrays){
//            System.out.println(array);
//        }
        printArray(arrays);
        int[] result = reverse(arrays);
        printArray(result);
    }
    //打印数组元素
    public static  void  printArray(int[]arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(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;
    }
}

多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。
二维数组
```
int a [][]=new int [2][5];
```

以上二维数组a可以看成一个两行五列的数组。

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}};
        ArrayDemo04.printArray(array[0]);// 1 2
        System.out.println(array[0][0]);// 1
        System.out.println(array.length);//4
        System.out.println(array[0].length);//2
    }
}

Arrays类

数组的工具类java.util.Arrays
由于数组对象本身并没有什么方法可以供我们调用,但API中提供了一个工具类Arrays供我们使用,从而可以对数据对象进行一些基本的操作。
Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而"不用"使用对象来调用(注意:是"不用”而不是"不能")
常用功能
给数组赋值:通过fill方法。
对数组排序:通过sort方法,按升序。
比较数组:通过equals 方法比较数组中元素值是否相等。
查找数组元素:通过binarySearch方法能对排序好的数组进行二分查找法操作。

package com.Array;

import java.lang.reflect.Array;
import java.util.Arrays;

public class ArrayDemo06 {
    public static void main(String[] args) {
        int [] a ={4,6,8,3,4,9,87,641,213,44,};
        Arrays.sort(a);//对数组进行排序
        System.out.println(Arrays.toString(a));//Arrays.toString()打印数组
        //[3, 4, 4, 6, 8, 9, 44, 87, 213, 641]
        Arrays.fill(a,2,4,0);//对数组2~4进行填充，填充值为0
        System.out.println(Arrays.toString(a));
        //[3, 4, 0, 0, 8, 9, 44, 87, 213, 641]
    }
}

排序(不完整)

冒泡排序

package com.Array;

import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args) {
        int [] array = {1,56,87,987,65,231,64,231,654,32,531};
        bubblesort(array);
        System.out.println(Arrays.toString(array));
        //[1, 32, 56, 64, 65, 87, 231, 231, 531, 654, 987]
    }
//冒泡排序
//1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
//2.每一次比较,都会产生出一个最大，或者最小的数字;
//3.下一轮则少一次排序
//4.依次循环，直到结束
public static void bubblesort(int[]array){
        //外部循环
    for (int i = 0; i < array.length-1; i++) {
        //内层循环
        for (int j = array.length-1; j > 0; j--) {
                // 判断相邻数组的大小，并交换值。
                int temp = array[j];
                if (array[j] <= array[j-1]){
                    array[j]=array[j-1];
                    array[j-1]=temp;
                }
            }
        }
    }
}

稀疏数组

1.定义

稀疏数组可以看做是普通数组的压缩，但是这里说的普通数组是值无效数据量远大于有效数据量的数组

例如：

//原数组
0 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0
0 0 0 0 2 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
//对应稀疏数组
11 11 2
1  2  1
2  4  2

存储

刚说到稀疏数组是一种压缩后的数组，为什么要进行压缩存储呢？

原数组中存在大量的无效数据，占据了大量的存储空间，真正有用的数据却少之又少
压缩存储可以节省存储空间以避免资源的不必要的浪费，在数据序列化到磁盘时，压缩存储可以提高IO效率

package com.Array;

public class SparseDemo07 {
    public static void main(String[] args) {
        //1.创建一个二维数组11*11
        int [][]array1 = new int[11][11];
        array1[1][2]=1;
        array1[2][4]=2;
        //打印原始数组
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+" ");
            }
            System.out.println();
        }
    //转换为稀疏数组
    //2.获取有效值的个数
        int sum = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[0].length; j++) {
                if (array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println(sum);
        //3.创建稀疏数组
        //赋值稀疏数组第一行
        int[][]array2 =new int [sum+1][3];
        array2[0][0]=array1.length;
        array2[0][1]=array1.length;
        array2[0][2]=sum;
        //遍历稀疏数组，将非零值，存放在稀疏数组中
        int count = 0;
        for (int i = 1; i < array1.length; i++) {
            for (int j = 0; j < array1[0].length; j++) {
                    if (array1[i][j]!=0){
                        count++;
                        array2[count][0]=i;
                        array2[count][1]=j;
                        array2[count][2]=array1[i][j];
                    }
                }
            }
        //输出稀疏数组
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+" "+array2[i][1]+" "+array2[i][2]);
        }
        //还原稀疏数组
        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];
        }
        for (int i = 0; i < array3.length; i++) {
            for (int j = 0; j < array3[0].length; j++) {
                System.out.print(array3[i][j]+" ");
            }
            System.out.println();
        }
        System.out.println();
    }
}

这篇关于Java数组的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程

Java数组

数组的定义

数组的声明与创建

内存四区

全局区

代码区

栈区

堆区

三种初始化

静态初始化

动态初始化

数组的默认初始化

数组的四个基本特点

数组边界

数组的使用

多维数组

Arrays类

排序(不完整)

冒泡排序

稀疏数组

1.定义

存储

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯