java包装基础类源码分析

最新推荐文章于 2022-12-06 13:20:35 发布

qq_40949759

最新推荐文章于 2022-12-06 13:20:35 发布

阅读量242

点赞数

分类专栏： java基础类源码文章标签： java 字符串后端

本文链接：https://blog.csdn.net/qq_40949759/article/details/106898407

版权

java基础类源码专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一、Integer

public final class Integer extends Number implements Comparable<Integer>
final修饰类
继承Number
实现comparable接口

1. 内部类

1.1 IntegerCache

唯一一个内部类
作用：
1. 默认缓存的范围是 [-128,127]，当Integer值在这个范围时如果缓存有则直接取出，不用重新实例化
2. 缓存值都是静态且 final 的，避免重复的实例化和回收
3. 可以改变这些值缓存的范围high(上限)，
  1. 在启动JVM时通过：-Djava.lang.Integer.IntegerCache.high=xxx 就可以改变缓存值的最大值

   private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        static {
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    500，2^31-128-1
                    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() {}
    }

源码分析：

上限设置：
- 当运行时未设置上限high，则通过局部变量127赋值，如果设置了，则parseInt(String)将字符串类型的high转变为int类型，并且通过Math.max(high，127)，设置最低为127.,接着通过Math.min设置输入的值最高不能超过2^31-128-1
Integer缓存数组大小
- new Integer[high-(-128)+1]
  - 为什么设置大小为high+129?
    - 因为数组的个数为[-128,high],相当于128+high+1(这个1就是0这个数)
填充Integer数组
- 用for循环遍历数组进行填充
  - 说明只要调用这个匿名内部类，缓存中就已经有这数组[-128,high]
全局只有valueOf(int i)调用它进行判断
构造器私有化，不能new对象，都是通过静态代码块进行初始化

2.构造方法

private final int value;

2.1 Integer(int)

public Integer(int value) {
    this.value = value;
}

2.2 Integer(String)

调用parseInt(s,10)

public Integer(String s) throws NumberFormatException {
        this.value = parseInt(s, 10);
    }

3.常用方法

装箱：基本类型可以先加宽，再转变为宽类型的其他类型，而不能至今转变成宽类型的包装类

意思：int可以加宽变成long，然后在包装变成Long的包装类，所以，优先使用基本数据类型

3.1 valueOf

static修饰，且返回都是Integer类型

3.1.1> valueOf(int)

唯一一个通过大小与IntegerCache类的缓存数组接触，有就返回没有就通过构造方法获取一个Integer对象

public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

3.1.2> valueOf(String)

调用valueOf（int）方法，仍然走缓存
- 调用parseInt将string转化为10进制数字

public static Integer valueOf(String s) throws NumberFormatException {
        return Integer.valueOf(parseInt(s, 10));
    }

3.1.3> valueOf(String,int)

调用valueOf(int)，仍然走缓存
- 比valueof(String)高级点，可以指定输入字符串的进制

public static Integer valueOf(String s, int radix) throws NumberFormatException {
        return Integer.valueOf(parseInt(s,radix));
    }

3.2 parseInt

static修饰，且返回是int类型

想要获得int

String 为十进制. 采用parseInt(String )合适. 非十进制,采用parseInt(String ,int)

3.2.1> parseInt(String ,int)

‘0’-‘1’----->48-56

注意：在初始化VM初始化IntegerCache期间，可能会提前调用此方法。必须注意不要使用valueOf方法。

执行流程：

当字符串为null，[-∞,2)U(36,+∞]，字符串长度小于0时抛出异常
当长度大于0时取出第一个字符判断<‘0’–>[(int)c<48]
1. 是（不存在数字，只有符号）
  - 看看是不是+或者-号,如果不是抛出异常，如果只有加号减号也抛出异常
2. 否（只能是数字或者以上）
  - while循环遍历string的长度
  - 如果不是数字字符，则Character.digit返回-1,抛出异常
  - 如果负数累加接近最大值时抛出异常
  - result递减，最终结果取反

