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
*/// :~