数组基础

定义数组
1. 数组是一组命名的同类型变量集合
2. 数组中的变量被称为数组元素
3. 数组第一个元素索引为0

public class MainClass {
  public static void main(String[] arg) {
    int[] intArray = new int[10];
    for (int i = 0; i < 10; i++) {
      intArray[i] = 100;
    }
    for (int i = 0; i < 10; i++) {
      System.out.println(intArray[i]);
    }
  }
}

字符数组

public class MainClass{
  public static void main(String[] arg){
     char[] message = new char[50];
     java.util.Arrays.fill(message, 'A');
     for(char ch: message){
       System.out.println(ch);
     }
  }
}

根据索引初始化数组

public class MainClass {
  public static void main(String args[]) {
    int month_days[];
    month_days = new int[12];
    month_days[0] = 31;
    month_days[1] = 28;
    month_days[2] = 31;
    month_days[3] = 30;
    month_days[4] = 31;
    month_days[5] = 30;
    month_days[6] = 31;
    month_days[7] = 31;
    month_days[8] = 30;
    month_days[9] = 31;
    month_days[10] = 30;
    month_days[11] = 31;
    System.out.println("April has " + month_days[3] + " days.");
  }
}

其他数组声明语法
例如下面两种方式声明数组是等价的：

int al[] = new int[3];
int[] a2 = new int[3];

下面两种也是等价的：

char twod1[][] = new char[3][4];
char[][] twod2 = new char[3][4];

下面这种声明方式在声明多个数组的时候很方便：

int[] nums, nums2, nums3; 

匿名数组的声明方式与常规数组类似

public class MainClass {
  public static void main (String args[]) {
    int array1[] = {1, 2, 3, 4, 5};
    for(int i: array1){
      System.out.println(i);
    }
  }
}

数组也是对象，初始化为null

public class MainClass {
  static String[] names;
  public static void main(String[] a) {
    if (names == null) {
      System.out.println("true");
    } else {
      System.out.println("false");
    }
  }
}

引用数组元素
java采用变量名加索引的方式引用数组元素, 例如,下面这段代码生成了一个包含四个字符串的数组，然后初始化第一个数组元素.

public class MainClass {
  public static void main(String[] args) {
    String[] names = new String[4];
    names[0] = "Hello World";
  }
}

数组长度.length

public class MainClass {
  public static void main(String[] arg) {
    int[] intArray = new int[10];
    for (int i = 0; i < intArray.length; i++) {
      intArray[i] = 100;
    }
    for (int i = 0; i < intArray.length; i++) {
      System.out.println(intArray[i]);
    }
  }
}

初始化数组

public class MainClass{
  public static void main(String[] arg){
    int[] primes = {2, 3, 5, 7, 11, 13, 17};   // An array of 7 elements     
    for (int i = 0; i < primes.length; i++) {
     System.out.println(primes[i]); 
    }
  }
}

使用for循环编列数组元素并赋值。

public class MainClass {
  public static void main(String[] arg) {
    double[] data = new double[50]; // An array of 50 values of type double
    for (int i = 0; i < data.length; i++) { // i from 0 to data.length-1
      data[i] = 1.0;
    }
    for (int i = 0; i < data.length; i++) { // i from 0 to data.length-1
      System.out.println(data[i]);
    }
  }
}

使用基于集合的for循环
现在遍历集合元素的时候，无需使用索引.可以使用下面的语法遍历集合元素：
for (元素类型 变量名: 集合名称)

import java.util.Arrays;
public class MainClass {
  public static void main(String[] arg) {
    double[] data = new double[50]; // An array of 50 values of type double
    Arrays.fill(data, 1.0);                     // Fill all elements of data with 1.0   
    for (double d: data) { 
      System.out.println(d);
    }
  }
}

改变数组长度
数组一旦创建，大小就不允许改变.如果想改变数组大小，需要新建一个数组，然后用原有数组的值来填充新数组.

public class MainClass {


  public static void main(String[] args) {
    int[] numbers = { 1, 2, 3 };
    int[] temp = new int[4];
    int length = numbers.length;
    for (int j = 0; j < length; j++) {
      temp[j] = numbers[j];
    }
    numbers = temp;
  }
}

数组再分配
可以克隆一个数组，然后让新数组与原数组的大小不同.

public static boolean[] copyOf (boolean[] original, int newLength)
public static byte[] copyOf (byte[] original, int newLength)
public static char[] copyOf (char[] original, int newLength)
public static double[] copyOf (double[] original, int newLength)
public static float [] copyOf (float[] original, int newLength)
public static int[] copyOf (int[] original, int newLength)
public static long[] copyOf (long[] original, int newLength)
public static short[] copyOf (short[] original, int newLength)
public static <T> T[] copyOf (T[] original, int newLength)
public static <T,U> T[] copyOf (U[] original, int newLength,java.lang.Class<? extends T[]> newType)

最后一个方法允许将数组元素上溯造型为其父类类型。与copyOf类似的一个方法在java6中引入：copyOfRange.copyOfRange将数组的一部分拷贝到新数组。
和copyOfRange一样，copyOfRange重写了各种java数据类型数组.

