基本数据类型及其封装类的常用方法

最新推荐文章于 2022-05-03 19:05:16 发布

dianhundeng

最新推荐文章于 2022-05-03 19:05:16 发布

阅读量630

点赞数

文章标签： java

本文链接：https://blog.csdn.net/dianhundeng/article/details/113686002

版权

基本数据类型及其封装类的常用方法

1.Byte

1.1四个常量

//byte类型的最小值
System.out.println("最小值MIN_VALUE:"+Byte.MIN_VALUE);
//byte类型的最大值
System.out.println("最大值MAX_VALUE:"+Byte.MAX_VALUE);
//byte的类型
System.out.println("类型Type:"+Byte.TYPE);
//byte类型的字节大小
System.out.println("位数size:"+Byte.SIZE);

输出结果：

最小值MIN_VALUE:-128
最大值MAX_VALUE:127
类型Type:byte
位数size:8

1.2数据类型转换

1.2.1valueof

1.2.1.1valueof（Byte b）

调用ByteCache.cache方法，赋值时不会创建一个新的版本，而是返回一个预先存在的版本中，这样可以节省内存

源代码：

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

ByteCache.cache代码：

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));
    }
}

基本上构造函数版本用于创建一个全新的版本,而valueOf版本返回一个预先存在的版本.这节省了内存,因为Byte.valueOf(10)只有一个值,无论您调用它的次数如何,但如果您执行新的Byte(10),则会为每次调用new创建一个新值.由于字节是不可变的(它们没有可变状态),因此没有理由为任何给定值创建多个字节.

1.2.1.2valueof(String str)

将一个String类型数据转换为Byte对象

System.out.println(Byte.valueOf(str).getClass());

输出结果：

class java.lang.Byte

1.2.1.3 valueof(String str，int radix)

str是radix进制的数，将其转换成10进制并转换为Byte类型，要注意Byte的范围，不可超出-128~127，也要注意str和radix的类型对应，不可出现radix为2，str为5的情况

Byte a1 = Byte.valueOf("111", 2);
Byte a2 = Byte.valueOf("12", 8);
System.out.println(a.getClass());
System.out.println(a1);
System.out.println(a2);

输出结果：

7
10

1.2.2toString

将byte/Byte类型转换为String类型

System.out.println(byetA.toString().getClass());

输出结果：

class java.lang.Byte

1.2.3parseByte（String str）

将String 类型转换为byte类型

byte b = Byte.parseByte(str);

1.2.4parseByte（String str，int radix）

str是radix进制的数，将其转换成10进制并转换为byte类型，要注意Byte的范围，不可超出-128~127，也要注意str和radix的类型对应，不可出现radix为2，str为5的情况

byte b1 = Byte.parseByte("11", 2);
byte b2= Byte.parseByte("11", 8);
System.out.println(b1);
System.out.println(b1);

输出结果为：

3
9

1.2.5value

intValue	将Byte类型转换为int型
floatValue	将Byte类型转换为float型
longValue	将Byte类型转换为long型
doubleValue	将Byte类型转换为double型
byteValue	将Byte类型转换为byte型
shortValue	将Byte类型转换为short型

示例：

public void valueTest() {
    Byte a = Byte.valueOf("10");
    byte b = a.byteValue();
    long c = a.longValue();
    int d = a.intValue();
    double e = a.doubleValue();
    short f = a.shortValue();
    float g = a.floatValue();
    System.out.println(b);
    System.out.println(c);
    System.out.println(d);
    System.out.println(e);
    System.out.println(f);
    System.out.println(g);
}

结果：

1.2.6toUnsigned

toUnsignedInt	将byte类型数值转换成无符号int型
toUnsignedLong	将byte类型数值转换成无符号long型

public void toUnsignedTest(){
    byte a=-12;
    byte b=12;
    int i = Byte.toUnsignedInt(a);
    int i1 = Byte.toUnsignedInt(b);
    long l = Byte.toUnsignedLong(a);
    long l1 = Byte.toUnsignedLong(b);
    System.out.println(i);
    System.out.println(i1);
    System.out.println(l);
    System.out.println(l1);
}

输出结果：

byte为正数的时候输出对应的long、int值，为负数时输出其值加上256的值

1.2.7decode

将一个十进制/八进制/十六进制的字符串数转换成十进制的Byte型，要注意Byte的范围，不可超出-128~127

public void decodeTest() {
    //16进制
    Byte a1 = Byte.decode("-0x6b");
    Byte a2 = Byte.decode("0x6b");
    Byte a3 = Byte.decode("-#4c");
    Byte a4 = Byte.decode("#4c");
    System.out.println(a1);
    System.out.println(a2);
    System.out.println(a3);
    System.out.println(a4);
    //8进制
    Byte a5 = Byte.decode("0123");
    System.out.println(a5);
}

输出结果：

1.4hashcode

返回一个Byte类型数值的hash码，Byte类型就是返回其对应的int型

public void hashcodeTest() {
    Byte a = Byte.valueOf("10");
    int x = a.hashCode();
    System.out.println(x);
    int i = Byte.hashCode(a);
    System.out.println(i);
}

输出结果：

10
10

1.5比较

1.5.1equals

判断两个byte类型数值是否相同，不可比较不同数据类型

public void equalsTest() {
    Byte a = Byte.valueOf("10");
    Byte b = Byte.valueOf("12");
    int c=10;
    byte d=10;
    boolean equalsA = a.equals(c);
    boolean equalsB = a.equals(b);
    boolean equalsC = a.equals(d);
    System.out.println(equalsA);
    System.out.println(equalsB);
    System.out.println(equalsC);
    
}

输出结果：

false
false
true

1.5.2compare

compare(byte a,byte b)或者compareTo(byte another)是求出两个byte数值的差

public void compareTest() {
    Byte a = Byte.valueOf("10");
    Byte b = Byte.valueOf("12");
    byte d = 10;
    int compareToA = a.compareTo(b);
    int compareToB = a.compareTo(d);
    int compareA = Byte.compare(a, b);
    int compareB = a.compare(a, d);
    System.out.println(compareA);
    System.out.println(compareB);
    System.out.println(compareToA);
    System.out.println(compareToB);
}

输出结果：

-2
0
-2
0

2.Integer

2.1常量

//int类型的最小值
System.out.println("Integer最小值："+Integer.MIN_VALUE);
//int类型的最大值
System.out.println("Integer最大值："+Integer.MAX_VALUE);
//int的类型
System.out.println("Integer类型："+Integer.TYPE);
//int类型的字节大小
System.out.println("Integer字节数："+Integer.SIZE);

输出结果：

Integer最大值：2147483647
Integer最小值：-2147483648
Integer字节数：32
Integer类型：int

2.2数据转换

2.2.1toString

toString(int i)	将int型数据i转换为String类型
toString(int i, int radix)	将十进制int型数值i转换为radix进制数值，再转换为String型
toBinaryString(int i)	将十进制int型数值i转换为2进制数值，再转换为String型
toOctalString(int i)	将十进制int型数值i转换为8进制数值，再转换为String型
toHexString(int i)	将十进制int型数值i转换为16进制数值，再转换为String型
toUnsignedLong(int x)	将int型转换为无符号的long型，x为正数则long为对应的值，为负数，则为x+4294967296
toUnsignedString(int i)	将int型转换为无符号的String型，x为正数则String为对应的值，为负数，则为x+4294967296，因为其是调用上一个函数实现
toUnsignedString(int i, int radix)	将int型转换为无符号的String型，x为正数则String为对应的值，为负数，则为x+4294967296，再将数值转换为radix进制数

