dianhundeng

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

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，xy返回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+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+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);
}

输出结果：

xy： 1
负数绝对值小于正数： 1
负数绝对值大于正数： 1
负数绝对值等于正数： 1
相等的两个负数： 0
xy两个负数： 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 + 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);
}

输出结果：

xy: 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，xy返回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+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+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);
    }

输出结果：

xy： 1
负数绝对值小于正数： 1
负数绝对值大于正数： 1
负数绝对值等于正数： 1
相等的两个负数： 0
xy两个负数： 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，d1d2返回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+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);
    }

输出结果：

xy： 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，d1d2返回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 + 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);
    }

输出结果：

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

输出结果：

你可能感兴趣的:(java)

打包springcloud微服务时，终端执行java -jar报错，没有主清单属性 ZL_do_it jar java maven
打包springcloud微服务时，终端执行java-jar报错，没有主清单属性使用SpringBoot微服务搭建框架，在eclipse和Idea下能正常运行，但是在打成jar包部署或者直接使用java-jar命令的时候，提示了xxxxxx.jar中没有主清单属性：C:\Users\zl\.m2\repository\com\kkb\eureka-server\1.0-SNAPSHOT>java-
Python之JSON数据结构 CL.LIANG python基础 python json 数据结构
JSON数据结构介绍JSON（JavaScriptObjectNotation）优势：1.易于阅读和编写JSON的结构直观、简单，类似于键值对的形式，易于人类阅读和编写。与XML等数据格式相比，JSON的语法更简洁，没有复杂的标记符号。2.轻量化JSON格式相比其他数据格式（如XML），更简洁，没有多余的标记，数据体积较小，这使得数据传输更加高效，尤其是在网络应用中。3.与JavaScript天然
java.math 包中的 BigInteger 类（详细案例拆解）励志去大厂的菜鸟 Java思想和方法 Java学习白话拆解Java 开发语言 java 学习方法
前言：小编打算近期更俩三期类的专栏，一些常用的专集类，给大家分好类别总结和详细的代码举例解释。今天是第四个java.lang.Math包中的BigInteger类我们一直都是以这样的形式，让新手小白轻松理解复杂晦涩的概念，把Java代码拆解的清清楚楚，每一步都知道他是怎么来的，为什么用这串代码关键字，对比同类型的代码，让大家真正看完以后融会贯通，举一反三，实践应用！！！！①官方定义和大白话拆解对比
华为OD机试E卷 --连续字母长度--24年OD统一考试（Java & JS & Python & C & C++）飞码创造者最新华为OD机试题库2024 java python 华为od javascript c语言
文章目录题目描述输入描述输出描述用例题目解析JS算法源码Java算法源码python算法源码c算法源码c++算法源码题目描述给定一个字符串，只包含大写字母，求在包含同一字母的子串中，长度第k长的子串的长度，相同字母只取最长的那个子串。输入描述第一行有一个子串(1<长度<=100)，只包含大写字母。第二行为k的值输出描述输出连续出现次数第k多的字母的次数。用例输入AAAAHHHBBCDHHHH3输出
springboot接入deepseek深度求索 java 笑发财了1 java spring boot 服务器
以下是在springboot中接入aideepseek的过程。官网并没有java的示例。1.创建APIkeydeepseekAPIkeys点击创建APIkey，把创建的key值复制下来，以后就不能再查看了，只能重新创建。2.封装询问deepseek的工具方法添加key值和询问路径。API_KEY为你创建的key值。privatestaticfinalStringAPI_URL="https://a
java版在线评标竞标邀标评审专家招标公告发布招投标系统源码 m0_72864708 java
功能描述1、门户管理：所有用户可在门户页面查看所有的公告信息及相关的通知信息。主要板块包含：招标公告、非招标公告、系统通知、政策法规。2、立项管理：企业用户可对需要采购的项目进行立项申请，并提交审批，查看所有的立项信息。主要功能包含：招标立项申请、非招标立项申请、采购立项管理。3、采购项目管理：可对项目采购过程全流程管理，包含功能有：评审人员的选取/抽取、基准价维护、供应商缴费审核、投标过程记录查
Java程序设计（二十四）：基于SSM框架的基于的快递代取系统的设计与实现人工智能_SYBH 2025年java程序设计 java python 开发语言 spring boot spring 后端
引言随着电子商务的发展，越来越多的高校学生通过网购获取日常所需物品，快递服务也逐渐成为大学生活中不可或缺的一部分。然而，繁忙的学习与生活让部分学生无法及时领取自己的快递，因此基于高校校园的快递代取服务应运而生。本文将详细介绍如何基于SSM（Spring、SpringMVC、MyBatis）技术栈设计并实现一个高校快递代取系统，解决高校学生快递代取问题。通过该系统，管理员、代取人和发布者三类用户可以
【AI+可视化工具】实现流程图快速生成 Unity青子问题解决（软件疑难杂症）深度学习 Mermaid
代码绘制流程图的工具有很多，以下是一些常用的工具：Mermaid：Mermaid是一个基于Markdown的图表语言，可以生成各种类型的图表，包括流程图、时序图、甘特图等。Mermaid可以使用JavaScript或TypeScript进行编写，可以通过Node.js运行。Graphviz：Graphviz是一个开源的图形可视化工具，可以生成各种类型的图表，包括流程图、时序图、网络拓扑图等。Gra
【自动化】使用PlayWright+代理IP实现多环境隔离青塬科技 Python
Playwright是由微软公司2020年初发布的新一代自动化测试工具，相较于目前最常用的Selenium，它仅用一个API即可自动执行Chromium、Firefox、WebKit等主流浏览器自动化操作。对各种开发语言也有非常好的支持。常用的NodeJs、Java、python都有支持，且有丰富的文档参考。Python环境下的安装使用1、安装依赖库pipinstallplaywright2、安装
【Java】常用工具类方法：树形结构、获取IP、对象拷贝、File相关、雪花算法等 PlanOne_A java 算法
1、生成子孙树/***生成子孙树**@paramdataArray遍历所有数据,每个数据加到其父节点下*@return子孙树json*/publicstaticJSONArraymakeTree(JSONArraydataArray){List>data=newArrayListmap=newHashMap>res=newArrayList>map=newHashMapvo:data){map.p
【Java】SpringBoot 全局异常捕获不到Filter中的异常的解决办法 PlanOne_A Java java spring boot spring
情景：当我想用一个过滤器（filter）来对所有请求进行jwt校验，当校验不通过时我想抛出异常，然后再通过@ExceptionHandler来全局捕获该异常，发现SpringBoot全局异常捕获不了filter中抛出的异常原因：因为filter是JavaWeb提供的技术，是在所有请求之前，spring是捕获不到filter抛出的异常的；解决：要想SpringBoot全局异常捕获到该filter抛出
java 阿里云上传文件到OSS，并返回文件路径凱凱啊 java 上传 java 阿里云
pom.xml依赖：com.aliyun.ossaliyun-sdk-oss3.12.0com.aliyunoss-client3.0.2上代码：/***图片上传*/@PostMapping("/imageUpload")@ApiOperation(value="图片上传")@ApiImplicitParams({@ApiImplicitParam(name="imageFile",value="
selenium自动化测试01 Meng XY selenium自动化测试 selenium 自动化测试工具
前言新人一个，打算写写博客，去记录个人的学习历程。花了一周的时间去学习了selenium自动化，然后记录下来，一些语法、代码之类的。文笔不是很好，一些代码标注、注释可能不是很准确，望见谅。selenium自动化测试呢我用的是Java+maven，工具是IDEA。我在学习自动化的时候用的是eclipse，我习惯用IDEA，看个人喜好了。（要有Java编程基础，Java的话可能会在后续上线，还没写）介
web开发工具之：一、UUID的介绍，java如何产生UUID，作为数据库的主键和加密算法的盐 java冯坚持 web开发 java 数据库
文章目录前言一、UUID是什么二、java如何产生UUID1.生成随机UUID（Version4）2.通过指定的字符串生成UUID三、UUID作为数据库主键1.优点2.缺点四、UUID作为加密的盐总结前言现在web开发中，很多使用UUID作为主键和加密的盐的，其实很简单，这里学习和介绍一下。一、UUID是什么UUID（UniversallyUniqueIdentifier，通用唯一标识符）是一种1
web开发工具之：二、加密和解密工具类，学习加密算法和非加密算法（哈希算法）知识，Java支持MD5和SHA系列的哈希算法。使用UUID作为盐进行增强哈希算法加密的数据完整性验证 java冯坚持 web开发前端学习哈希算法
文章目录前言一、加密算法/非加密算法-了解和学习为主1、加密算法和秘钥a、介绍b、常用加密算法-对称加密算法c、常用加密算法-对称加密算法2、非加密算法：哈希算法（MD5、SHA系列）a、哈希算法介绍b、MD5和SHA系列介绍二、哈希算法应用场景概念介绍1.数据完整性验证2.密码存储（借助数据完整性验证来进行密码存储）3.数字签名4.总结三、注册和登录-采用哈希算法进行密码存储和验证流程1.加密过
PAT乙级真题 — 1064 朋友数(java) 黄昏岭算法
如果两个整数各位数字的和是一样的，则被称为是“朋友数”，而那个公共的和就是它们的“朋友证号”。例如123和51就是朋友数，因为1+2+3=5+1=6，而6就是它们的朋友证号。给定一些整数，要求你统计一下它们中有多少个不同的朋友证号。输入格式：输入第一行给出正整数N。随后一行给出N个正整数，数字间以空格分隔。题目保证所有数字小于104。输出格式：首先第一行输出给定数字中不同的朋友证号的个数；随后一行
【Java】阿里云OSS上传、删除文件 PlanOne_A java 阿里云数据库
阿里云OSS上传、删除文件编写AliOssConfig：importlombok.Data;/***DESC:*VERSION:1.0.0*/@DatapublicclassAliOssConfig{privateStringendpoint;privateStringaccessKey;privateStringaccessSecret;privateStringbucket;privateSt
华为OD机试E卷 --分苹果 --24年OD统一考试（Java & JS & Python & C & C++）飞码创造者最新华为OD机试题库2024 华为od java javascript python js c语言
文章目录题目描述输入描述输出描述用例题目解析JS算法源码Java算法源码python算法源码c算法源码c++算法源码题目描述A、B两个人把苹果分为两堆，A希望按照他的计算规则等分苹果，他的计算规则是按照二进制加法计算，并且不计算进位12+5=9(1100+0101=9)，B的计算规则是十进制加法，包括正常进位，B希望在满足A的情况下获取苹果重量最多。输入苹果的数量和每个苹果重量，输出满足A的情况下
OpenAI模块重构 S-X-S 重构开发语言 openai
文章目录1.common-openai-starter1.目录结构2.OpenAiProperties.java新增apiUrl3.OpenAIAutoConfiguration.java4.OpenAiClient.java使用gson重构2.common-openai-starter-demo1.目录结构2.application.yml新增api-url3.OpenAiController.
Liferay 前世今生 leisurelyZ Liferay Portal 开源项目 java paas 低代码
从今天开始，我会开辟一个新的专栏，主攻Liferay这个开源框架。Liferay是一款基于Java技术栈的开源企业级门户解决方案，它被广泛应用于构建企业门户、内容管理系统、协作平台、社交网络、以及其他多种Web应用。Liferay提供了一个统一的平台，可以整合企业内部的各种应用、数据和内容，帮助组织提升运营效率、增强团队协作和改善客户体验。本文将详细介绍Liferay的基本概念、用途、官方资源、以
基于JAVA软件技术课程学习系统设计与实现计算机毕业设计源码+数据库+lw文档+系统+部署小朱科技学习
基于JAVA软件技术课程学习系统设计与实现计算机毕业设计源码+数据库+lw文档+系统+部署基于JAVA软件技术课程学习系统设计与实现计算机毕业设计源码+数据库+lw文档+系统+部署本源码技术栈：项目架构：B/S架构开发语言：Java语言开发软件：ideaeclipse前端技术：Layui、HTML、CSS、JS、JQuery等技术后端技术：JAVA运行环境：Win10、JDK1.8数据库：MySQ
【Vue】Part4 接口调用福安德信息科技 WEB开发 vue.js okhttp 前端
接口调用方式原生ajax基于jQuery的ajaxfetchaxios异步JavaScript的执行环境是「单线程」所谓单线程，是指JS引擎中负责解释和执行JavaScript代码的线程只有一个，也就是一次只能完成一项任务，这个任务执行完后才能执行下一个，它会「阻塞」其他任务。这个任务可称为主线程异步模式可以一起执行多个任务JS中常见的异步调用定时任何ajax事件函数promise主要解决异步深层
java计算机毕业设计-学生宿舍故障报修管理信息系统-源码+数据库+系统+lw文档+mybatis+运行部署雪夜科技 mybatis java 数据库
java计算机毕业设计-学生宿舍故障报修管理信息系统-源码+数据库+系统+lw文档+mybatis+运行部署java计算机毕业设计-学生宿舍故障报修管理信息系统-源码+数据库+系统+lw文档+mybatis+运行部署本源码技术栈：项目架构：B/S架构开发语言：Java语言开发软件：ideaeclipse前端技术：Layui、HTML、CSS、JS、JQuery等技术后端技术：JAVA运行环境：Wi
MarsCode青训营打卡Day11（2025年1月24日）|稀土掘金-373.字母出现次数的统计 Aqua Cheng. MarsCode青训营 java 算法数据结构
资源引用：373.字母出现次数的统计今日小记：感冒生病，多休息。稀土掘金-373.字母出现次数的统计（373.字母出现次数的统计）题目分析：给定一个由小写字母组成的字符串s，请找出有多少个小写字母在字符串中至少出现了k次。解题思路：显然，遍历s，用Map记录每个小写字母及其出现次数，最终遍历该Map，找出value大于等于k的键值对的数量。importjava.util.Map;importjav
探索Java中的JToggleButton组 2501_90323865 java python 开发语言个人开发
在Java编程中，JToggleButton是一个非常实用的组件，它可以被用来创建类似单选按钮的功能，同时又保留了按钮的外观和行为。通过将多个JToggleButton组合到一个ButtonGroup中，我们可以实现单选逻辑，即一次只能选择一个按钮。本文将通过一个简单的实例，展示如何使用JToggleButton组来实现类似单选按钮的功能。一、实例代码以下是一个完整的代码示例，展示如何使用JTog
vite webpack原理和区别
Vite和Webpack的工作原理有显著的不同，以下是对它们各自原理的简要说明：Vite原理原生ES模块：Vite利用浏览器对原生ES模块（ESM）的支持，实现按需加载和编译。开发服务器启动时，Vite只需解析入口文件，并将导入的模块路径记录下来。按需编译：当浏览器请求某个模块时，Vite会实时编译该模块及其依赖。使用esbuild或Vite自带的编译器快速处理JavaScript和CSS。热模块
Java中double保留2位小数(精度丢失)的两种方式元正~Richarlie java 开发语言
在我们日常开发中，使用double数据类型进行计算，偶尔会出现精度丢失的情况，例如实际结果是0.75，就可能出现0.7500000000000001或0.7499999999999999。这边介绍两种方式（四舍五入）保留2位小数，可以满足开发中处理double精度丢失的大部分需求。方式一：使用round函数（同理：保留4位的话就是10000）Doubled=3.141592653589;doubl
Java Web学习笔记淘气的然酱计算机学习笔记 java 学习后端
JavaWeb后端基础第1章Maven项目1.1Maven简介Maven基于项目对象模型，通过一小段描述信息来管理项目的构建、报告和文档。Maven提供了一套标准化的项目结构、构建流程和一套依赖管理机制。Maven模型：pom.xml→项目对象模型↔依赖管理模型→仓库Maven仓库包含本地仓库、中央仓库、远程仓库（私服）。Maven项目获取jar包时，首先在本地仓库寻找是否有对应jar包，若没有则
grafana+prometheus+nginx监控负载均衡杰森斯坦森1150 性能测试 #性能监控工具 nginx linux
目录一、安装java项目二、安装nginx三、安装nginx-vts-export四、配置nginx五、启动nginx-vts-export六、安装promethus七、安装grafana一、安装java项目安装jdk，安装tomcat，请参看文章一台linux服务器上配置多台tomcat二、安装nginx请参考文章Linux安装nginx步骤三、安装nginx-vts-export1.安装git
double保留两位小数的四种方法小小野猪 Java基础 java double
这里写目录标题引言方法一：使用`BigDecimal`类方法二：使用`DecimalFormat`类方法三：使用`NumberFormat`类方法四：使用`String.format`方法结论声明引言在Java编程中，我们经常遇到需要对double类型的浮点数进行精确截断或四舍五入保留两位小数的需求。由于double类型在进行浮点运算时存在精度问题，因此，为了获得期望的精确表示，我们可以采用一些专
java数字签名三种方式知了ing java jdk
以下3钟数字签名都是基于jdk7的 1，RSA String password="test"; // 1.初始化密钥 KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA"); keyPairGenerator.initialize(51
Hibernate学习笔记 caoyong Hibernate
1>、Hibernate是数据访问层框架，是一个ORM(Object Relation Mapping)框架，作者为:Gavin King 2>、搭建Hibernate的开发环境 a>、添加jar包: aa>、hibernatte开发包中/lib/required/所
设计模式之装饰器模式Decorator（结构型）漂泊一剑客 Decorator
1. 概述若你从事过面向对象开发，实现给一个类或对象增加行为，使用继承机制，这是所有面向对象语言的一个基本特性。如果已经存在的一个类缺少某些方法，或者须要给方法添加更多的功能（魅力），你也许会仅仅继承这个类来产生一个新类—这建立在额外的代码上。
读取磁盘文件txt，并输入String 一炮送你回车库 String
public static void main(String[] args) throws IOException { String fileContent = readFileContent("d:/aaa.txt"); System.out.println(fileContent);
js三级联动下拉框 3213213333332132 三级联动
//三级联动省/直辖市<select id="province"></select> 市/省直辖<select id="city"></select> 县/区 <select id="area"></select>
erlang之parse_transform编译选项的应用 616050468 parse_transform 游戏服务器属性同步 abstract_code
最近使用erlang重构了游戏服务器的所有代码，之前看过C++/lua写的服务器引擎代码，引擎实现了玩家属性自动同步给前端和增量更新玩家数据到数据库的功能，这也是现在很多游戏服务器的优化方向，在引擎层面去解决数据同步和数据持久化，数据发生变化了业务层不需要关心怎么去同步给前端。由于游戏过程中玩家每个业务中玩家数据更改的量其实是很少
JAVA JSON的解析 darkranger java
// { // “Total”：“条数”， // Code: 1, // // “PaymentItems”:[ // { // “PaymentItemID”:”支款单ID”, // “PaymentCode”:”支款单编号”, // “PaymentTime”:”支款日期”, // ”ContractNo”:”合同号”， //
POJ-1273-Drainage Ditches aijuans ACM_POJ
POJ-1273-Drainage Ditches http://poj.org/problem?id=1273 基本的最大流，按LRJ的白书写的 #include<iostream> #include<cstring> #include<queue> using namespace std; #define INF 0x7fffffff int ma
工作流Activiti5表的命名及含义 atongyeye 工作流 Activiti
activiti5 - http://activiti.org/designer/update在线插件安装 activiti5一共23张表 Activiti的表都以ACT_开头。第二部分是表示表的用途的两个字母标识。用途也和服务的API对应。 ACT_RE_*: 'RE'表示repository。这个前缀的表包含了流程定义和流程静态资源（图片，规则，等等）。 A
android的广播机制和广播的简单使用百合不是茶 android 广播机制广播的注册
Android广播机制简介在Android中，有一些操作完成以后，会发送广播，比如说发出一条短信，或打出一个电话，如果某个程序接收了这个广播，就会做相应的处理。这个广播跟我们传统意义中的电台广播有些相似之处。之所以叫做广播，就是因为它只负责“说”而不管你“听不听”，也就是不管你接收方如何处理。另外，广播可以被不只一个应用程序所接收，当然也可能不被任何应
Spring事务传播行为详解 bijian1013 java spring 事务传播行为
在service类前加上@Transactional，声明这个service所有方法需要事务管理。每一个业务方法开始时都会打开一个事务。 Spring默认情况下会对运行期例外(RunTimeException)进行事务回滚。这
eidtplus operate 征客丶 eidtplus
开启列模式: Alt+C 鼠标选择 OR Alt+鼠标左键拖动列模式替换或复制内容(多行): 右键-->格式-->填充所选内容-->选择相应操作 OR Ctrl+Shift+V(复制多行数据,必须行数一致) -------------------------------------------------------
【Kafka一】Kafka入门 bit1129 kafka
这篇文章来自Spark集成Kafka(http://bit1129.iteye.com/blog/2174765)，这里把它单独取出来，作为Kafka的入门吧下载Kafka http://mirror.bit.edu.cn/apache/kafka/0.8.1.1/kafka_2.10-0.8.1.1.tgz 2.10表示Scala的版本，而0.8.1.1表示Kafka
Spring 事务实现机制 BlueSkator spring 代理事务
Spring是以代理的方式实现对事务的管理。我们在Action中所使用的Service对象，其实是代理对象的实例，并不是我们所写的Service对象实例。既然是两个不同的对象，那为什么我们在Action中可以象使用Service对象一样的使用代理对象呢？为了说明问题，假设有个Service类叫AService，它的Spring事务代理类为AProxyService，AService实现了一个接口
bootstrap源码学习与示例：bootstrap-dropdown（转帖） BreakingBad bootstrap dropdown
bootstrap-dropdown组件是个烂东西，我读后的整体感觉。一个下拉开菜单的设计： <ul class="nav pull-right"> <li id="fat-menu" class="dropdown">
读《研磨设计模式》-代码笔记-中介者模式-Mediator bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ /* * 中介者模式（Mediator）：用一个中介对象来封装一系列的对象交互。 * 中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。 * * 在我看来，Mediator模式是把多个对象（
常用代码记录 chenjunt3 UI Excel J#
1、单据设置某行或某字段不能修改 //i是行号,"cash"是字段名称 getBillCardPanelWrapper().getBillCardPanel().getBillModel().setCellEditable(i, "cash", false); //取得单据表体所有项用以上语句做循环就能设置整行了 getBillC
搜索引擎与工作流引擎 comsci 算法工作搜索引擎网络应用
最近在公司做和搜索有关的工作，(只是简单的应用开源工具集成到自己的产品中)工作流系统的进一步设计暂时放在一边了，偶然看到谷歌的研究员吴军写的数学之美系列中的搜索引擎与图论这篇文章中的介绍，我发现这样一个关系(仅仅是猜想) -----搜索引擎和流程引擎的基础--都是图论，至少像在我在JWFD中引擎算法中用到的是自定义的广度优先
oracle Health Monitor daizj oracle Health Monitor
About Health Monitor Beginning with Release 11g, Oracle Database includes a framework called Health Monitor for running diagnostic checks on the database. About Health Monitor Checks Health M
JSON字符串转换为对象 dieslrae java json
作为前言,首先是要吐槽一下公司的脑残编译部署方式,web和core分开部署本来没什么问题,但是这丫居然不把json的包作为基础包而作为web的包,导致了core端不能使用,而且我们的core是可以当web来用的(不要在意这些细节),所以在core中处理json串就是个问题.没办法,跟编译那帮人也扯不清楚,只有自己写json的解析了.
C语言学习八结构体，综合应用，学生管理系统 dcj3sjt126com C语言
实现功能的代码： # include <stdio.h> # include <malloc.h> struct Student { int age; float score; char name[100]; }; int main(void) { int len; struct Student * pArr; int i,
vagrant学习笔记 dcj3sjt126com vagrant
想了解多主机是如何定义和使用的, 所以又学习了一遍vagrant 1. vagrant virtualbox 下载安装 https://www.vagrantup.com/downloads.html https://www.virtualbox.org/wiki/Downloads 查看安装在命令行输入vagrant 2.
14.性能优化-优化-软件配置优化 frank1234 软件配置性能优化
1.Tomcat线程池修改tomcat的server.xml文件： <Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" maxThreads="1200" m
一个不错的shell 脚本教程入门级 HarborChung linux shell
一个不错的shell 脚本教程入门级建立一个脚本　　Linux中有好多中不同的shell，但是通常我们使用bash (bourne again shell) 进行shell编程，因为bash是免费的并且很容易使用。所以在本文中笔者所提供的脚本都是使用bash（但是在大多数情况下，这些脚本同样可以在 bash的大姐，bourne shell中运行）。　　如同其他语言一样
Spring4新特性——核心容器的其他改进 jinnianshilongnian spring 动态代理 spring4 依赖注入
Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API Spring4新
Linux设置tomcat开机启动 liuxingguome tomcat linux 开机自启动
执行命令sudo gedit /etc/init.d/tomcat6 然后把以下英文部分复制过去。（注意第一句#!/bin/sh如果不写，就不是一个shell文件。然后将对应的jdk和tomcat换成你自己的目录就行了。 #!/bin/bash # # /etc/rc.d/init.d/tomcat # init script for tomcat precesses
第13章 Ajax进阶（下） onestopweb Ajax
index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
Troubleshooting Crystal Reports off BW blueoxygen BO
http://wiki.sdn.sap.com/wiki/display/BOBJ/Troubleshooting+Crystal+Reports+off+BW#TroubleshootingCrystalReportsoffBW-TracingBOE Quite useful, especially this part: SAP BW connectivity For t
Java开发熟手该当心的11个错误 tomcat_oracle java jvm 多线程单元测试
#1、不在属性文件或XML文件中外化配置属性。比如，没有把批处理使用的线程数设置成可在属性文件中配置。你的批处理程序无论在DEV环境中，还是UAT（用户验收测试）环境中，都可以顺畅无阻地运行，但是一旦部署在PROD 上，把它作为多线程程序处理更大的数据集时，就会抛出IOException，原因可能是JDBC驱动版本不同，也可能是#2中讨论的问题。如果线程数目可以在属性文件中配置，那么使它成为
正则表达式大全 yang852220741 html 编程正则表达式
今天向大家分享正则表达式大全，它可以大提高你的工作效率正则表达式也可以被当作是一门语言，当你学习一门新的编程语言的时候，他们是一个小的子语言。初看时觉得它没有任何的意义，但是很多时候，你不得不阅读一些教程，或文章来理解这些简单的描述模式。一、校验数字的表达式数字：^[0-9]*$ n位的数字：^\d{n}$ 至少n位的数字：^\d{n,}$ m-n位的数字：^\d{m,n}$