十二.常用类

1.包装类

在Java中有一个设计的原则“一切皆对象”，那么这样一来Java中的一些基本的数据类型，就完全不符合于这种设计思想，因为Java中的八种基本数据类型并不是引用数据类型，所以Java中为了解决这样的问题，引入了八种基本数据类型的包装类。

以上的八种包装类，可以将基本数据类型按照类的形式进行操作。但是，以上的八种包装类也是分为两种大的类型的： · Number：Integer、Short、Long、Double、Float、Byte都是Number的子类表示是一个数字。 · Object：Character、Boolean都是Object的直接子类。

包装类和基本数据的转换

以下以Integer和Float为例进行操作

将一个基本数据类型变为包装类，那么这样的操作称为装箱操作。

将一个包装类变为一个基本数据类型，这样的操作称为拆箱操作，

因为所有的数值型的包装类都是Number的子类，Number的类中定义了如下的操作方法，以下的全部方法都是进行拆箱的操作

public class Integer01 {
    public static void main(String[] args) {
        //演示 int <--> Integer 的装箱和拆箱
        //jdk5 前是手动装箱和拆箱
        //手动装箱 int->Integer
        int n1 = 100;
        Integer integer = new Integer(n1);
        Integer integer1 = Integer.valueOf(n1);
        //手动拆箱
        //Integer -> int
        int i = integer.intValue();
        //jdk5 后，就可以自动装箱和自动拆箱
        int n2 = 200;
        //自动装箱 int->Integer
        Integer integer2 = n2; //底层使用的是 Integer.valueOf(n2)
        //自动拆箱 Integer->int
        int n3 = integer2; //底层仍然使用的是 intValue()方法
    }
}

包装类型和 String 类型的相互转换

public class WrapperVSString {
    public static void main(String[] args) {
        //包装类(Integer)->String
        Integer i = 100;//自动装箱
        //方式 1
        String str1 = i + "";
        //方式 2
        String str2 = i.toString();
        //方式 3
        String str3 = String.valueOf(i);
        //String -> 包装类(Integer)
        String str4 = "12345";
        Integer i2 = Integer.parseInt(str4);//使用到自动装箱
        Integer i3 = new Integer(str4);//构造器
        System.out.println("ok~~");
    }
}

Integer 类和 Character 类的常用方法

public static void main(String[] args) {
    System.out.println(Integer.MIN_VALUE); //返回最小值
    System.out.println(Integer.MAX_VALUE);//返回最大值
    System.out.println(Character.isDigit('a'));//判断是不是数字
    System.out.println(Character.isLetter('a'));//判断是不是字母
    System.out.println(Character.isUpperCase('a'));//判断是不是大写
    System.out.println(Character.isLowerCase('a'));//判断是不是小写
    System.out.println(Character.isWhitespace('a'));//判断是不是空格
    System.out.println(Character.toUpperCase('a'));//转成大写
    System.out.println(Character.toLowerCase('A'));//转成小写
}

2.String 类

1）String对象用于保存字符串，也就是一组字符序列。

2）字符串常量对象时用双引号括起的字符序列。

3）字符串的字符使用Unicode字符编码，一个字符(不区分字母还是汉字)占两个字节。

public static void main(String[] args) {
    //1.String 对象用于保存字符串，也就是一组字符序列
    //2. "jack" 字符串常量, 双引号括起的字符序列
    //3. 字符串的字符使用 Unicode 字符编码，一个字符(不区分字母还是汉字)占两个字节
    //4. String 类有很多构造器，构造器的重载
    // 常用的有 String s1 = new String(); //
    //String s2 = new String(String original);
    //String s3 = new String(char[] a);
    //String s4 = new String(char[] a,int startIndex,int count)
    //String s5 = new String(byte[] b)
    //5. String 类实现了接口 Serializable【String 可以串行化:可以在网络传输】
    // 接口 Comparable [String 对象可以比较大小]
    //6. String 是 final 类，不能被其他的类继承
    //7. String 有属性 private final char value[]; 用于存放字符串内容
    //8. 一定要注意：value 是一个 final 类型， 不可以修改(需要功力)：即 value 不能指向
    // 新的地址，但是单个字符内容是可以变化
    String name = "jack";
    name = "tom";
    final char[] value = {'a','b','c'};
    char[] v2 = {'t','o','m'};
    value[0] = 'H';
    //value = v2; 不可以修改 value 地址
}

