java学习——字符串

最新推荐文章于 2024-07-29 14:22:26 发布

snow deer

最新推荐文章于 2024-07-29 14:22:26 发布

阅读量793

点赞数 23

文章标签： java 学习开发语言

本文链接：https://blog.csdn.net/ping12138/article/details/136487401

版权

二、StringBuild和StringBuffer

在StringBuilder存储区指定偏移位置处插入指定的字符串

将存储区的内容倒序

获取指定字符串在存储区中的位置

4、String、StringBuffer、StringBuilder的区别

一、String的相关延申用法

1、特性介绍

String类位于java. lang包中，无需引入，直接使用即可。
String类是由final修饰的，表示String 类是一个最终类，不能够被继承。
String类构建的对象不可再被更改。

例子

package stringTest;

public class example1 {
    public static void main(String[] args) {
        //当使用一个字面量给字符串赋值时，首先会去字符串常量池中检测是否存在这个字面量。
        //如果存在，则直接使用这个字面量的地址赋值即可。如果不存在，则需要在字符串常量
        //池中创建这个字面量，然后再将地址赋值过去即可。
        String s="第一个字符串产生";
        s+="查看存储位置"; //字符串拼接动作发生在堆内存上
        System.out.println(s);
    }
}

2、常用构造方法

public String(String original);

public String(char value[ ]);

public String(char value[ ], int offset, int count);

public String(byte bytes[ ]);

public String(byte bytes[ ], int offset, int length);

public String(byte bytes[ ], charset charset);

例子

package stringTest;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

import java.nio.charset.Charset;

public class example2 {
    public static void main(String[] args) {
        //这里会创建两个对象，一个是字面量会在常量池中创建一个对象，
        //另一个是 new String("") 构造方法创建出来的对象
        String s1 = new String("字符串学习");
        System.out.println(s1);

        char[] values={'a','d','m','i','n'};
        String s2=new String(values);
        System.out.println(s2);

        //在使用这个构造方法时必须要考虑到数组下表越界的可能
        String s3=new String(values,1,3);//指数组偏移一个，从1下标开始，输出三个字符
        System.out.println(s3);

        //字节可以存储整数，字符也可以使用整数表示，这个整数就是ASCII码对应的整数值
        byte[] bytes={97,98,99,100,101,102};
        String s4=new String(bytes);
        System.out.println(s4);
        String s5=new String(bytes,2,3);//数组偏移2个，从2下标开始，输出3个数组元素
        System.out.println(s5);

        Charset charset=Charset.forName("UTF-8");//构造UTF-8字符集
        String s6=new String(bytes,charset);
        System.out.println(s6);
    }

}

3、常用方法

a、获取长度

public int length(); //获取字符串长度

b、字符串比较

public boolean equals( Object anObject); //比较两个字符串是否相同

//忽略大小比较两个字符串是否相同

public boolean equalsIgnoreCase( String anotherString );

c、字符串大小转换

public String toUpperCase(); //大写转换

public String toLowerCase(); //小写转换

例子

package stringTest;

public class example3 {
    public static void main(String[] args) {
        String s1="字符串学习";
        int length=s1.length();//获得字符串长度
        System.out.println(length);

        String s2="abc";
        String s3="abc";
        String s4="ABC";
        System.out.println(s2==s3);//输出true
        //字符串之间进行比较时，首先会查看两个字符串长度是否一致，如果一致，再看其中的每一个字符是否相同
        System.out.println(s2.equals(s3));//输出true
        System.out.println(s2.equals(s4));//输出false
        System.out.println(s2.equalsIgnoreCase(s4));//忽略字符串大小写进行比较，输出true

        String s5=s2.toUpperCase();//大写转换
        System.out.println(s5);//输出ABC
        String s6=s4.toLowerCase();//小写转换
        System.out.println(s6);//输出abc
    }
}

d、获取字符在字符串中的下标

public int indexof(int ch); //获取指定字符在字符串中第一次出现的下标位置

public int lastIndexof(int ch); //获取指定字符在字符串中最后一次出现的下标位置

e、获取字符串在字符串中的下标

public int indexof(String str); //获取指定字符串在字符串中第一次出现的下标位置

public int lastIndexof(String str); //获取指定字符串在字符串中最后一次出现的下标位置

f、获取字符串中指定下标的字符

public char charAt(int index); //获取字符串中指定下标的字符

例子

package stringTest;

public class example4 {
    public static void main(String[] args) {
        String s1="apk@qq.com";
        //'@'=> char => int
        //获取指定字符在字符串中第一次出现的下标位置
        int index1=s1.indexOf('@');//相互兼容的数据类型之间可以发生自动类型转换
        System.out.println(index1);

        String s2="apk@we@qq.cpm";
        //获取指定字符在字符串中最后一次出现的下标位置
        int index2=s2.lastIndexOf('@');
        System.out.println(index2);

        //获取字符串中指定下标的字符
        System.out.println(s1.charAt(0));
    }
}

g、字符串截取

public String substring(int beginIndex); //从指定开始位置到字符串末尾位置截取字符串