用负数去存储正数，最后返回时去反

    public static int parseInt(String s, int radix)
                throws NumberFormatException
    {
         if (s == null) {
            throw new NumberFormatException("null");
        }

        if (radix < Character.MIN_RADIX) {
            throw new NumberFormatException("radix " + radix +
                                            " less than Character.MIN_RADIX");
        }

        if (radix > Character.MAX_RADIX) {
            throw new NumberFormatException("radix " + radix +
                                            " greater than Character.MAX_RADIX");
        }

        int result = 0;
        boolean negative = false; //默认是＋号，如果为true这表示-号
        int i = 0, len = s.length();
        int limit = -Integer.MAX_VALUE;//-2^31
        int multmin;
        int digit;

        if (len > 0) {
            char firstChar = s.charAt(0);
            if (firstChar < '0') { // Possible leading "+" or "-"
                if (firstChar == '-') {
                    negative = true;
                    limit = Integer.MIN_VALUE;//-2^31-1
                } else if (firstChar != '+')
                    throw NumberFormatException.forInputString(s);

                if (len == 1) // Cannot have lone "+" or "-"
                    throw NumberFormatException.forInputString(s);
                i++;
            }
            multmin = limit / radix;//214748364
            while (i < len) {
               
                //如果是非整数则返回-1
                digit = Character.digit(s.charAt(i++),radix);
                if (digit < 0) {
                    throw NumberFormatException.forInputString(s);
                }
                // 负数累加避免接近最大值时出现意外
                if (result < multmin) {
                    throw NumberFormatException.forInputString(s);
                }
                result *= radix;
                if (result < limit + digit) {
                    throw NumberFormatException.forInputString(s);
                }
                result -= digit;
            }
        } else {
            throw NumberFormatException.forInputString(s);
        }
        return negative ? result : -result;
    }

3.2.2> parseInt(String)

调用上面的方法

public static int parseInt(String s) throws NumberFormatException {
        return parseInt(s,10);
    }

3.2.3> parseUnsignedInt

parseUnsignedInt(String s)
parseUnsignedInt(String s, int radix)
1.8添加无符号操作

3.3 toString

String返回类型，除Object继承的以外，其他都是static修饰

3.3.1> toString()

Ojbect的,调用toString(int)

 public String toString() {
        return toString(value);
    }

3.3.2> toString(int)

public static String toString(int i) {
    if (i == Integer.MIN_VALUE) //等于最小值直接返回最小值字符串，避免getChars方法遇到最小值发生错误
        return "-2147483648"; 
    //判断i的位数，若位负数增加1位用来保存符号位
    int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
    char[] buf = new char[size];
    //将i转换位buf符号数组
    getChars(i, size, buf);
    //因为buf数组是在方法内部生成，其他地方不会有其引用，所以直接将其引用给String内部的value保存，用来初始化String
    return new String(buf, true);
}

3.3.3> toString(int,int)

public static String toString(int i, int radix)返回由第二个参数指定的基数中的第一个参数的字符串表示形式。
如果基数小于Character.MIN_RADIX或大于Character.MAX_RADIX ，则使用基数10 。
如果第一个参数为负，结果的第一个元素是ASCII减号’-’ （ ‘\u002D’ ）。
- 如果第一个参数不为负，则结果中不会出现符号字符。
结果的剩余字符表示第一个参数的大小。
- 如果幅度为零，则由单个零字符’0’ （ ‘\u0030’ ）表示;
- 否则，幅度的表示的第一个字符将不是零字符。以下ASCII字符用作数字： 0123456789abcdefghijklmnopqrstuvwxyz

这些是’\u0030’至’\u0039’和’\u0061’至’\u007A’ 。如果radix是N ，则这些字符的前N个按照所示的顺序用作小数位数N。因此，十六进制（小数16）的数字是0123456789abcdef 。如果需要大写字母，可以对结果调用String.toUpperCase()方法：
Integer.toString(n, 16).toUpperCase()

