Java 数组

        数组是最常见的一种数据结构，是相同类型的、用一个标识符封装到一起的基本类型数据序列或对象序列。可以用一个统一的数组名和下标来唯一确定数组中的元素。实质上数组是一个简单的线性序列，因此数组访问起来很快。
Java中虽然数据类型不是对象，但是由数据基本类型组成的则是对象，在程序中引入数组可以更有效的管理和处理数据。

  数组根据维数的不同分为：一维数组、二维数组和多维数组。

5.1  一维数组
5.1.1 创建一维数组
  数组作为对象使用new关键字进行分配内存，必须首先定义数组变量所属的类型，即声明数组。声明一维数组有两种形式:
数组元素类型 数组名字[];
数组元素类型[] 数组名字；
注：
1.数组元素类型：决定了数组的数据类型，它可以是java中的任意的数据类型，包括基本数据类型和非基本数据类型。
2.数组名字：为一个合法的标识符。
3.符号“[]”:指明变量是一个数组类型变量类型，单个“[]”表示要创建的是一位数组。
【例】声明一位数组
int arr[]    //声明int型数组，数组中的每个元素都是int型数值
String[]str  //声明String数组，数组中的每个元素都是String型数值
声明数组后，还不能访问它的任何元素，因为声明数组仅仅是给出了数组名字的元素的数据类型，要想使用数组还要为其分配内存空间，且分配空间需要指明数组的长度，分配内存空间的语法格式：
数组名字=new 数组元素类型[数组元素的个数];
.数组名字：已经声明的数组变量的名称
.new：对数组分配空间的关键字。
.数组元素的个数：指定数组中变量的个数，即数组的长度。
【例】为数组分配内存
arr =new int[5];
5.1.2 初始化一维数组
数组可以与基本数据类型一样进行初始化的操作，数组的初始化可以分别初始化数组中的每个元素，数组的初始化有两种方式。
【例】初始化一维数组
int arr[]=new int[]{1,2,3,4}     //第一种初始化方式

int arr2[]={1,2,3,4}             //第二种初始化方式

5.2 二维数组 
二维数组是应用最为广泛的一种数组，二维数组是指有两个底标的数组。
5.2.1声明二维数组
声明二维数组有两种方法，语法格式分别如下:
数组元素类型 数组名字[][];
数组元素类型[][] 数组名字；
注：
1.数组元素类型：决定了数组的数组类型，它可以是java中的任意的数据类型，包括基本数据类型和非基本数据类型。
2.数组名字：使用一个合法的标识符。
3.[][]:两个“[]”表示要创建的数组是二维数组。
【例】声明二维数组
float A[][];
5.2.2 创建二维数组
创建二维数组的过程，世纪实际上就是在计算机中申请一个存储空间。
【例】创建二维数组
int A [][]={1,2,3},{4,5,6}
通过上述代码创建了一个二维数组，A是数组名，实质上此二维数组相当于一个两行三列的矩阵，当需要取多维中的值时，可以使用下标来显示。
5.2.3 初始化二维数组
二维数组的初始化与一位数组的初始化类似，同样可以使用大括号来完成二维数组的初始化。语法格式：
type arrayname[][]={value1，value2,…value n}
type :数组数据类型
arrayname：数组名称，一个合法的标识符
value：数组中各元素的值。
【例】初始化二维数组
int mychar[][]={{12,23},{56,96}}

初始化二维数组后要明确数组的下标都是从0开始的。

5.3三维数组
三维数组是多维数组的一种，是二维数组和一位数组的升级。三维数组则使用三个中括号，初始化三维数组时，由三层大括号进行初始化，使用时也麻烦一些，需要使用三层for循环。

[例]创建Ransack类，在类的主方法中创建三维数组，并将三维数组在控制台输出。

1.  
   public class Ransack_ {
2.  
   public static void main(String[] args) {
3.  
   int arr[][][]=new int[][][]{
4.  
   {{ 1,2,3},{4,5,6}},{{7,8,9},{10,11,12}},{{13,14,15},{16,17,18}}};
5.  
   //遍历数组
6.  
   for (int i = 0; i < arr.length; i++) {
7.  
   System.out.println( "三维数组的第"+(i+1)+"个元素是一个"+arr[0].length+"维数组，内容如下：");
8.  
   //遍历数组
9.  
   for (int j = 0; j < arr[0].length; j++) {
10.  
    //遍历数组
11.  
    for (int k = 0; k < arr[0][0].length; k++) {
12.  
    System.out.print(arr[i][j][k]+ "\n");
13.  
    }
14.  
    System.out.println();
15.  
    }
16.  
    }
17.  
    }
18.  
    }

