Java中String、StringBuffer及包装类

目录

String

• 字符串是一个特殊的对象
• 字符串一旦初始化就不可变
• 数据会被存在字符串常量池中

public final class String
extends Object
implements Serializable, Comparable, CharSequence
String类代表字符串。
Java程序中的所有字符串文字（例如”abc” ）都被实现为此类的实例。
字符串不变; 它们的值在创建后不能被更改。
字符串缓冲区支持可变字符串。
因为String对象是不可变的，它们可以被共享。 例如：

String str = "abc";

相当于：

char data[] = {'a', 'b', 'c'};
String str = new String(data);

—— 引用于jdk1.8 api中描述

class _string{
    public static void main(String[] args) throws Exception{
        String str1 = "Hello World!";

        String str2 = new String(str1);
        sop(str1 == str2);  
        //false str2有两个对象的引用 new "Hello World!"
        String str3 = "Hello"+" "+"World!";
        sop(str1 == str3);  
        //true
        String str4 = "Hello" + new String(" World!");
        sop(str1 == str4);  
        //false 
        sop(str1.equals(str2)&&str1.equals(str4));  
        //true

        //一.查找 str1 = "Hello World!"; 
        sop(str1.length());     
        //12 获取长度
        sop(str1.charAt(6));    
        //W index=6的字符 角标从0开始
        int index_first_o = str1.indexOf('o');
        sop(str1.indexOf('o')); 
        //4 查找 o 的索引
        sop(str1.indexOf('o',index_first_o+1)); 
        //7 从指定的索引开始
        sop(str1.lastIndexOf('o')); 
        //7 最后一次出现的字符串中的索引

        //二.判断 str1 = "Hello World!";
        String str5 = "Hello";
        sop(str5.isEmpty());
        //false 判断length()是否为 0
        sop("".isEmpty());
        //true
        sop(str5.startsWith("He"));
        //true 判断以He开头？
        sop(str5.endsWith("lo"));
        //true 判断以lo结尾？
        sop(str1.contains(str5));
        //true 字符串str1中是否包含一个子串str5
        sop(str1.indexOf(str5));
        //true -1表示不存在 返回str5在str1中出现的索引
        sop(str5.equalsIgnoreCase("hello"));
        //true 忽略大小写的比较

        //三.转换
        sop(new String(str1.toCharArray()));
        //Hello World! 先转换为字符数组 再转为字符串
        sop(new String(str1.getBytes()));
        //Hello World! 先转换为字节数组 再转为字符串
        sop(new String(str1.getBytes(),"UTF-8"));
        //Hello World! 先转换为字节数组 再以utf-8解码转为字符串
        sop(new String().valueOf(str1.toCharArray()));
        sop(new String().valueOf(str1.getBytes()));
        //若是不能转换则返回原类型及数据
        sop(str1.valueOf(3.14159));
        //valueOf 可以将基本类型、char[] 、Object转换为String类型

        //四.替换
        sop(str1.replace(" ","-"));
        //将str1中的空格替换为-
        sop(str1.replace(" ","\n"));
        //将str1中的空格替换为换行符

        //五.切割
        sopArray(str1.split(" "));
        //以“ ”空格进行分割成String数组 Hello  World！ 
        sopArray(str1.split(" [A-Z]"));
        //以正则匹配 分割成 Hello  orld！ 

        //六.获取子串
        sop(str2.substring(3));
        //lo World! 从角标为3开始取子串
        sop(str1.substring(3,10));
        //lo Worl 从角标为3开始 10 结束开始取子串 

        //七.转换、去空格、比较
        sop(str1.toUpperCase());
        //HELLO WORLD! 转为大写
        sop(str1.toLowerCase());
        //hello world! 转为小写
        sop("  Hello World!  ".trim());
        //hello world! 去掉两边的空格
        sop(str1.compareTo(str2));
        //0 尊重ASCII码值排序进行比较 0则为相同 正数则为str1>str2
    }

