XxwGit 的个人博客

记录精彩的程序人生

目录
一起学jdk--lang篇
/  

一起学jdk--lang篇

java.lang中的源码详解

Object

  1. equals(Object)方法
    navtive方法,用于返回当前运行时对象的Class对下你给,使用了 final 关键字修饰,所以不允许子类重写
  2. hashCode()方法
    nactive方法,用于返回对象的哈希吗,主要使用在哈希表中,比如jdk中的 HashMap
  3. toString()方法
    这个方法就是将至转换为String返回,一般这个方法都会重写。
    Object 类的 toString 方法返回一个字符串,该字符串由类名(对象是该类的一个实例)、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。换句话说,该方法返回一个字符串,它的值等于: getClass().getName() + '@' + Integer.toHexString(hashCode())
  4. getClass方法
    final方法,返回一个对象的运行时类
  5. wait(),wait(long)和wait(long,int)方法----点击查看详解
    wait(),就是导致当前的线程等待,直到其他线程调用此对象的notify( ) 方法或 notifyAll( ) 方法。
    wait(long),就是导致当前的线程等待,直到其他线程调用此对象的notify() 方法或 notifyAll() 方法,或者指定的时间过完。
    wait(long,int),就是导致当前的线程等待,直到其他线程调用此对象的notify( ) 方法或 notifyAll( ) 方法,或者其他线程打断了当前线程,或者指定的时间过完。
  6. notify()和notifyAll()方法----点击查看详解
    notify是唤醒在此对象监视器上等待的单个线程,notifyAll唤醒在此对象监视器上等待的所有线程。
  7. clone()方法
    另存一个当前存在的对象
  8. finalize()方法
    垃圾回收那一块的方法,当垃圾回收器确定不存在对该对象的更多引用时,由对象的垃圾回收器调用此方法

String

  1. String的构造方法
  • public String()
    空构造方法
  • public String(String original)
    把字符串常量值转成字符串
  • public String(char value[])
    把字符数组转成字符串
  • public String(char value[], int offset, int count)
    把字符数组的一部分转成字符串
  • public String(int[] codePoints, int offset, int count)
    把数组的一部分转成字符串
  • public String(byte bytes[], int offset, int length)
    把字节数组的一部分转成字符串
  • public String(byte bytes[])
    把字节数组转成字符串
/**
 * 
 *
 * @author xuxinwei 2019年9月3日
 */
public class TestString {
	public static void main(String[] args) {
		String string1 = new String();
		System.out.println(string1);
		
		String string2=new String("TestString");
		System.out.println(string2);
		
		byte[] array1={97,98,99,100};
		String string3=new String(array1); //解码,将计算机读的懂的转换成我们读的懂得
		System.out.println(string3);
		
		byte[] array2={97,98,99,100,101,102}; //将arr2字节数组从2索引开始转换3个
		String string4=new String(array2,2,4);
		System.out.println(string4);
		
		char[] array3={'a','b','c','d','e'}; //将字符数组转换成字符串
		String string5=new String(array3);
		System.out.println(string5);
		
		String string6=new String(array3,1,3);
		System.out.println(string6);
	}
}
  1. 其他方法
  • public int length()
    返回字符串的长度
  • public boolean isEmpty()
    判断字符串是否为空
  • public char charAt(int index)
    返回对应索引处的字符
  • public void getChars(int start,int end,char c[],int offset)
    将当前字符串从start到end-1位置上的字符复制到字符数组c中,并从c的offset处开始存放
  • public byte[] getBytes(String charsetName)
    据指定的decode编码返回某字符串在该编码下的byte数组表示
  • public boolean equals(Object anObject)
    判断值是否相等---equals和==的区别
  • public boolean startsWith(String prefix, int toffset)
    从offset位置开始查询,判断是否以prefix开始
  • public boolean endsWith(String suffix)
    判断是否以suffix结束
  • public int indexOf(String str, int startIndex)
    从指定的索引处开始,返回第一次出现的指定子字符串在此字符串中的索引。
  • public int lastIndexOf(String str, int startIndex)
    从指定的索引处开始向后搜索,返回在此字符串中最后一次出现的指定子字符串的索引。
  • public String substring(int beginIndex, int endIndex)
    第一个int为开始的索引,对应String数字中的开始位置,第二个是截止的索引位置,对应String中的结束位置
  • public String replace(char oldChar, char newChar)
    将这个字符串中的所有的oldchar全部换成newchar,并返回一个新的字符串
  • public String[] split(String regex)
    根据匹配给定的正则表达式来拆分此字符串
  • public String toLowerCase()
    将所有英文字母转换为小写字母
  • public String toUpperCase()
    将所有英文字母转换为大写字母
  • public String trim()
    去掉字符串前面和后面的空格
  • public char[] toCharArray()
    该方法的作用是返回一个字符数组,该字符数组中存放了当前字符串中的所有字符
  • public static String valueOf(int i)
    将其他格式的对象转换为string
  • public String concat(String str)
    拼接字符串(拼接之后是另一个对象)