参数
- i - 要转换为字符串的整数。
- radix - 在字符串表示中使用的基数。
结果
指定基数中的参数的字符串表示形式。

另请参见：
Character.MAX_RADIX ， Character.MIN_RADIX
MAX_RADIX = 2 ；
MIN_RADIX = 36；

public static String toString(int i, int radix) {
        if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
            radix = 10;

        /* Use the faster version */
        if (radix == 10) {
            return toString(i);
        }

        char buf[] = new char[33];
        boolean negative = (i < 0);
        int charPos = 32;

        if (!negative) {
            i = -i;
        }

        while (i <= -radix) {
            buf[charPos--] = digits[-(i % radix)];
            i = i / radix;
        }
        buf[charPos] = digits[-i];

        if (negative) {
            buf[--charPos] = '-';
        }

        return new String(buf, charPos, (33 - charPos));
    }

3.4 1.8添加

都是static修饰，且返回int类型

3.4.1 sum(int a, int b)

 public static int sum(int a, int b) {
        return a + b;
    }

3.4.2 max(int a, int b)

public static int max(int a, int b) {
        return Math.max(a, b);
    }

3.4.3 min(int a, int b)

public static int min(int a, int b) {
        return Math.min(a, b);
    }

或者有些方法是在之前的基础上添加了无符号操作

3.5 getInteger

方法static修饰，返回类型是Integer
getInteger方法确定具有指定名称的系统属性的整数值。

3.5.1getInteger(String,Integer)

第一个参数被视为系统属性的名称，通过 System.getProperty(java.lang.String) 方法可以访问系统属性，然后根据每个Integer.decode方法，将该属性的字符串值解释为一个整数值，并返回一个表示该值的Integer对象
如果属性值以两个ASCII字符0x或者ASCII字符#开始，并且后面没有减号，则将它的剩余部分解析为十六进制整数，就好像以16为基数调用valueOf(java.lang.String,int)方法一样。
如果属性值以ASCII字符0开始，后面还有其他字符，则将它解析为八进制整数，就好像以8为基数调用valueOf(java.lang.String, int)方法一样；
- 否则，将属性值解析为十进制整数，就好像以10为基数调用valueOf(java.lang.String, int)方法一样。
第二个参数是默认值。如果没有具有指定名称的属性，或者属性的数字格式不正确，或者指定名称为空或null，则返回默认值。

public static Integer getInteger(String nm, Integer val) {
        String v = null;
        try {
            v = System.getProperty(nm);
        } catch (IllegalArgumentException | NullPointerException e) {
        }
        if (v != null) {
            try {
                return Integer.decode(v);
            } catch (NumberFormatException e) {
            }
        }
        return val;
    }

3.5.2 getInteger(String,int )

第一个参数被视为系统属性的名称，通过System.getProperty(java.lang.String)方法可以访问系统属性，然后将该属性的字符串值解释为一个整数值，并返回表示该值的Integer对象。使用getProperty的定义可以找到可能出现的数字格式的详细信息。
第二个参数是默认值。如果没有具有指定名称的属性，或者属性的数字格式不正确，或者指定名称为空或null，则返回一个表示第二个参数的值的Integer对象。

在getInteger(String)的基础上进行判断，如果为null则返回valueOf的默认值。

 public static Integer getInteger(String nm, int val) {
        Integer result = getInteger(nm, null);
        return (result == null) ? Integer.valueOf(val) : result;
    }

3.5.2 getInteger(String )

调用GetInteger(String,Integer)

 public static Integer getInteger(String nm) {
        return getInteger(nm, null);
    }

3.6 decode

static修饰，返回Integer类型

decode(String)

用来分析数字
valueof 只能分析纯数字的String而它可以分析0x、0X、#、0开头的

想要获得Integer:

String 为十进制. 采用valueof(String)合适. 非十进制,采用decode(String)

3.7 XXXValue

abstract class Number implements java.io.Serializable来的
都是强转