示例：

public void toStringTest(){
    String s = Integer.toString(10);
    String s1 = Integer.toString(10, 8);

    //转换进制并转为String
    String s2 = Integer.toBinaryString(10);
    String s3 = Integer.toHexString(10);
    String s4 = Integer.toOctalString(10);

    //无符号转换
    String s5 = Integer.toUnsignedString(-10);
    String s6 = Integer.toUnsignedString(10);
    String s7 = Integer.toUnsignedString(-10, 8);
    String s8 = Integer.toUnsignedString(10, 8);
    long l = Integer.toUnsignedLong(10);
    long l1 = Integer.toUnsignedLong(-10);
    System.out.println(s);
    System.out.println(s1);
    System.out.println();
    System.out.println("转换为2进制String："+s2);
    System.out.println("转换为16进制String："+s3);
    System.out.println("转换为8进制String："+s4);
    System.out.println();
    System.out.println(s5);
    System.out.println(s6);
    System.out.println(s7);
    System.out.println(s8);
    System.out.println("正数转换为无符号long："+l);
    System.out.println("负数转换为无符号long："+l1);
}

输出结果：

10
12

转换为2进制String：1010
转换为16进制String：a
转换为8进制String：12

4294967286
10
37777777766
12
正数转换为无符号long：10
负数转换为无符号long：4294967286

2.2.2parseInt

parseInt(String s)	将String变量s转换为int类型
parseInt(String s, int radix)	将String类型的radix进制数s转换成int型
parseUnsignedInt(String s)	将String变量s转换为无符号int类型，如果s包含负号，则报异常：java.lang.NumberFormatException
parseUnsignedInt(String s, int radix)	将String类型的radix进制数s转换成无符号int型如果s包含负号，则报异常：java.lang.NumberFormatException

示例：

public void parseTest(){
        int i = Integer.parseInt("10");
        int i1 = Integer.parseInt("10", 8);
        int i2 = Integer.parseUnsignedInt("10");
        int i4 = Integer.parseUnsignedInt("10", 8);

        System.out.println(i);
        System.out.println(i1);
        System.out.println(i2);
        System.out.println(i4);
}

输出结果：

2.2.3valueOf

valueOf(int i)	将int转换为Integer对象
valueOf(String s)	将String转换为Integer类型
valueOf(String s, int radix)	将String类型的radix进制数s转换为Integer类型

示例：

public void valueOfTest(){
    int a=10;
    Integer integer = Integer.valueOf(a);
    Integer integer1 = Integer.valueOf("10");
    Integer integer2 = Integer.valueOf("10", 8);

    System.out.println(integer);
    System.out.println(integer1);
    System.out.println(integer2);
}

返回结果：

10
10
8

2.2.4value

intValue	将Integer类型转换为int型
floatValue	将Integer类型转换为float型
longValue	将Integer类型转换为long型
doubleValue	将Integer类型转换为double型
byteValue	将Integer类型转换为byte型
shortValue	将Integer类型转换为short型

示例：

public void valueTest(){
    Integer a=10;
    byte b = a.byteValue();
    double v = a.doubleValue();
    float v1 = a.floatValue();
    int i = a.intValue();
    long l = a.longValue();
    short i1 = a.shortValue();

    System.out.println(b);
    System.out.println(v);
    System.out.println(v1);
    System.out.println(i);
    System.out.println(l);
    System.out.println(i1);
}

输出结果：

2.2.5decode

将String类型的值转换为Integer类型，并且可以识别进制的写法

public void decodeTest(){
    Integer decode = Integer.decode("12");
    Integer decode1 = Integer.decode("010");
    Integer decode2 = Integer.decode("0x1a");

    System.out.println(decode);
    System.out.println(decode1);
    System.out.println(decode2);
}

输出结果：

12
8
26

故在进行不同进制的String转化Integer的时候可以选择此方法

2.3hashCode

获取Integer的hashCode，返回将float数据ieee754标准的二进制视为普通二进制的值

示例：

public void hashCodeTest() {
        Float a = 10f;
        int i = a.hashCode();
        System.out.println(i);
    }

输出结果：

1092616192

2.4getInteger

获取系统变量的值

getInteger(String nm)	获取名为nm的系统变量的值并转换为Integer型，没有则返回null
getInteger(String nm, int val)	获取名为nm的系统变量的值并调用decode(String nm)方法转换为Integer型，没有则返回val的Integer型
getInteger(String nm, Integer val)	获取名为nm的系统变量的值并decode(String nm)转换为Integer型，没有则返回val

示例：

  public void getIntegerTest(){
        String b="198";
        Integer a = Integer.getInteger("a");
        Integer b1 = Integer.getInteger(b);
        Integer c1 = Integer.getInteger("c");
        System.out.println(b1);
        System.out.println(a);
        System.out.println(c1);

        Integer e=16;
        Integer a1 = Integer.getInteger("a", 13);
        Integer b2 = Integer.getInteger("b", e);
        System.out.println(a1);
        System.out.println(b2);
    }

输出结果：

null
10
null
10
16

a之所以有值是因为在vmoption里面设置了相应的参数：
在这里插入图片描述

2.5算数

divideUnsigned(int dividend, int divisor)	求dividend和divisor的商
remainderUnsigned(int dividend, int divisor)	求dividend和divisor的余数
highestOneBit(int i)	取 i 这个数的二进制形式最左边的最高一位且高位后面全部补零，最后返回int型的结果（若i为负整数，最高位1为符号位，返回值为-2147483648）
lowestOneBit(int i)	取 i 这个数的二进制形式最右边的第一个1其余全部补零，最后返回int型的结果
numberOfLeadingZeros	返回这个数据的二进制串中从最左边算起连续的“0”的总数量
numberOfTrailingZeros(int i)	返回这个数据的二进制串中从最右边算起连续的“0”的总数量
bitCount(int i)	返回这个数据的二进制串中“1”的总数量
sum(int a, int b)	返回a+b

示例：

public void suanshuTest() {
    // 商和余
    int i = Integer.divideUnsigned(10, 5);
    int i1 = Integer.remainderUnsigned(10, 3);
    System.out.println("10/5：" + i);
    System.out.println("10%3:" + i1);

    //取 i 这个数的二进制形式最左边的最高一位且高位后面全部补零，最后返回int型的结果
    int i2 = Integer.highestOneBit(10);
    int i3 = Integer.highestOneBit(-19);
    System.out.println("i2: "+i2);
    System.out.println("i3: "+i3);
    //取 i 这个数的二进制形式最右边的第一个1全部补零，最后返回int型的结果
    int i4 = Integer.lowestOneBit(10);
    int i5 = Integer.lowestOneBit(0);
    System.out.println("i4: "+i4);
    System.out.println("i5: "+i5);

    //返回从左、右边算0连续的数量
    int i6 = Integer.numberOfLeadingZeros(2);
    int i7 = Integer.numberOfTrailingZeros(2);
    System.out.println("i6: "+i6);
    System.out.println("i7: "+i7);

    //返回这个数据的二进制串中“1”的总数量
    int i8 = Integer.bitCount(3);
    System.out.println("i8: "+i8);

    //和
    int sum = Integer.sum(10, 27);
    System.out.println("sum: "+sum);
}

输出结果：

10/5：2
10%3:1
i2: 8
i3: -2147483648
i4: 2
i5: 0
i6: 30
i7: 1
i8: 2
sum: 37

2.6循环位移

