java 常用类之String-StringBuffer

最新推荐文章于 2023-01-09 01:01:48 发布

wll_peng

最新推荐文章于 2023-01-09 01:01:48 发布

阅读量286

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/wulailailai/article/details/78418423

版权

java 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

一.String类：

String 类代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。 

字符串是常量；它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的，所以可以共享。

1.String类常用的构造方法:

    String():表示一个空字符序列。
    public String(byte[] bytes,Charset ch):默认字符集(编码格式):GBK,如果是GBK格式,可以不写第二个参数
    public String(byte[] bytes,int index,int length):将部分字节数组构造成一个字符串
    public String(char[] value):将字符数组构造成一个字符串
    public String(char[] value,int index,int length):将部分的字符数组构造成一个字符串
    public String(String original):通过字符串常量构造一个字符串对象

获取字符串的长度功能:
                public int length()

面试题:

    数组中有没有length(),字符串(字符串缓冲区:StringBuffer)中没有length(),集合中有没有length()(集合后面讲)?
        数组没有length(),length属性
        字符串中有length()

        集合中没有length(),获取集合中元素数量:size()

编码和解码:

一定要保证编码格式一致

    编码:
        把能看懂的东西转换成一个看不懂的东西:String----->byte[]:public byte[] getBytes(String charsetName)
    解码:
        把当前的byte[]转成能看懂的东西(String):byte[]----->String  :public String(byte[] bytes,CharsetName ch)

举例:
谍战片:
今天老地方见:

        编码:"今"----->字节数组:byte[]---->字节类型:形成一种二进制数据
        解码:二进制数据---->十进制进制数据----->String:"今"

public class StringDemo {

    public static void main(String[] args) throws UnsupportedEncodingException {
        //创建一个String对象
        String s1 = new String() ;
        System.out.println("s1.length():"+s1.length());
        System.out.println("s1:"+s1);
        System.out.println("----------------------");

        //public String(byte[] bytes,Charset ch):默认字符集(编码格式):GBK,如果是GBK格式,可以不写第二个参数
        //创建一个字节数组
        byte[] bys = {97, 98, 99, 100, 101} ; 
        String s2 = new String(bys) ;//字节的值要找它对应的ASCII码表中的字符
        System.out.println("s2:"+s2);
        //abcde
        System.out.println("s2.length():"+s2.length());//5
        System.out.println("----------------------");

        /**
         * 编码和解码
         */
        //定义一个字符串:
        String s = "你好" ;
        //[-60, -29, -70, -61]  :GBK
        //[-28, -67, -96, -27, -91, -67]:utf-8
//      byte[] bys2 = s.getBytes("utf-8") ;//编码:以:GBK格式编码     utf-8:一个中文:对应三个字节
        byte[] bys2 = s.getBytes() ;
//      System.out.println(bys2);
        //Arrays:数组工具类:toString(byte[] bys)
        System.out.println(Arrays.toString(bys2));

        System.out.println("-------");
//      String str = new String(bys2, "utf-8") ;
        String str = new String(bys2) ;
        System.out.println("str:"+str);

        System.out.println("------------------");
        //public String(char[] value):将字符数组构造成一个字符串
        //定义一个字符数组
        char[] chs = {'我','爱','高','圆','圆'} ;
        String s3 = new String(chs) ;
        System.out.println("s3.length():"+s3.length());
        System.out.println("s3:"+s3);

        System.out.println("--------------------");
        String s4 = new String(chs, 1, 4) ;
        System.out.println("s4:"+s4);
        System.out.println("s4.length():"+s4.length());

        System.out.println("--------------------");
        //public String(String original):通过字符串常量构造一个字符串对象
        String s5 = new String("hello") ;
        System.out.println("s5:"+s5);
        System.out.println("s5.length():"+s5.length());

        String s6 = "hello" ;
        System.out.println("s6:"+s6);
        System.out.println("s6.length():"+s6.length());
    }
}

