Java常用类

1.包装类

package demo01;

/**
 * @Description: TODO Integer 包装类 - 对应的就是 int 类型
 */
public class Demo01 {
    public static void main(String[] args) {
        System.out.println("Integer 类型的最大取值范围" + Integer.MAX_VALUE);
        System.out.println("Integer 类型的最小取值范围" + Integer.MIN_VALUE);
        System.out.println("=============================");
        System.out.println("Byte 类型的最大取值范围" + Byte.MAX_VALUE);
        System.out.println("Byte 类型的最小取值范围" + Byte.MIN_VALUE);
    }
}

package demo01;

/**
 * @Description: TODO 将具体的常量或者变量封装成包装类对象
 */
public class Demo02 {
    public static void main(String[] args) {
        Integer integer01 = new Integer(9527);   //不推荐
        System.out.println(integer01);
        System.out.println("============================");
        Integer integer02 = Integer.valueOf(9527);   //推荐 - 手动装箱
        System.out.println(integer02);
        System.out.println("============================");
        Integer integer03 = 9527;    //自动装箱
        System.out.println(integer03);
        System.out.println("============================");
        Integer integer04 = Integer.valueOf("1314");  //手动装箱
        System.out.println(integer04);
    }
}

 

package demo01;
/**
 * @Description: TODO int 与 String 类型的相互转换
 */
public class Demo03 {
    public static void main(String[] args) {
        // int to String
        // 方法一
        String s01 = "" + 9527;
        System.out.println(s01.length());  //输出字符串长度

        // 方法二
        String s02 = Integer.toString(9527);
        System.out.println(s02.length());

        // 方法三
        String s03 = String.valueOf(9527);
        System.out.println(s03.length());

        System.out.println("=======================");
        // String to int
        // 方法一
        Integer i01 = Integer.valueOf("9527");
        System.out.println(i01 + 1);

        //方法二
        int i02 = Integer.parseInt("9527");
        System.out.println(i02 + 1);

    }
}

 

自动装箱和拆箱

        装箱：把基本数据类型转换为对应的包装类类型。

        拆箱：把包装类类型转换为对应的基本数据类型。 

package demo01;

/**
 * @Description: TODO 自动装箱和拆箱
 */
public class Demo04 {
    public static void main(String[] args) {
        Integer integer = Integer.valueOf(9527);  //手动装箱
        System.out.println(integer);

        Integer integer1 = 9527;   //自动装箱 jdk > 1.5
        System.out.println(integer1);

        System.out.println("===========================");

        int i = integer.intValue();  //手动拆箱
        integer1 += 9527;  //自动拆箱 + 自动装箱
        // 等号右边的部分相当于是自动拆箱然后做相加的动作，等号左边部分相当于是将计算结果再自动装箱
        //integer1 = integer1.intValue() + 9527;

        System.out.println(integer1);

        Integer integer2 = null;
        if(null != integer2)
            integer2 += 1314;    //NullPointerException
        System.out.println(integer2);
    }
}

 

2.String类 

无论是常量还是变量，只要是字符串，在Java中就都是字符串对象。

2.1字符串类的特点

a.字符串是不可变的，它们的值在创建之后是不能被修改的。

String类型的字符串在定义之后，值是不能被修改的。所以String字符串也被称为不可变字符串。

String str = "Hello";  //此时，Hello这个字符串常量就已经有了属于自己固定的内存空间
str = "world";   //此时只是将str指向world所在的地址，但原来的Hello仍然在内存中
//所以真正变化的是str对象指向的内存地址，而不是字符串本身

b.虽然String的值是不可变的，但它们是可以共享的。

String str01 = "Java";
String str02 = "Java";
//此时, str01 和 str02 共享 "Java" 这个字符串的地址，也就是说，无论访问的是 str01 还是
//str02，访问到的都是 "Java" 在内存中的同一个地址，获得的值也是相同的

 c.字符串在效果上相当于字符数组（char[]）——JDK版本 <= JDK8

 d.字符串的底层原理实际上是字节数组（byte[]）——JDK版本 >= JDK9

