Java(三) 数组的定义与使用

一  一维数组

1 什么是数组？

数组就是一组相关类型的变量集合，并且这些变量需要按照统一的方式进行操作。

这里需要重点理解的是什么叫相关变量？为什么不是相同呢？

所谓相关变量就是有一定的联系，可以互相进行转换的变量。例如：整型与字符型就是相关的，字符串和整型就不相关。

也就是说：

        int[] intarray4 = {1,'2',3,4};//right
        int[] intarray5 = {1,"2",3,4};//error,字符串类型无法与int型转换

2  数组的初始化以及空间开辟

1 动态初始化及空间开辟

数据类型[ ] 数组名称 = new 数据类型 [长度]；

Java中获得书数组长度的方法是：数组名称.length;

例如：int [ ]  intArray = new int [3]; 此时就开辟了intArray [0],intArray [1],intArray [2]这样的三个空间，默认值为null。

空间分栈空间与堆空间。

栈空间上存放变量，堆空间上存放真正的数据。

（但是除了8种基本数据类型之外，其他的符合上述规则，而基本数据类型为了使用方便，直接存放在栈空间上）

例如下图所示：

由上图图（5）可知：同一块堆内存空间可以由不同的栈内存所指向。

数组属于引用数据类型，需要在使用前进行实例化，否则会产生NPE(空指针异常)

下图展示的是Java的一大特点：不需要人为的free空间。在没有栈空间引用的时候，Java会自动回收堆空间。

2 静态初始化

完整格式：数据类型[ ] 数组名称 = new 数据类型{值，值，...};

简化格式：数据类型[ ] 数组名称 = {值，值，...};

这样定义数组的缺陷是：长度固定（存在越界问题）

在开发中，一般推荐使用完整格式。

下面是静态初始化数组的例子：

public static void code2(){
        int[] intarray2 = new int[]{1,2,3,4};
               for(int i = 0;i<4;i++){
            System.out.println(intarray2[i]);
        }
    }

3 匿名数组

匿名数组：顾名思义就是没有名字的数组。格式为：new 数据类型[ ]{值，值，...};

 public static void code3(){
        System.out.println(new int[]{1,2,3,4});
    }

二、二维数组

二维数组的本质是一个行列的集合，也就是说，在一个二维数组中，要想获得某个数据，既需要行索引，也需要列索引。

1 动态初始化

数据类型 [ ][ ]  数组名称 = new 数据类型 [行个数][列个数]；

2 静态初始化

 

数据类型[ ][ ] 数组名称 = new 数据类型{{值，值，...}，{值，值，...}，...};

下面定义一个二维数组：

  public static void code4(){
        int [][] data = new int[][]{
                {1,2,3},{4,5},{6,7,8,9}
        };
        for(int x = 0;x<data.length;x++){
            for(int y = 0;y<data[x].length;y++){
                System.out.println("data["+x+"]["+y+"]="+data[x][y]+"、");
            }
            System.out.println();
        }
    }

运行结果如下图所示：

三  数组与方法互相操作

数组是引用数据类型，所有引用数据类型都可以为其设置多个栈内存指向。即：同一块堆内存空间可以由不同的栈内存所指向。

所以，数组操作也可以用方法进行实现。

方法可以接收数组、返回数组、修改数组。下面一一举例说明：

方法接收数组：

 public class Array1{
    public static void main(String[] args) {   
        //用方法接收数组
        int[] data = new int[] {1,2,3,4};
        printArray(data);//效果等价与int[] temp = data;
    }
     public static void printArray(int[] temp){
        for(int i = 0;i<temp.length;i++){
            System.out.println(temp[i]);
        }
    }
}

方法返回数组：

 public class Array1{
    public static void main(String[] args) {   
      用方法返回数组
        int[] data = init();
        printArray(data);    
    }

    public static int[] init(){
        return new int[]{1,2,3,4,5};
     }
    public static void printArray(int[] temp){
        for(int i = 0;i<temp.length;i++){
            System.out.println(temp[i]);
        }
    }
}