2.String类的中常用的判断功能:

    boolean equals(Object obj):当前该对象是否obj这个对象是否相等;
    boolean equalsIgnoreCase(String str):比较字符串是否相等,忽略大小写
    boolean contains(String str):判断str这个字符串是否包含在当前字符串中
    boolean startsWith(String str):是否以str子字符串开头
    boolean endsWith(String str):判断是否以str子字符串结尾
    boolean isEmpty():判断字符串是否为空

    String s = ""    ;空字符
    String s = " " ;字符串"空格"
    String s = null ;当前字符串对象为空

public class StringDemo {

    public static void main(String[] args) {

        //定义一个字符串
        String s1 = "helloworld" ;
        String s2 = "HelloWorld" ;

//      boolean equals(Object obj):当前该对象是否obj这个对象是否相等;String重写equals(),比较的是两个字符串的内容是否相同
        System.out.println("equals:"+s1.equals(s2));
        //boolean equalsIgnoreCase(String str):比较字符串是否相等,忽略大小写
        System.out.println("equalsIgnoreCase:"+s1.equalsIgnoreCase(s2));

        //boolean contains(String str):判断str这个字符串是否包含在当前字符串中
        System.out.println("contains:"+s1.contains("owo"));
        System.out.println("contains:"+s1.contains("ak47"));

        //boolean startsWith(String str):是否以str子字符串开头
        System.out.println("starsWith:"+s1.startsWith("hel"));
        //boolean endsWith(String str):判断是否以str子字符串结尾  自己测试

        //boolean isEmpty():判断字符串是否为空
        System.out.println("isEmpty:"+s1.isEmpty());
    }
}

3.String类的获取功能:

    int length()        :获取字符串长度功能
    char charAt(int index):返回的是索引处对应的字符
    int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引
            为什么这里的字符用int来定义:        97      'a'
    int indexOf(String str):返回指定子字符串在此字符串中第一次出现的索引
    int indexOf(int ch,int fromIndex):返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
    int indexOf(String str,int fromIndex):返回在此字符串中第一次出现指定字符串处的索引，从指定的索引开始搜索

    String substring(int start):从指定位置开始截取字符串,默认截取到末尾
    String substring(int start,int end):从指定位置开始截取到指定位置结束,包前(start索引)不包后(end索引)

public class StringDemo {

    public static void main(String[] args) {
        //定义一个字符串:
        String str = "helloworld" ;

        //int length()  :获取字符串长度功能
        System.out.println("length:"+str.length());

        //char charAt(int index):返回的是索引处对应的字符
        System.out.println("charAt:"+str.charAt(1));
        System.out.println("charAt:"+str.charAt(8));
        System.out.println("-------------------------------");

        //int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引
        System.out.println("indexof:"+str.indexOf('l'));
        System.out.println("indexof:"+str.indexOf('k'));//-1

        //int indexOf(String str):返回指定子字符串在此字符串中第一次出现的索引
        System.out.println("indexOf:"+str.indexOf("owo"));
        System.out.println("-------------------------------");
        //int indexOf(int ch,int fromIndex):返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
        System.out.println("indexOf:"+str.indexOf('l', 4));

        //int indexOf(String str,int fromIndex):返回在此字符串中第一次出现指定字符串处的索引，从指定的索引开始搜索 (自己测试)

        //String substring(int start):从指定位置开始截取字符串,默认截取到末尾(返回一个新的字符串,不再是字符串本身!)
        System.out.println("substring:"+str.substring(5));

        //String substring(int start,int end):从指定位置开始截取到指定位置结束,包前(start索引)不包后(end索引)
        System.out.println("substring:"+str.substring(4, 8));//owor
    }
}

4.String类的转换功能(重点)