public static boolean[] copyOfRange (boolean[] original,int from, int to)
public static byte[] copyOfRange (byte[] original,int from, int to)
public static char[] copyOfRange (char[] original,int from, int to)
public static double[] copyOfRange (double[] original,int from, int to)
public static float[] copyOfRange (float[] original,int from, int to)
public static int[] copyOfRange (int[] original, int from, int to)
public static long[] copyOfRange (long[] original, int from, int to)
public static short[] copyOfRange (short[] original, int from, int to)
public static <T> T[] copyOfRange (T[] original, int from, int to)
public static <T,U> T[] copyOfRange (U[] original, int from,int to, java.lang.Class<? extends T[]> newType)

看一个数组再分配的例子

import java.util.Arrays;


public class ArrayReallocationDemo {
  public static void main(String[] args) {
    int[] data1 = new int[] { 1, 3, 5, 7, 9 };
    printArray(data1);
    int[] data2 = Arrays.copyOf(data1, 6);
    data2[5] = 11;
    printArray(data2);
    int[] data3 = Arrays.copyOfRange(data1, 2, 10);
    printArray(data3);
  }

  // print array elements
  private static void printArray(int[] data) {
    StringBuilder stringBuilder = new StringBuilder("[");
    for (int i = 0; i < data.length; i++) {
      stringBuilder.append(data[i]);
      if (i < data.length - 1)
        stringBuilder.append(", ");
    }
    stringBuilder.append("]");
    System.out.println(stringBuilder);
  }
}

使用System.arraycopy方法复制数组

public class ArrayCopyDemo {
  public static void main(String[] args) {
    char[] copyFrom = { 'd', 'e', 'c', 'a', 'f', 'f', 'e', 'i', 'n', 'a', 't',
        'e', 'd' };
    char[] copyTo = new char[7];
    System.arraycopy(copyFrom, 2, copyTo, 0, 7);
    System.out.println(new String(copyTo));
  }
}

数组最大和最小元素

import java.util.Arrays;
import java.util.Collections;
public class Main {
  public static void main(String[] args) {
    Integer[] numbers = { 8, 2, 6, 7, 0, 1, 4, 9, 5, 3 };
    int min = (int) Collections.min(Arrays.asList(numbers));
    int max = (int) Collections.max(Arrays.asList(numbers));
    System.out.println("Min number: " + min);
    System.out.println("Max number: " + max);
  }
}

打乱数组元素

import java.util.Arrays;
import java.util.Collections;
import java.util.List;


public class Main {
  public static void main(String[] args) {
    String[] alphabets = { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J" };
    List<String> list = Arrays.asList(alphabets);
    Collections.shuffle(list);
    for (String alpha : list) {
      System.out.print(alpha + " ");
    }
  }
}

数组合并

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Main {
  public static void main(String args[]) {
    String a[] = { "a", "b", "c" };
    String b[] = { "d", "e" };
    List<String> list = new ArrayList<String>(Arrays.asList(a));
    list.addAll(Arrays.asList(b));
    Object[] c = list.toArray();
    System.out.println(Arrays.toString(c));
  }
}

环形缓冲器

public class TestCircularBuffer {
  public static void main(String args[]) {
    TestCircularBuffer t = new TestCircularBuffer();
  }
  public TestCircularBuffer() {
    CircularBuffer c = new CircularBuffer(8);
    System.out.println("Storing: 1");
    c.store(1);
    System.out.println("Reading: " + c.read());
    System.out.println("Storing: 2");
    c.store(2);
    System.out.println("Storing: 3");
    c.store(3);
    System.out.println("Storing: 4");
    c.store(4);
    System.out.println("Reading: " + c.read());
    System.out.println("Reading: " + c.read());
    System.out.println("Storing: 8");
    c.store(8);
    System.out.println("Storing: 9");
    c.store(9);
    System.out.println("Storing: 10");
    c.store(10);
    System.out.println("Storing: 11");
    c.store(11);
    System.out.println("Storing: 12");
    c.store(12);
    System.out.println("Reading: " + c.read());
    System.out.println("Reading: " + c.read());
    System.out.println("Reading: " + c.read());
    System.out.println("Reading: " + c.read());
    System.out.println("Reading: " + c.read());
    System.out.println("Reading: " + c.read());
    System.out.println("Reading: " + c.read());
    System.out.println("Reading: " + c.read());
  }
}


class CircularBuffer {
  private Integer data[];
  private int head;
  private int tail;
  public CircularBuffer(Integer number) {
    data = new Integer[number];
    head = 0;
    tail = 0;
  }
  public boolean store(Integer value) {
    if (!bufferFull()) {
      data[tail++] = value;
      if (tail == data.length) {
        tail = 0;
      }
      return true;
    } else {
      return false;
    }
  }


  public Integer read() {
    if (head != tail) {
      int value = data[head++];
      if (head == data.length) {
        head = 0;
      }
      return value;
    } else {
      return null;
    }
  }


  private boolean bufferFull() {
    if (tail + 1 == head) {
      return true;
    }
    if (tail == (data.length - 1) && head == 0) {
      return true;
    }
    return false;
  }
}