创建 String 对象的两种方式

方式一：直接赋值 String s = "hello";

方式二：调用构造器 String s2 = new String("hello");

内存分布

String类的常用方法

equals ：区分大小写

equalsIgnoreCase ：忽略大小写判断内容是否相等

length ：获取字符的个数，字符串的长度

indexOf ：获取字符在字符串中第一次出现的索引，索引从0开始，如果找不到，返回-1。

lastIndexOf ：获取字符在字符串中最后一次出现的索引，索引从0开始，如果找不到，返回-1.

substring ：截取指定范围的子串

trim ：去前后空格

charAt ：获取某索引处的字节，注意不能使用Str[index]这种方式

3.StringBuffer

StringBuffer 的直接父类是 AbstractStringBuilder
StringBuffer 实现了 Serializable, 即 StringBuffer 的对象可以串行化
在父类中 AbstractStringBuilder 有属性 char[] value,不是 final 该 value 数组存放字符串内容，引出存放在堆中的
StringBuffer 是一个 final 类，不能被继承
因为 StringBuffer 字符内容是存在 char[] value, 所有在变化(增加/删除) 不用每次都更换地址(即不是每次创建新对象)，所以效率高于 String

String VS StringBuffe

String 和 StringBuffer 相互转换

public static void main(String[] args) {
?
    //看 String——>StringBuffer
    String str = "hello tom";
    //方式 1 使用构造器
    //注意： 返回的才是 StringBuffer 对象，对 str 本身没有影响
    StringBuffer stringBuffer = new StringBuffer(str);
    //方式 2 使用的是 append 方法
    StringBuffer stringBuffer1 = new StringBuffer();
    stringBuffer1 = stringBuffer1.append(str);
    
    //看看 StringBuffer ->String
    StringBuffer stringBuffer3 = new StringBuffer("韩顺平教育");
    //方式 1 使用 StringBuffer 提供的 toString 方法
    String s = stringBuffer3.toString();
    //方式 2: 使用构造器来搞定
    String s1 = new String(stringBuffer3);
}

StringBuffer 类常见方法

public static void main(String[] args) {
    StringBuffer s = new StringBuffer("hello");
    
    //增
    s.append(',');// "hello,"
    s.append("张三丰");//"hello,张三丰"
    s.append("赵敏").append(100).append(true).append(10.5);//"hello,张三丰赵敏 100true10.5"                    System.out.println(s);//"hello,张三丰赵敏 100true10.5"
    
    
    //删
    /*
    * 删除索引为>=start &&     * 解读: 删除 11~14 的字符 [11, 14)
    */
    s.delete(11, 14);
    System.out.println(s);//"hello,张三丰赵敏 true10.5"
    
    
    //改
    //老韩\\解读，使用 周芷若 替换 索引 9-11 的字符 [9,11)
    s.replace(9, 11, "周芷若");
    System.out.println(s);//"hello,张三丰周芷若 true10.5"
    //查找指定的子串在字符串第一次出现的索引，如果找不到返回-1
    int indexOf = s.indexOf("张三丰");
    System.out.println(indexOf);//6
    
    //插
    解读，在索引为 9 的位置插入 "赵敏",原来索引为 9 的内容自动后移
    s.insert(9, "赵敏");
    System.out.println(s);//"hello,张三丰赵敏周芷若 true10.5"
    //长度
    System.out.println(s.length());//22
    System.out.println(s);
}

4.StringBuilder 类

StringBuffer 的直接父类是 AbstractStringBuilder
StringBuffer 实现了 Serializable, 即 StringBuffer 的对象可以串行化
在父类中 AbstractStringBuilder 有属性 char[] value,不是 final // 该 value 数组存放字符串内容，引出存放在堆中
StringBuffer 是一个 final 类，不能被继承 //5. 因为 StringBuffer 字符内容是存在 char[] value, 所有在变化(增加/删除) // 不用每次都更换地址(即不是每次创建新对象)，所以效率高于 String。

StringBuilder和StringBuffer和String的比较

1）StringBuilder和StringBuffer非常相似，均可以代表可变的字符序列，而且方法也一样。

2）String：不可变字符序列，效率低，但是复用率高。

3）StringBuffer：可变字符序列，效率较高(增删)，线程安全。

4）StringBuilder：可变字符序列，效率最高，线程不安全

Java基础

十二.常用类