AbstractStringBuilder

抽象类不可实例化
实现了两个接口:Appendable和CharSequence
两个子类:StringBuilder和StringBuffer的区别
父类方法

  • public int length()
    返回自定义的对象的长度
  • public int capacity()
    返回的是在新建对象时对象的长度会加16,这是对象的容量,也就是length+16
  • public void ensureCapacity(int minimumCapacity)
    扩容机制---点击查看详解
  • public void trimToSize()
    格式化容量,删除不用的空间,删除至和其中的字节数组长度length一致即可
  • public void setLength(int newLength)
    用空字符填充未使用的空间。首先对数组进行扩容,然后将剩余未使用的空间全部填充为'0'字符。
  • public char charAt(int index)
    获取字符序列中指定位置的字符,范围为0到count,超出范围抛StringIndexOutOfBoundsException异常。
  • public int codePointAt(int index)
    获取字符序列中指定位置的字符,所对应的代码点,即ascii码。
  • public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
    将字符序列中指定区间srcBegin到srcEnd内的字符拷贝到dst字符数组中从dstBegin开始往后的位置中。
  • public void setCharAt(int index, char ch)
    设置字符序列中指定索引index位置的字符为ch。
  • public AbstractStringBuilder append(Object obj)
    增加字符串
  • public AbstractStringBuilder delete(int start, int end)
    删除字符序列指定区间的内容。这个操作不改变原序列的容量。
  • public AbstractStringBuilder deleteCharAt(int index)
    删除字符序列中指定索引index位置的字符。
  • public AbstractStringBuilder replace(int start, int end, String str)
    将原字符序列指定区间start到end区间内的内容替换为str,替换过程中序列长度会改变,所以需要进行扩容和改就count的操作。
  • public String substring(int start, int end)
    切割原字符序列指定区间start到end内的内容,返回字符串形式。
  • public AbstractStringBuilder insert()
    在字符串中插入
  • public int indexOf(String str, int fromIndex)
    查询给定字符串在原字符序列中第一次出现的位置。调用的其实是String类的indexOf方法
  • public AbstractStringBuilder reverse()
    该方法用于将字符序列反转,如"hellow"执行reverse后变成"wolleh"。
  • public String toString()
    该方法将StrinfBuilder对象转换为String对象,在子类中重写。
 /**
 * StringBuilder 演示程序
 *
 * @author skywang
 */
import java.util.HashMap;

public class StringBuilderTest {

    public static void main(String[] args) {
        testOtherAPIs() ;
        testIndexAPIs() ;
        testInsertAPIs() ;
        testAppendAPIs() ;
        testReplaceAPIs() ;
        testDeleteAPIs() ;
    }

    /**
     * StringBuilder 的其它API示例
     */
    private static void testOtherAPIs() {

        System.out.println("-------------------------------- testOtherAPIs --------------------------------");

        StringBuilder sbuilder = new StringBuilder("0123456789");

        int cap = sbuilder.capacity();
        System.out.printf("cap=%d\n", cap);

        char c = sbuilder.charAt(6);
        System.out.printf("c=%c\n", c);

        char[] carr = new char[4];
        sbuilder.getChars(3, 7, carr, 0);
        for (int i=0; i<carr.length; i++)
            System.out.printf("carr[%d]=%c ", i, carr[i]);
        System.out.println();

        System.out.println();
    }

