02-Arrays

《java collections》 学习笔记

Arrays

数组是java语言唯一支持的集合数据结构。
它实现了Serializable和Cloneable接口。

声明和创建数组

数组长度可以为0，但是不能为负数，如果为负数则会抛出

异常.

原生数据 数组

Object数组

多维数组

	float[][] bowling = new float[4][];
	for(int i = 0 ; i < 4 ; i++){
		bowling[i] = new float[i + 1];
	}

数组初始化值

Copying and Cloning Arrays

copy
数组copy是调用System.arraycopy native 方法实现的。
System.arraycopy()

//java.lang.System
/*
 * @param      src      the source array.
  * @param      srcPos   starting position in the source array.
  * @param      dest     the destination array.
  * @param      destPos  starting position in the destination data.
  * @param      length   the number of array elements to be copied.
  */
 public static native void arraycopy(Object src,  int  srcPos,
                                     Object dest, int destPos,
                                     int length);

Arrays.copyXXX

//java.util.Arrays
public static int[] copyOfRange(int[] original, int from, int to) {
    int newLength = to - from;
    if (newLength < 0)
        throw new IllegalArgumentException(from + " > " + to);
    int[] copy = new int[newLength];
    //最终调用System.arraycopy();
    System.arraycopy(original, from, copy, 0,
                     Math.min(original.length - from, newLength));
    return copy;
}

public static byte[] copyOf(byte[] original, int newLength) {
    byte[] copy = new byte[newLength];
     System.arraycopy(original, 0, copy, 0,
                      Math.min(original.length, newLength));
     return copy;
 }

clone

	static int[] cloneArray(int[] src){
		return src.clone();
	}

java深copy和浅copy

不可变数组

final int array[] = {1, 2, 3, 4, 5};
array = new int[3]; //编译不通过
array[0] = -1; //编译通过

Array Assignments

//java.awt.Button extends Componen
Button[] buttons = {new Button("1"), new Button("2"), new Button("3")};
Component[] components = buttons;

判断数组“相等”

==
使用==运算符检查两个对象，如果是true,则他们是同一存储空间的两个引用。
如：上一节代码中：components == buttons // true

Arrays.equals([] a, [] b)
数据a,b 必须满足如下条件：

• 二者长度相同
• 两数组中的对应位置的元素相等(==)orequal

//java.util.Arrays
public static boolean equals(long[] a, long[] a2) {
   if (a==a2)
        return true;
    if (a==null || a2==null)
        return false;

    int length = a.length;
    if (a2.length != length)
        return false;

    for (int i=0; i<length; i++)
        if (a[i] != a2[i])
            return false;

    return true;
}

public static boolean equals(Object[] a, Object[] a2) {
        if (a==a2)
            return true;
        if (a==null || a2==null)
            return false;

        int length = a.length;
        if (a2.length != length)
            return false;

        for (int i=0; i<length; i++) {
            Object o1 = a[i];
            Object o2 = a2[i];
            //Object 则判断 equals
            if (!(o1==null ? o2==null : o1.equals(o2)))
                return false;
        }

        return true;
    }

数组反射

newInstance()I

//java.lang.reflect.Array

//一纬数组
public static Object newInstance(Class<?> componentType, int length)
    throws NegativeArraySizeException {
    return newArray(componentType, length);
}


//多维数组
public static Object newInstance(Class<?> componentType, int... dimensions)
    throws IllegalArgumentException, NegativeArraySizeException {
    return multiNewArray(componentType, dimensions);
}

例:

//一维数组
int dimensions1[] = {5};
int array1[] = (int[]) Array.newInstance(int.class, dimensions1);

//二纬数组
int dimensions2[] = {3, 4};
int array2[][] = (int[][])Array.newInstance(int.class, dimensions2); //array2[3][4]

//二维数组 componentType: float[].class
float bowling[][] = (float[][])Array.newInstance(float[].class, 4); //arrays[4][];

其他API

public static native int getLength(Object array);

//get方法
public static native Object get(Object array, int index);
public static native int getInt(Object array, int index);
public static native boolean getBoolean(Object array, int index);

//set方法
public static native void set(Object array, int index, Object value);
public static native void setInt(Object array, int index, int i);
public static native void setBoolean(Object array, int index, boolean z);

字符数组和字节数组

字符数组(char[])
字符数组在Java不是字符串。 虽然您可以使用String轻松地在String和char[]之间来回切
构造函数（它接受一个char对象的数组）和String.toCharArray()方法，它们肯定是
不同。

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    private final char value[];


    private int hash; // Default to 0

    public String(char value[]) {
        this.value = Arrays.copyOf(value, value.length);
    }

    public char[] toCharArray() {
        // Cannot use Arrays.copyOf because of class initialization order issues
        char result[] = new char[value.length];
        System.arraycopy(value, 0, result, 0, value.length);
        return result;
    }
}

字节数组(byte[])
字节数组是另一种情况,虽然它也不是String，但是它也可以转换为String。
因为Java中的字符串是基于Unicode的16位宽。你需要告诉String构造函数编码格式是什么。

public String(byte bytes[], Charset charset) {
    this(bytes, 0, bytes.length, charset);
 }

下表为主要的编码格式：

例：

byte[] bytes = "嘻嘻".getBytes(StandardCharsets.UTF_8);
System.out.println(new String(bytes,StandardCharsets.UTF_8)); // 嘻嘻
System.out.println(new String(bytes,StandardCharsets.ISO_8859_1)); // 嘻嘻