java数组的定义和使用

大家好，欢迎来到IT知识分享网。

什么是数组？

数组是一组相同数据类型元素的集合。在Java中数组属于引用类型，即数组是一个对象。这里的数据类型不仅含八大基本数据类型，还包含引用数据类型，如数组里面可以存数组,数组里面可以存放字符串。

数组的作用？

在程序中常常需要使用数组，利用循环可以对数组中的数据进行批量操作，大大提高了效率，十分方便。

如何使用数组？

数组的声明方式：
1.数据类型 [] 数组名称 eg：int [] a;

2数据类型 数组名称 [] eg：int a [];

注：推荐使用第一种声明方式，因为可以方便看出变量a是一个整型数组类型。此时a并没有指向具体的一块堆内存，因此它的默认值为null.

数组的初始化:
1.动态初始化： 数据类型 [] 数组名称 = new 数据类型 [长度]；
eg： int [] arr = new int [10];然后通过下标索引为每个元素赋值。

public class Test
{ 
   
    public static void main(String[] args)
    { 
   
        // 动态初始化
        int[] arr = new int [5];
        arr[0] = 0;
        arr[1] = 1;
        arr[2] = 3;
        arr[3] = 4;
        arr[4] = 5;

        // 利用循环实处每一个元素的值
        for(int i = 0;i < arr.length;i++)//数组名.length就是数组长度
        { 
   
            System.out.print(arr[i]+" ");  
        }
    }
}

注：new关键字的含义是在堆上开辟一块新的空间。只要有new关键字的出现，就意味着有新空间的开辟。
因此
2.静态初始化：在定义数组的同时设置元素的值。
简化格式：
数据类型 [] 数组名称 = {值1，值2，…};
完整格式：
数据类型 [] 数组名称 = new 数据类型 [] {值1，值2，…};

public class Test
{ 
   
    public static void main(String[] args)
    { 
   
        int[] arr1={ 
   1,2,3,4,5};//简化格式
        int[] arr2 = new int []{ 
   1,2,3,4,5};//完整格式
    }
}

匿名数组

利用完整格式，可以方便使用匿名数组。
匿名数组就是没有名称的数组，本质是一块没有栈内存指向的堆内存。只能使用一次，用完就被回收了。

public class Test
{ 
   
    public static void main(String[] args)
    { 
   
        int[] arr = init();
        for(int i=0; i < arr.length;i++)
        { 
   
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }
     public static int[] init()
     { 
   
         return new int[]{ 
   1,2,3,4,5};//方法返回一个匿名数组
     }
}

二维数组

概念：数组里的每一个元素都是是一个一维数组的数组被称为二维数组。
定义： 静态初始化：

 int[][] arr1 = { 
   { 
   1,2,3},{ 
   1,2}};//简化格式
 
 int[][] arr2 = new int[][] { 
   { 
   1,2,3},{ 
   4,5}};//完整格式

动态初始化：

  int arr[][] = new int[2][3];//2 行个数，3，列个数

注：其中列个数可以省略不写，因为Java中的二维数组存在不规则矩阵这样的数组，因此写了也没有多大意义。
eg：不规则二维数组的使用：

public class Test
{ 
   
    public static void main(String[] args)
    { 
   
        int[][] arr=new int[3][]
        { 
   
            { 
   1,2,3,4},
            { 
   1,2},
            { 
   3,4}
        };
        for(int i=0;i<arr.length;i++)  //利用两重for循环打印输出二维数组的元素。
        { 
   
            for(int j=0;j<arr[i].length;j++)
            { 
   
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();
        }
    }    
}

输出结果：

在C语言中二维数组每一行的个数都是相同的。

利用增强型for循环（foreach循环）打印多维数组

格式：for（part1：part2）{part3}

part2 是一个数组对象
part1：定义一个变量，变量的类型是数组中元素的类型。
part3：循环体
原理：将part2 数组中的元素值拷贝一份逐一赋给part1，然后利用part3循环体将值打印出来。因此该循环只能作为输出不能修改数组中元素的值。因为它仅是一份值得拷贝。

public class Foreach
{ 
   
    public static void main(String[] args)
    { 
   
        int[] arr1=new int[]{ 
   1,2,3,4,5};
        int[][] arr2=new int[][]{ 
   { 
   1,2,3},{ 
   4,5}};
        int[][][] arr3=new int[][][]{ 
   { 
   { 
   1,2,3},{ 
   4,5}}};
        //方法重载，方法的新参类型不同。
        printArr(arr1);
        printArr(arr2);
        printArr(arr3);
    }

    // 利用增强型for循环打印一维数组
     public static void printArr(int[] arr)
    { 
   
         for(int i: arr)
         { 
   
            System.out.print(i+" ");
         }
        System.out.println();
    }

    // 利用增强型for循环打印二维数组
    public static void printArr(int[][] arr)
    { 
   
        for(int[] data:arr)
        { 
   
            for(int i: data)
            { 
   
                System.out.print(i+" ");
            }
        }
         System.out.println();
    }


    // 利用增强型for循环打印三维数组
     public static void printArr(int[][][] arr)
     { 
   
         for(int[][]data:arr)
         { 
   
             for(int[]daat:data)
             { 
   
                 for(int i:daat)
                 { 
   
                     System.out.print(i+" ");
                 }
             }
         }
          System.out.println();
     }
    
} 

输出结果：

利用增强型for循环输出多维数组和一维数组的本质思想是一样的。
以二维数组为例：
首先二维数组的每一个元素类型都是一维数组，因此第一个增强型for循环的第一个局部变量为一维数组类型，第二部分是二维数组名。但不能利用循环体直接将一维数组整体输出。因此需要再嵌套一个增强型for循环，此时的for循环里的局部变量类型为外部增强型for循环里面的一维数组元素的类型，第二部分是第一层增强型for循环里的一维数组本身。然后循环体中依次输出这个局部变量即OK了！

引用传递

概念：多个栈空间同时指向同一块堆内存

赋值语句从右向左执行，因此首先执行new int[] {1,2,3}，则在堆上开辟12个字节的空间，每四个分别用来存放arr[0],arr[1],arr[2],并对它们进行初始化。然后在栈上为局部变量arr分配空间，并将堆空间的地址（首地址）存到栈空间的arr里面，此时栈上的arr的值就是堆上的数组空间的地址，因此二者建立了一定联系，这里用指向来表示。
再接着在栈上定义了一个局部变量x，并把arr的值赋给x，因此x里面也存的是堆空间的首地址，此时x也指向那块堆空间，利用x也可对堆空间的值进行操作，这便称为引用传递。本质：多个栈空间同时指向同一块堆内存。没有栈内存指向的堆内存也被称为垃圾空间。

注：在C语言里面曾经学过，在函数内部修改其它函数局部变量的值可以通过该变量的地址或者返回值的方式。因此我们可以利用引用传递来修改堆空间的值。

数组常用操作

Java中提供了很多对数组操作的方法可以方便得实现对数组的各种操作。
1.数组长度： 数组名.length
2.数组排序： java.util.Arrays.sort(数组名) 升序
3.数组扩容：java.util.Arrays.(数组名称，新数组长度）
（这个很像C语言中的realloc函数）。
4.在数组中查找指定元素：Arrays.binarySearch(数组，指定元素)。
（看名字像是二分查找实现的）。
5.数组拷贝：System.arraycopy(源数组名称，源数组开始点，目标数组 名称，目标数组开始点，拷贝长度)。