java入门---数组声明&创建&初始化&arrays类

    数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。Java 语言中提供的数组是用来存储固定大小的同类型元素。我们可以声明一个数组变量，如 numbers[100] 来代替直接声明 100 个独立变量 number0，number1，....，number99。这次我们来看Java 数组的声明、创建和初始化。

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

dataType[] arrayRefVar;   // 首选的方法
 
或
 
dataType arrayRefVar[];  // 效果相同，但不是首选方法

    建议使用 dataType[] arrayRefVar 的声明风格声明数组变量。dataType arrayRefVar[] 风格是来自 C/C++ 语言 ，在Java中采用是为了让 C/C++ 程序员能够快速理解java语言。下面是这两种语法的代码示例：

double[] myList;         // 首选的方法
 
或
 

double myList[];         //  效果相同，但不是首选方法

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

arrayRefVar = new dataType[arraySize];

    上面的语法语句做了两件事：

• 一、使用 dataType[arraySize] 创建了一个数组。
• 二、把新创建的数组的引用赋值给变量 arrayRefVar。

    数组变量的声明，和创建数组可以用一条语句完成，如下所示：

dataType[] arrayRefVar = new dataType[arraySize];

    我们还可以使用如下的方式创建数组：

dataType[] arrayRefVar = {value0, value1, ..., valuek};

    数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 arrayRefVar.length-1。下面的语句首先声明了一个数组变量 myList，接着创建了一个包含 10 个 double 类型元素的数组，并且把它的引用赋值给 myList 变量：

public class TestArray {
   public static void main(String[] args) {
      // 数组大小
      int size = 10;
      // 定义数组
      double[] myList = new double[size];
      myList[0] = 5.6;
      myList[1] = 4.5;
      myList[2] = 3.3;
      myList[3] = 13.2;
      myList[4] = 4.0;
      myList[5] = 34.33;
      myList[6] = 34.0;
      myList[7] = 45.45;
      myList[8] = 99.993;
      myList[9] = 11123;
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < size; i++) {
         total += myList[i];
      }
      System.out.println("总和为： " + total);
   }
}

    运行结果为：

总和为： 11367.373

    下面的图片描绘了数组 myList。这里 myList 数组里有 10 个 double 元素，它的下标从 0 到 9：

    然后我们来看下arrays类。java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的，具体有以下功能：

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

    具体说明请看下表：

序号	方法和说明
1	public static int binarySearch(Object[] a, Object key) 用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
2	public static boolean equals(long[] a, long[] a2) 如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
3	public static void fill(int[] a, int val) 将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
4	public static void sort(Object[] a) 对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。

    

// 声明二维数组：有两行，列数待定，数组结构 = { { }, { } }

String s[][] = new String[2][]; 

// 确定每行的元素个数，第一行有2个元素，第二行有3个元素，

// 数组结构 = {{"E1", "E2"}, {"E1", "E2", "E3"}}

s[0] = new String[2];

s[1] = new String[3];

    看完了数组声明、创建、初始化的实例后，我们再来看下arrays的实例：

import java.util.Arrays;