public String substring(int beginIndex,int endIndex); //从指定开始位置到指定结束位置截取 //字符串，截取使用的是左闭右开区间

h、字符串替换

public String replace(char oldChar,newChar); //替换旧字符串中指定的字符，变为新字符

public String replace(CharSequence target,CharSequence replacement); //替换旧字符串

//中的指定字符串，变为新的字符串

public String replaceAll(String regex,String replacement); //使用新的字符串替换旧的字符 //串中满足条件的字符串

例子

package stringTest;

public class example5 {
    public static void main(String[] args) {
        String s1="本次学习Java中的字符串知识";
        //从指定开始位置到指定结束位置截取字符串，截取使用的是左闭右开区间[4,8)
        String sub1= s1.substring(4,8);
        System.out.println(sub1);//输出结果是Java
        //从指定开始位置到字符串末尾位置截取字符串
        String sub2=s1.substring(10);
        System.out.println(sub2);

        String s2="Hello World";
        //替换旧字符串中指定字符为新字符
        s2.replace('o','a');//无法实现在s2上直接替换
        System.out.println(s2);//仍是"Hello World"
        String s3=s2.replace('o','a');//需要接收新字符串
        System.out.println(s3);//输出结果是"Hella Warld"

        //替换旧字符串中的指定字符串为新的字符串
        String s4=s2.replace("o","a");
        System.out.println(s4);//输出结果是"Hella Warld"

        String info="a1b2c3d4";
        //使用新的字符串替换旧的字符串中满足条件的字符串
        // regex => regular expression 正则表达式
        String result1=info.replaceAll("[0-9]","");//把0-9替换为""
        System.out.println(result1);//输出结果是abcd
        String result2=info.replaceAll("a-z","");//把a-z替换为""
        System.out.println(result2);//输出结果是1234
        String result3=info.replaceAll("A-Z","");//把A-Z替换为""
        String result4=info.replaceAll("a-zA-Z","");//把a-z和A-Z替换为""
    }
}

i、获取字符数组

public char[] toCharArray(); //获取字符数组

j、获取字节数组

public byte[] getBytes(); //获取字节数组

public byte[] getBytes(Charset charset); //获得指定编码下的字节数组

k、字符串拼接

public String concat(String str); //将字符串追加到末尾

l、去除字符串两端空白字符

public String trim(); //将字符串两端的空白字符修剪掉

例子

package stringTest;

import java.nio.charset.Charset;

public class example6 {
    public static void main(String[] args) {
        String s="My God!";
        //获取字符数组
        char[] values=s.toCharArray();
        for(int i=0;i<values.length;i++){
            System.out.println(values[i]);
        }

        //获取字节数组
        byte[] bytes=s.getBytes();
        for(int i=0;i<bytes.length;i++){
            System.out.print(bytes[i]+" ");
        }
        System.out.println();

        //获得指定编码下的字节数组
        byte[] bytes1=s.getBytes(Charset.forName("GB2312"));
        for(int i=0;i<bytes1.length;i++){
            System.out.print(bytes1[i]+" ");
        }
        System.out.println();

        String s1="Hello";
        String s2="World";
        String s3=s1+s2;
        System.out.println(s3);//输出HelloWorld
        //将s2追加到s1的末尾
        String s4=s1.concat(s2);
        System.out.println(s4);//输出HelloWorld

        String s5="  ab  cde  ";
        //将字符串两端的空白字符修剪掉
        String s6=s5.trim();
        System.out.println(s6);//输出"ab  cde"
    }
}

m、字符串分割

public String[ ] split(String regex); //将字符串按照匹配的正则表达式进行分割

n、字符串正则表达式

public boolean matches(String regex); //检测字符串是否匹配给定的正则表达式

例子

package stringTest;

public class example7 {
    public static void main(String[] args) {
        String s="a1b2c3d4";
        //字符串分割
        String[] arr=s.split("[0-9]");
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]);
        }//输出结果是"abcd"
        System.out.println();
        String personInfo="张三，男，20岁";
        //字符串分割
        String[] arr1=personInfo.split("，");
        for (int i=0;i<arr1.length;i++){
            System.out.println(arr1[i]);
        }//输出结果去除了 "，"

        //字符串匹配正则表达式
        String regex="[a-z0-9]+";
        boolean match=s.matches(regex);//检查字符串中是否仅有"a到z,0到9"的字符
        System.out.println(match);//输出true
        String s1="A1b2c3d4";
        boolean match1=s1.matches(regex);
        System.out.println(match1);//输出false
    }
}

o、intern() 方法学习

public native String intern();

例子

package stringTest;

public class example8 {
    public static void main(String[] args) {
        String s1="字符串";
        String s2="知识学习";
        String s3="字符串知识学习";
        String s4=s1+s2;
        System.out.println(s3==s4);//输出false
        //将字符串s4放入字符串常量池中，放入时会先检测常量池中是否存在s4字符串，
        //如果字符串常量池中存在字符串s4，那么s5直接使用常量池中的s4字符串地址
        //即可。如果不存在，则在常量池中创建字符串s3.
        String s5=s4.intern();
        System.out.println(s5==s3);//输出true
    }
}