2.2常用构造方法

String的常用构造方法如下表所示。

方法名	说明
public String()	创建一个空白字符串对象，不含任何内容
public String(char[] chs)	根据字符数组内容来创建字符串对象
public String(byte[] bys)	根据字节数组内容来创建字符串对象
String str = "Hello"	用直接赋值的方式创建创建字符串对象，内容就是Hello

package demo02;

import java.util.Arrays;

/**
 * @Description: TODO 获取字符串
 */
public class Demo01 {
    public static void main(String[] args) {
        String s1 = new String();   //空字符串
        System.out.println("s1 = " + s1);

        char[] chars = {'J','a','v','a'};
        String s2 = new String(chars);
        System.out.println("s2 = " + s2);

        byte[] bytes = {74, 97, 118, 97};
        //byte[] bytes = "Java".getBytes();
        //System.out.println(Arrays.toString(bytes));
        String s3 = new String(bytes);
        System.out.println("s3 = " + s3);

        String s4 = "JavaEE";
        System.out.println("s4 = " + s4);
    }
}

 

2.3String对象的特点 

a.通过new创建的字符串对象，每一次new，JVM都会申请一个新的内存空间，即使内容相同，但是地址不同。

b.以""方式给出的字符串，只要字符序列相同（包括顺序和大小写），无论在程序中出现多少次，JVM都只会建立一个String对象，并存放在字符串池中进行维护。

3.StringBuilder & StringBuffer 

StringBuilder是一个可变的字符串类，我们可以把它看成一个容器，可变指的是StringBuilder对象中的内容是可变的。

3.1String和StringBuilder的区别

String是不可变的

StringBuilder是可变的

3.2StringBuilder的构造方法

StringBuilder的构造方法如下表所示。

方法名	说明
public StringBuilder()	创建一个空白的StringBuilder对象，不含有任何内容
public StringBuilder(String str)	根据字符串的内容创建一个StringBuilder对象

package demo03;

/**
 * @Description: TODO StringBuilder 的构造方法
 */
public class Demo01 {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        System.out.println(sb);
        System.out.println(sb.length());

        StringBuilder xs = new StringBuilder("小肆");
        System.out.println(xs + "你好");
        System.out.println(xs.length());
    }
}

3.3StringBuilder的添加和反转方法

StringBuilder的添加和反转方法如下表所示。

方法名	说明
public StringBuilder append(任意类型值)	将内容添加到对象中并返回对象本身
public StringBuilder reverse()	返回相反的字符串序列对象

package demo03;

/**
 * @Description: TODO StringBuilder 中的常用方法
 */
public class Demo02 {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello");
        //sb.append(" JavaSE");
        //sb.append(" StringBuilder");

        System.out.println(sb.append(" JavaSE").append(" StringBuilder").append(" so").append(" happy").toString());

        //============================================

        System.out.println(sb.reverse().toString());
        System.out.println(sb.reverse().reverse());
    }
}

 

5.Arrays 

注意：以下Arrays工具类中的方法均为静态方法，需要直接使用类名进行调用。 

方法名	说明
Arrays.fill()	初始化数组（填充）
Arrays.sort()	排序
Arrays.toString()	将数组拼接成字符串

package demo04;

import java.util.Arrays;
import java.util.Random;
/**
 * @Description: TODO Arrays 数据的工具类
 */
public class Demo01 {
    public static void main(String[] args) {
        int[] arr = new int[10];
        Random random = new Random();
        //Arrays.fill(arr,9);  // 初始化填充数组

        for (int i = 0; i < arr.length; i++) {
            arr[i] = random.nextInt(100);
        }   //利用随机值对数组进行随机初始化

        Arrays.sort(arr);   // 默认排序规则 - 升序

        String arrStr = Arrays.toString(arr);  // 将数组转换为字符串，便于输出
        System.out.println(arrStr);
    }
}