    /**
     * StringBuilder 中index相关API演示
     */
    private static void testIndexAPIs() {
        System.out.println("-------------------------------- testIndexAPIs --------------------------------");

        StringBuilder sbuilder = new StringBuilder("abcAbcABCabCaBcAbCaBCabc");
        System.out.printf("sbuilder=%s\n", sbuilder);

        // 1. 从前往后,找出"bc"第一次出现的位置
        System.out.printf("%-30s = %d\n", "sbuilder.indexOf(\"bc\")", sbuilder.indexOf("bc"));

        // 2. 从位置5开始,从前往后,找出"bc"第一次出现的位置
        System.out.printf("%-30s = %d\n", "sbuilder.indexOf(\"bc\", 5)", sbuilder.indexOf("bc", 5));

        // 3. 从后往前,找出"bc"第一次出现的位置
        System.out.printf("%-30s = %d\n", "sbuilder.lastIndexOf(\"bc\")", sbuilder.lastIndexOf("bc"));

        // 4. 从位置4开始,从后往前,找出"bc"第一次出现的位置
        System.out.printf("%-30s = %d\n", "sbuilder.lastIndexOf(\"bc\", 4)", sbuilder.lastIndexOf("bc", 4));

        System.out.println();
    }

    /**
     * StringBuilder 的replace()示例
     */
    private static void testReplaceAPIs() {

        System.out.println("-------------------------------- testReplaceAPIs ------------------------------");

        StringBuilder sbuilder;

        sbuilder = new StringBuilder("0123456789");
        sbuilder.replace(0, 3, "ABCDE");
        System.out.printf("sbuilder=%s\n", sbuilder);

        sbuilder = new StringBuilder("0123456789");
        sbuilder.reverse();
        System.out.printf("sbuilder=%s\n", sbuilder);

        sbuilder = new StringBuilder("0123456789");
        sbuilder.setCharAt(0, 'M');
        System.out.printf("sbuilder=%s\n", sbuilder);

        System.out.println();
    }

    /**
     * StringBuilder 的delete()示例
     */
    private static void testDeleteAPIs() {

        System.out.println("-------------------------------- testDeleteAPIs -------------------------------");

        StringBuilder sbuilder = new StringBuilder("0123456789");
        
        // 删除位置0的字符,剩余字符是“123456789”。
        sbuilder.deleteCharAt(0);
        // 删除位置3(包括)到位置6(不包括)之间的字符,剩余字符是“123789”。
        sbuilder.delete(3,6);

        // 获取sb中从位置1开始的字符串
        String str1 = sbuilder.substring(1);
        // 获取sb中从位置3(包括)到位置5(不包括)之间的字符串
        String str2 = sbuilder.substring(3, 5);
        // 获取sb中从位置3(包括)到位置5(不包括)之间的字符串,获取的对象是CharSequence对象,此处转型为String
        String str3 = (String)sbuilder.subSequence(3, 5);

        System.out.printf("sbuilder=%s\nstr1=%s\nstr2=%s\nstr3=%s\n", 
                sbuilder, str1, str2, str3);
    }

    /**
     * StringBuilder 的insert()示例
     */
    private static void testInsertAPIs() {

        System.out.println("-------------------------------- testInsertAPIs -------------------------------");

        StringBuilder sbuilder = new StringBuilder();

        // 在位置0处插入字符数组
        sbuilder.insert(0, new char[]{'a','b','c','d','e'});
        // 在位置0处插入字符数组。0表示字符数组起始位置,3表示长度
        sbuilder.insert(0, new char[]{'A','B','C','D','E'}, 0, 3);
        // 在位置0处插入float
        sbuilder.insert(0, 1.414f);
        // 在位置0处插入double
        sbuilder.insert(0, 3.14159d);
        // 在位置0处插入boolean
        sbuilder.insert(0, true);
        // 在位置0处插入char
        sbuilder.insert(0, '\n');
        // 在位置0处插入int
        sbuilder.insert(0, 100);
        // 在位置0处插入long
        sbuilder.insert(0, 12345L);
        // 在位置0处插入StringBuilder对象
        sbuilder.insert(0, new StringBuilder("StringBuilder"));
        // 在位置0处插入StringBuilder对象。6表示被在位置0处插入对象的起始位置(包括),13是结束位置(不包括)
        sbuilder.insert(0, new StringBuilder("STRINGBUILDER"), 6, 13);
        // 在位置0处插入StringBuffer对象。
        sbuilder.insert(0, new StringBuffer("StringBuffer"));
        // 在位置0处插入StringBuffer对象。6表示被在位置0处插入对象的起始位置(包括),12是结束位置(不包括)
        sbuilder.insert(0, new StringBuffer("STRINGBUFFER"), 6, 12);
        // 在位置0处插入String对象。
        sbuilder.insert(0, "String");
        // 在位置0处插入String对象。1表示被在位置0处插入对象的起始位置(包括),6是结束位置(不包括)
        sbuilder.insert(0, "0123456789", 1, 6);
        sbuilder.insert(0, '\n');

        // 在位置0处插入Object对象。此处以HashMap为例
        HashMap map = new HashMap();
        map.put("1", "one");
        map.put("2", "two");
        map.put("3", "three");
        sbuilder.insert(0, map);

        System.out.printf("%s\n\n", sbuilder);
    }

