操作类字符串（String，StringBuffer，StringBuilder）相关知识及常见笔试题

布满荆棘的人生 2023-01-17 03:21 50阅读 0赞

### 目录 ###

*  
 *   *  
     *   *  
 *  一、操作字符串及区别及相关考点
 *  二、String的常用方法
 *   *   *   *  （一）常用的构造方法
             *  (二) 常用的成员方法1
             *  (三) 常用的成员方法2
             *  (三) 常用的成员方法3
             *  (四) 常用的成员方法4
 *  三、StringBuilder常用方法
 *   *   *   *  （一）常用的构造方法
             *  （二）常见的成员方法
             *  （三）StringBuilder常见方法练习

#  #

##  ##

###  ###

# 一、操作字符串及区别及相关考点 #

1.java中常见的操作字符串有什么？
            String  StringBuffer  StringBuilder
        2.String，StringBuffer，StringBuilder 的区别
            （1）String修饰的是不可变的，String一旦被创建，里面的值便不可被改变，如果需要改变就需要创建新的对象。
            （2）StringBuffer和StringBuilder可以再原有对象的基础上进行操作：
            	   ①StringBuffer从jdk1.0开始存在，属于线程安全的类，性能低
                   ②StringBuilder从jdk1.5开始存在，属于线程不安全的类，性能高
                   ③ StringBuffer一般在多线程环境下使用
                     StringBulder一般在单线程环境下使用  
            （3）效率： StringBuilder>StringBuffer>String

String类：   public final class String {
        }
    StringBuilder类   public final class StringBuilder{
        }

1. String类能否被继承？
            不能，String类是被final修饰的类，该类是最终类，不能被继承。
        2. String底层存储数据的类型是什么？
            JDK1.9之前是char[]来存储数据，1.9之后用byte[]来存储数据，原因是我们存储的大多数数据都是一个字节，这样的情况下用char就会浪费一个字节，造成内存的浪费。
        3. String类型描述的字符串内容是常量，一旦定义是不可被改变的，因此会被虚拟机放在常量池中，如果后续我们的代码中有相同的字符串内容则直接可以使用常量池中已有的对象，无需创建新的对象，提高了性能。
        4. 请问下面的代码会创建几个对象？分别存放在什么地方？
            String str1="he";   //一个对象，存放在常量池
            String str2=new String("he");  //两个对象，一个在常量池中，一个在堆内存中
    	5. String str="abcdef";
           String str1="abc"+"def";
           System.out.println(str==str1);  //true，因为常量有优化机制，而变量没有
    	6. 既然StringBuilder类的对象本身可以修改，那么为什么还会有返回值呢？
            	返回值返回的是自身，目的为了连续调用，例如： s.reverse().append("a").insert(4,"s");
    	7. 如何实现StringBuilder类型与String类型之间的转换呢？
            	String转StringBuilder： StringBuilder sb=new StringBuilder(s)；
            	StringBuilder转String： String s=sb.toString();

# 二、String的常用方法 #

#### （一）常用的构造方法 ####

String ()       使用无参方式构造对象得到空字符串
            String(byte[] bytes,int offset,int length)     
            		使用bytes数组中下标从offset位置开始的length个字节来构造对象
            String(byte[] bytes)      使用bytes数组中的所有内容构造对象
            String(char[] value,int offset,int length)     
            		使用bytes数组中下标从offset位置开始的length个字节来构造对象
            String(char[] value)      使用value数组中的所有内容构造对象
            String(String original)     根据参数指定的字符串内容来构造对象，新创建对象为参数对象的副本

public class Test1 {
        
        public static void main(String[] args) {
        
            // 使用无参构造方式创建对象并打印
            String str=new String();
            System.out.println("str= "+str);
            // 创建一个字节型数组str1
            byte[] str1={
        88,89,45,88,52,89,98,58};
            // 使用参数指定的byte数组创建对象并打印
            String str2= new String(str1,2,5);
            System.out.println("str2= "+str2);
            // 使用byte数组创建对象并打印
            String str3=new String(str1);
            System.out.println("str3= "+str3);
            // 创建一个字符型对象str4
            char[] str4={
        88,89,90,91,99,100};
            System.out.println("str4= "+str4);
            // 使用参数指定的char数组创建对象并打印
            String str5=new String(str4,2,3);
            System.out.println("str5= "+str5);
            // 使用char数组创建对象并打印
            String str6=new String(str4);
            System.out.println("str6= "+str6);
        }
    }

#### (二) 常用的成员方法1 ####

String toString()          返回字符串本身
        byte[] getBytes()          将当前字符串内容转换为byte数组并返回
        char[] toCharArray()          将当前字符串内容转换为char数组并返回
        char  charAt(int index)       用于返回字符串指定位置的字符
        int length()            返回字符串字符序列的长度
        boolean isEmpty()             判断字符串是否为空

public class Test2 {
        
        public static void main(String[] args) {
        
            // 创建一个String对象赋值并输出
            String str=new String("abcdef");
            System.out.println(str);
            // 将str转为数组并输出
            byte[] str1=str.getBytes();
            for(Object o:str1){
        
                System.out.println(o);
            }
            System.out.println("-----------------------------------------------");
            // 输出字符串位置3的字符
            System.out.println("字符串中下标为3的元素为："+str.charAt(3));
            // 输出字符串长度
            System.out.println("字符串的长度为："+str.length());
            // 判断字符串是否为空
            System.out.println(str.isEmpty()?"字符串为空":"字符串不为空");
        }
    }

#### (三) 常用的成员方法2 ####