    public static void sop(Object obj){
        System.out.println(obj);
    }

    public static void sopArray(String[] strArray){
        for (int i = 0 ; i < strArray.length ; i++) {
            System.out.println(strArray[i]);
        }
    }
}

String之常量池小结

StringBuffer

• 是一个长度可变化的容器
• 字符串缓冲区
• 当需要数据长度可变化、需直接操作多个数据类型、最终通过toString变成字符串时即可使用

public final class StringBuffer
extends Object
implements Serializable, CharSequence
线程安全，可变的字符序列。
字符串缓冲区就像一个String ，但可以修改。
在任何时间点，它包含一些特定的字符序列，但可以通过某些方法调用来更改序列的长度和内容。
字符串缓冲区可以安全地被多个线程使用。
这些方法在必要时进行同步，以便任何特定实例上的所有操作都按照与所涉及的各个线程所执行的方法调用顺序一致的顺序发生。
StringBuffer的主要StringBuffer是append和insert方法，它们被重载以便接受任何类型的数据。
每个都有效地将给定的数据转换为字符串，然后将该字符串的字符附加或插入到字符串缓冲区。
append方法总是在缓冲区的末尾添加这些字符; insert方法将insert添加到指定点。
—— 引用于jdk1.8 api中描述

/**
* stringBuffer 和 stringBuilder 都是长度可变化，可直接操作多个数据
* 类型，最终可通过toString变成字符串的
* stringBuffer 用于同步中
* stringBuilder 不支持同步 但是效率有所提高 所以推荐用这个 
*/
class _stringBuffer{
    public static void main(String[] args){
        StringBuffer sbf = new StringBuffer();
        sbf.append("1");
        sbf.append(1).append("123").append(1.2).append('a');
        print(sbf.toString());//转为String类型
        //111231.2a
        print(sbf.capacity());
        //16
        print(sbf.delete(1,4));
        //131.2a
        print(sbf.deleteCharAt(1));
        //11.2a 删除的是容器中的数据 不变的是容器 变的是数据
        print(sbf.charAt(2));
        //.
        print(sbf.indexOf("1"));
        //0
        print(sbf.lastIndexOf("1"));
        //1
        print(sbf.length());
        //5
        print(sbf.substring(2));
        //.2a
        print(sbf.replace(1,4,"hello"));
        //1helloa
        print(sbf.insert(2,true));
        //1htrueelloa
        sbf.setCharAt(2,'H');
        print(sbf.reverse());
        //aolleeurHh1
    }

    public static void print(Object obj){
        System.out.println(obj);
    }
}

包装类

• Java有两大数据类型
• 一：内置数据类型：8种基本数据类型（4个整数:byte,int,short,long、2个浮点:float,double、1个字符:char、1个布尔boolean）
• 二：引用数据类型：对象（String）和数组（默认值都为null）
• 每一个基本数据类型有一个包装类所以共有8个包装类（Byte,Integer,Short,Long,Float,Double,Character,Boolean）
• 包装类主要作用于基本数据类型和字符串之间的转换
• 基本数据类型+”” OR 包装类.toString(数据)

class IntegerDemo{
    public static void main(String[] args){

        Integer i1 = new Integer(127);
        Integer i2 = new Integer(127);
        print("i1==i2:"+(i1==i2));
        //false 因为每一个new对象都是不同的
        print("i1==i2:"+i1.equals(i2));
        //true
        print(Integer.valueOf(i1)==Integer.valueOf(i2));
        //true 直接指向值Integer对象
        print(Integer.valueOf("128")==Integer.valueOf("128"));
        //false
        //Integer设置-128到127的静态缓存

        print(Integer.toString(123));
        print(Integer.parseInt("120"));
        //str -> Int
        print(Integer.toString(123));
        //str <- Int
        print(new Integer(456).intValue());
        //Integer -> int

    }

    public static void print(Object obj){
        System.out.println(obj);
    }
}

java关于Integer设置-128到127的静态缓存