3.7.1 int intValue();

public int intValue() {
        return value;
    }

3.7.2 long longValue();

public long longValue() {
        return (long)value;
    }

3.7.3 float floatValue();

 public float floatValue() {
        return (float)value;
    }

3.7.4 double doubleValue();

public double doubleValue() {
        return (double)value;
    }

3.7.5 *byteValue()

在抽象类中的非抽象方法，已经实现了，Integer也是这样写的

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

3.7.6 *shortValue()

在抽象类中的非抽象方法，已经实现了，Integer也是这样写的

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

3.8 比较有关

implements Comparable<Integer>

3.8.1 jdk1.2compareTo

因为实现comparable接口，必须实现compareTo

public int compareTo(Integer anotherInteger) {
        return compare(this.value, anotherInteger.value);
    }

3.8.2 jdk1.7compare

最终实现的方式

public static int compare(int x, int y) {
        return (x < y) ? -1 : ((x == y) ? 0 : 1);
    }

3.8.3 compareUnsigned

无符号类型，最终使用jdk1.7的方式实现

public static int compareUnsigned(int x, int y) {
        return compare(x + MIN_VALUE, y + MIN_VALUE);
    }

二、Byte

public final class Byte extends Number implements Comparable<Byte>
final修饰类
继承Number
实现comparable接口

1. 内部类

1.1 ByteCache

将[-128,127]放入缓存中

 private static class ByteCache {
        private ByteCache(){}

        static final Byte cache[] = new Byte[-(-128) + 127 + 1];

        static {
            for(int i = 0; i < cache.length; i++)
                cache[i] = new Byte((byte)(i - 128));
        }
    }

2. 构造方法

private final byte value;

2.1 Byte(byte )

 public Byte(byte value) {
        this.value = value;
    }

2.2 Byte(String )

public Byte(String s) throws NumberFormatException {
        this.value = parseByte(s, 10);
    }

3. 常用方法

3.1 valueOf

static修饰，且返回都是Byte类型

3.1.1 valueOf(byte)

走缓存，直接缓存中返回

public static Byte valueOf(byte b) {
        final int offset = 128;
        return ByteCache.cache[(int)b + offset];
    }

3.1.2 valueOf(String)

默认是10进制转换

public static Byte valueOf(String s) throws NumberFormatException {
        return valueOf(s, 10);
    }

3.1.3 valueOf(String,int)

通过radix转换进制，然后走缓存找出返回

 public static Byte valueOf(String s, int radix)
        throws NumberFormatException {
        return valueOf(parseByte(s, radix));
    }

3.2 parseByte

static修饰，且返回是byte类型
想要获得byte

String 为十进制. 采用parseByte(String )合适. 非十进制,采用parseByte(String ,int)

3.2.1 parseByte(String)

 public static byte parseByte(String s) throws NumberFormatException {
        return parseByte(s, 10);
    }

3.2.2 parseByte(String,int)

public static byte parseByte(String s, int radix)
        throws NumberFormatException {
        int i = Integer.parseInt(s, radix);
        if (i < MIN_VALUE || i > MAX_VALUE)
            throw new NumberFormatException(
                "Value out of range. Value:\"" + s + "\" Radix:" + radix);
        return (byte)i;
    }

3.3 *toString

String返回类型，除Object继承的以外，其他都是static修饰

3.3.1 toString()

转入integer调用String

public String toString() {
    return Integer.toString((int)value);
}

3.3.2 toString(byte)

public static String toString(byte b) {
    return Integer.toString((int)b, 10);
}

3.4 *decode

static修饰，返回Byte类型

decode(String)

分析数字，走integer的decode，并通过valueof走缓存输出

public static Byte decode(String nm) throws NumberFormatException {
        int i = Integer.decode(nm);
        if (i < MIN_VALUE || i > MAX_VALUE)
            throw new NumberFormatException(
                    "Value " + i + " out of range from input " + nm);
        return valueOf((byte)i);
    }

