深入学习java源码之Arrays.asList()与Arrays.stream()

Serialization序列化

序列化 (Serialization)将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。以后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象。

三种情况：

1. 将对象存储再硬盘上。

2. 将对象通过网络传输。

3. 通过RMI远程调用等方式传输对象的时候。

在这三种情况下，是需要进行序列化然后传输的。

对象只要实现了Serilizable接口，这个对象就可以被序列化，java的这种序列化模式为开发者提供了很多便利，我们可以不必关系具体序列化的过程，只要这个类实现了Serilizable接口，这个类的所有属性和方法都会自动序列化。

然而在实际开发过程中，我们常常会遇到这样的问题，这个类的有些属性需要序列化，而其他属性不需要被序列化，打个比方，如果一个用户有一些敏感信息（如密码，银行卡号等），为了安全起见，不希望在网络操作（主要涉及到序列化操作，本地序列化缓存也适用）中被传输，这些信息对应的变量就可以加上transient关键字。换句话说，这个字段的生命周期仅存于调用者的内存中而不会写到磁盘里持久化。

总之，java 的transient关键字为我们提供了便利，你只需要实现Serilizable接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;/*** @description 使用transient关键字不序列化某个变量* 注意读取的时候，读取数据的顺序一定要和存放数据的顺序保持一致* * @author Alexia* @date 2013-10-15*/
public class TransientTest {public static void main(String[] args) {User user = new User();user.setUsername("Alexia");user.setPasswd("123456");System.out.println("read before Serializable: ");System.out.println("username: " + user.getUsername());System.err.println("password: " + user.getPasswd());try {ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("C:/user.txt"));os.writeObject(user); // 将User对象写进文件os.flush();os.close();} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}try {ObjectInputStream is = new ObjectInputStream(new FileInputStream("C:/user.txt"));user = (User) is.readObject(); // 从流中读取User的数据is.close();System.out.println("\nread after Serializable: ");System.out.println("username: " + user.getUsername());System.err.println("password: " + user.getPasswd());} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} catch (ClassNotFoundException e) {e.printStackTrace();}}
}class User implements Serializable {private static final long serialVersiOnUID= 8294180014912103005L; private String username;private transient String passwd;public String getUsername() {return username;}public void setUsername(String username) {this.username = username;}public String getPasswd() {return passwd;}public void setPasswd(String passwd) {this.passwd = passwd;}}

输出为：

read before Serializable:
username: Alexia
password: 123456read after Serializable:
username: Alexia
password: null

密码字段为null，说明反序列化时根本没有从文件中获取到信息。

transient使用小结

1）一旦变量被transient修饰，变量将不再是对象持久化的一部分，该变量内容在序列化后无法获得访问。

2）transient关键字只能修饰变量，而不能修饰方法和类。注意，本地变量是不能被transient关键字修饰的。变量如果是用户自定义类变量，则该类需要实现Serializable接口。

3）被transient关键字修饰的变量不再能被序列化，一个静态变量不管是否被transient修饰，均不能被序列化。

第三点可能有些人很迷惑，因为发现在User类中的username字段前加上static关键字后，程序运行结果依然不变，即static类型的username也读出来为“Alexia”了，这不与第三点说的矛盾吗？实际上是这样的：第三点确实没错（一个静态变量不管是否被transient修饰，均不能被序列化），反序列化后类中static型变量username的值为当前JVM中对应static变量的值，这个值是JVM中的不是反序列化得出的

我们知道在Java中，对象的序列化可以通过实现两种接口来实现，若实现的是Serializable接口，则所有的序列化将会自动进行，若实现的是Externalizable接口，则没有任何东西可以自动序列化，需要在writeExternal方法中进行手工指定所要序列化的变量，这与是否被transient修饰无关。因此第二个例子输出的是变量content初始化的内容，而不是null。

public class ExternalizableTest implements Externalizable {private transient String cOntent= "是的，我将会被序列化，不管我是否被transient关键字修饰";@Overridepublic void writeExternal(ObjectOutput out) throws IOException {out.writeObject(content);}@Overridepublic void readExternal(ObjectInput in) throws IOException,ClassNotFoundException {cOntent= (String) in.readObject();}public static void main(String[] args) throws Exception {ExternalizableTest et = new ExternalizableTest();ObjectOutput out = new ObjectOutputStream(new FileOutputStream(new File("test")));out.writeObject(et);ObjectInput in = new ObjectInputStream(new FileInputStream(new File("test")));et = (ExternalizableTest) in.readObject();System.out.println(et.content);out.close();in.close();}
}

java源码

package java.util;import java.lang.reflect.Array;
import java.util.concurrent.ForkJoinPool;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.function.DoubleBinaryOperator;
import java.util.function.IntBinaryOperator;
import java.util.function.IntFunction;
import java.util.function.IntToDoubleFunction;
import java.util.function.IntToLongFunction;
import java.util.function.IntUnaryOperator;
import java.util.function.LongBinaryOperator;
import java.util.function.UnaryOperator;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
import java.util.stream.LongStream;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;public class Arrays {private static final int MIN_ARRAY_SORT_GRAN = 1 <<13;// Suppresses default constructor, ensuring non-instantiability.private Arrays() {}static final class NaturalOrder implements Comparator {@SuppressWarnings("unchecked")public int compare(Object first, Object second) {return ((Comparable)first).compareTo(second);}static final NaturalOrder INSTANCE = new NaturalOrder();}private static void rangeCheck(int arrayLength, int fromIndex, int toIndex) {if (fromIndex > toIndex) {throw new IllegalArgumentException("fromIndex(" + fromIndex + ") > toIndex(" + toIndex + ")");}if (fromIndex <0) {throw new ArrayIndexOutOfBoundsException(fromIndex);}if (toIndex > arrayLength) {throw new ArrayIndexOutOfBoundsException(toIndex);}}@SafeVarargs@SuppressWarnings("varargs")public static List asList(T... a) {return new ArrayList<>(a);}/*** @serial include*/private static class ArrayList extends AbstractListimplements RandomAccess, java.io.Serializable{private static final long serialVersiOnUID= -2764017481108945198L;private final E[] a;ArrayList(E[] array) {a = Objects.requireNonNull(array);}@Overridepublic int size() {return a.length;}@Overridepublic Object[] toArray() {return a.clone();}@Override@SuppressWarnings("unchecked")public T[] toArray(T[] a) {int size = size();if (a.length ) a.getClass());System.arraycopy(this.a, 0, a, 0, size);if (a.length > size)a[size] = null;return a;}@Overridepublic E get(int index) {return a[index];}@Overridepublic E set(int index, E element) {E oldValue = a[index];a[index] = element;return oldValue;}@Overridepublic int indexOf(Object o) {E[] a = this.a;if (o == null) {for (int i = 0; i spliterator() {return Spliterators.spliterator(a, Spliterator.ORDERED);}@Overridepublic void forEach(Consumer action) {Objects.requireNonNull(action);for (E e : a) {action.accept(e);}}@Overridepublic void replaceAll(UnaryOperator operator) {Objects.requireNonNull(operator);E[] a = this.a;for (int i = 0; i c) {Arrays.sort(a, c);}}public static int hashCode(long a[]) {if (a == null)return 0;int result = 1;for (long element : a) {int elementHash = (int)(element ^ (element >>> 32));result = 31 * result + elementHash;}return result;}public static int hashCode(int a[]) {if (a == null)return 0;int result = 1;for (int element : a)result = 31 * result + element;return result;} public static int hashCode(short a[]) {if (a == null)return 0;int result = 1;for (short element : a)result = 31 * result + element;return result;} public static int hashCode(char a[]) {if (a == null)return 0;int result = 1;for (char element : a)result = 31 * result + element;return result;}public static int hashCode(byte a[]) {if (a == null)return 0;int result = 1;for (byte element : a)result = 31 * result + element;return result;} public static int hashCode(boolean a[]) {if (a == null)return 0;int result = 1;for (boolean element : a)result = 31 * result + (element ? 1231 : 1237);return result;} public static int hashCode(float a[]) {if (a == null)return 0;int result = 1;for (float element : a)result = 31 * result + Float.floatToIntBits(element);return result;}public static int hashCode(double a[]) {if (a == null)return 0;int result = 1;for (double element : a) {long bits = Double.doubleToLongBits(element);result = 31 * result + (int)(bits ^ (bits >>> 32));}return result;}public static int hashCode(Object a[]) {if (a == null)return 0;int result = 1;for (Object element : a)result = 31 * result + (element == null ? 0 : element.hashCode());return result;}public static int deepHashCode(Object a[]) {if (a == null)return 0;int result = 1;for (Object element : a) {int elementHash = 0;if (element instanceof Object[])elementHash = deepHashCode((Object[]) element);else if (element instanceof byte[])elementHash = hashCode((byte[]) element);else if (element instanceof short[])elementHash = hashCode((short[]) element);else if (element instanceof int[])elementHash = hashCode((int[]) element);else if (element instanceof long[])elementHash = hashCode((long[]) element);else if (element instanceof char[])elementHash = hashCode((char[]) element);else if (element instanceof float[])elementHash = hashCode((float[]) element);else if (element instanceof double[])elementHash = hashCode((double[]) element);else if (element instanceof boolean[])elementHash = hashCode((boolean[]) element);else if (element != null)elementHash = element.hashCode();result = 31 * result + elementHash;}return result;}public static boolean deepEquals(Object[] a1, Object[] a2) {if (a1 == a2)return true;if (a1 == null || a2==null)return false;int length = a1.length;if (a2.length != length)return false;for (int i = 0; i eClass = element.getClass();if (eClass.isArray()) {if (eClass == byte[].class)buf.append(toString((byte[]) element));else if (eClass == short[].class)buf.append(toString((short[]) element));else if (eClass == int[].class)buf.append(toString((int[]) element));else if (eClass == long[].class)buf.append(toString((long[]) element));else if (eClass == char[].class)buf.append(toString((char[]) element));else if (eClass == float[].class)buf.append(toString((float[]) element));else if (eClass == double[].class)buf.append(toString((double[]) element));else if (eClass == boolean[].class)buf.append(toString((boolean[]) element));else { // element is an array of object referencesif (dejaVu.contains(element))buf.append("[...]");elsedeepToString((Object[])element, buf, dejaVu);}} else { // element is non-null and not an arraybuf.append(element.toString());}}if (i == iMax)break;buf.append(", ");}buf.append(&＃39;]&＃39;);dejaVu.remove(a);}public static void setAll(T[] array, IntFunction generator) {Objects.requireNonNull(generator);for (int i = 0; i void parallelSetAll(T[] array, IntFunction generator) {Objects.requireNonNull(generator);IntStream.range(0, array.length).parallel().forEach(i -> { array[i] = generator.apply(i); });}public static void setAll(int[] array, IntUnaryOperator generator) {Objects.requireNonNull(generator);for (int i = 0; i { array[i] = generator.applyAsInt(i); });}public static void setAll(long[] array, IntToLongFunction generator) {Objects.requireNonNull(generator);for (int i = 0; i { array[i] = generator.applyAsLong(i); });}public static void setAll(double[] array, IntToDoubleFunction generator) {Objects.requireNonNull(generator);for (int i = 0; i { array[i] = generator.applyAsDouble(i); });}public static Spliterator spliterator(T[] array) {return Spliterators.spliterator(array,Spliterator.ORDERED | Spliterator.IMMUTABLE);}public static Spliterator spliterator(T[] array, int startInclusive, int endExclusive) {return Spliterators.spliterator(array, startInclusive, endExclusive,Spliterator.ORDERED | Spliterator.IMMUTABLE);}public static Spliterator.OfInt spliterator(int[] array) {return Spliterators.spliterator(array,Spliterator.ORDERED | Spliterator.IMMUTABLE);}public static Spliterator.OfInt spliterator(int[] array, int startInclusive, int endExclusive) {return Spliterators.spliterator(array, startInclusive, endExclusive,Spliterator.ORDERED | Spliterator.IMMUTABLE);}public static Spliterator.OfLong spliterator(long[] array) {return Spliterators.spliterator(array,Spliterator.ORDERED | Spliterator.IMMUTABLE);}public static Spliterator.OfLong spliterator(long[] array, int startInclusive, int endExclusive) {return Spliterators.spliterator(array, startInclusive, endExclusive,Spliterator.ORDERED | Spliterator.IMMUTABLE);}public static Spliterator.OfDouble spliterator(double[] array) {return Spliterators.spliterator(array,Spliterator.ORDERED | Spliterator.IMMUTABLE);}public static Spliterator.OfDouble spliterator(double[] array, int startInclusive, int endExclusive) {return Spliterators.spliterator(array, startInclusive, endExclusive,Spliterator.ORDERED | Spliterator.IMMUTABLE);}public static Stream stream(T[] array) {return stream(array, 0, array.length);}public static Stream stream(T[] array, int startInclusive, int endExclusive) {return StreamSupport.stream(spliterator(array, startInclusive, endExclusive), false);}public static IntStream stream(int[] array) {return stream(array, 0, array.length);}public static IntStream stream(int[] array, int startInclusive, int endExclusive) {return StreamSupport.intStream(spliterator(array, startInclusive, endExclusive), false);}public static LongStream stream(long[] array) {return stream(array, 0, array.length);}public static LongStream stream(long[] array, int startInclusive, int endExclusive) {return StreamSupport.longStream(spliterator(array, startInclusive, endExclusive), false);}public static DoubleStream stream(double[] array) {return stream(array, 0, array.length);}public static DoubleStream stream(double[] array, int startInclusive, int endExclusive) {return StreamSupport.doubleStream(spliterator(array, startInclusive, endExclusive), false);}
}

package java.util;public interface RandomAccess {
}