Java数组详解

数组的定义

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

数组的声明和创建

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

dataType[] arrayRefVar;		// 首选的方法，推荐使用
或
dataType arrayRefVar[];		// 为C/C++程序员保留的方式，不推荐

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

示例：

package com.wmwx.array;

public class Demo01 {
    public static void main(String[] args) {
        int[] numbers;          //数组的声明
        numbers = new int[5];   //数组的创建
    }
}

数组的赋值

数组可以通过使用下标来执行赋值操作。数组的下标从0开始，到length-1结束（length为数组长度）。

如果下标超过length-1，就会报错：ArraylndexOutOfBoundsException ，即数组下标越界异常。

示例：

package com.wmwx.array;

public class Demo01 {
    public static void main(String[] args) {
        int[] numbers = new int[5];
        numbers[0] = 1;                     //下标从0开始
        numbers[1] = 2;
        numbers[2] = 3;
        numbers[3] = 4;
        numbers[4] = 5;
        System.out.println(numbers[0]);     //输出1
        System.out.println(numbers[1]);     //输出2
        System.out.println(numbers[2]);     //输出3
        System.out.println(numbers[3]);     //输出4
        System.out.println(numbers[4]);     //输出5
        System.out.println(numbers[5]);     //报错：越界异常
    }
}

数组的遍历

数组的元素类型和数组的大小都是确定的。所以当处理数组元素时候，我们通常使用循环结构。

示例：

package com.wmwx.array;

public class Demo01 {
    public static void main(String[] args) {
        int[] numbers = new int[5];         //声明和创建
        numbers[0] = 1;                     //赋值
        numbers[1] = 2;
        numbers[2] = 3;
        numbers[3] = 4;
        numbers[4] = 5;
        int sum =  0;
        //通过array.length可以得到数组的长度
        for (int i = 0; i < numbers.length; i++) {
            sum = sum + numbers[i];
        }
        System.out.println(sum);            //输出15
    }
}

数组的初始化

数组的初始化有以下三种方式：

静态初始化
动态初始化
默认初始化

示例：

package com.wmwx.array;

public class Demo02 {
    public static void main(String[] args) {
        //静态初始化：创建+赋值
        int[] a = {1, 2, 3, 4};
        System.out.println(a[0]);   //输出1

        //动态初始化（包含默认初始化）
        int[] b = new int[4];
        b[0] = 5;
        System.out.println(b[0]);   //输出5

        //默认初始化
        System.out.println(b[1]);   //输出0
        System.out.println(b[2]);   //输出0
        System.out.println(b[3]);   //输出0
    }
}

数组的基本特点

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

For-Each循环

Java5 引进了一种新的循环类型，被称为 For-Each 循环或者加强型循环，它能在不使用下标的情况下遍历数组。

其语法格式如下：

for(type element: array)
{
    System.out.println(element);
}

示例：

package com.wmwx.array;

public class Demo03 {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};

        //输出数组的所有元素
        //for循环
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }

        //for-each循环
        for (int i: array) {
            System.out.println(i);
        }
    }
}

数组作为参数和返回值

示例：

package com.wmwx.array;

public class Demo04 {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        int[] new_array = reverse(array);
        for (int i: new_array) {
            System.out.println(i);      //输出5、4、3、2、1
        }
    }

    //数组作为返回值
    public static int[] reverse(int[] array){		//数组作为参数
        int[] result = new int[array.length];
        //反转整个数组
        for (int i=0, j=array.length-1;i<array.length;i++,j--){
            result[j] = array[i];
        }
        return result;
    }
}

多维数组

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

示例：

package com.wmwx.array;

public class Demo05 {
    public static void main(String[] args) {
        //二维数组
        int[][] array = {{1, 2, 3}, {2, 3, 4}, {3, 4, 5}, {4, 5, 6}};

        System.out.println(array[0][1]);    //输出2
        System.out.println(array[1][2]);    //输出4
        System.out.println(array[2][0]);    //输出3

        //遍历二维数组
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.println(array[i][j]);
            }
        }
    }
}

