字符串相关笔记

目录

 

1.字符串是什么

2.字符串在java中以什么形式实现

3.java中的字符串的数据类型

4.字符串的存储与使用

5字符串方法的代码

 6.StringBuffer和StringBuilder

        1.为什么有这两个类

        2.StringBuffer的拼接

        3.其他方法：

        4.StringBuilder和StringBuffer一样只不过Buffer是线程安全的

7.StringTokenizer

 8.综合代码

---

 

1.字符串是什么

        由多个字符组合在一起的一个序列就叫做字符串

2.字符串在java中以什么形式实现

        在java中用char[]或者byte[]来实现

3.java中的字符串的数据类型

        1.字符串也是一个引用数据类型，用String来表示

        2.java中的字符串用""来标识，就和字符类型用''来标识差不多

4.字符串的存储与使用

        在java当中有个字符串常量池。通过引号创建出来的字符串都会存储到字符串常量池当中

        同一个字符串在字符串常量池当中只创建一次

        String引用就是只是一个单纯的引用、

        String对象其实就是在内部会指向字符串常量池

public class Run{
    public static void main(String[] args){
        String a = "asd";
        String b = "asd";
        System.out.println(a==b);//此行判断直接创建字符串只会在字符串常量池生成一次
        String e = new String("asd");
        System.out.println(e==a);//此行表明生成的对象不是字符串常量，而是一个“字符串”对象，所以引用存储的地址是对象的地址而不是常量的地址
        String c = new String("xcx");
        String d = new String("xcx");
        System.out.println(c==d);//此行表明生成的对象不是字符串常量，而是一个“字符串”对象，每一次都会生成一个字符串对象，但是字符串常量只有一个
//”几乎所有“对象都是在堆区中分配空间，所以字符串也是个对象，可以直接调用字符串方法，而不需要/依托于变量（不在堆区的情况叫做对象逃逸，大三才学）
//如果以new的形式创建字符串变量，那么这个时候就和刚才不同了，new几次创建几次，即使内容一样也要创建，而且new出来的这个对象指向一个字符串常量值的对象
    }
}

        所以综合以上内容就可以知道

                String引用可以指向String对象然后再由对象指向字符串常量池

                String引用也可以直接指向字符串常量池（”几乎所有“对象都是在堆区中分配空间，所以字符串也是个对象，可以直接调用字符串方法，而不需要依托于变量）

5.字符串的相关方法 