3.5 XXXValue

同上Integer，都是强转

3.6 比较有关

3.6.1 JDK1.2

 public int compareTo(Byte anotherByte) {
        return compare(this.value, anotherByte.value);
    }

3.6.2 JDK1.7

 public static int compare(byte x, byte y) {
        return x - y;
    }

三、Short

public final class Short extends Number implements Comparable<Short>
final修饰类
继承Number
实现comparable接口

1. 内部类

1.1 ShortCache

将[-128,127]放入缓存中

private static class ShortCache {
        private ShortCache(){}

        static final Short cache[] = new Short[-(-128) + 127 + 1];

        static {
            for(int i = 0; i < cache.length; i++)
                cache[i] = new Short((short)(i - 128));
        }
    }

2. 构造方法

private final short value;

2.1 Short(short)

 public Short(short value) {
        this.value = value;
    }

2.2 Short(String)

 public Short(String s) throws NumberFormatException {
        this.value = parseShort(s, 10);
    }

3. 常用方法

基本都是跟byte相似，该调用Integer的调用，最后强转

四、long

设计模式同Integer

五、Character

public finalclass Character implements java.io.Serializable, Comparable<Character>
final修饰
可序列化
可排序

1. 内部类

1.1 CharacterCache

0-127强制转换为char，然后放入缓存中

  private static class CharacterCache {
        private CharacterCache(){}

        static final Character cache[] = new Character[127 + 1];

        static {
            for (int i = 0; i < cache.length; i++)
                cache[i] = new Character((char)i);
        }
    }

1.2 Subset

public static class Subset

JDK1.2
此类的实例表示Unicode字符集的特定子集。

在{@code Character}类中定义的唯一子集系列是{@link字符.UnicodeBlock}.

Java API的其他部分可以为自己的目的定义其他子集。

1.3 UnicodeBlock

public static final class UnicodeBlock extends Subset

1.4 UnicodeScript

public static enum UnicodeScript

2. 构造方法

2.1 Character

 public Character(char value) {
        this.value = value;
    }

3. 常用方法

3.1 valueOf(char)

public static Character valueOf(char c) {
        if (c <= 127) { // must cache
            return CharacterCache.cache[(int)c];
        }
        return new Character(c);
    }

3.2 equals(Object)

   public boolean equals(Object obj) {
        if (obj instanceof Character) {
            return value == ((Character)obj).charValue();
        }
        return false;
    }

3.3 hashcode

3.3.1 hashCode()

public int hashCode() {
    return Character.hashCode(value);
}

3.3.2 hashCode(char)

public static int hashCode(char value) {
    return (int)value;
}

3.4 toString

3.4.1 toString()

 public String toString() {
        char buf[] = {value};
        return String.valueOf(buf);
    }

3.4.2 toString(char)

 public static String toString(char c) {
        return String.valueOf(c);
    }

3.5 比较

3.5.1 JDK1.2compareTo

public int compareTo(Character anotherCharacter) {
    return compare(this.value, anotherCharacter.value);
}

3.5.2 JDK1.7compare

public static int compare(char x, char y) {
    return x - y;
}

3.6 判断

3.6.1 isDigit(char)

如果字符是数字则返回true

3.6.2 isLetter(ch)

判断是否是字母

3.6.3 isLetterOrDigit(ch)

判断是否是字母或者数字

3.6.4 isLowerCase(ch)

判断是否是小写字母

3.6.5 isUpperCase(ch)

判断是否是大写字母

3.6.6 toLowerCase(ch)

返回字符的小写形式

3.6.7 toUpperCase(ch)

返回字符的大写形式

六、Float

1. 构造方法

1.1 Float(float)

    public Float(float value) {
        this.value = value;
    }

1.2 Float(double)

public Float(double value) {
    this.value = (float)value;
}

1.3 Float(String)

public Float(String s) throws NumberFormatException {
    value = parseFloat(s);
}

2. 常用方法

2.1 1.8添加的比较