rotateLeft(int i, int distance)	i循环左移distance位
rotateRight(int i, int distance)	i循环右移distance位

示例：

public void roateTest(){
    System.out.println("10循环左移三位: "+Integer.rotateLeft(10, 3));
    System.out.println("10循环右移三位: "+Integer.rotateRight(10, 3));
}

输出结果：

10循环左移三位: 80
10循环右移三位: 1073741825

原理：10的二进制是0000 0000 0000 0000 0000 0000 0000 1010，

左移3位后为：0000 0000 0000 0000 0000 0000 0101 0000值为80

右移3位后为：0100 0000 0000 0000 0000 0000 0000 0001值为1073741825

2.7反转

reverse(int i)	最低位与最高位互换
reverseBytes(int i)	一四位字节互换，二三位字节互换

示例：

public void reverseTest(){
    int reverse = Integer.reverse(10);
    int i = Integer.reverseBytes(10);
    String s = Integer.toBinaryString(reverse);
    String s1 = Integer.toBinaryString(i);
    System.out.println("最低位与最高位互换: "+reverse);
    System.out.println("最低位与最高位互换后的二进制:            "+s);
    System.out.println("一四位字节互换，二三位字节互换: "+i);
    System.out.println("一四位字节互换，二三位字节互换后的二进制: "+s1);
}

输出结果：

最低位与最高位互换: 1342177280
最低位与最高位互换后的二进制:            0101 0000 0000 0000 0000 0000 0000 0000
一四位字节互换，二三位字节互换: 167772160
一四位字节互换，二三位字节互换后的二进制:  0000 1010 0000 0000 0000 0000 0000 0000

2.8判断正负

signum(int i)，判断i的正负，负数则返回-1，正数返回1，0返回0

public void signumTest(){
    System.out.println("10符号位： "+Integer.signum(10));
    System.out.println("-10符号位： "+Integer.signum(-10));
    System.out.println("0符号位： "+Integer.signum(0));
}

输出结果：

1
-1
0

2.9比较

compare(int x, int y)	x，y相等返回0，x<y返回-1,x>y返回1
compareUnsigned(int x, int y)	x为正y为负则返回-1，x为负y为正则返回1，同为负或者同为负，遵循compare规律
compareTo(Integer anotherInteger)	与另一个integer值比较，比anotherInteger大返回1，比anotherInteger小返回-1，相等返回0
equals(Object obj)	判断是否相等
max(int a, int b)	取a,b的二者较大的那个
min(int a, int b)	取a,b的二者较小的那个

示例：

public void bijiaoTest() {
    //compare
    Integer c=10;
    int compare = Integer.compare(10, 12);
    int compare1 = Integer.compare(10, 10);
    int compare2 = Integer.compare(12, 10);
    System.out.println("x<y： "+compare);
    System.out.println("x=y： "+compare1);
    System.out.println("x>y： "+compare2);
    int i = Integer.compareUnsigned(-12, 13);
    int i1 = Integer.compareUnsigned(-12, 10);
    int i2 = Integer.compareUnsigned(-12, 12);
    int i3 = Integer.compareUnsigned(-12, -12);
    int i4 = Integer.compareUnsigned(-12, -10);
    int i5 = Integer.compareUnsigned(-12, -13);
    System.out.println("负数绝对值小于正数： "+i);
    System.out.println("负数绝对值大于正数： "+i1);
    System.out.println("负数绝对值等于正数： "+i2);
    System.out.println("相等的两个负数： "+i3);
    System.out.println("x<y两个负数： "+i4);
    System.out.println("x>y两个负数： "+i5);

    int i6 = c.compareTo(11);
    int i7 = c.compareTo(9);
    int i8 = c.compareTo(10);
    System.out.println("compareTo同值相比： "+i8);
    System.out.println("compareTo与大值相比： "+i6);
    System.out.println("compareTo与小值相比： "+i7);

    //equals
    boolean equals = c.equals(10);

    //max and min
    int max = Integer.max(10, 12);
    int min = Integer.min(10, 12);
    System.out.println(max);
    System.out.println(min);
    System.out.println(equals);
}

输出结果：

x<y： -1
x=y： 0
x>y： 1
负数绝对值小于正数： 1
负数绝对值大于正数： 1
负数绝对值等于正数： 1
相等的两个负数： 0
x<y两个负数： -1
x>y两个负数： 1
compareTo同值相比： 0
compareTo与大值相比： -1
compareTo与小值相比： 1
12
10
true

3.Short

3.1四个常量

public  void changlaing(){
    System.out.println("Short最大值：" + Short.MAX_VALUE);
    System.out.println("Short最小值：" + Short.MIN_VALUE);
    System.out.println("Short字节数：" + Short.SIZE);
    System.out.println("Short类型：" + Short.TYPE);
}

Short最大值：32767
Short最小值：-32768
Short字节数：16
Short类型：short

3.2数据转换

3.2.1toString

将short转换位String

public  void toStringTest(){
    Short a=10;
    String s = a.toString();
    String s1 = Short.toString(a);
    System.out.println(s);
    System.out.println(s1);
}

输出结果：

10
10

3.2.2parseShort

parseShort(String s)	将十进制的String类型s转换为short类型
parseShort(String s, int radix)	将radix进制的String类型s转换为十进制后再short类型

示例：

public  void parseTest(){
    short i = Short.parseShort("10");
    short i1 = Short.parseShort("10", 8);
    System.out.println(i);
    System.out.println(i1);
}

输出结果：

10
8

3.2.3valueOf

valueOf(short s)	将short转换为Short
valueOf(String s)	将十进制的String类型s转换为Short类型
valueOf(String s, int radix)	将radix进制的String类型s转换为十进制后再转换为Short类型

示例：

public  void valueOfTest(){
    short a=10;
    Short aShort = Short.valueOf(a);
    Short aShort1 = Short.valueOf("10");
    Short aShort2 = Short.valueOf("10", 8);
    System.out.println(aShort);
    System.out.println(aShort1);
    System.out.println(aShort2);
}

输出结果：

10
10
8

3.2.4decode

将String类型转换为Short并可以识别进制

示例：

public void decodeTest(){
    Short decode = Short.decode("010");
    Short decode1 = Short.decode("0x10");
    Short decode2 = Short.decode("10");
    System.out.println(decode);
    System.out.println(decode1);
    System.out.println(decode2);
}

输出结果：

8
16
10

3.2.5value

intValue	将Short类型转换为int型
floatValue	将Short类型转换为float型
longValue	将Short类型转换为long型
doubleValue	将Short类型转换为double型
byteValue	将Short类型转换为byte型
shortValue	将Short类型转换为short型

示例：

public void valueTest() {
    Short a = 10;
    byte b = a.byteValue();
    double v = a.doubleValue();
    float v1 = a.floatValue();
    int i = a.intValue();
    long l = a.longValue();
    short i1 = a.shortValue();

    System.out.println(b);
    System.out.println(v);
    System.out.println(v1);
    System.out.println(i);
    System.out.println(l);
    System.out.println(i1);
}

输出结果：

3.3hashcode

Short的hashcode是其int类型对应的值

示例：

public void hashCodeTest() {
    Short a = 10;
    int i = a.hashCode();
    System.out.println(i);
}

输出结果：

3.4比较

compare(short x, short y)	返回x-y
compareTo(Short anotherShort)	返回和anotherShort的差
equals(Object obj)	判断是否相等

示例：

