Thinking in java4 16章 数组

Thinking in java4 16章 数组

1 数组特性
效率，类型，保存基本类型的能力，是一种效率最高的存储和随机访问对象引用序列的方式。

数组和List 获取数据性能分析，数组胜出

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

/**
 * 数组和List 获取数据性能分析，数组胜出
 * @author zhouhanxiu
 */
public class TestArray2List {

    private static final int MAX = 1000000;
    public static void main(String[] args) {
        testArrays();
        testList();
    }   

    public static void testList(){
        List<String> list = new ArrayList<String>();
        for(int i = 0 ; i< 5; i++){
            list.add("1");
        }
        System.out.println(list);
        String target = null;
        long l = System.currentTimeMillis();
        for(int i = 0; i < MAX; i++){
            for(int j = 0 ; j < list.size(); j++){
                target = list.get(j);
            }
        }
        System.out.println("list : " + (System.currentTimeMillis() - l) +" ms");
        System.out.println(target);
    }

    public static void testArrays(){
        String[] array = new String[5];
        Arrays.fill(array, "1");
        System.out.println(Arrays.toString(array));
        String target = null;
        long l = System.currentTimeMillis();
        for(int i = 0; i < MAX; i++){
            for(int j = 0 ; j < array.length; j++){
                target = array[j];
            }
        }
        System.out.println("array : " + (System.currentTimeMillis() - l) +" ms");
        System.out.println(target);
    }
}
/*
 * [1, 1, 1, 1, 1]
 * array : 9 ms
 * 1
 * [1, 1, 1, 1, 1]
 * list : 17 ms
 * 1
 */// :~

2 数组初始值
对象为null，int为0，可以把数组看做一种特殊的对象，里面的元素是它的属性，创建一个对象，对象的属性初始值也是如此

3 打印数组

//: arrays/MultidimensionalPrimitiveArray.java
// Creating multidimensional arrays.
import java.util.*;

public class MultidimensionalPrimitiveArray {
    public static void main(String[] args) {
        Integer[] b = { 2, 3, 4 };
        System.out.println(Arrays.toString(b));
        int[][] a = { { 1, 2, 3, }, { 4, 5, 6, }, };
        System.out.println(Arrays.deepToString(a));
    }
} /*
 * Output: [2, 3, 4]
[[1, 2, 3], [4, 5, 6]]
 */// :~

4 泛型和数组

//: arrays/ArrayOfGenerics.java
// It is possible to create arrays of generics.
import java.util.*;

public class ArrayOfGenerics {
    @SuppressWarnings("unchecked")
    public static void main(String[] args) {
        List<String>[] ls ;
        List[] la = new List[10];
        ls = (List<String>[]) la; // "Unchecked" warning
        ls[0] = new ArrayList<String>();
        // 编译失败
        // ! ls[1] = new ArrayList<Integer>();

        // The problem: List<String> is a subtype of Object
        Object[] objects = ls; // So assignment is OK
        // 数组是协变的
        objects[0] = new ArrayList<String>();
        objects[1] = new ArrayList<Integer>();

        // However, if your needs are straightforward it is
        // possible to create an array of generics, albeit
        // with an "unchecked" warning:
        List<BerylliumSphere>[] spheres = (List<BerylliumSphere>[]) new List[10];
        for (int i = 0; i < spheres.length; i++)
            spheres[i] = new ArrayList<BerylliumSphere>();
    }
} // /:~

5 Arrays.fill填充数组

//: arrays/FillingArrays.java
// Using Arrays.fill()
import java.util.*;
import static net.mindview.util.Print.*;

/**
 * Arrays.fill填充数组
 * @author zhouhanxiu
 * 
 */
