Java【数组】

数组是一组类型相同的数据（基本类型或引用类型）的集合，数组中每个数据称为元素。数组也是Java的对象，一旦创建，数组长度就固定了。

声明数组变量

声明一个数组类型的引用变量（数组变量），但是不能指定数组长度；

int[] scores;     //合法，首选方法
String names[];   //合法，这是源于C/C++语言风格

//int scores[30]; //非法

可以用符号“...”声明数目可变参数；

//有一个max()方法要从一组int类型的数组中找出最大值，但是数组的数目不固定（2~6之间）
public class Varable{
  public static int max(int... datas){ //datas为可变参数
    if(datas.length == 0)
      return -1;  //为传入任何参数
 
    int result = 0;
    for(int a: datas)  //从datas中选出每个int类型的元素，把它赋值给变量a
      if(result<a)
        result=a;
    
    return result;
  }
  
  public static void main(String[] args){
    System.out.println(max(5));
    System.out.println(max(5,8,9,3));
    System.out.println(max(new int[]{4,10,7,3}));  //传入数组
    System.out.println(max());
  }
}

创建数组

使用new创建数组对象

• 按大小为数组分配内存
• 为每个数组元素赋予数字类型的默认值
• 返回数组对象的引用

dataType[] arrayRefVar = new dataType[arraySize];

示例： 

int[] scores = new int[50];     //使用int[50]创建了一个数组，把新创建的数组的引用赋值给变量scores
System.out.println(scores[0]);  //打印0
String[] names = new String[50];
System.out.println(names[0]);   //打印null

显式创建数组

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

数组初始化

int[] x = new int[]{5,6,7,8,9};     //合法
//int[] x = new int[5]{5,6,7,8,9};  //非法，不能在[]中指定数组长度

int[] y = new int[5];
for(int i=0; i<y.length; i++)
  y[i] = y.length - i;   //合法

遍历数组

可以使用 For-Each 循环遍历数组

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

示例：

//遍历数组
/**报数Game：有编号的玩家轮流报数1~3，每次报道3的出局，按顺序进行，问最后剩下的是哪个玩家
   1、isActive数组记录玩家是否在圈内，若isActive[i]=false，那么编号为i+1的玩家已出局
   2、为了跟踪报数状态：定义了三个变量
         size：表示当前在圈内的玩家数
         count：表示当前的报数，为3时，会将其置0
         point：当前正在报数的玩家在isActive数组中的索引位置，为n时，重置0 */

public class Game{
  public static int play(int n){
    boolean[] isActive = new boolean[n];    //记录每个玩家是否在圈

    //初始化开局玩家信息
    for(int i = 0; i < isActive.length; i++)
      isActive[i] = true;

    int size = n;     //圈内玩家数
    int count = 0;    //当前报数
    int point = 0;    //当前报数玩家的索引

    while(size > 1){  //循环报数至圈内只剩下一人
      if(isActive[point]){  //当前轮到的玩家在圈内
        count++;  //报下一个数
        if(count == 3){     //如果当前报数已到3，处理count、isActive[point]
          count = 0;
          isActive[point] = false;  //玩家出局
          size--;     //玩家规模减一
        }
      }

      point++;    //轮到下一个报数人
      if(point == n) //如果以及轮完一圈
         point = 0;  //从第一个玩家开始再来报数
    }

    int last = 0;
    for(int i = 0; i < n; i++)
      if(isActive[i])
        last = i + 1;
    
    return last;
  }
   
  public static void main(String[] args){
    System.out.println(play(20));  //打印
  }
}

数组作为函数参数

示例：

public class example(){
  public static void printArray(int[] array) {
    for (int i = 0; i < array.length; i++) {
      System.out.print(array[i] + " ");
    }
  }

  public static void main(String[] args) {
    printArray(new int[]{3, 1, 2, 6, 4, 2});
  }
}

数组作为函数的返回值

示例：

public static int[] reverse(int[] list) {
  int[] result = new int[list.length];
 
  for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
    result[j] = list[i];
  }
  return result;
}

多维数组

格式（二维数组为例）

type[][] typeName = new type[typeLength1][typeLength2];

从最高维开始分配空间，typeName.length-多少行，typeName[0].length-多少列。

//求转置矩阵
public class Reversal{
  public static int[][] change(int[][] from){
    int rows = from.length;     //原始矩阵行数
    int cols = from[0].length;  //原始矩阵列数
    int[][] to = new int[cols][rows];  //转置后矩阵

    for(int i = 0; i < from.length; i++)  //循环行
        for(int j = 0; j < from[i].length; j++)  //循环列
          to[j][i]=from[i][j];
    
    return to;
  }

  public static void main(String[] args){
    int[][] from = {{11,22,33,44},
                    {55,66,77,88},
                    {99,92,23,38}};
    int[][] to = change(from);

    for(int i = 0; i < from.length; i++){ 
        for(int j = 0; j < from[i].length; j++)  
          System.out.print(to[i][j]+" ");
        
        System.out.println();
    }
  }
}

---

Arrays 类

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

具有以下功能：

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

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