    /**
     * StringBuilder 的append()示例
     */
    private static void testAppendAPIs() {

        System.out.println("-------------------------------- testAppendAPIs -------------------------------");

        StringBuilder sbuilder = new StringBuilder();

        // 追加字符数组
        sbuilder.append(new char[]{'a','b','c','d','e'});
        // 追加字符数组。0表示字符数组起始位置,3表示长度
        sbuilder.append(new char[]{'A','B','C','D','E'}, 0, 3);
        // 追加float
        sbuilder.append(1.414f);
        // 追加double
        sbuilder.append(3.14159d);
        // 追加boolean
        sbuilder.append(true);
        // 追加char
        sbuilder.append('\n');
        // 追加int
        sbuilder.append(100);
        // 追加long
        sbuilder.append(12345L);
        // 追加StringBuilder对象
        sbuilder.append(new StringBuilder("StringBuilder"));
        // 追加StringBuilder对象。6表示被追加对象的起始位置(包括),13是结束位置(不包括)
        sbuilder.append(new StringBuilder("STRINGBUILDER"), 6, 13);
        // 追加StringBuffer对象。
        sbuilder.append(new StringBuffer("StringBuffer"));
        // 追加StringBuffer对象。6表示被追加对象的起始位置(包括),12是结束位置(不包括)
        sbuilder.append(new StringBuffer("STRINGBUFFER"), 6, 12);
        // 追加String对象。
        sbuilder.append("String");
        // 追加String对象。1表示被追加对象的起始位置(包括),6是结束位置(不包括)
        sbuilder.append("0123456789", 1, 6);
        sbuilder.append('\n');

        // 追加Object对象。此处以HashMap为例
        HashMap map = new HashMap();
        map.put("1", "one");
        map.put("2", "two");
        map.put("3", "three");
        sbuilder.append(map);
        sbuilder.append('\n');

        // 追加unicode编码
        sbuilder.appendCodePoint(0x5b57);    // 0x5b57是“字”的unicode编码
        sbuilder.appendCodePoint(0x7b26);    // 0x7b26是“符”的unicode编码
        sbuilder.appendCodePoint(0x7f16);    // 0x7f16是“编”的unicode编码
        sbuilder.appendCodePoint(0x7801);    // 0x7801是“码”的unicode编码

        System.out.printf("%s\n\n", sbuilder);
    }
}

Boolean

  1. 构造方法
  • public Boolean(boolean value)
    true或者false(只可以定义这两个)
  • public Boolean(String value)
    只要不是true,就会返回fals
  1. 其他方法
  • public boolean booleanValue()
    返回当前布尔值
  • public static Boolean valueOf(boolean b)
    这个方法如同Integer的valueof(int i)方法,这里也是返回一个Boolean类型的实例,这个实例也是早就创建好的,这个地方就是采用了装箱操作,只不过是用了缓存里面提前创建好的实例.这是创建Boolean对象的静态工厂方法
  • public static String toString(boolean b)
    将boolean类型转换成String类型
  • public String toString()
    将Boolean类型的值转换成String类型
  • public boolean equals(Object obj)
    比较两个Boolean对象是否相等,通过转换成boolean类型进行比较,最后返回boolean类型的数据。
  • public static boolean getBoolean(String name)
    判断系统属性存在并且是字符串“true”,如果不是,则返回false
  • public static int compare(boolean x,boolean y)
    较两个boolean类型的变量,如果相等返回0,如果不相等,第一个变量为true,返回1;第一个变量为false返回-1

