Java源码 —— Integer

红太狼 2022-06-01 13:29 207阅读 0赞

# Java源码 —— Integer #

> Integer 类在对象中封装了一个基本类型 int 的值。
> 
> Integer 类型的对象包含一个 int 类型的字段。  
> 
> 
> 此外，该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。  
>

## 一、Integer类图 ##

> ![SouthEast][]  
> 
> 
>   
>

## 二、单类拆解 ##

> ### 2.1 Number ###
> 
> 抽象类 Number 是 BigDecimal、BigInteger、Byte、Double、Float、Integer、Long 和 Short 类的超类，此外JDK1.8还扩
> 
> 展出了一些累加器（扩展抽象类Striped64，并基于此类实现累加器）。
> 
> Number定义了一系列将表示的数值转换基本数值类型的方法，具体类型如下：
> 
> **整数类型：**
> 
>  byte（8位，用于表示最小数据单位；数值范围在-128~127）、int（32位，最常用）、long（64位，常用，后缀L/l，为了区分字母l与数字1通常用大写L，后缀一般比较少用）、short（16位，很少用）
> 
> **浮点类型：**
> 
>  double（64位，后最D/d）、float（32位，后缀F/f）
> 
> ![SouthEast 1][]  
> 
> 
> Number实现了两个数值转换的方法，分别是byteValue()、shortValue()，在方法体重调用intValue()强制转换，代码如下：
> 
>     public byte byteValue() {
>             return (byte)intValue();
>         }
>         public short shortValue() {
>             return (short)intValue();
>         }
> 
> ### 2.2 Serializable ###
> 
> 接口Serializable是一个标识接口，用于标识一个类是否启用序列号功能。未实现此接口的类将无法使其任何状态序列化或反序列化。
> 
>   
> 
> 
> ### 2.3 Comparable ###
> 
> 接口Comparable定义了一个public int compareTo(T o)方法，可用于比较或排序。
> 
> 实现Comparable接口的对象列表或数组，可以通过Collections.sort或Arrays.sort进行自动排序。
> 
> 实现Comparable接口的对象可以用作有序映射（SortMap）中的键或有序集合（SortedSet）中的元素。
> 
>   
> 
> 
> **排序代码**
> 
>     // 来自Collections类的方法
>         public static <T extends Comparable<? super T>> void sort(List<T> list) {
>             list.sort(null);
>         }
>         public static <T> void sort(List<T> list, Comparator<? super T> c) {
>             list.sort(c);
>         }
>         // 来自List接口的方法
>         default void sort(Comparator<? super E> c) {
>             Object[] a = this.toArray();// 将当前list对象转成数组
>             Arrays.sort(a, (Comparator) c);// 对数组进行排序
>             ListIterator<E> i = this.listIterator();// 获得当前list对象对应的List迭代器
>             for (Object e : a) {// 对做好排序的数组进行迭代
>                 i.next();// 将迭代器的指标指向下一个元素的指针位置
>                 i.set((E) e);// 替换list当前指针对应元素
>             }
>         }
> 
> 从上面代码可以看到，Collections中不管是哪个sort方法最后都是调用List对象本身的sort方法做排序。
> 
> 在List.sort中将list对象转成数组，并调用Arrays.sort排序，排序之后再将排序顺序的对象按照下标一一替换List中的元素。  
>   
> 
> 
> ### 2.4 IntegerCache ###
> 
> IntegerCache是Integer类内部封装的一个缓存池，用于缓存自动装箱时的对象。默认缓存值范围在-128到127之间的Integer对象。
> 
> 缓存池的大小可以通过-XX:AutoBoxCacheMax=<size>参数来控制缓存的最大值，最小值-128不可配置，即缓存池的区间范围为\[-128, <size>\]。除此之外还可以通过设置虚拟机的java.lang.Integer.IntegerCache.high属性来控制缓存池的上限。不管以哪种方式设置上限值，最终都将以java.lang.Integer.IntegerCache.high property的方式呈现，最终上限值大于等于127。IntegerCache源码如下：
> 
>     private static class IntegerCache {
>             static final int low = -128;// 缓存池值下限
>             static final int high;// 缓存池值上限
>             static final Integer cache[];// 缓存Integer对象的数组
>     
>             static {
>                 // high value may be configured by property
>                 int h = 127;// 缓存池上限默认127
>                 String integerCacheHighPropValue =
>                     sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");// 获取设置的上限值（不管通过哪种方式设置上限，最终都会以property的方式呈现）
>                 if (integerCacheHighPropValue != null) {// 获取缓存池上限值
>                     try {
>                         int i = parseInt(integerCacheHighPropValue);
>                         i = Math.max(i, 127);// 缓存上限值最低不小于127
>                         // Maximum array size is Integer.MAX_VALUE
>                         h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
>                     } catch( NumberFormatException nfe) {
>                         // If the property cannot be parsed into an int, ignore it.
>                     }
>                 }
>                 high = h;
>     
>                 cache = new Integer[(high - low) + 1];
>                 int j = low;
>                 for(int k = 0; k < cache.length; k++)
>                     cache[k] = new Integer(j++);
>     
>                 // range [-128, 127] must be interned (JLS7 5.1.7)
>                 assert IntegerCache.high >= 127;
>             }
>     
>             private IntegerCache() {}
>         }

## 三、常用方法 ##

> 3.1 byteValue()
> 
> 3.2 shortValue()
> 
> 3.3 intValue()
> 
> 3.4 longValue()
> 
> 3.5 floatValue()
> 
> 3.6 doubleValue()
> 
> 3.7 int parseInt(String s)，将字符串转换成int（十进制数）
> 
>     public static int parseInt(String s) throws NumberFormatException {
>             return parseInt(s,10);
>         }
> 
> 3.8 int max(int a, int b)，两个数取最大值，jdk1.8，内部调用Math类方法
> 
>     public static int max(int a, int b) {
>             return Math.max(a, b);
>         }
> 
> 3.9 int min(int a, int b)，两个数取最小值，jdk1.8，内部调用Math类方法
> 
>     public static int min(int a, int b) {
>             return Math.max(a, b);
>         }
> 
> 3.10 int sum(int a, int b)，两数求和，jdk1.8
> 
>     public static int sum(int a, int b) {
>             return a + b;
>         }
> 
> 3.11 Integer valueOf(String s)，将字符串转换成int（十进制）
> 
>     public static Integer valueOf(String s) throws NumberFormatException {
>             return Integer.valueOf(parseInt(s, 10));
>         }
> 
> 3.12 Integer valueOf(int i)，返回一个表示指定int值的Integer对象，如果指定值在缓存区间则从IntegerCache中取，否则new Integer(i)返回一个新的对象
> 
>     public static Integer valueOf(int i) {
>             if (i >= IntegerCache.low && i <= IntegerCache.high)
>                 return IntegerCache.cache[i + (-IntegerCache.low)];
>             return new Integer(i);
>         }
> 
>   
>   
> 
> 
>   
>

[SouthEast]: /images/20220601/d2478c5b160e460096d7514fb4561d19.png
[SouthEast 1]: /images/20220601/41933b9f6b9e4f199161bfd85e07abab.png