方法名	性质	形参	返回值	作用
length	非静态		int	统计字符串长度
isEmpty	非静态		boolean	查探是否字符串是空的(字符串没内容而不是null)
charAt	非静态	int (0,length）	char	返回对应下标的字符值（从0开始算）
equalsIgnoreCase	非静态	字符串	boolean	忽略大小写进行字符串的比较
compareTo	非静态	字符串	int	字符串比较
indexOf	非静态	字符串	int	返回新字符串在旧字符串当中第一次出现的下标
lastIndexOf	非静态	字符串	int	返回新字符串在旧字符串当中最后一次出现的下标
concat	非静态	字符串	字符串	创建一个新字符串由新旧两个字符串拼接而成
split	非静态	字符串	字符串数组	以新字符串为分割符，把旧字符串拆分成字符串数组
replace	非静态	字符串，字符串	字符串	把新字符串替换掉旧字符串里面的一些内容
subString	非静态	int	字符串	截取自该下标起往后的字符串
		int，int		截取该下标区间的字符串（左闭右开）
toUpperCase	非静态		字符串	生成新字符串把旧字符串的字符全部转成大写
toLowerCase	非静态		字符串	生成新字符串把旧字符串的字符全部转成小写

5字符串方法的代码

public class Run{
    public static void main(String[] args){
        String a = "asd";
        String b = "asd";
        System.out.println(a==b);//此行判断直接创建字符串只会在字符串常量池生成一次
        String e = new String("asd");
        System.out.println(e==a);//此行表明生成的对象不是字符串常量，而是一个“字符串”对象，所以引用存储的地址是对象的地址而不是常量的地址
        String c = new String("xcx");
        String d = new String("xcx");
        System.out.println(c==d);//此行表明生成的对象不是字符串常量，而是一个“字符串”对象，每一次都会生成一个字符串对象，但是字符串常量只有一个


        //方法
        //length，返回长度
        String aa = "zjh";
        System.out.println("lenght:\t"+aa.length());

        //isEmpty，返回是否为空字符串
        String bb = "";
        String bb1 = "zjh";
        System.out.println("bb: isEmpty:\t"+bb.isEmpty());
        System.out.println("bb1: isEmpty:   "+bb1.isEmpty());


        //charAt，返回下标对应的字符
        String cc = "asd";
        System.out.println("charAt:\t"+cc.charAt(0));

        //equalsIgnoreCase，忽略大小写比较
        String dd = "asdfghjkl";
        System.out.println("equalsIgnoreCase:\t"+dd.equalsIgnoreCase("ASDFGHJKL"));

        //compareTo,字符串比较,如果从某个字符开始比较发现该字符和原字符不同，那么返回新字符ASCII码于旧字符的差值，如果旧字符串比新字符串多出来一些内容，返回多出来的长度（正数），如果少一些内容，返回少的长度（负数）
        String ee = "abcd";
        System.out.println("compareTo:\t"+ee.compareTo("abcd"));//相等
        System.out.println("compareTo:\t"+ee.compareTo("Abcd"));//字符大小不同
        System.out.println("compareTo:\t"+ee.compareTo("aBcde"));//字符大小不同顺便看一下优先字符还是优先长度
        System.out.println("compareTo:\t"+ee.compareTo("a"));//看看短了返回正数还是负数
        System.out.println("compareTo:\t"+ee.compareTo("abcdeajshdk"));//看看长了返回证书还是负数

        //indexOf
        String ff="zxcvbxc,.";
        System.out.println("indexof:\t"+ff.indexOf("xc"));

        //lastIndexOf
        String gg = "asdfghjkasdjkasd";
        System.out.println("lastIndexOf:\t"+gg.lastIndexOf("asd"));//作用是拼接字符串

        //concat
        String hh ="aaaaaaa";
        System.out.println("concat:\t"+hh.concat("sd"));
        System.out.println(hh);

        //split,以指定字符串来分割现有字符串为一个字符串数组
        String ii = "asd, dfg, ghj, jkl, sdf,sdf";
        String[] iichuan = ii.split(", ");
        for(String o: iichuan){
            System.out.print(o+"\t");
        }

        //replace,替换就字符串里面的而一些内容
        String jj = "zjhzjzjzjzjzjzjzjjzjzjzjjzjzjzj";
        System.out.println("\nreplace:\t"+jj.replace("zj","xx"));

        //subString
        String kk ="zjhzjhzjhzjhzjzhzjzhzjhzjh";
        System.out.println("单参数subString:\t"+kk.substring(10));
        System.out.println("双参数subString:\t"+kk.substring(0,3));

        //toUpperCase
        String ll = "asdasdSDSD";
        System.out.println("toUpperCase:\t"+ll.toUpperCase()+"\n\t原字符串"+ll);

        //toLowerCase
        String mm =  "asdasdSDSDSD";
        System.out.println("toLowerCase:\t"+mm.toLowerCase()+"\n\t原字符串"+mm);
    }
}

运行结果： 

true
false
false
lenght:    3
bb: isEmpty:    true
bb1: isEmpty:   false
charAt:    a
equalsIgnoreCase:    true
compareTo:    0
compareTo:    32
compareTo:    32
compareTo:    3
compareTo:    -7
indexof:    1
lastIndexOf:    13
concat:    aaaaaaasd
aaaaaaa
asd    dfg    ghj    jkl    sdf,sdf    
replace:    xxhxxxxxxxxxxxxxxjxxxxxxjxxxxxx
单参数subString:    jhzjzhzjzhzjhzjh
双参数subString:    zjh
toUpperCase:    ASDASDSDSD
    原字符串asdasdSDSD
toLowerCase:    asdasdsdsdsd
    原字符串asdasdSDSDSD

 6.StringBuffer和StringBuilder

        1.为什么有这两个类

                由于String每次进行修改之后都要重新新建一个字符串，需要申请一块空间，所以对于需要反复修改的字符串，如果采用String的话会占用很多空间

        2.StringBuffer的拼接

                原本String的拼接需要创建String对象吗，hello，world，hello world，

                而对于StringBuffer不需要再创建hello world了

        StringBuffer aaa =new StringBuffer("hello");
        System.out.println("拼接字符串：\t"+aaa.append(" world"));

        3.其他方法：

方法名	形参	返回值	作用	性质
delete	（int,int）	String	删除下标区间范围内的字符串（左闭右开）	非静态
insert	(int,String)	String	把字符串插入到对应下标的位置	非静态
reserve		String	倒序字符串	非静态
toString		String	StringBuffer转String	非静态

//StringBuffer类
        StringBuffer aaa =new StringBuffer("hello");
        System.out.println("拼接字符串：\t"+aaa.append(" world"));//原本String的拼接需要创建String对象吗，hello，world，hello world，而对于StringBuffer不需要再创建hello world了
        //delete方法//左闭右开的删除下标区间对应的字符串
        System.out.println("delete:\t"+aaa.delete(1,1));
        //insert方法//插入到对应下标的位置
        System.out.println("insert:\t"+aaa.insert(1,"e"));
        //reserve方法//倒叙
        System.out.println("reserve:\t"+aaa.reverse());

        String bbb = aaa.toString();
        System.out.println(bbb);
    

        4.StringBuilder和StringBuffer一样只不过Buffer是线程安全的

7.StringTokenizer

        就是用来分隔的一个类

        构造方法传递要分割的字符串以及用什么来作为分割符

        hasMoreToken方法查探是否还有分割符

        nextToken返回下一个分割符之前的内容值

String nn = "asd,asd,asd,asd,asd,asd,asd,as,das,dasd,asd";
        StringTokenizer oo = new StringTokenizer(nn,",");//这句话的意思是要分割的是nn字符串，分割符是逗号
        while(oo.hasMoreTokens()){//看看从现在起后面有没有分割符了
            System.out.print(oo.nextToken()+"\t");//返回下一个分割符前面的内容
        }

 8.综合代码

public class Run{
    public static void main(String[] args){
        String a = "asd";
        String b = "asd";
        System.out.println(a==b);//此行判断直接创建字符串只会在字符串常量池生成一次
        String e = new String("asd");
        System.out.println(e==a);//此行表明生成的对象不是字符串常量，而是一个“字符串”对象，所以引用存储的地址是对象的地址而不是常量的地址
        String c = new String("xcx");
        String d = new String("xcx");
        System.out.println(c==d);//此行表明生成的对象不是字符串常量，而是一个“字符串”对象，每一次都会生成一个字符串对象，但是字符串常量只有一个


        //方法
        //length，返回长度
        String aa = "zjh";
        System.out.println("lenght:\t"+aa.length());

        //isEmpty，返回是否为空字符串
        String bb = "";
        String bb1 = "zjh";
        System.out.println("bb: isEmpty:\t"+bb.isEmpty());
        System.out.println("bb1: isEmpty:   "+bb1.isEmpty());


        //charAt，返回下标对应的字符
        String cc = "asd";
        System.out.println("charAt:\t"+cc.charAt(0));

        //equalsIgnoreCase，忽略大小写比较
        String dd = "asdfghjkl";
        System.out.println("equalsIgnoreCase:\t"+dd.equalsIgnoreCase("ASDFGHJKL"));

        //compareTo,字符串比较,如果从某个字符开始比较发现该字符和原字符不同，那么返回新字符ASCII码于旧字符的差值，如果旧字符串比新字符串多出来一些内容，返回多出来的长度（正数），如果少一些内容，返回少的长度（负数）
        String ee = "abcd";
        System.out.println("compareTo:\t"+ee.compareTo("abcd"));//相等
        System.out.println("compareTo:\t"+ee.compareTo("Abcd"));//字符大小不同
        System.out.println("compareTo:\t"+ee.compareTo("aBcde"));//字符大小不同顺便看一下优先字符还是优先长度
        System.out.println("compareTo:\t"+ee.compareTo("a"));//看看短了返回正数还是负数
        System.out.println("compareTo:\t"+ee.compareTo("abcdeajshdk"));//看看长了返回证书还是负数

        //indexOf
        String ff="zxcvbxc,.";
        System.out.println("indexof:\t"+ff.indexOf("xc"));

        //lastIndexOf
        String gg = "asdfghjkasdjkasd";
        System.out.println("lastIndexOf:\t"+gg.lastIndexOf("asd"));//作用是拼接字符串

        //concat
        String hh ="aaaaaaa";
        System.out.println("concat:\t"+hh.concat("sd"));
        System.out.println(hh);

        //split,以指定字符串来分割现有字符串为一个字符串数组
        String ii = "asd, dfg, ghj, jkl, sdf,sdf";
        String[] iichuan = ii.split(", ");
        for(String o: iichuan){
            System.out.print(o+"\t");
        }

        //replace,替换就字符串里面的而一些内容
        String jj = "zjhzjzjzjzjzjzjzjjzjzjzjjzjzjzj";
        System.out.println("\nreplace:\t"+jj.replace("zj","xx"));

        //subString
        String kk ="zjhzjhzjhzjhzjzhzjzhzjhzjh";
        System.out.println("单参数subString:\t"+kk.substring(10));
        System.out.println("双参数subString:\t"+kk.substring(0,3));

        //toUpperCase
        String ll = "asdasdSDSD";
        System.out.println("toUpperCase:\t"+ll.toUpperCase()+"\n\t原字符串"+ll);

        //toLowerCase
        String mm =  "asdasdSDSDSD";
        System.out.println("toLowerCase:\t"+mm.toLowerCase()+"\n\t原字符串"+mm);



        //StringBuffer类
        StringBuffer aaa =new StringBuffer("hello");
        System.out.println("拼接字符串：\t"+aaa.append(" world"));//原本String的拼接需要创建String对象吗，hello，world，hello world，而对于StringBuffer不需要再创建hello world了
        //delete方法//左闭右开的删除下标区间对应的字符串
        System.out.println("delete:\t"+aaa.delete(1,1));
        //insert方法//插入到对应下标的位置
        System.out.println("insert:\t"+aaa.insert(1,"e"));
        //reserve方法//倒叙
        System.out.println("reserve:\t"+aaa.reverse());

        String bbb = aaa.toString();
        System.out.println(bbb);

        String nn = "asd,asd,asd,asd,asd,asd,asd,as,das,dasd,asd";
        StringTokenizer oo = new StringTokenizer(nn,",");//这句话的意思是要分割的是nn字符串，分割符是逗号
        while(oo.hasMoreTokens()){//看看从现在起后面有没有分割符了
            System.out.print(oo.nextToken()+"\t");//返回下一个分割符前面的内容
        }
    }