public void bijiaoTest() {
    //compare
    short a = 9;
    short b = 12;
    Short c = 10;
    int compare = Short.compare(a, b);
    int compare1 = Short.compare(b, a);
    int compare2 = Short.compare(a, a);
    System.out.println("x<y: " + compare);
    System.out.println("x>y: " +compare1);
    System.out.println("x=y: " +compare2);
    int i = c.compareTo(a);
    int i1 = c.compareTo(c);
    int i2 = c.compareTo(b);
    System.out.println("与小值比较: "+i);
    System.out.println("与等值比较: "+i1);
    System.out.println("与大值比较: "+i2);

    //equals
    boolean equals = c.equals(a);
    boolean equals1 = c.equals(b);
    System.out.println(equals);
    System.out.println(equals1);
}

输出结果：

x<y: -3
x>y: 3
x=y: 0
与小值比较: 1
与等值比较: 0
与大值比较: -2
false
false

3.5toUnsignedInt和toUnsignedLong

toUnsignedInt	将short转换为int类型，正数转换值不变，负数+65536（2的16次方）
toUnsignedLong	将short转换为long类型，正数转换值不变，负数+65536（2的16次方）

示例：

public void toUnsignedTest(){
    Short a=10;
    Short b=-10;
    int i = Short.toUnsignedInt(a);
    int i1 = Short.toUnsignedInt(b);
    long l = Short.toUnsignedLong(a);
    long l1 = Short.toUnsignedLong(b);
    System.out.println(i);
    System.out.println(i1);
    System.out.println(l);
    System.out.println(l1);
}

输出结果：

4.Long(Long和Integer的方法基本一样)

4.1常量

public void changlaing() {
    System.out.println("Long最大值：" + Long.MAX_VALUE);
    System.out.println("Long最小值：" + Long.MIN_VALUE);
    System.out.println("Long字节数：" + Long.SIZE);
    System.out.println("Long类型：" + Long.TYPE);
}

输出结果：

Long最大值：9223372036854775807
Long最小值：-9223372036854775808
Long字节数：64
Long类型：long

4.2数据转换

4.2.1toString

toString(long i)	将long型数据i转换为String类型
toString(long i, int radix)	将十进制long型数值i转换为radix进制数值，再转换为String型
toBinaryString(long i)	将十进制long型数值i转换为2进制数值，再转换为String型
toOctalString(long i)	将十进制long型数值i转换为8进制数值，再转换为String型
toHexString(long i)	将十进制long型数值i转换为16进制数值，再转换为String
toUnsignedString(long i, int radix)	将long型转换为无符号的String型，x为正数则String为对应的值，为负数，则为x+18446744073709551616，再将数值转换为radix进制数
toUnsignedString(long i)	将long型转换为无符号的String型，x为正数则String为对应的值，为负数，则为x+4294967296，因为其是调用上一个函数实现

示例：

public void toStringTest() {
    String s = Long.toString(10l);
    String s1 = Long.toString(10l, 8);
    System.out.println(s);
    System.out.println(s1);
    System.out.println();

    //转换进制并转为String
    String s2 = Long.toBinaryString(10l);
    String s3 = Long.toHexString(10l);
    String s4 = Long.toOctalString(10l);
    System.out.println("转换为2进制String：" + s2);
    System.out.println("转换为16进制String：" + s3);
    System.out.println("转换为8进制String：" + s4);
    System.out.println();

    //无符号转换
    String s5 = Long.toUnsignedString(-10l);
    String s6 = Long.toUnsignedString(10l);
    String s7 = Long.toUnsignedString(-10l, 8);
    String s8 = Long.toUnsignedString(10l, 8);

    System.out.println(s5);
    System.out.println(s6);
    System.out.println(s7);
    System.out.println(s8);
}

输出结果：

10
12

转换为2进制String：1010
转换为16进制String：a
转换为8进制String：12

18446744073709551606
10
1777777777777777777766
12

4.2.2parseInt

parseInt(String s)	将String变量s转换为long类型
parseInt(String s, int radix)	将String类型的radix进制数s转换成十进制long型
parseUnsignedInt(String s)	将String变量s转换为无符号long类型，如果s包含负号，则报异常：java.lang.NumberFormatException
parseUnsignedInt(String s, int radix)	将String类型的radix进制数s转换成无符号十进制long型如果s包含负号，则报异常：java.lang.NumberFormatException

示例：

public void parseTest() {
        long i = Long.parseLong("10");
        long i1 = Long.parseLong("10", 8);
        long i2 = Long.parseUnsignedLong("10");
//       long i3 = Long.parseUnsignedLong("-10");
        long i4 = Long.parseUnsignedLong("10", 8);
//        long i5 = Long.parseUnsignedLong("-10", 8);

        System.out.println(i);
        System.out.println(i1);
        System.out.println(i2);
//        System.out.println(i3);
        System.out.println(i4);
//        System.out.println(i5);
    }

输出结果：

4.2.3valueOf

valueOf(long i)	将long转换为Long对象
valueOf(String s)	将String转换为Long类型
valueOf(String s, int radix)	将String类型的radix进制数s转换为Long类型

示例：

public void valueOfTest() {
    long a = 10l;
    Long l = Long.valueOf(a);
    Long l1 = Long.valueOf("10");
    Long l2 = Long.valueOf("10", 8);

    System.out.println(l);
    System.out.println(l1);
    System.out.println(l2);
}

输出结果：

10
10
8

4.2.4value

intValue	将Long类型转换为int型
floatValue	将Long类型转换为float型
longValue	将Long类型转换为long型
doubleValue	将Long类型转换为double型
byteValue	将Long类型转换为byte型
shortValue	将Long类型转换为short型

示例：

 public void valueTest() {
        Long a = 12l;
        byte b = a.byteValue();
        double v = a.doubleValue();
        float v1 = a.floatValue();
        int i = a.intValue();
        long l = a.longValue();
        short i1 = a.shortValue();

        System.out.println(b);
        System.out.println(v);
        System.out.println(v1);
        System.out.println(i);
        System.out.println(l);
        System.out.println(i1);
    }

输出结果：

4.2.5decode

将String类型的值转换为Long类型，并且可以识别进制的写法

public void decodeTest() {
        Long decode = Long.decode("12");
        Long decode1 = Long.decode("010");
        Long decode2 = Long.decode("0x1a");

        System.out.println(decode);
        System.out.println(decode1);
        System.out.println(decode2);
    }

输出结果：

12
8
26

故在进行不同进制String转化Long的时候可以选择此方法

4.3hashCode

获取Long的hashCode，为他前32位和后32位异或得到

示例：

public void hashCodeTest() {
        Long a = 111111111111111111l;
        int i = a.hashCode();
        System.out.println(i);
    }

输出结果：

-2048209104

4.4getLong

获取系统变量的值

getLong(String nm)	获取名为nm的系统变量的值并转换为Long型，没有则返回null
getLong(String nm, long val)	获取名为nm的系统变量的值并调用decode(String nm)方法转换为Long型，没有则返回val的Long型
getLong(String nm, Long val)	获取名为nm的系统变量的值并decode(String nm)转换为Long型，没有则返回val

示例：

 public void getLongTest() {
        String b = "198";
        Long a = Long.getLong("a");
        Long b1 = Long.getLong(b);
        Long c1 = Long.getLong("c");
        System.out.println(b1);
        System.out.println(a);
        System.out.println(c1);

        Long e = 16l;
        Long a1 = Long.getLong("a", 13l);
        Long b2 = Long.getLong("b", e);
        System.out.println(a1);
        System.out.println(b2);
    }

输出结果：

null
10
null
10
16