2.1.1 sum(float,float)

public static float sum(float a, float b) {
        return a + b;
    }

2.1.2 max(float,float)

public static float max(float a, float b) {
    return Math.max(a, b);
}

2.1.3 min(float,float)

public static float min(float a, float b) {
        return Math.min(a, b);
    }

2.2 比较

2.2.1 JDK1.2compareTo

public int compareTo(Float anotherFloat) {
    return Float.compare(value, anotherFloat.value);
}

2.2.1 JDK1.4compare

public static int compare(float f1, float f2) {
    if (f1 < f2)
        return -1;           // Neither val is NaN, thisVal is smaller
    if (f1 > f2)
        return 1;            // Neither val is NaN, thisVal is larger

    // Cannot use floatToRawIntBits because of possibility of NaNs.
    int thisBits    = Float.floatToIntBits(f1);
    int anotherBits = Float.floatToIntBits(f2);

    return (thisBits == anotherBits ?  0 : // Values are equal
            (thisBits < anotherBits ? -1 : // (-0.0, 0.0) or (!NaN, NaN)
             1));                          // (0.0, -0.0) or (NaN, !NaN)
}

2.3 valueOf

2.3.1 valueOf(float)

 public static Float valueOf(float f) {
        return new Float(f);
    }

2.3.2 valueOf(String)

public static Float valueOf(String s) throws NumberFormatException {
        return new Float(parseFloat(s));
    }

2.4 toString

2.4.1 toString()

public String toString() {
        return toString(value);
    }

2.4.2 toString(float)

public static String toString(float f) {
        return FloatingDecimal.toJavaFormatString(f);
    }

2.5 hashCode

2.5.1 hashCode()

 public int hashCode() {
        return Float.hashCode(value);
    }

2.5.2 hashCode(float)

public static int hashCode(float value) {
        return floatToIntBits(value);
    }

七、Double

public final class Double extends Number implements Comparable<Double>
final修饰
number继承
comparable实现

1. 构造方法

1.1 Double(double)

 public Double(double value) {
        this.value = value;
    }

1.2 Double(String)

public Double(String s) throws NumberFormatException {
    value = parseDouble(s);
}

2. 常用方法

几乎同float

八、Boolean

1. 构造方法

1.1 Boolean(boolean)

public Boolean(boolean value) {
        this.value = value;
    }

1.2 Boolean(String)

public Boolean(String s) {
        this(parseBoolean(s));
    }

2. 常用方法

2.1 parseBoolean(String)

 public static boolean parseBoolean(String s) {
        return ((s != null) && s.equalsIgnoreCase("true"));
    }

2.2 valueOf

2.2.1 valueOf(boolean)

public static Boolean valueOf(boolean b) {
    return (b ? TRUE : FALSE);
}

2.2.2 valueOf(String)

public static Boolean valueOf(String s) {
    return parseBoolean(s) ? TRUE : FALSE;
}

2.3 toString

2.3.1 toString()

Object

public String toString() {
    return value ? "true" : "false";
}

2.3.1 toString(boolean)

public static String toString(boolean b) {
    return b ? "true" : "false";
}

2.4 hashCode

value ? 1231 : 1237;

2.5 1.8比较

2.5.1 logicalAnd(boolean,boolean)

 public static boolean logicalAnd(boolean a, boolean b) {
        return a && b;
    }

2.5.2 logicalOr(boolean,boolean)

public static boolean logicalOr(boolean a, boolean b) {
    return a || b;
}

2.5.3 logicalXor(boolean,boolean)

public static boolean logicalXor(boolean a, boolean b) {
    return a ^ b;
}

2.5 比较

2.5.1 JDK1.5 compareTo

public int compareTo(Boolean b) {
    return compare(this.value, b.value);
}

2.5.2 JDK1.7 compare

public static int compare(boolean x, boolean y) {
    return (x == y) ? 0 : (x ? 1 : -1);
}

九、String