Arrays类

java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。

具有以下功能：

打印数组：通过 toString 方法
给数组赋值：通过 fill 方法。
对数组排序：通过 sort 方法,按升序。
比较数组：通过 equals 方法比较数组中元素值是否相等。
查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

示例：

package com.wmwx.array;

import java.util.Arrays;

public class Demo06 {
    public static void main(String[] args) {
        int[] array = {1, 234, 56, 7890};

        //打印数组
        System.out.println(array);                      //输出[[email protected]
        System.out.println(Arrays.toString(array));     //输出[1, 234, 56, 7890]

        //排序数组
        Arrays.sort(array);                             //升序排序
        System.out.println(Arrays.toString(array));     //输出[1, 56, 234, 7890]

        //查找元素
        System.out.println(Arrays.binarySearch(array, 234));            //输出2

        //填充数组
        Arrays.fill(array, 0);
        System.out.println(Arrays.toString(array));     //输出[0, 0, 0, 0]

        //比较数组
        System.out.println(Arrays.equals(array, new int[]{0, 0, 0, 0}));    //输出true
    }
}

稀疏数组

当一个数组中大部分元素为0，或为同一值时，可以使用稀疏数组来保存该数组。

稀疏数组的处理方式是：

记录数组一共有几行几列，有多少个不同的值
把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模

示例：

package com.wmwx.array;

import java.util.Arrays;

public class Demo07 {
    public static void main(String[] args) {
        //11*11的棋盘上：0 空格     1 黑棋     2 白棋
        int[][] chess = new int[11][11];
        chess[1][2] = 1;
        chess[2][3] = 2;
        //输出原始数组：
        System.out.println("原始数组如下：");
        for (int[] arrs: chess) {
            for (int i: arrs) {
                System.out.print(i+" ");
            }
            System.out.println();
        }
        System.out.println("=====================");
        //转换为稀疏数组并输出
        chess = sparse(chess);
        System.out.println("稀疏数组如下：");
        for (int[] arrs: chess) {
            for (int i: arrs) {
                System.out.print(i+" ");
            }
            System.out.println();
        }
        System.out.println("=====================");
        //还原成原始数组并输出
        chess = toArray(chess);
        System.out.println("还原数组如下：");
        for (int[] arrs: chess) {
            for (int i: arrs) {
                System.out.print(i+" ");
            }
            System.out.println();
        }
    }

    public static int[][] sparse(int[][] array){
        //第一步：获取有效值的个数
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数："+sum);
        System.out.println("=====================");

        //第二步：创建一个稀疏数组
        int[][] sparseArray = new int[sum+1][3];
        sparseArray[0][0] = array.length;
        sparseArray[0][1] = array[0].length;
        sparseArray[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++;
                    sparseArray[count][0] = i;
                    sparseArray[count][1] = j;
                    sparseArray[count][2] = array[i][j];
                }
            }
        }

        //第四步：返回稀疏数组
        return sparseArray;
    }

    public static int[][] toArray(int[][] sparse){
        //第一步：构建原始数组
        int[][] array = new int[sparse[0][0]][sparse[0][1]];

        //第二步：还原其中的值
        for (int i = 1; i < sparse.length; i++) {
            array[sparse[i][0]][sparse[i][1]] = sparse[i][2];
        }

        //第三步：返回原始数组
        return array;
    }
}

最终的输出结果如下：

原始数组如下：
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 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 0 
=====================
有效值的个数：2
=====================
稀疏数组如下：
11 11 2 
1 2 1 
2 3 2 
=====================
还原数组如下：
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 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 0

Java数组详解Java数组详解

Java数组详解

数组的定义

数组的声明和创建

数组的赋值

数组的遍历

数组的初始化

数组的基本特点

For-Each循环

数组作为参数和返回值

多维数组

Arrays类

稀疏数组

继续阅读

关于Gradle配置的小结

Java小案例——随机数猜测随机数猜测

nginx location中斜线的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method