a之所以有值是因为在vmoption里面设置了相应的参数：
在这里插入图片描述

4.5算数

divideUnsigned(long dividend, long divisor)	求dividend和divisor的商
remainderUnsigned(long dividend,long divisor)	求dividend和divisor的余数
highestOneBit(long i)	取 i 这个数的二进制形式最左边的最高一位且高位后面全部补零，最后返回int型的结果（若i为负整数，最高位1为符号位，返回值为-9223372036854775808）
lowestOneBit(long i)	取 i 这个数的二进制形式最右边的第一个1其余全部补零，最后返回long型的结果
numberOfLeadingZeros(long i)	返回这个数据的二进制串中从最左边算起连续的“0”的总数量
numberOfTrailingZeros(long i)	返回这个数据的二进制串中从最右边算起连续的“0”的总数量
bitCount(long i)	返回这个数据的二进制串中“1”的总数量
sum(long a, long b)	返回a+b

示例：

public void suanshuTest() {
        // 商和余
        long i = Long.divideUnsigned(10l, 5l);
        long i1 = Long.remainderUnsigned(10l, 3l);
        System.out.println("10/5：" + i);
        System.out.println("10%3:" + i1);

        //取 i 这个数的二进制形式最左边的最高一位且高位后面全部补零，最后返回int型的结果
        long i2 = Long.highestOneBit(10l);
        long i3 = Long.highestOneBit(-19l);
        System.out.println("i2: "+i2);
        System.out.println("i3: "+i3);
        //取 i 这个数的二进制形式最右边的第一个1全部补零，最后返回int型的结果
        long i4 = Long.lowestOneBit(10l);
        long i5 = Long.lowestOneBit(0l);
        System.out.println("i4: "+i4);
        System.out.println("i5: "+i5);

        //返回从左、右边算0连续的数量
        int i6 = Long.numberOfLeadingZeros(2l);
        int i7 = Long.numberOfTrailingZeros(2l);
        System.out.println("i6: "+i6);
        System.out.println("i7: "+i7);

        //返回这个数据的二进制串中“1”的总数量
        int i8 = Long.bitCount(3l);
        System.out.println("i8: "+i8);

        //和
        long sum = Long.sum(10l, 27l);
        System.out.println("sum: "+sum);
    }

输出结果：

10/5：2
10%3:1
i2: 8
i3: -9223372036854775808
i4: 2
i5: 0
i6: 62
i7: 1
i8: 2
sum: 37

4.6循环位移

rotateLeft(long i, int distance)	i循环左移distance位
rotateRight(long i, int distance)	i循环右移distance位

示例：

 public void roateTest(){
        System.out.println("10循环左移三位: "+Long.rotateLeft(8l, 3));
        System.out.println("10循环右移三位: "+Long.rotateRight(8l, 3));
    }

输出结果：

8循环左移三位: 64
8循环右移三位: 1

4.7反转

reverse(long i)	最低位与最高位互换
reverseBytes(long i)	1/8位字节互换，2/7位字节互换…

示例：

public void reverseTest(){
        long reverse = Long.reverse(10l);
        long i = Long.reverseBytes(10l);
        String s = Long.toBinaryString(reverse);
        String s1 = Long.toBinaryString(i);
        System.out.println("最低位与最高位互换: "+reverse);
        System.out.println("最低位与最高位互换后的二进制:            "+s);
        System.out.println("1/8位字节互换，2/7位字节互换...: "+i);
        System.out.println("1/8位字节互换，2/7位字节互换...: "+s1);
    }

输出结果：

最低位与最高位互换: 5764607523034234880
最低位与最高位互换后的二进制:            101000000000000000000000000000000000000000000000000000000000000
1/8位字节互换，2/7位字节互换...: 720575940379279360
1/8位字节互换，2/7位字节互换...: 101000000000000000000000000000000000000000000000000000000000

4.8判断正负

signum(long i)，判断i的正负，负数则返回-1，正数返回1，0返回0

public void signumTest(){
        System.out.println("10符号位： "+Long.signum(10l));
        System.out.println("-10符号位： "+Long.signum(-10l));
        System.out.println("0符号位： "+Long.signum(0l));
    }

输出结果：

10符号位： 1
-10符号位： -1
0符号位： 0

4.9比较

compare(long x, long y)	x，y相等返回0，x<y返回-1,x>y返回1
compareUnsigned(long x, long y)	x为正y为负则返回-1，x为负y为正则返回1，同为负或者同为负，遵循compare规律
compareTo(Long anotherLong)	与另一个Long值比较，比anotherLong大返回1，比anotherLong小返回-1，相等返回0
equals(Object obj)	判断是否相等
max(long a, long b)	取a,b的二者较大的那个
min(long a, long b)	取a,b的二者较小的那个

示例：

public void bijiaoTest() {
        //compare
        Long c=10l;
        int compare = Long.compare(10l, 12l);
        int compare1 = Long.compare(10l, 10l);
        int compare2 = Long.compare(12l, 10l);
        System.out.println("x<y： "+compare);
        System.out.println("x=y： "+compare1);
        System.out.println("x>y： "+compare2);
        int i = Long.compareUnsigned(-12l, 13l);
        int i1 = Long.compareUnsigned(-12l, 10l);
        int i2 = Long.compareUnsigned(-12l, 12l);
        int i3 = Long.compareUnsigned(-12l, -12l);
        int i4 = Long.compareUnsigned(-12l, -10l);
        int i5 = Long.compareUnsigned(-12l, -13l);
        System.out.println("负数绝对值小于正数： "+i);
        System.out.println("负数绝对值大于正数： "+i1);
        System.out.println("负数绝对值等于正数： "+i2);
        System.out.println("相等的两个负数： "+i3);
        System.out.println("x<y两个负数： "+i4);
        System.out.println("x>y两个负数： "+i5);

        int i6 = c.compareTo(11l);
        int i7 = c.compareTo(9l);
        int i8 = c.compareTo(10l);
        System.out.println("compareTo同值相比： "+i8);
        System.out.println("compareTo与大值相比： "+i6);
        System.out.println("compareTo与小值相比： "+i7);

        //equals
        boolean equals = c.equals(10l);

        //max and min
        long max = Long.max(10l, 12l);
        long min = Long.min(10l, 12l);

        System.out.println(max);
        System.out.println(min);
        System.out.println(equals);
    }

输出结果：

x<y： -1
x=y： 0
x>y： 1
负数绝对值小于正数： 1
负数绝对值大于正数： 1
负数绝对值等于正数： 1
相等的两个负数： 0
x<y两个负数： -1
x>y两个负数： 1
compareTo同值相比： 0
compareTo与大值相比： -1
compareTo与小值相比： 1
12
10
true

5.Double

5.1常量

public void changlaing() {
    System.out.println("Double最大值：" + Double.MAX_VALUE);
    System.out.println("Double最小值：" + Double.MIN_VALUE);
    System.out.println("Double字节数：" + Double.SIZE);
    System.out.println("Double类型：" + Double.TYPE);
    System.out.println(Double.NaN);
    System.out.println(Double.BYTES);
    System.out.println("正无穷大： "+Double.POSITIVE_INFINITY);
    System.out.println("负无穷大： "+Double.NEGATIVE_INFINITY);
}

输出结果：

Double最大值：1.7976931348623157E308
Double最小值：4.9E-324
Double字节数：64
Double类型：double
NaN
8
正无穷大： Infinity
负无穷大： -Infinity

5.2数据转换

5.2.1toString