Byte

  1. 常用方法
  • public Byte(byte value)
    构造方法,创建一个Byte对象,需要一个byte数值
  • public Byte(String s)
    构造方法,创建一个Byte对象,string范围是-128-127
  • public byte byteValue()
    返回此值Byte作为byte
  • public short shortValue()
    将此对象转化为short
  • public int intValue()
    将此对象转化为int
  • public long longValue()
    将此对象转化为long
  • public float floatValue()
    将此对象转化为float
  • public double doubleValue()
    将此对象转化为double
  • public String toString()
    将此对象转换为string
  • public boolean equals(Object obj)
    将此对象与指定的对象进行比较
  • public int compareTo(Byte anotherByte)
    用Byte数字比较两个对象
  1. 其他方法
  • static Byte valueOf(byte b)
    指定byte值,返回Byte表示的实例
  • static Byte valueOf(String s)
    使用s构造一个新的Byte对象,s为byte范围内的整数
  • static byte parseByte(String s)
    将字符串参数解析为带符号的byte

Integer

  1. 构造函数
  • Integer(int value)
    通过指定的int值构成一个Integer对象
  • Integer(String s)
    通过指定的String值构成一个Integer对象
  1. 方法
  • int intValue()
    将此对象转化为int。

  • long longValue()
    将此对象转化为long。

  • byte byteValue()
    将此对象转化为byte。

  • short shortValue()
    将此对象转化为short。

  • double doubleValue()
    将此对象转化为double。

  • float floatValue()
    将此对象转化为float。

  • boolean equals(Object obj)
    将此对象与指定的对象进行比较。

  • int compareTo(Integer anotherInteger)
    用Integer数字比较两个对象。

  • int hashCode()
    返回此的哈希码Integer。

  • String toString()
    返回String表示此Integer值的对象 。

  1. 静态方法
  • static Integer valueOf(int i)
    将int转化为Integer。

  • static Integer valueOf(String s)
    将String转化为Integer。

  • static Integer valueOf(String s, int radix)
    返回一个Integer对象,该对象String包含使用第二个参数给出的基数(计算机进制)解析时从指定的值中提取的值。

  • static int max(int a, int b)
    返回两个int值中的较大值,就像通过调用Math.max。一样

  • static int min(int a, int b)
    返回两个int值中较小的一个,就像通过调用Math.min一样。

  • static int sum(int a, int b)
    根据+运算符将两个整数相加。

  • static String toBinaryString(int i)
    返回整数参数的字符串表示形式,作为基数为2中的无符号整数。

  • static String toHexString(int i)
    返回整数参数的字符串表示形式,作为基数为16的无符号整数。

  • static String toOctalString(int i)
    返回整数参数的字符串表示形式,作为基数为8的无符号整数。

  • static long toUnsignedLong(int x)
    通过无符号转换将参数转换为long。

  • static String toUnsignedString(int i)
    以无符号十进制值的形式返回参数的字符串表示形式。

  • static String toUnsignedString(int i, int radix)
    返回第一个参数的字符串表示形式,作为第二个参数指定的基数中的无符号整数值。

  • static int signum(int i)
    返回指定int值的signum(符号)函数。

  • static int bitCount(int i)
    返回指定int值的二进制补码表示形式中的一位数。

  • static Integer getInteger(String nm)
    根据指定的系统属性名称获取Integer。

  • static Integer getInteger(String nm, int val)
    根据指定的系统属性名称获取Integer,如果没有则返回val

  • static Integer getInteger(String nm, Integer val)
    根据指定的系统属性名称获取Integer。如果没有则返回val

  • static Integer decode(String nm)
    将String解码为Integer。(0xf,041,99)

  • static int divideUnsigned(int dividend, int divisor)
    返回将第一个参数除以第二个参数的无符号商,其中每个参数和结果都被解释为无符号值。

  • static int lowestOneBit(int i)
    返回一个int最多只有一位的值,位于指定int值中最低位(“最右侧”)一位的位置 。

  • static int highestOneBit(int i)
    返回一个int最多只有一位的值,位于指定int值中最高位(“最左侧”)一位的位置 。

  • static int numberOfLeadingZeros(int i)
    返回指定int值的二进制补码表达式中最高位(“最左侧”)一位之前的零位数。

  • static int numberOfTrailingZeros(int i)
    返回指定int值的二进制补码表达式中最低位(“最右侧”)一位之后的零位数 。

  • static int parseInt(String s)
    将字符串参数解析为带符号的十进制整数。

  • static int parseInt(String s, int radix)
    将字符串参数解析为第二个参数指定的基数(计算机进制)中的有符号整数。

  • static int parseUnsignedInt(String s)
    将字符串参数解析为无符号十进制整数。

  • static int parseUnsignedInt(String s, int radix)
    将字符串参数解析为第二个参数指定的基数(计算机进制)中的无符号整数。

  • static int remainderUnsigned(int dividend, int divisor)
    返回将第一个参数除以第二个参数的无符号余数,其中每个参数和结果都被解释为无符号值。

  • static int reverse(int i)
    返回通过反转指定int 值的二进制补码二进制表示中的位顺序而获得的值。

  • static int reverseBytes(int i)
    返回通过反转指定int值的二进制补码表示中的字节顺序获得的值。

  • static int rotateLeft(int i, int distance)
    返回通过旋转int指定位数左侧的指定值的二进制补码表示获得的值。

  • static int rotateRight(int i, int distance)
    返回通过将指定int值的二进制补码表示法旋转指定的位数而获得的值。

  • static int hashCode(int value)
    返回int值的哈希码; 兼容 Integer.hashCode()。

  • static int compare(int x, int y)
    以int数字方式比较两个值。

  • static int compareUnsigned(int x, int y)
    比较两个int值,以数值方式将值视为无符号。

  • static String toString(int i)
    返回String表示指定整数的对象。

  • static String toString(int i, int radix)
    返回第二个参数指定的基数(计算机进制)中第一个参数的字符串表示形式。