public class TestArrays {
    public static void output(int[] array) {
        if (array != null) {
            for (int i = 0; i < array.length; i++) {
                System.out.print(array[i] + " ");
            }
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int[] array = new int[5];
        // 填充数组
        Arrays.fill(array, 5);
        System.out.println("填充数组：Arrays.fill(array, 5)：");
        TestArrays.output(array);
        // 将数组的第2和第3个元素赋值为8
        Arrays.fill(array, 2, 4, 8);
        System.out.println("将数组的第2和第3个元素赋值为8：Arrays.fill(array, 2, 4, 8)：");
        TestArrays.output(array);
        int[] array1 = { 7, 8, 3, 2, 12, 6, 3, 5, 4 };
        // 对数组的第2个到第6个进行排序进行排序
        Arrays.sort(array1, 2, 7);
        System.out.println("对数组的第2个到第6个元素进行排序进行排序：Arrays.sort(array,2,7)：");
        TestArrays.output(array1);
        // 对整个数组进行排序
        Arrays.sort(array1);
        System.out.println("对整个数组进行排序：Arrays.sort(array1)：");
        TestArrays.output(array1);
        // 比较数组元素是否相等
        System.out.println("比较数组元素是否相等:Arrays.equals(array, array1):" + "\n" + Arrays.equals(array, array1));
        int[] array2 = array1.clone();
        System.out.println("克隆后数组元素是否相等:Arrays.equals(array1, array2):" + "\n" + Arrays.equals(array1, array2));
        // 使用二分搜索算法查找指定元素所在的下标（必须是排序好的，否则结果不正确）
        Arrays.sort(array1);
        System.out.println("元素3在array1中的位置：Arrays.binarySearch(array1, 3)：" + "\n" + Arrays.binarySearch(array1, 3));
        // 如果不存在就返回负数
        System.out.println("元素9在array1中的位置：Arrays.binarySearch(array1, 9)：" + "\n" + Arrays.binarySearch(array1, 9));
    }
}

    输出的结果为：

填充数组：Arrays.fill(array, 5)：
5 5 5 5 5 
将数组的第2和第3个元素赋值为8：Arrays.fill(array, 2, 4, 8)：
5 5 8 8 5 
对数组的第2个到第6个元素进行排序进行排序：Arrays.sort(array,2,7)：
7 8 2 3 3 6 12 5 4 
对整个数组进行排序：Arrays.sort(array1)：
2 3 3 4 5 6 7 8 12 
比较数组元素是否相等:Arrays.equals(array, array1):
false
克隆后数组元素是否相等:Arrays.equals(array1, array2):
true
元素3在array1中的位置：Arrays.binarySearch(array1, 3)：
1
元素9在array1中的位置：Arrays.binarySearch(array1, 9)：
-9

    数组容量如果不够用可以使用 Arrays.copyOf() 进行扩容：

Array.copy(E[] e,newLength);

    其第一个形参指的是需要扩容的数组，后面是扩容后的大小，其内部实现其实是使用了 System.arrayCopy(); 在内部重新创建一个长度为 newLength 类型是 E 的数组。

import java.util.Arrays;  
public class Main {
    public static void main(String[] args) {
        int[] a= {10,20,30,40,50};
        a= Arrays.copyOf(a,a.length+1);
        for(int i=0;i<a.length;i++) {
            System.out.println(a[i]);
        }
    }
}

    默认补 0，输出结果为： 10 20 30 40 50 0。

    数组这里有一个问题容易搞不清楚的。在 java 中，关于数组描述正确的是( B，D )：

• A.数组中的索引下标从1开始
• B.存储在数组当中的数据都属于同一数据类型
• C.通过数组名.length()能获得数组的长度
• D.数组的最大索引下标是数组的长度减1

    比如说一个 int 类型的数组：

int[] arr = { 'a', 25, 45, 78, 'z' };
System.out.println(Arrays.toString(arr));

    输出结果是：[97, 25, 45, 78, 122]。存放进去的 char 类型的字符会自动转为 int 类型的 ASCII 码。上面的代码中就将 a 转成了 97，z 转成了 122。所以数组只能存放同一类型的数据是正确的。

    数组的长度固定时，为了防止下标越界，应该在索引的时候将下标减一。

int[] arr = { 'a', 25, 45, 78, 'z' };
int arrs = arr[5];
System.out.println(Arrays.toString(arr));
System.out.println(arrs);

    上面的代码中数组总长度为 5，因为数组是索引是从 0 开始取值，索引取值为5的时候就会产生下标越界异常，在这里最大的索引应当为 4。

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5

    好啦，这次就到这里了。如果感觉不错的话，请多多点赞支持哦。。。