toString(double i)	将double型数据i转换为String类型
toHexString(double i)	将十进制double型数值i转换为16进制数值，再转换为String，浮点数的表示形式

示例：

public void toStringTest(){
    double a=123.123456;
    String s = Double.toString(a);
    String s1 = Double.toHexString(a);
    String s2 = Double.toHexString(10);
    System.out.println(s);
    System.out.println(s1);
    System.out.println(s2);
}

输出结果：

123.123456
0x1.ec7e6b3fe9faep6
0x1.4p3

5.2.2valueOf

valueOf(double i)	将double转换为Double对象
valueOf(String s)	将String转换为Double类型

示例：

public void valueOfTest() {
    double a = 10;
    Double double1 = Double.valueOf(a);
    Double double2 = Double.valueOf("10");

    System.out.println(double1);
    System.out.println(double2);
}

输出结果：

10.0
10.0

5.2.3parseDouble

将String类型转换为double

示例：

public void parseTest() {
    double v = Double.parseDouble("10");
    System.out.println(v);
}

输出结果：

10.0

5.2.4value

intValue	将Double类型转换为int型
floatValue	将Double类型转换为float型
longValue	将Double类型转换为long型
doubleValue	将Double类型转换为double型
byteValue	将Double类型转换为byte型
shortValue	将Double类型转换为short型

示例：

public void valueTest() {
    Double a = 10.0;
    byte b = a.byteValue();
    double v = a.doubleValue();
    float v1 = a.floatValue();
    int i = a.intValue();
    long l = a.longValue();
    short i1 = a.shortValue();

    System.out.println(b);
    System.out.println(v);
    System.out.println(v1);
    System.out.println(i);
    System.out.println(l);
    System.out.println(i1);
}

输出结果：

5.2.5doubleToLongBits

该方法可以将double类型数据转换成long类型数据，从而可以使double类型数据按照long的方法判断，根据 IEEE 754 浮点双精bai度格式 (“double format”) 位布局，返回指定浮点值的表示形式。用不到

示例：

public void dtsTest(){
    long l = Double.doubleToLongBits(10.0);
    System.out.println(l);
}

输出结果：

4621819117588971520

5.3is判断

isFinite(double d)	判断d是否小于double的最大值
isInfinite(double v)	判断v是否为正无穷或者负无穷
isNaN(double v)	判断v是否为nan

示例：

public  void isTest(){
    boolean finite = Double.isFinite(10.0);
    boolean infinite = Double.isInfinite(10.0);
    boolean infinite1 = Double.isInfinite(Double.NEGATIVE_INFINITY);
    boolean naN1 = Double.isNaN(10.0);
    boolean naN = Double.isNaN(Double.NaN);
    System.out.println(finite);
    System.out.println("不是正负无穷： "+infinite);
    System.out.println("是正负无穷： "+infinite1);
    System.out.println("是nan： "+naN);
    System.out.println("不是nan： "+naN1);
}

输出结果：

true
不是正负无穷： false
是正负无穷： true
是nan： true
不是nan： false

5.4hashCode

获取Double的hashCode，调用doubleToLongBits方法，为他前32位和后32位异或得到

示例：

 public void hashCodeTest() {
        Double a = 10.0;
        int i = a.hashCode();
        System.out.println(i);
    }

输出结果：

1076101120

5.5比较

compare(double d1, double d2)	d1，d2相等返回0，d1<d2返回-1,d1>d2返回1
compareTo(Double anotherDouble)	与另一个Double值比较，比anotherDouble大返回1，比anotherDouble小返回-1，相等返回0
equals(Object obj)	判断是否相等
max(double a, double b)	取a,b的二者较大的那个
min(double a, double b)	取a,b的二者较小的那个

示例：

public void bijiaoTest() {
        //compare
        Double c=10.0;
        int compare = Double.compare(10, 12);
        int compare1 = Double.compare(10, 10);
        int compare2 = Double.compare(12, 10);
        System.out.println("x<y： "+compare);
        System.out.println("x=y： "+compare1);
        System.out.println("x>y： "+compare2);


        int i6 = c.compareTo(11.0);
        int i7 = c.compareTo(9.0);
        int i8 = c.compareTo(10.0);
        System.out.println("compareTo同值相比： "+i8);
        System.out.println("compareTo与大值相比： "+i6);
        System.out.println("compareTo与小值相比： "+i7);

        //equals
        boolean equals = c.equals(10.0);

        //max and min
        double max = Double.max(10.0, 12.0);
        double min = Double.min(10.0, 12.0);
        System.out.println(max);
        System.out.println(min);
        System.out.println(equals);
    }

输出结果：

x<y： -1
x=y： 0
x>y： 1
compareTo同值相比： 0
compareTo与大值相比： -1
compareTo与小值相比： 1
12.0
10.0
true

6.Float(与Double的方法基本一样)

6.1常量

public void changlaing() {
        System.out.println("Float最大值：" + Float.MAX_VALUE);
        System.out.println("Float最小值：" + Float.MIN_VALUE);
        System.out.println("Float字节数：" + Float.SIZE);
        System.out.println("Float类型：" + Float.TYPE);
        System.out.println(Float.NaN);
        System.out.println(Float.BYTES);
        System.out.println("正无穷大： " + Float.POSITIVE_INFINITY);
        System.out.println("负无穷大： " + Float.NEGATIVE_INFINITY);
    }

输出结果：

Float最大值：3.4028235E38
Float最小值：1.4E-45
Float字节数：32
Float类型：float
NaN
4
正无穷大： Infinity
负无穷大： -Infinity

6.2数据转换

6.2.1toString

toString(float f)	将float型数据i转换为String类型
toHexString(float f)	将十进制float型数值i转换为16进制数值，再转换为String，以浮点数形式

示例：

public void toStringTest() {
        float a = 10f;
        String s = Float.toString(a);
        String s1 = Float.toHexString(a);
        System.out.println(s);
        System.out.println(s1);
    }

输出结果：

10.0
0x1.4p3

6.2.2valueOf

valueOf(float f)	将float转换为Float对象
valueOf(String s)	将String转换为Float类型

示例：

public void valueOfTest() {
        float a = 10f;
        Float Float1 = Float.valueOf(a);
        Float Float2 = Float.valueOf("10");

        System.out.println(Float1);
        System.out.println(Float2);
    }

输出结果：

10.0
10.0

6.2.3parseFloat

将String类型转换为double

示例：

public void parseTest() {
        Float v = Float.parseFloat("10");
        System.out.println(v);
    }

输出结果：

10.0

5.2.4value

intValue	将Flaot类型转换为int型
floatValue	将Flaot类型转换为float型
longValue	将Flaot类型转换为long型
doubleValue	将Flaot类型转换为double型
byteValue	将Flaot类型转换为byte型
shortValue	将Flaot类型转换为short型

示例：

public void valueTest() {
        Float a = 10f;
        byte b = a.byteValue();
        double v = a.doubleValue();
        float v1 = a.floatValue();
        int i = a.intValue();
        long l = a.longValue();
        short i1 = a.shortValue();

        System.out.println(b);
        System.out.println(v);
        System.out.println(v1);
        System.out.println(i);
        System.out.println(l);
        System.out.println(i1);
    }

输出结果：

6.2.5floatToIntBits

该方法可以将float类型数据转换成int类型数据，返回指定浮点值的表示形式。用不到

示例：

public void dtsTest() {
        long l = Float.floatToIntBits(10f);
        System.out.println(l);
    }

输出结果：

1092616192

5.3is判断

