用来存储同一类型值的集合
在声明变量时，需要指出数组类型和数组变量的名字
int [] a;
需要将数组初始化为一个真正的数组
`int [] a = new int [100];
数组长度不要求时常量：new int[n]会创建一个长度为n的数组
给数组元素赋值

for(int i= 0;i<100;i++)
a[i]= i;

• 所有元素初始化为0，boolean数组的元素会初始化为false，对象数组的元素则初始化为null
  *想要获取数组的个数使用array.length

for(int i=0;i<a.length;i++)
System.out.println(a[i]);

一旦创建了数组，就不能改变它的大小

foreach循环

依次处理数组中的每个元素
for(variable:collection)statement

for(int element:a)
System.out.println(element);

• for each 循环语句的循环变量将会遍历数组中的每个元素，而不需要使用下标值
• 打印数组中的所有值，利用Arrays类中的toString方法。用Arrays.toString(a)，返回一个包含数组元素的字符串，这些元素放在括号内，并用逗号隔开
  System.out.println(Arrays.toString(a));

数组初始化以及匿名数组

创建数组对象并同时赋予初始值简化书写形式

int[] smallPrimes = {2,3,5,7,11.13};//不需要调用new

• 允许数组长度为0

数组拷贝

允许将一个数组变量拷贝给另一个数组变量，两个变量引用同一个数组

int[] luckNumbers = smallPrimes;
luckNumbers[5] = 12;//now smallPrimes[5] is also 12

将一个数组的所有值拷贝到一个新的数组中去，就要使用Arrays类中的copyOf方法：

int[] copiedLuckyNumers = Arrays.copyOf(luckNumbers,luckNumbers.length);

这个方法通常用来增加数组的大小

luckNumbers = Arrays.coyOf(luckNumbers,2*luckNumbers.length);

• 如果数组元素时数值型，那么多余的元素将被赋值为0；如果时布尔型，将被赋值为false型，如果小于原始长度，则只拷贝最前面的数据元素

数组排序

想要对数据型数组进行排序，可以使用Arrays类中的sort方法

int [] a = new int[10000];
Arrays.sort(a);

• Math.random方法返回了一个从0到1（包含0不包含1）的随机浮点数，用n乘这个浮点数，就可以得到从0到n-1之间的随机数

int r= (int) (Math.random()*n);

import java.util.*;
public class LotteryDrawing
{
   public static void main(String[] args)
   {
      Scanner in = new Scanner(System.in);

      System.out.print("How many numbers do you need to draw? ");
      int k = in.nextInt();

      System.out.print("What is the highest number you can draw? ");
      int n = in.nextInt();

      //用数字1、2、3填充数组。…n
      int[] numbers = new int[n];
      for (int i = 0; i < numbers.length; i++)
         numbers[i] = i + 1;

      // 写出K数并将其放入第二个数组中
      int[] result = new int[k];
      for (int i = 0; i < result.length; i++)
      {
         //在0和n-1之间创建随机索引
         int r = (int) (Math.random() * n);

         //在随机位置选取元素
         result[i] = numbers[r];

         // 将最后一个元素移动到随机位置
         numbers[r] = numbers[n - 1];
         n--;
      }

      // 打印排序数组中
      Arrays.sort(result);
      System.out.println("Bet the following combination. It'll make you rich!");
      for (int r : result)
         System.out.println(r);
   }
}

数组的方法总结

• static String toString(type[] a)
  返回a中数据元素的字符串，这些元素放在括号内，并用逗号隔开
• static type copyOf(type[] a,int length)
• static type copyOfRange(type[]a,int start,int end)
  返回与a类型相同的一个数组，其长度为length或者end-start，数组元素为a的值
• static void sort(type[] a)
  采用优先快速排序的方法对数组进行排序
• static int binarySearch(type[] a,type v)
• static int binarySeach(type[] a,int start ,int end , type v)
  采用二分法查找v，如果成功，返回相应的下标值；否则，返回一个负数值r。-r-1是为了保证a有序v应插入的地方
• static void fill(type[] a,type v)
  将数组所有元素的值设置为v
• static boolean equals(type[] a, type[] b)
  如果两个数组大小相同，并且对应位置的元素对应相等，返回true

public class LotteryArray;
{
   public static void main(String[] args)
   {
      final int NMAX = 10;

      //分配三角形阵列
      int[][] odds = new int[NMAX + 1][];
      for (int n = 0; n <= NMAX; n++)
         odds[n] = new int[n + 1];

      // 填充三角形数组
      for (int n = 0; n < odds.length; n++)
         for (int k = 0; k < odds[n].length; k++)
         {
            /*
             * 计算二项式系数n*（n-1）*（n-2）*…（n-k+1）/（1*2*3*…*k）
             */
            int lotteryOdds = 1;
            for (int i = 1; i <= k; i++)
               lotteryOdds = lotteryOdds * (n - i + 1) / i;

            odds[n][k] = lotteryOdds;
         }

      //打印三角形阵列
      for (int[] row : odds)
      {
         for (int odd : row)
            System.out.printf("%4d", odd);
         System.out.println();
      }
   }
}