5.4遍历数组
1.遍历一维数组

【例】在项目中创建一个Getday类，在主方法中创建int型数组，并实现将各月份的天数打印出来。

1.  
   public class Getday {
2.  
   public static void main(String[] args) {
3.  
   int day[]=new int[]{31,28,31,30,31,30,31,31,30,31,30,31};
4.  
   for (int i = 0; i < 12; i++) {
5.  
   System.out.println((i+ 1)+"月有"+day[i]+"天"+"\t");
6.  
   if ((i+1)%3==0) {
7.  
   System.out.println();
8.  
   }
9.  
   }
10.  
    }
11.  
    }

2.遍历二维数组
【例】使用二维数组，输出一个3行4列的所有元素都是0的矩阵。

1.  
   public class matrix_ {
2.  
   public static void main(String[] args) {
3.  
   int a[][]=new int[3][4];
4.  
   for (int i = 0; i < a.length; i++) {
5.  
   for (int j = 0; j < a[i].length; j++) {
6.  
   System.out.print(a[i][j]);
7.  
   }
8.  
   System.out.println();
9.  
   }
10.  
    }
11.  
    }

5.5数组的基本操作
Java.util包的Arrays类包含了用来操作数组的各种方法。
5.5.1填充替换数组元素
数组中的元素定义完成后，可以通过Arrays类的静态方法fill()来对数组中的元素进行替换，该方法可以通过各种重载形式可以完成对任意类型数组元素的替换，fill()方法可以有两种参数类型。(下面以int型为例)
1、fill(int []a,int value)
a:要进行元素替换的数组
value：要储存数组中的所有元素值。
2.fill(int[]a ，int fromIndex,int toIndex,int value)
a:要进行填充的数组
fromIndex:要使用指定值填充的第一个元素的索引（包括）。
toIndex：使用指定值填充的最后一个元素的索引（不包括）。
value： 要储存在数组中的所有元素的值。

【例】创建一维数组，并通过fill()方法替换数组中的元素，最后将数组中的各个元素输出。

1.  
   public class Displace_ {
2.  
   public static void main(String[] args) {
3.  
   int arr[]=new int[]{45,1,2,3};//定义初始化数组
4.  
   Arrays.fill(arr, 1,2,8);//使用fill()方法对数组进行初始化
5.  
   for (int i = 0; i < arr.length; i++) {
6.  
   /**
7.  
   * 使用for循环遍历数组中的元素
8.  
   */
9.  
   System.out.println( "第"+i+"个元素是："+arr[i]);//输出数组中的每个元素
10.  
    }
11.  
    }
12.  
    }

5.5.2对数组进行排序
通过Arrays类的静态，sort()方法可以实现对数组的排序，sort（）方法提供了多种重载形式。可以对任意类型的数组进行升序排序。语法如下：Arrays.sort(object),其中，object是指进行排序的数组名称。

1.  
   【例】创建一维数组，将数组排序后输出。
2.  
   public class text_03 {
3.  
   public static void main(String[] args) {
4.  
   int []arr=new int[]{23,56,42,6};
5.  
   Arrays.sort(arr); //将数组进行升序排序
6.  
   for (int i = 0; i < arr.length; i++) {
7.  
   System.out.println(arr[i]);
8.  
   }
9.  
   }
10.  
    }

5.5.3复制数组
Arrays类的copyOf()方法与copyOfRange()可以实现对数组的复制。
1、copyOf()方法
语法：copyOf(arr，int newlength)
arr：要进行复制的数组
newlengh：int常量，是指复制后新数组的长度。如果新数组的长度大于数组的长度，则用0来补充。（根据复制数组的类型来决定填充的值，整型数组用0来补充，char型数组用null来补充，如果复制后的数组的长度小于数组arr的长度，则会从数组的第一个元素开始的截取至满足新数组的长度为止。）

1.  
   【例】创建一维数组实现将此数组复制到的一个新的长度为 5的新数组，并将数组的元素输出。
2.  
   public class text4 {
3.  
   public static void main(String[] args) {
4.  
   int []arr=new int []{23,42,12};//定义数组
5.  
   int []newarr=Arrays.copyOf(arr, 5);//复制数组arr得到新的数组newarr
6.  
   for (int i = 0; i < newarr.length; i++) {
7.  
   /**
8.  
   * 遍历新数组
9.  
   */
10.  
    System.out.println(newarr[i]); //将新的数组输出
11.  
    }
12.  
    }
13.  
    }