public class FillingArrays {
    public static void main(String[] args) {
        int size = 6;
        double[] a8 = new double[size];
        String[] a9 = new String[size];
        Arrays.fill(a8, 47);
        print("a8 = " + Arrays.toString(a8));
        Arrays.fill(a9, "Hello");
        print("a9 = " + Arrays.toString(a9));
        // Manipulating ranges:
        Arrays.fill(a9, 3, 5, "World");
        print("a9 = " + Arrays.toString(a9));
    }
} /*
 * a8 = [47.0, 47.0, 47.0, 47.0, 47.0, 47.0]
 * a9 = [Hello, Hello, Hello, Hello, Hello, Hello]
 * a9 = [Hello, Hello, Hello, World, World, Hello]
 */// :~

6 泛型数组

//: net/mindview/util/Generator.java
// A generic interface.
package net.mindview.util;

public interface Generator<T> {
    T next();
} // /:~

//: net/mindview/util/CollectionData.java
// A Collection filled with data using a generator object.
package net.mindview.util;

import java.util.ArrayList;

public class CollectionData<T> extends ArrayList<T> {
    public CollectionData(Generator<T> gen, int quantity) {
        for (int i = 0; i < quantity; i++)
            add(gen.next());
    }

    // A generic convenience method:
    public static <T> CollectionData<T> list(Generator<T> gen, int quantity) {
        return new CollectionData<T>(gen, quantity);
    }
} // /:~

//: net/mindview/util/Generated.java
package net.mindview.util;


public class Generated {
    // Fill an existing array:
    public static <T> T[] array(T[] a, Generator<T> gen) {
        return new CollectionData<T>(gen, a.length).toArray(a);
    }

    // Create a new array:
    @SuppressWarnings("unchecked")
    public static <T> T[] array(Class<T> type, Generator<T> gen, int size) {
        T[] a = (T[]) java.lang.reflect.Array.newInstance(type, size);
        return new CollectionData<T>(gen, a.length).toArray(a);
    }
} // /:~

7 Arrays 方法
数组打印 Arrays.toString() Arrays.deepToString
数组填充Arrays.fill
数组复制 System.arraycopy
数组比较 Arrays.equals(a1, a2)
数组排序 Arrays.sort(a1) a1元素实现Comparable接口
数组排序逆序 Arrays.sort(a, Collections.reverseOrder());
数组排序之后查找 Arrays.binarySearch

//: arrays/Reverse.java
// The Collections.reverseOrder() Comparator

import static net.mindview.util.Print.print;

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

public class Reverse {
    public static void main(String[] args) {
        String[] a = { "sc", "oe", "xy" };
        String[] b = { "aa", "ab", "bb" ,"ef"};

        System.out.println("Arrays.toString(a) : " + Arrays.toString(a));
        System.out.println("Arrays.toString(b ): " + Arrays.toString(b));
        System.out.println("Arrays.equals(a, b): " + Arrays.equals(a, b));
        System.out.println("Arrays.equals(a, a): " + Arrays.equals(a, a));

        System.arraycopy(a, 0, b, 0, 2);
        System.out.println("System.arraycopy b: " + Arrays.toString(b));

        Arrays.sort(a);
        System.out.println("Arrays.sort(a) : " + Arrays.toString(a));

        String locateTarget = "oe";

        int location1 = Arrays.binarySearch(a, locateTarget);
        System.out.println("ab location at: " + location1);

        Arrays.sort(a, Collections.reverseOrder());
        System.out.println("Collections.reverseOrder(): " + Arrays.toString(a));

        Arrays.sort(a, String.CASE_INSENSITIVE_ORDER);
        print("Case-insensitive sort: " + Arrays.toString(a));
        int location2 = Arrays.binarySearch(a, locateTarget,
                String.CASE_INSENSITIVE_ORDER);
        System.out.println("ab location at: " + location2);

    }
}
/*
 * Arrays.toString(a) : [sc, oe, xy]
 * Arrays.toString(b ): [aa, ab, bb, ef]
 * Arrays.equals(a, b): false
 * Arrays.equals(a, a): true
 * System.arraycopy b: [sc, oe, bb, ef]
 * Arrays.sort(a) : [oe, sc, xy]
 * ab location at: 0
 * Collections.reverseOrder(): [xy, sc, oe]
 * Case-insensitive sort: [oe, sc, xy]
 * ab location at: 0
 */// :~