isFinite(float d)	判断d是否小于float的最大值
isInfinite(float v)	判断v是否为正无穷或者负无穷
isNaN(float v)	判断v是否为nan

示例：

public void isTest() {
        boolean finite = Float.isFinite(10f);
        boolean infinite = Float.isInfinite(10f);
        boolean infinite1 = Float.isInfinite(Float.NEGATIVE_INFINITY);
        boolean naN1 = Float.isNaN(10f);
        boolean naN = Float.isNaN(Float.NaN);
        System.out.println(finite);
        System.out.println("不是正负无穷： " + infinite);
        System.out.println("是正负无穷： " + infinite1);
        System.out.println("是nan： " + naN);
        System.out.println("不是nan： " + naN1);
    }

输出结果：

true
不是正负无穷： false
是正负无穷： true
是nan： true
不是nan： false

5.4hashCode

获取float的hashCode，调用floatToIntBits方法，为他前32位和后32位异或得到

示例：

 public void hashCodeTest() {
        Double a = 10.0;
        int i = a.hashCode();
        System.out.println(i);
    }

输出结果：

1076101120

5.5比较

compare(floatd 1, floatd 2)	d1，d2相等返回0，d1<d2返回-1,d1>d2返回1
compareTo(Float anotherFloat)	与另一个Float值比较，比anotherFloat大返回1，比anotherFloat小返回-1，相等返回0
equals(Object obj)	判断是否相等
max(floatd a, floatd b)	取a,b的二者较大的那个
min(floatd a, floatd b)	取a,b的二者较小的那个

示例：

public void bijiaoTest() {
        //compare
        Float c = 10f;
        int compare = Float.compare(10, 12);
        int compare1 = Float.compare(10, 10);
        int compare2 = Float.compare(12, 10);
        System.out.println("x<y： " + compare);
        System.out.println("x=y： " + compare1);
        System.out.println("x>y： " + compare2);

        int i6 = c.compareTo(11f);
        int i7 = c.compareTo(9f);
        int i8 = c.compareTo(10f);
        System.out.println("compareTo同值相比： " + i8);
        System.out.println("compareTo与大值相比： " + i6);
        System.out.println("compareTo与小值相比： " + i7);

        //equals
        boolean equals = c.equals(10f);

        //max and min
        Float max = Float.max(10f, 12f);
        Float min = Float.min(10f, 12f);
        System.out.println(max);
        System.out.println(min);
        System.out.println(equals);
    }

输出结果：

x<y： -1
x=y： 0
x>y： 1
compareTo同值相比： 0
compareTo与大值相比： -1
compareTo与小值相比： 1
12.0
10.0
true

7.Boolean

7.1常量

public void cahnglaing(){
    System.out.println("错误："+Boolean.FALSE);
    System.out.println("正确："+Boolean.TRUE);
    System.out.println("类型："+Boolean.TYPE);
}

输出结果：

错误：false
正确：true
类型：boolean

7.2数据转换

7.2.1parseBoolean

将String转换为boolean，只有字符串为true时才返回boolean类型true，其余皆是false

示例：

public void parseTest(){
    boolean aTrue = Boolean.parseBoolean("true");
    boolean b = Boolean.parseBoolean("");
    boolean fsa = Boolean.parseBoolean("fsa");
    System.out.println("true转换为boolean： "+aTrue);
    System.out.println("空转换为boolean： "+b);
    System.out.println("任意字符串转换为boolean： "+fsa);
}

输出结果：

true转换为boolean： true
空转换为boolean： false
任意字符串转换为boolean： false

7.2.2booleanValue

将Boolean转换为boolean

示例:

public void valueTest(){
    Boolean b=true;
    boolean b1 = b.booleanValue();
    System.out.println(b1);
}

输出结果：

true

7.2.3valueOf

valueOf(boolea i)	将boolean转换为Boolean对象
valueOf(String s)	将String转换为Boolean类型

示例：

public void valueOfTest(){
    boolean a=true;
    //调用parseBoolean方法，结论与其一样
    Boolean aTrue = Boolean.valueOf("true");
    Boolean aBoolean = Boolean.valueOf(a);
    System.out.println(aTrue);
    System.out.println(aBoolean);
}

输出结果：

true
true

7.2.4toString

将boolean类型转换为String

示例：

public void btsTest(){
    String s = Boolean.toString(true);
    String s1 = Boolean.toString(false);
    System.out.println(s);
    System.out.println(s1);

}

输出结果：

true
false

7.3hashcode

获得true或者false的hash值

示例：

public void hashCodeTest() {
    int i = Boolean.hashCode(true);
    int i1 = Boolean.hashCode(false);
    System.out.println("true的hashcode： "+i);
    System.out.println("false的hashcode： "+i1);
}

输出结果：

true的hashcode： 1231
false的hashcode： 1237

7.4比较