Short

  1. 构造函数
  • Short(short value)
    通过指定的short构造一个Short对象。

  • Short(String s)
    通过指定的String构造一个Short对象。

  1. 方法
  • byte byteValue()
    将此对象转化为byte。

  • double doubleValue()
    将此对象转化为double。

  • float floatValue()
    将此对象转化为float。

  • int intValue()
    将此对象转化为int。

  • long longValue()
    将此对象转化为long。

  • short shortValue()
    将此对象转化为short。

  • boolean equals(Object obj)
    将此对象与指定的对象进行比较。

  • int hashCode()
    返回此哈希码Short; 等于调用的结果intValue()。

  • int compareTo(Short anotherShort)
    用Short数字比较两个对象。

  • String toString()
    返回String表示此Short值的对象 。

  1. 静态方法
  • static int toUnsignedInt(short x)
    通过无符号转换将参数转换为int。

  • static long toUnsignedLong(short x)
    通过无符号转换将参数转换为long 。

  • static Short valueOf(short s)
    将short转化为Short。

  • static Short valueOf(String s)
    将String转化为Short。

  • static Short valueOf(String s, int radix)
    返回一个Short对象,该对象保存String使用第二个参数给出的基数(计算进制)解析时从指定的值中提取的值。

  • static short parseShort(String s)
    将字符串参数解析为带符号的short。

  • static short parseShort(String s, int radix)
    将字符串参数解析为short,第二个参数指定计算进制 。

  • static short reverseBytes(short i)
    返回通过反转指定short值的二进制补码的值。

  • static Short decode(String nm)
    将String解码为Short。(String可以为10进制、16进制。8进制)

  • static int compare(short x, short y)
    以short数字方式比较两个值。

  • static int hashCode(short value)
    返回short值的哈希码; 兼容 Short.hashCode()。

  • static String toString(short s)
    将指定的short转化为String。

Thread


标题:一起学jdk--lang篇
作者:XxwGit
地址:http://xxwgit.cn/solo/articles/2019/08/30/1567158653831.html

评论