方法修改数组：

/**
 * Author: PuTongFish
 * Array content enlarged five times
 * Create:2019/1/18
 */
public class ArrayDemo {
    public static void main(String[] args) {
        int[] data = init();
        bigger(data);
        printArray(data);
    }
    public static int[] init(){
        return new int[]{1,2,3,4,5};
    }
    public static void bigger(int[] array){
        for(int i = 0;i<array.length;i++){
            array[i]*=5;
        }
    }
    public static void printArray(int[] temp){
        for(int i=0;i<temp.length;i++){
            System.out.println(temp[i]);
        }
    }
}

四、Java中自带的数组方法

JavaSE给出的类库中提供了许多与数组相关的方法。（包括数组排序、数组拷贝等，可以在JDK中具体查看。）

数组排序：java.util.Arrays.sort(数组名称)；

只要是基本数据类型的数组，sort方法都可以进行升序处理。

​/**
 * Author: PuTongFish
 * Array sort
 * Create:2019/1/15
 */

//只要是基本数据类型的数组，都可以进行sort方法排序（升序处理）
public class ArraySort {
    public static void main(String[] args) {
        int[] intArray = new int[]{1,5,78,34,244};
        char[] charArray = new char[]{'a','r','d','p','f'};
        java.util.Arrays.sort(intArray);
        java.util.Arrays.sort(charArray);
        printArray(intArray);
        printArray(charArray);
    }
    public static void printArray(int[] data){
        for(int i=0;i<data.length;i++){
            System.out.print(data[i]+"  ");
        }
        System.out.println();
    }
    public static void printArray(char[] data){
        for(int i=0;i<data.length;i++){
            System.out.print(data[i]+"  ");
        }
        System.out.println();
    }
}
​

运行结果如下图：

数组拷贝（拷贝的内容在数组中是连续的）：

1      System.arraycopy(dataB,4,dataA,1,3);将源数组B的数组下标为4的元素开始，共计3个元素复制到目标数组A，元素下标为1的位置上。具体使用见下例：

   

import java.util.Arrays;

/**
 * Author: PuTongFish
 * Copy elements of array B to fixed positions of array A
 * Create:2019/1/15
 */
public class ArrayCopy {
    public static void main(String[] args) {
        int[] dataA = new int[]{1,2,3,4,5,6,7,8,9};
        int[] dataB = new int[]{11,22,33,44,55,66,77,88,99};
        System.arraycopy(dataB,4,dataA,1,3);
        //将数组B的数组下标为4的元素开始，共计3个元素复制到数组A的元素下表为1的位置
        printArray(dataA);
    }
    public static void printArray(int[] data){
        for(int i=0;i<data.length;i++){
            System.out.println(data[i]);
        }
    }
}

运行结果如下图所示：

2     Arrays.copyOf(dataA,N);将数组A中的元素前N个元素复制到新数组desc中，若N超过原数组长度，则用默认值0补齐

具体使用见下例：

import java.util.Arrays;

/**
 * Author: PuTongFish
 * Copy elements of array B to fixed positions of array A
 * Create:2019/1/15
 */
public class ArrayCopy {
    public static void main(String[] args) {
        int[] dataA = new int[]{1,2,3,4,5,6,7,8,9};
        //将数组A中的元素前N个元素复制到新数组desc中，若N超过原数组长度，则用默认值0补齐
        int[] desc1 = Arrays.copyOf(dataA,3);
        printArray(desc1);
        int[] desc2 = Arrays.copyOf(dataA,10);
        printArray(desc2);
        int[] desc3 = Arrays.copyOf(dataA,13);
        printArray(desc3);
    }
    public static void printArray(int[] data){
        for(int i=0;i<data.length;i++){
            System.out.print(data[i]+"    ");
        }
        System.out.println();
    }
}

运行情况见下图：

后续会有数组的相关案例。