二、StringBuild和StringBuffer

1、特性介绍

StringBuilder类位于java.lang包中，无需引入，直接使用即可。

StringBuilder类是由final修饰的，表示StringBuilder类是一个最终类，不可被继承。

StringBuilder类构建的对象，可以实现字符序列的追加，但不会产生新的对象，只是将这个字符序列保存在字符数组中。

2、构造方法

public StringBuilder(); //构建一个StringBuilder对象，默认容量为16

public StringBuilder(int capacity); //构建一个StringBuilder对象并指定初始化容量

public StringBuilder(String str); //构建一个StringBuilder对象，并将指定字符串存储在其中

例子

package stringTest1;

public class example1 {
    public static void main(String[] args) {
        StringBuilder s1=new StringBuilder();//构建一个初始化容量为16的字符串构建器
        StringBuilder s2=new StringBuilder(1024);//构建了一个初始化容量为1024位的字符串
        StringBuilder s3=new StringBuilder("字符串学习");
        //由于创建时StringBuilder会自动为它加16位，故它成为了一个默认有21位的字符串数组
    }
}

3、常用方法

追加

public StringBuilder append(String str); //将一个字符串添加到StringBuilder存储区

public StringBuilder append(StringBuffer s);

//将StringBuffer存储的内容添加到StringBuilder存储区

例子

package stringTest1;

import java.security.spec.RSAOtherPrimeInfo;

public class example2 {
    public static void main(String[] args) {
        StringBuilder s=new StringBuilder(1024);
        s.append("字符串学习");//将"字符串学习"存储到s中
        System.out.println(s);//输出"字符串学习"
        s.append("字符串学习");
        System.out.println(s);//输出"字符串学习字符串学习"

        StringBuffer buffer=new StringBuffer(1024);
        //StringBuffer的append里有synchronized，与多线程有关
        buffer.append("buffer测试");
        System.out.println(buffer);//输出"buffer测试"
        buffer.append(1);
        buffer.append(1.0);
        buffer.append('a');
        buffer.append(true);
        System.out.println(buffer);//输出"buffer测试11.0atrue"

        StringBuilder s1=new StringBuilder(1024);
        s1.append("字符串学习").append(1).append(1.0).append('a').append(true);
        System.out.println(s1);//输出"字符串学习11.0atrue"
    }
}

删除指定区间存储的内容

public StringBuilder delete(int start,int end);

//将StringBuilder存储区指定的开始位置到指定的结束位置间的内容删除掉

删除存储区指定下标位置存储的字符

public StringBuilder deleteCharAt(int index);

例子

package stringTest1;

public class example3 {
    public static void main(String[] args) {
        StringBuilder builder=new StringBuilder("abcdefg");
        builder.delete(1,5);
        System.out.println(builder);//输出"afg"

        builder.deleteCharAt(0);
        System.out.println(builder);//输出"fg"

    }
}

在StringBuilder存储区指定偏移位置处插入指定的字符串

public StringBuilder insert(int offset,String str);

将存储区的内容倒序

public StringBuilder reverse();

例子

package stringTest1;

public class example4 {
    public static void main(String[] args) {
        StringBuilder builder=new StringBuilder("admin");
        builder.reverse();//倒序存储
        System.out.println(builder);

        builder.insert(2,",");//偏移两位，在偏移的第二位后加上","
        System.out.println(builder);//输出"ni,mda"

        //这里的length()方法返回的是char[]中使用的数量
        System.out.println(builder.length());//输出6
    }
}

获取指定字符串在存储区中的位置

public int indexof(String str); //获取指定字符串在存储区第一次出现的位置

public int lastIndexof(String str); //获取指定字符串在存储区最后一次出现的位置

4、String、StringBuffer、StringBuilder的区别

String、StringBuilder 和StringBuffer都是用来处理字符串的。在处理少量字符串的时候，它们之间的处理效率几乎没有任何区别。但在处理大量字符串的时候，由于String类的对象不可再更改，因此在处理字符串时会产生新的对象，对于内存的消耗来说较大，导致效率低下。而StringBuilder和StringBuffer使用的是对字符串的字符数组内容进行拷贝，不会产生新的对象，因此效率较高。而StringBuffer为了保证在多线程情况下字符数组中内容的正确使用，在每一个成员方法上面加了锁，有锁就会增加消耗，因此StringBuffer在处理效率上要略低于StringBuilder。

snow deer

关注

23
点赞
踩
23

收藏

觉得还不错? 一键收藏
1
评论
java学习——字符串

String类位于java. lang包中，无需引入，直接使用即可。String类是由final修饰的，表示String 类是一个最终类，不能够被继承。String类构建的对象不可再被更改。例子//当使用一个字面量给字符串赋值时，首先会去字符串常量池中检测是否存在这个字面量。//如果存在，则直接使用这个字面量的地址赋值即可。如果不存在，则需要在字符串常量//池中创建这个字面量，然后再将地址赋值过去即可。String s="第一个字符串产生";s+="查看存储位置";
复制链接

扫一扫