compare(boolean x, boolean y)	true和false比较： 1 true和true比较： 0 false和false比较： 0 false和true比较： -1
compareTo(Boolean anotherBoolean）	true和false比较： 1 true和true比较： 0 false和false比较： 0 false和true比较： -1
equals(Object obj)	不是Boolean返回false，是Boolean则判断是否相等

示例：

public void bijaoTest(){
    int compare = Boolean.compare(true, false);
    int compare1 = Boolean.compare(true, true);
    int compare2 = Boolean.compare(false, false);
    int compare3 = Boolean.compare(false, true);
    System.out.println("true和false比较： "+compare);
    System.out.println("true和true比较： "+compare1);
    System.out.println("false和false比较： "+compare2);
    System.out.println("false和true比较： "+compare3);

    Boolean a=true;
    Boolean b=false;
    int i = a.compareTo(false);
    int i1 = a.compareTo(true);
    int i2 = b.compareTo(false);
    int i3 = b.compareTo(a);
    System.out.println("true和false比较： "+i);
    System.out.println("true和true比较： "+i1);
    System.out.println("false和false比较： "+i2);
    System.out.println("false和true比较： "+i3);

    boolean equals = a.equals("true");
    boolean equals1 = a.equals(true);
    System.out.println(equals);
    System.out.println(equals1);
}

输出结果：

true和false比较： 1
true和true比较： 0
false和false比较： 0
false和true比较： -1
true和false比较： 1
true和true比较： 0
false和false比较： 0
false和true比较： -1
false
true

7.5getBoolean

获取系统变量

系统变量存在且为true或者false则返回相应的值，存在但为任意字符串或者不存在，则返回false

示例：

public void getBooleanTest(){
    boolean a = Boolean.getBoolean("a");
    boolean b = Boolean.getBoolean("b");
    boolean fs = Boolean.getBoolean("fs");
    System.out.println("系统变量为true： "+a);
    System.out.println("系统变量为任意字符串： "+b);
    System.out.println("系统变量不存在： "+fs);
}

输出结果：

系统变量为true： true
系统变量为任意字符串： false
系统变量不存在： false

7.6运算

logicalAnd(boolean a, boolean b)	返回a和b的&&值
logicalOr(boolean a, boolean b)	返回a和b的\|\|值
logicalXor(boolean a, boolean b)	返回a和b的^值

示例：

public void yunsuanTest(){
    //&&
    boolean b = Boolean.logicalAnd(true, false);
    boolean b1 = Boolean.logicalAnd(false, false);
    boolean b2 = Boolean.logicalAnd(true, true);
    System.out.println("true和false&&： "+b);
    System.out.println("false和false&&： "+b1);
    System.out.println("true和true&&： "+b2);
    //||
    boolean b3 = Boolean.logicalOr(true, false);
    boolean b4 = Boolean.logicalOr(true, true);
    boolean b5 = Boolean.logicalOr(false, false);
    System.out.println("true和false||： "+b3);
    System.out.println("true和true||： "+b4);
    System.out.println("false和false||： "+b5);
    //^
    boolean b6 = Boolean.logicalXor(true, true);
    boolean b7 = Boolean.logicalXor(true, false);
    boolean b8 = Boolean.logicalXor(false, false);
    System.out.println("true和true^： "+b6);
    System.out.println("true和false^： "+b7);
    System.out.println("false和false^： "+b8);

}

输出结果：

true和false&&： false
false和false&&： false
true和true&&： true
true和false||： true
true和true||： true
false和false||： false
true和true^： false
true和false^： true
false和false^： false

8.Character

8.1常量

Character类里设置了大量的常量用以表示特殊字符，基本用不到，常见的为以下几个：

public void changlaing() {
    System.out.println("Character最大值：" + Character.MAX_VALUE);
    System.out.println("Character最小值：" + Character.MIN_VALUE);
    System.out.println("Character字节数：" + Character.SIZE);
    System.out.println("Character类型：" + Character.TYPE);
    System.out.println("Character最大基数：" + Character.MAX_RADIX);
    System.out.println("Character最小基数：" + Character.MIN_RADIX);
}

输出结果：

Character最大值：
Character最小值： 
Character字节数：16
Character类型：char
Character最大基数：36
Character最小基数：2

8.2数据转换

8.2.1toString

Character转换为String

public void ctsTest(){
    Character c='a';
    String a = Character.toString('a');
    String s = c.toString();
    System.out.println(a);
    System.out.println(s);
}

输出结果：

a
a

8.2.2valueOf

将char转换为Character

public void valueOfTest(){
    Character c = Character.valueOf('c');
    System.out.println(c);
}

输出结果：

8.2.3charValue

将Character转换为char

public void charValueTest(){
    Character c = 'c';
    char c1 = c.charValue();
    System.out.println(c1);
}

输出结果：

8.2.5大小写转换

toLowerCase(char ch)	ch转换为小写
toUpperCase(char ch)	ch转换为大写

示例：

public void lowUppTest(){
    char a = Character.toLowerCase('A');
    char a1 = Character.toUpperCase('a');
    System.out.println("A转换为小写： "+a);
    System.out.println("a转换为大写： "+a1);
}

输出结果：

A转换为小写： a
a转换为大写： A

8.3判断

代码点：代码点&代码单元，是从Unicode标准而来的术语，Unicode标准的核心是一个编码字符集，
它为每一个字符分配一个唯一数字。Unicode标准始终使用16进制数字，并且在书写时在前面加上U+，
如字符“A”的编码为“U+0041”。
代码点是指可用于编码字符集的数字。编码字符集定义一个有效的代码点范围，
但是并不一定将字符分配给所有这些代码点。有效的Unicode代码点范围是U+0000至U+10FFFF。
Unicode4.0将字符分配给一百多万个代码点中的96382个代码点。

isValidCodePoint(int codePoint)	判断codePoint是否是一个有效代码点
isBmpCodePoint(int codePoint)	codePoint是否在基本多文种平面这个区段
isSupplementaryCodePoint(int codePoint)	codePoint是否在增补字符范围内
isHighSurrogate(char ch)	确定给出的 `char` 值是否为一个高代理项代码单元（也称为前导代理项代码单元）
isLowSurrogate(char ch)	给定的char值是否为Unicode low-surrogate代码单元
isSurrogate(char ch)	给定的char值是否是Unicode 代理代码单元

Character中有多种涉及到unicode的方法，暂且不表，有兴趣可自查

常用判断：

isLowerCase(char ch)	判断字符是否为小写字母
isUpperCase(char ch)	判断字符是否为大写字母
isDigit(char ch)	判断字符是否为数字
isLetter(char ch)	判断字符是否为字母
isLetterOrDigit(char ch)	判断字符是否为字母或者数字
isSpaceChar(char ch)	判断字符是否为空格
isWhitespace(char ch)	判断字符是否为空格

方法isSpaceChar(char)仅用于检查unicode空格字符，而方法isWhiteSpace(char)用于空格以及其他空格字符,如制表符,回车符等

示例：

public void pandaunTest(){
    //小写
    boolean a = Character.isLowerCase('A');
    boolean a1 = Character.isLowerCase('a');
    System.out.println("A是否为小写： "+a);
    System.out.println("a是否为小写： "+a1);

    //大写
    boolean a2 = Character.isUpperCase('A');
    boolean a3 = Character.isUpperCase('a');
    System.out.println("A是否为大写： "+a2);
    System.out.println("a是否为大写： "+a3);

    //数字
    boolean digit = Character.isDigit('2');
    boolean digit1 = Character.isDigit('a');
    System.out.println("2是否为数字： "+digit);
    System.out.println("a是否为数字： "+digit1);

    //字母
    boolean a4 = Character.isLetter('a');
    boolean a5 = Character.isLetter('A');
    boolean a6 = Character.isLetter('8');
    boolean a7 = Character.isLetter('#');
    System.out.println("a是字母： "+a4);
    System.out.println("A是字母： "+a5);
    System.out.println("8是字母： "+a6);
    System.out.println("#是字母： "+a7);

    //字母或数字
    boolean a8 = Character.isLetterOrDigit('#');
    boolean a9 = Character.isLetterOrDigit('a');
    boolean a10 = Character.isLetterOrDigit('8');
    System.out.println("#是字母或数字： "+a8);
    System.out.println("a是字母或数字： "+a9);
    System.out.println("8是字母或数字： "+a10);
    
    //空格
    boolean spaceChar = Character.isSpaceChar(' ');
    boolean whitespace = Character.isWhitespace(' ');
    System.out.println(spaceChar);
    System.out.println(whitespace);
}

输出结果：

A是否为小写： false
a是否为小写： true
A是否为大写： true
a是否为大写： false
2是否为数字： true
a是否为数字： false
a是字母： true
A是字母： true
8是字母： false
#是字母： false
#是字母或数字： false
a是字母或数字： true
8是字母或数字： true
true
true

8.4比较

equals(Object obj)	判断是否相等
compareTo(Character anotherCharacter)	返回thisCharacter-anotherCharacter
compare(char x, char y)	返回x-y

示例：

public void bijiaoTest(){
    Character c='a';
    boolean b = c.equals('b');
    boolean a = c.equals('a');
    int a1 = c.compareTo('a');
    int a2 = c.compareTo('e');
    int compare = Character.compare('a', 'd');
    int compare1 = Character.compare('a', 'a');
    System.out.println(a);
    System.out.println(b);
    System.out.println(a1);
    System.out.println(a2);
    System.out.println(compare);
    System.out.println(compare1);
}

输出结果：

true
false
0
-4
-3
0

8.5hashcode

获取字符的hash值，为其对应的码值

public void hashcodeTest(){
    Character c = 'c';
    int i = c.hashCode();
    System.out.println(i);
}

输出结果：

dianhundeng

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
基本数据类型及其封装类的常用方法

基本数据类型及其封装类的常用方法1.Byte1.1四个常量//byte类型的最小值System.out.println("最小值MIN_VALUE:"+Byte.MIN_VALUE);//byte类型的最大值System.out.println("最大值MAX_VALUE:"+Byte.MAX_VALUE);//byte的类型System.out.println("类型Type:"+Byte.TYPE);//byte类型的字节大小System.out.println("位数size:"+
复制链接

扫一扫