String concat(String str)       用于实现字符串的拼接
    	boolean contains(CharSequence s)       用于判断当前字符串是否包含参数指定的内容
    	String toLowerCase()         返回字符串的小写形式
        String toUpperCase()         返回字符串的大写形式
    	String trim()            返回去掉前面和后面空白的字符串
    	boolean startsWith(String prefix)       判断字符串是否以参数字符串开头
    	boolean startsWith(String prefix，int toffset)       
        						从指定位置判断字符串是否以参数字符串开头boolean
        boolean endsWith(String suffix)     判断字符串是否以参数字符串结尾

public class Test3 {
        
        public static void main(String[] args) {
        
            String arr=new String("  abhdhjdGHUJbbff ");
            System.out.println("arr=["+arr+"]");
            System.out.println("arr中包含as："+arr.contains("as"));
            System.out.println("arr中包含ab："+arr.contains("ab"));
            System.out.println("arr的小写形式："+arr.toLowerCase());
            System.out.println("arr的大写形式："+arr.toUpperCase());
            System.out.println("去掉前后空格的arr："+arr.trim());
            System.out.println("-----------------------------------------");
            // 判断字符转是否以a开头
            System.out.println(arr.startsWith("a")?"字符串以a开头":"字符串不以a开头");
            // 判断字符转是否以a结尾
            System.out.println(arr.endsWith("a")?"字符串以a结尾":"字符串不以a结尾");
        }
    }

#### (三) 常用的成员方法3 ####

boolean equals(Object object)   用于比较字符串是否相等并返回
        int hasgCode()    获取调用对象的哈希码值
        boolean equalsIgnoreCase(String anotherString)  
                   用于比较字符串内容是否相等并返回，不考虑大小写是否相等
        String sbustring(int beginIndex,int endIndex)
               返回字符串中从下标beginIndex开始到endIndex结束的子字符串
        String substring(int beginIndex)    
               返回字符串中从下标beginIndex开始到字符串结尾的子字符串

#### (四) 常用的成员方法4 ####

int indexOf(int c)    用于返回当前字符串中参数c指定的字符喜欢第一次出现的下标
        int indexOf(int c,int index)  用于从index位置开始查找c指定的字符
        int indexOf(String s)   在字符串中检索s返回其第一次出现的位置，若找不到返回-1
        int indexOf(String s,int index)  从字符串的index位置开始检索自渡川s第一次出现的位置
        int lastIndex(int c)    用于返回c指定的字符最后一次出现的下标
        int lastIndex(int c,int index)  用于从index位置开始查下好c指定字符出现的下标
        int lastIndexOf(String s)     返回s指定字符串最后一次出现的下标
        int lastIndexOf(String s,int index)   用于从index位置开始检索s第一次出现的下标

# 三、StringBuilder常用方法 #

#### （一）常用的构造方法 ####

StringBuilder()           使用无参方式构造对象，容量为16
        Stringbuider(int c)          根据参数指定的容量来构造对象，容量为参数指定大小
        StringBuilder(String s)          根据参数指定的字符串来构造对象，容量为：16＋字符串长度

#### （二）常见的成员方法 ####

int capacity()             用于返回调用对象的容量
        int length()             用于返回字符串的长度，也就是字符的个数
        StringBuilder insert(int offest,String s)
            	            在offest处插入字符串s并返回调用对象的引用
        StringBuilder append(String s)          追加字符串
        StringBuilder deleteCharAt(int index)      将当前字符串中下标为index位置的单个字符删除
        StringBuilder delete(int start,int end)      删除字符串从start到end，也就是删除字符串全部
        StringBuilder replace(int start,int end,String str)       替换字符串
        StringBuilder reverse()                  字符串反转

#### （三）StringBuilder常见方法练习 ####

public class Test1 {
        
        public static void main(String[]  args) {
        
            // 使用无参方式构造对象并输出
            StringBuilder s1 = new StringBuilder();
            System.out.println("无参构造的s1="+s1);
            // 输出对象的容量
            System.out.println("s1的容量的为："+s1.capacity());
            // 输出字符串长度，也就是s1里面存储的字符串个数
            // 由于创建时是无参，所以s1为什么都没有，长度为0
            System.out.println("s1的长度为："+s1.length());
            // 追加字符串
            s1.append("a");
            s1.append("b");
            s1.append("c");
            s1.append("d");
            s1.append(5);
            s1.append(6);
            System.out.println("追加过字符串后的s1："+s1);
            // 在指定位置插入字符串
            s1.insert(2,4);
            System.out.println("在2位置添加字符串4后的s1："+s1);
            // 删除指定位置的字符
            s1.deleteCharAt(1);
            System.out.println("删除1位置元素后的s1："+s1);
            // 字符串反转
            s1.reverse();
            System.out.println("反转过的s1："+s1);
            System.out.println("-----------------------------------------------------------");
            // 使用指定的字符串构造对象并输出
            StringBuilder s2 = new StringBuilder("huixianchangcun");
            System.out.println("指定参数构造的s2="+s2);
            // 输出对象的容量
            System.out.println("s2的容量的为："+s2.capacity());
            // 输出字符串长度，也就是s1里面存储的字符串个数
            System.out.println("s2的长度为："+s2.length());
            // 在指定位置插入字符串
            s2.insert(2,4);
            System.out.println("在2位置添加字符串4后的s2："+s2);
            // 删除指定位置的字符
            s2.deleteCharAt(2);
            System.out.println("删除2位置元素后的s2："+s2);
            // 字符串反转
            s2.reverse();
            System.out.println("反转过的s2："+s2);
            System.out.println("-------------------------------------------------------");
            // 替换字符串
            s2.replace(3,8, String.valueOf(s1));
            System.out.println("在s2指定位置用s1替换过后的s2："+s2);
        }
    }