概述

Java的原生型別就是指基本型別：byte、short、int、long、float、double、char和boolean。

• 基本型別byte: 8位 -128~127

• 基本型別char char 是字元資料型別 ，是無符號型的，佔2位元組(Unicode碼),大小範圍 是0—65535;char是一個16位二進位制的Unicode字元，JAVA用char來表示一個字元 。Java是用unicode來表示字元，”中”這個中文字元的unicode就是2個位元組。通常gbk/gb2312是2個位元組，utf-8是3個位元組。如果不指定encoding則取系統預設的encoding。

• 基本型別：short 二進位制位數：16
  包裝類：java.lang.Short
  最小值：Short.MIN_VALUE=-32768 （-2的15此方）
  最大值：Short.MAX_VALUE=32767 （2的15次方-1）

• 基本型別：int 二進位制位數：32
  包裝類：java.lang.Integer
  最小值：Integer.MIN_VALUE= -2147483648 （-2的31次方）
  最大值：Integer.MAX_VALUE= 2147483647 （2的31次方-1）

• 基本型別：long 二進位制位數：64
  包裝類：java.lang.Long
  最小值：Long.MIN_VALUE=-9223372036854775808 （-2的63次方）
  最大值：Long.MAX_VALUE=9223372036854775807 （2的63次方-1）

• 基本型別：float 二進位制位數：32
  包裝類：java.lang.Float

• 基本型別：double 二進位制位數：64
  包裝類：java.lang.Double

• float的小數點後6位，double的小數點後16位。

• 建議：在從Guava查詢原生型別方法之前，可以先查查Arrays類，或者對應的基礎型別包裝類，如Integer，Float。Integer是一個類，是int的擴充套件，定義了很多的轉換方法類似的還有float，Float;doubleDouble;String等，其中String較為特殊，基本型別和複雜類似關鍵字相同。

Guava原聲型別的支援

• 意義：原生型別不能當作物件或泛型的型別引數使用，這意味著許多通用方法都不能應用於它們。Guava提供了若干通用工具，包括原生型別陣列與集合API的互動，原生型別和位元組陣列的相互轉換，以及對某些原生型別的無符號形式的支援。

支援的所有的：

Bytes工具類沒有定義任何區分有符號和無符號位元組的方法，而是把它們都放到了SignedBytes和UnsignedBytes工具類中，因為位元組型別的符號性比起其它型別要略微含糊一些。

int和long的無符號形式方法在UnsignedInts和UnsignedLongs類中，但由於這兩個型別的大多數用法都是有符號的，Ints和Longs類按照有符號形式處理方法的輸入引數。

此外，Guava為int和long的無符號形式提供了包裝類，即UnsignedInteger和UnsignedLong，以幫助你使用型別系統，以極小的效能消耗對有符號和無符號值進行強制轉換。

在本章下面描述的方法簽名中，我們用Wrapper表示JDK包裝類，prim表示原生型別。（Prims表示相應的Guava工具類。）

Bytes

把陣列轉為相應包裝類的List

1. List asList(prim… backingArray)
2. Arrays.asList類似這個

 //這個是包裝陣列，不然會報錯的 JDK的
 List<Byte> listByte = Arrays.asList(new Byte[]{1,2,3});

 //這個是原生的資料沒得事 Guava的
 List<Byte> listbyte = Bytes.asList(new byte[]{1,2,3});

JDK的實現：使用了ArrayList

   public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }

Guava的實現，自己繼承抽象List，新的List的實現

 public static List<Byte> asList(byte... backingArray) {
    if (backingArray.length == 0) {
      return Collections.emptyList();
    }
    return new ByteArrayAsList(backingArray);
  }