byte[] getBytes():将字符串转换字节数组
char[] toCharArray():将字符串转换成 字符数组 (开发中经常使用)
static String valueOf(char[] chs):将字符数组转换成字符串
static String valueOf(int i):将一个int类型的数据转换成字符串

注意:String类中的valueOf()可以将任何数据类型转换成字符串

String toLowerCase():将字符串全部转成小写
String toUpperCase():将字符串全部转换成大写
String concat(String str):字符串拼接方法

public class StringDemo {

    //构造方法:
    //构造方法不能使用递归
    /*public StringDemo(){
        StringDemo();
    }*/

    public static void main(String[] args) {
        //定义一个字符串
        String s = "JavaSE" ;

        //byte[] getBytes():将字符串转换字节数组
        byte[] bys = s.getBytes() ;
        //遍历字节数组
        for(int x = 0 ; x < bys.length ; x++){
            System.out.println(bys[x]);
        }
        System.out.println("---------------------");

        //char[] toCharArray():将字符串转换成 字符数组
        char[] chs = s.toCharArray() ;
        for (int x = 0; x < chs.length; x++) {
            System.out.println(chs[x]);
        }

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

        //static String valueOf(char[] chs):将字符数组转换成字符串
        String s2 = String.valueOf(chs) ;
        System.out.println("s2:"+s2);

        //static String valueOf(int i):将一个int类型的数据转换成字符串
        String s3 = String.valueOf(100) ;
        System.out.println("s3:"+s3);

        //String toLowerCase():将字符串全部转成小写
        System.out.println("toLowerCase:"+s.toLowerCase());
        //String toUpperCase():将字符串全部转换成大写
        System.out.println("toUpperCase:"+s.toUpperCase());

        //String concat(String str):字符串拼接方法
        String s4 = "hello" ;
        String s5 = "world" ;
        System.out.println("contact:"+s4.concat(s5));

        String s6 = "java" ;
        s6 += "web" ;
        System.out.println("s6:"+s6);
        }

二.StringBuffer类

线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。 

可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。 

StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。 

例如，如果 z 引用一个当前内容为 "start" 的字符串缓冲区对象，则此方法调用 z.append("le") 会使字符串缓冲区包含 "startle"，而 z.insert(4, "le") 将更改字符串缓冲区，使之包含 "starlet"。 

通常，如果 sb 引用 StringBuilder 的一个实例，则 sb.append(x) 和 sb.insert(sb.length(), x) 具有相同的效果。

面试题:

StringBuffer和String 的区别?
StringBuffer会构造一个字符串缓冲区,从内存角度考虑,一般情况使用StringBuffer比较多(在单线程程序中使用StringBulider替代
StringBuffer:线程不安全,单线程单纯为了提供执行效率!)
String:普通的一个字符串,从内存角度考虑,耗费空间!

StringBuffer的构造方法(三种初始化方式):

public StringBuffer()
说明：构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符
public StringBuffer(int capacity)
说明：构造一个不带字符，但具有指定初始容量的字符串缓冲区
public StringBuffer(String str)
说明：构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容；该字符串的初始容量为 16 加上字符串参数的长度。

常用的功能:

    public int length():获取字符串长度数
    public int capacity():获取当前字符串缓冲区的容量

    public class StringBufferDemo {