5.6数组排序算法
程序常用的排序方法有冒泡排序、直接选择排序、反转排序。
在程序设计中，经常需要将一组数列进行排序，这样更加方便统计与查询。程序常用的排序方法有冒泡排序、选择排序和快速排序等。
5.6.1冒泡排序
1、基本思想
冒泡算法是由双层循环实现的，其中外层循环用于控制排序轮数，内层循环主要用于对比数组中每个临近元素的大小，以确定是否要交换位置，对比和交换次数随排序轮数而减少。
2、算法的实现

1.  
   【例】创建一个类，类的代码将实现冒泡排序的一个演示，排序使用的是正排序。
2.  
   public class BubbleSort {
3.  
   public static void main(String[] args) {
4.  
   //创建一个二维数组，数组中的元素是乱序的
5.  
   int[]array={63,56,12,36,2,15};
6.  
   //创建冒泡排序的类的一个对象
7.  
   BubbleSort sorter= new BubbleSort();
8.  
   //调用排序方法，将数组进行排序
9.  
   sorter.sort(array);
10.  
    }
11.  
    /**
12.  
    * 冒泡法排序
13.  
    * @param array
14.  
    */
15.  
    public void sort(int[] array) {
16.  
    for (int i = 0; i < array.length; i++) {
17.  
    //比较两个相邻元素，较大的数往后冒泡
18.  
    for (int j = 0; j < array.length-i; j++) {
19.  
    if (array[j]>array[j+1]) {
20.  
    int temp=array[i];//把第一个元素的值保存到临时变量中
21.  
    array[j]=array[j+ 1];//把第二个元素的值保存到第一个元素的单元中
22.  
    array[j+ 1]=temp;//把临时变量保存到第二个元素中
23.  
    }
24.  
    }
25.  
    }
26.  
    showArray(array); //输出冒泡排序后的数组的元素
27.  
    }
28.  
    /**
29.  
    * 显示数组中的所有元素
30.  
    * @param array
31.  
    */
32.  
    public void showArray(int[] array) {
33.  
    for (int i:array) {//遍历数组
34.  
    System.out.println( ">"+i);//输出每个元素值
35.  
    }
36.  
    System.out.println();
37.  
    }
38.  
    }

5.6.2直接选择排序
1、基本思想
直接选择排序的基本思想是指定排序位置与其他数组有元素分别进行对比，如果满足条件，就交换数组元素，注意，这里区别于冒泡排序，不是交换相邻的元素，而是把满足条件的元素与指定的排序位置交换。这样排序好的位置逐渐扩大，最后整个数组都成为已排序好的格式。
2、算法实现

1.  
   【例】创建SelectSort类，这个类的代码作为直接选择排序的一个演示，其中排序使用正序排序。
2.  
   public class SelectSort_ {
3.  
   public static void main(String[] args) {
4.  
   //创建一个数组，数组的元素是乱序的
5.  
   int[]array={63,4,24,1,31,15};
6.  
   //创建直接排序的对象
7.  
   SelectSort_ sorter= new SelectSort_();
8.  
   //调用排序对象的方法将数组排序
9.  
   sorter.sort(array);
10.  
    }
11.  
    /**
12.  
    * 直接排序
13.  
    * @param array
14.  
    */
15.  
    public void sort(int[] array) {
16.  
    int index;
17.  
    for (int i = 1; i < array.length; i++) {
18.  
    index= 0;
19.  
    for (int j = 1; j < array.length-i; j++) {
20.  
    if(array[j]>array[index]){
21.  
    index=j;
22.  
    }
23.  
    }
24.  
    //交换位置array.length-i和index（最大值）上的两个数
25.  
    int temp=array[array.length-i];//把第一个元素值保存到临时变量中
26.  
    array[array.length-i]=array[index]; //把第二个元素值保存到第一个元素单元中
27.  
    array[index]=temp; //把临时变量即就是第一个元素值保存到第二个元素中
28.  
    }
29.  
    showArray(array); //输出直接选择排序后的数组值
30.  
    }
31.  
    /**
32.  
    * 显示数组中的所有元素
33.  
    * @param array
34.  
    */
35.  
    public void showArray(int[] array) {
36.  
    for (int i:array) {
37.  
    System.out.print(i);
38.  
    }
39.  
    System.out.println();
40.  
    }
41.  
    }

5.6.3反转排序
1、基本思想
思路就是把数组的最后一个元素和第一个元素替换，倒数第二个数和第二个元素替换，以此类推，直到把所有数组元素反转替换。

5.7小结
数组的下标是从0开始的，最后一个元素的表示总是“数组名.length-1”