這裡自己實現的ByteArrayAsList和Collections.emptyList一樣的，都是重寫了一個immutalbe-list
EmptyList

 public static final List EMPTY_LIST = new EmptyList<>();
 public static final <T> List<T> emptyList() {
        return (List<T>) EMPTY_LIST;
 }
 // immtable 的emptyList 很多的額許可權都沒得哈哈
 private static class EmptyList<E>
        extends AbstractList<E>
        implements RandomAccess, Serializable {

        public Iterator<E> iterator() {
            return emptyIterator();
        }
        public ListIterator<E> listIterator() {
            return emptyListIterator();
        }

        public int size() {return 0;}
        public boolean isEmpty() {return true;}

        public boolean contains(Object obj) {return false;}
        public boolean containsAll(Collection<?> c) { return c.isEmpty(); }

        public Object[] toArray() { return new Object[0]; }

        public <T> T[] toArray(T[] a) {
            if (a.length > 0)
                a[0] = null;
            return a;
        }

        public E get(int index) {
            throw new IndexOutOfBoundsException("Index: "+index);
        }

        public boolean equals(Object o) {
            return (o instanceof List) && ((List<?>)o).isEmpty();
        }

        public int hashCode() { return 1; }
    }

Guava Bytes中的內部類的處理,儲存的是原生的byte，sublist也是使用同一個list，沒有進行資料的複製，但是不是執行緒安全的類！

private static class ByteArrayAsList extends AbstractList<Byte>
      implements RandomAccess, Serializable {
    final byte[] array;
    final int start;
    final int end;

    ByteArrayAsList(byte[] array) {
      this(array, 0, array.length);
    }

    ByteArrayAsList(byte[] array, int start, int end) {
      this.array = array;
      this.start = start;
      this.end = end;
    }

    @Override
    public int size() {
      return end - start;
    }

    @Override
    public boolean isEmpty() {
      return false;
    }
    //只有Get的使用才是轉換為Byte封裝類
    @Override
    public Byte get(int index) {
      checkElementIndex(index, size());
      return array[start + index];
    }

    @Override
    public boolean contains(Object target) {
      // Overridden to prevent a ton of boxing
      return (target instanceof Byte) 
      && 
      Bytes.indexOf(array, (Byte) target, start, end) != -1;
    }

    @Override
    public int indexOf(Object target) {
      // Overridden to prevent a ton of boxing
      if (target instanceof Byte) {
        int i = Bytes.indexOf(array, (Byte) target, start, end);
        if (i >= 0) {
          return i - start;
        }
      }
      return -1;
    }

    @Override
    public int lastIndexOf(Object target) {
      // Overridden to prevent a ton of boxing
      if (target instanceof Byte) {
        int i = Bytes.lastIndexOf(array, (Byte) target, start, end);
        if (i >= 0) {
          return i - start;
        }
      }
      return -1;
    }
    @Override
    public Byte set(int index, Byte element) {
      checkElementIndex(index, size());
      byte oldValue = array[start + index];
      // checkNotNull for GWT (do not optimize)
      array[start + index] = checkNotNull(element);
      return oldValue;
    }

    @Override
    public List<Byte> subList(int fromIndex, int toIndex) {
      int size = size();
      checkPositionIndexes(fromIndex, toIndex, size);
      if (fromIndex == toIndex) {
        return Collections.emptyList();
      }//使用同一個陣列
      return new ByteArrayAsList(array, start + fromIndex, start + toIndex);
    }
    //使用JDK的
    byte[] toByteArray() {
      return Arrays.copyOfRange(array, start, end);
    }
    private static final long serialVersionUID = 0;
  }

Guava Bytes中方法

• 查詢 int indexOf(prim[] array, prim target)
• 給定值在陣列中首次出現處的索引，若不包含此值返回-1
• 類似 List.indexOf

public static int indexOf(byte[] array, byte target) {
    return indexOf(array, target, 0, array.length);
  }
private static int indexOf(byte[] array, byte target, int start, int end) {
    for (int i = start; i < end; i++) {
      if (array[i] == target) {
        return i;
      }
    }
    return -1;
}
private static int lastIndexOf(byte[] array, byte target, int start, int end) {
    for (int i = end - 1; i >= start; i--) {
      if (array[i] == target) {
        return i;
      }
    }
    return -1;
  }

• 連線,這種操作，都是基於原生的型別進行處理的!
• prim[] concat(prim[]… arrays)
• 串聯多個原生型別陣列
• 類似方法：Iterables.concat