    public static void main(String[] args) {

      /* public StringBuffer()
       * 构造方法说明：构造一个其中不带字符的字符串缓冲区，其初始容量为 16个字符
       * 创建一个字符串缓冲区对象：
       * sb.length()：查看字符缓冲区字符长度
       * sb.capacity():查看字符缓冲区容量(看出默认的容量)
        */
        StringBuffer sb = new StringBuffer() ;
        System.out.println("sb.length:"+sb.length());   
        System.out.println("sb.capacity:"+sb.capacity());
        System.out.println("----------------------------");

        /*public StringBuffer(int capacity)
         *构造方法说明：构造一个不带字符，但具有指定初始容量的字符串缓冲区
         * 
         * */
        StringBuffer sb2 = new StringBuffer(50) ;
        System.out.println("sb2.length:"+sb2.length());
        System.out.println("sb2.capacity:"+sb2.capacity());//50
        System.out.println("----------------------------");
        /* public StringBuffer(String str)
         * 说明：构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容；
         * 该字符串的初始容量为 16 加上字符串参数的长度
         * */
        StringBuffer sb3 = new StringBuffer("hello") ;
        System.out.println("sb3.length:"+sb3.length());
        System.out.println("sb3.capacity:"+sb3.capacity());//默认:初始容量16 + 当前字符串长度

    }
}

1.StringBuffer中的和添加有关的方法

public StringBuffer append(int/String/char/boolean/double/float....)
  功能:当前这个方法追加,给缓冲中追加数据,返回字符串缓冲区本身(经常使用的)
public StringBuffer insert(int offset,String str)
  功能:在某一个位置处(索引)去插入str这个字符串,返回字符串缓冲区本身

public class StringBufferDemo2 {

    public static void main(String[] args) {

        //创建一个字符串缓冲区对象
        StringBuffer sb = new StringBuffer() ;

        //追加数据
        sb.append("hello") ;
        sb.append(true) ;
        sb.append(13.45) ;
        sb.append('A') ;
        sb.append(12.56F);
        System.out.println(sb);
        /* 对append说明：
         * 只是创建了一个对象(未开辟新的对象)，在原来对象的内容里添加新的内容
         * 对print()说明：重写了Object类toString方法
         * StringBuffer类中toString()方法
         * 说明：将字符缓冲区转换成String类型
         * */
        //链式编程sb.append("hello").append(true).append(13.45).append('A').append(12.56F);

        /*public StringBuffer insert(int offset,String str)
         *说明:在某一个位置处去插入str这个字符串,返回字符串缓冲区本身
         *内存情况(理解)
         **/    
        sb.insert(5, "world") ;
        System.out.println("sb:"+sb);
    }
}

2 . StringBuffer的删除功能:

    public StringBuffer deleteCharAt(int index)
    说明:删除指定位置处的字符,返回的是字符串缓冲区本身!
    public StringBuffer delete(int start,int end)
    说明:删除从指定位置开始到指定位置结束的字符,返回的是字符串缓冲区本身!

public class StringBufferDemo3 {

    public static void main(String[] args) {
        //创建字符串缓冲区对象
        StringBuffer sb = new StringBuffer() ;

        //给缓冲区追加数据
        sb.append("hello") ;
        sb.append("world") ;
        sb.append("java!!") ;

        /*public StringBuffer deleteCharAt(int index)
         *需求:要删除当前缓冲区中对应索引的字符
         */
        sb.deleteCharAt(14);
        sb.deleteCharAt(14);
        System.out.println("sb:"+sb);
        /*public StringBuffer delete(int start,int end)
         *从当前索引(star)开始,到(end-1)索引结束
         */
        sb.delete(5, 9);//删除制定位置字符
        System.out.println("sb:"+sb);

    }
}

3.StringBuffer的反转功能(重点掌握):

public StringBuffer reverse()
返回值类型：StringBuffer 
功能:将此字符串中的字符序列直接反转


public class StringBufferDemo4 {

    public static void main(String[] args) {

        //创建键盘录入对象
        Scanner sc = new Scanner(System.in) ;

        //录入并接收数据
        System.out.println("请您输入一个字符串:");
        String line = sc.nextLine() ;

        //可以创建字符串缓冲区对象
        StringBuffer sb = new StringBuffer(line) ;
        /*
         * public String toString()
         * 说明：StirngBuffer类型的toString()方法
         * 将StringBuffer类型转换成String类型
         */
        String result = sb.reverse().toString() ;
        System.out.println("result:"+result);
    }
}

5.StringBuffer的替换功能:

public StringBuffer replace(int start, int end,String str)
功能：从指定位置开始到指定位置(包前不包后)结束的字符用str子字符串去替代
返回值类型：StringBuffer


public class StringBufferDemo5 {