public final class String implements java.io.Serializable, Comparable<String>, CharSequence
final修饰
实现serializable
实现comparable
实现CharSequence
```
private final char value[];
```

1. 内部类

1.CaseInsensitiveComparator

private static class CaseInsensitiveComparator implements Comparator<String>, java.io.Serializable

不区分大小写的比较

private static class CaseInsensitiveComparator
            implements Comparator<String>, java.io.Serializable {
        // use serialVersionUID from JDK 1.2.2 for interoperability
        private static final long serialVersionUID = 8575799808933029326L;

        public int compare(String s1, String s2) {
            int n1 = s1.length();
            int n2 = s2.length();
            int min = Math.min(n1, n2);
            for (int i = 0; i < min; i++) {
                char c1 = s1.charAt(i);
                char c2 = s2.charAt(i);
                if (c1 != c2) {
                    c1 = Character.toUpperCase(c1);
                    c2 = Character.toUpperCase(c2);
                    if (c1 != c2) {
                        c1 = Character.toLowerCase(c1);
                        c2 = Character.toLowerCase(c2);
                        if (c1 != c2) {
                            // No overflow because of numeric promotion
                            return c1 - c2;
                        }
                    }
                }
            }
            return n1 - n2;
        }

        /** Replaces the de-serialized object. */
        private Object readResolve() { return CASE_INSENSITIVE_ORDER; }
    }

声明之后调用了一次public static final Comparator<String> CASE_INSENSITIVE_ORDER CaseInsensitiveComparator();

只有在这个方法中调用了

public int compareToIgnoreCase(String str) {
        return CASE_INSENSITIVE_ORDER.compare(this, str);
    }

2. 构造方法

16个构造函数

1590907321649

2.1 String()

public String() {
        this.value = "".value;
    }

2.2 String(String)

public String(String original) {
        this.value = original.value;
        this.hash = original.hash;
    }

2.3 String(char[])

public String(char value[]) {
        this.value = Arrays.copyOf(value, value.length);
    }

2.4 String(StringBuffer)

public String(StringBuffer buffer) {
        synchronized(buffer) {
            this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
        }
    }

2.5 String(StringBuilder)

public String(StringBuilder builder) {
        this.value = Arrays.copyOf(builder.getValue(), builder.length());
    }

2.6 String(char[],boolean)

 String(char[] value, boolean share) {
        // assert share : "unshared not supported";
        this.value = value;
    }

3. 常用方法

3.1 valueOf

valueOf(int)---------》底层调用Integer.toString(xx)
valueOf(long)---------》底层调用Long.toString(xx)
valueOf(float)---------》底层调用Float.toString(xx)
valueOf(double)---------》底层调用Double.toString(xx)
valueOf(char)---------》底层调用new String(char[],boolean);
valueOf(char[])---------》底层调用new String(char[]);
valueOf(boolean)---------》底层调用 boolean? “true”:“false”
valueOf(Object)---------》底层调用 (obj == null) ? “null” : obj.toString();
valueOf(char[], int , int )---------》底层调用 new String(data, offset, count);

3.2 比较

3.2.1 compareTo

public int compareTo(String anotherString) {
        int len1 = value.length;
        int len2 = anotherString.value.length;
        int lim = Math.min(len1, len2);
        char v1[] = value;
        char v2[] = anotherString.value;

        int k = 0;
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2;
    }

3.2.1 compareToIgnoreCase

不区分大小的
内部其实用来匿名实现类，并调用CaseInsensitiveComparator这个对象

3.3 equals(Object)

 public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

qq_40949759

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java包装基础类源码分析

一、Integerpublic final class Integer extends Number implements Comparable<Integer>final修饰类继承Number实现comparable接口1. 内部类1.1 IntegerCache唯一一个内部类作用：默认缓存的范围是 [-128,127]，当Integer值在这个范围时如果缓存有则直接取出，不用重新实例化缓存值都是静态且 final 的，避免重复的实例化和回收可以改变这些值缓存的范
复制链接

扫一扫

专栏目录