public static byte[] concat(byte[]... arrays) {
    int length = 0;
    for (byte[] array : arrays) {
      length += array.length;
    }
    byte[] result = new byte[length];
    int pos = 0;
    for (byte[] array : arrays) {
      System.arraycopy(array, 0, result, pos, array.length);
      pos += array.length;
    }
    return result;
}

把集合拷貝為陣列，和collection.toArray()一樣執行緒安全

1. prim[] toArray(Collection collection)
2. Collection.toArray() 類似這個方法

JDK中集合toArray

List<Integer> list =Arrays.asList(1,2,3,45);
Integer[] a = (Integer[]) list.toArray();

//這裡是Object物件，轉換為其他的還要報錯。
//只能和當前的陣列型別相關的包裝類
public Object[] toArray() {
  return Arrays.copyOf(elementData, size);
}
//而且這裡只能轉換為包裝類

看看Bytes中的實現，將Collection轉換為基本型別的byte[]

  List<Integer> list =Arrays.asList(1,2,3,256);
    byte[] changByBytes = Bytes.toArray(list);
    for(int i=0;i < changByBytes.length;i++){
        System.out.println("i:"+changByBytes[i]);
  }
i:1
i:2
i:3
i:0

怎麼樣不錯吧，哈哈，速度可以的~
先看看JDK Number介面，各種包裝類都繼承這個玩意

用於在原始型別之間轉換。因此，轉換可能丟失有關數值的整體大小的資訊，失去精度，甚至可能返回一個不同的標誌的結果。

public abstract class Number implements java.io.Serializable {

    public abstract int intValue();

    public abstract long longValue();

    public abstract float floatValue();

    public abstract double doubleValue();

    public byte byteValue() {
        return (byte)intValue();
    }
    public short shortValue() {
        return (short)intValue();
    }
}

這裡還是使用collection.toArray，然後轉換為byte，這個可能會失去精度！優勢在哪裡，返回原生的資料型別。

public static byte[] toArray(Collection< ? extends Number> collection) {
    if (collection instanceof ByteArrayAsList) {
      return ((ByteArrayAsList) collection).toByteArray();
    }

    Object[] boxedArray = collection.toArray();
    int len = boxedArray.length;
    byte[] array = new byte[len];
    for (int i = 0; i < len; i++) {
      // checkNotNull for GWT (do not optimize)
      array[i] = ((Number) checkNotNull(boxedArray[i])).byteValue();
    }
    return array;
  }

陣列中最小大的值

• prim min(prim… array) prim max(prim… array)
• Collections.max 類似這個
• 不過這個是對於原生的陣列
  Ints中的哦！

public static int min(int... array) {
    checkArgument(array.length > 0);
    int min = array[0];
    for (int i = 1; i < array.length; i++) {
      if (array[i] < min) {
        min = array[i];
      }
    }
    return min;
  }

把陣列用給定分隔符連線為字串

• String join(String separator, prim… array)
• Joiner.on(separator).join 類似這個(不過這個要強大一點)
  Ints中的哦！

public static String join(String separator, int... array) {
    checkNotNull(separator);
    if (array.length == 0) {
      return "";
    }

    // For pre-sizing a builder, just get the right order of magnitude
    StringBuilder builder = new StringBuilder(array.length * 5);
    builder.append(array[0]);
    for (int i = 1; i < array.length; i++) {
      builder.append(separator).append(array[i]);
    }
    return builder.toString();
  }

把int轉換為byte陣列

public static byte[] toByteArray(int value) {
    return new byte[] {
      (byte) (value >> 24), (byte) (value >> 16), (byte) (value >> 8), (byte) value
    };
  }

把byte轉換為int

public static int fromByteArray(byte[] bytes) {
    checkArgument(bytes.length >= BYTES, "array too small: %s < %s", bytes.length, BYTES);
    return fromBytes(bytes[0], bytes[1], bytes[2], bytes[3]);
  }
public static int fromBytes(byte b1, byte b2, byte b3, byte b4) {
    return b1 << 24 | (b2 & 0xFF) << 16 | (b3 & 0xFF) << 8 | (b4 & 0xFF);
  }