    public static void main(String[] args) {

        //创建字符串缓冲区对象
        StringBuffer sb = new StringBuffer() ;
        //给缓冲添加数据
        sb.append("hello") ;
        sb.append("world") ;
        sb.append("java") ;
        sb.replace(5, 10, "节日快乐") ; 
        System.out.println("sb:"+sb);
    }
}

6.StringBuffer的截取功能(得到字符串):

    public String substring(int start)
  功能:从指定位置默认截取到末尾,返回值是一个新的字符串
  返回值类型：String
 ******************************************
    public String substring(int start,int end)
  功能:从指定位置开始截取到指定位置结束,包前不包后,返回一个新的字符串
  返回值类型：String

public class StringBufferDemo6 {

    public static void main(String[] args) {
        //创建字符串缓冲区对象
        StringBuffer sb = new StringBuffer() ;

        //添加
        sb.append("hello") ;
        sb.append("world") ;
        sb.append("java") ;
        //截取形成新的字符串(创建了一个新的对象)      
        String s1 = sb.substring(5) ;
        System.out.println("s1:"+s1);
        //此时字符串缓冲区内容(可以看到上述操作并未对缓冲区内容进行操作,原因？)
        System.out.println("sb:"+sb);
        //截取形成新的字符串(创建了一个新的对象)
        String s2 = sb.substring(5,10) ;
        System.out.println("s2:"+s2);
        //此时字符串缓冲区内容(可以看到上述操作并未对缓冲区内容进行操作)
        System.out.println("sb:"+sb);
    }
}

补充：

String,StringBuffer,StringBuilder的区别?
从可变性：
String:一个不可变的字符序列,
StringBuffer和StringBuilder是可变的字符序列,在单个线程时候的时候(优先采用StringBuilder)
从线程角度考虑:
StringBuilder线程不安全,不同步,执行效率高!它比StringBuffer要快!

String和StringBuffer作为形式参数

String类型作为形式参数和基本数据类型作为形式参数的效果一样!


public class StringBufferDemo7 {

    public static void main(String[] args) {

        //定义两个字符串
        String s1 = "hello" ;
        String s2 = "world" ;
        System.out.println(s1+"---"+s2);
        change(s1,s2);//自己定义方法
        System.out.println(s1+"---"+s2);
        System.out.println("---------------------");
         //定义两个字符串缓冲区对象
        StringBuffer sb1 = new StringBuffer("hello") ;
        StringBuffer sb2 = new StringBuffer("world") ;
        System.out.println(sb1+"---"+sb2);//hello---world
        change(sb1,sb2);//调用方法
        System.out.println(sb1+"---"+sb2);//hello---worldworld
        //缓冲区是不变()
    }

    public static void change(StringBuffer sb1 ,StringBuffer sb2){
        sb1 = sb2 ;  //缓冲区不变"world"
        /**
         * 形参其实是与实参指向同一个对象的不同引用(堆和方法(形参)区);
         * 在方法区也有一个sb1和sb2，将对象(引用)分别辅给sb1,sb2；
         * 此时将sb2指向sb1，此时理解为(方法区)这两个引用指向同一个对象("world");
         * 此时再sb2.append(sb1);就是在sb2的缓冲区内继续添加内容，sb1不变
         * 自己可以画个内存形式图：
         * */
        sb2.append(sb1) ;//worldworld
    }

    public static void change(String s1,String s2){
        s1 = s2 ;
        s2 = s1 + s2 ;
    }
}

wll_peng

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java 常用类之String-StringBuffer

一.String类：String 类代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。字符串是常量；它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的，所以可以共享。1.String类常用的构造方法: String():表示一个空字符序列。 public String(byte[] bytes,Char
复制链接

扫一扫