String 與StringBuffer習題

1: 畫出如下幾行代碼的結構

 

        // 畫出如下幾行代碼的結構

        String s1 = "hello";   // value存儲在常量池內
        String s2 = "hello";  // value存儲在常量池內 和s1指向同一個值
        String s3 = new String("hello"); // 創建兩個對象一個是在堆中創建, 一個是在char [] 中創建 指向常量池
        s1 += "world";  // value改變到堆中,堆中指向一個地址值, 然后這個地址值指向常量池,在常量池中新建一個value被指向

 

 

 

2: 如何理解String類的不可變性

不可變性,是因為我們再改變一個String的值時其實不是對以前的值進行修改,是新建立一個值, 把新的引用指向這個新建立的值 而不是對以前的修改

 

 

3: String類是否可被繼承,為什么?

不可被繼承,因為源碼中這個String類被聲明為final的  是不可以被繼承的

 

 

 

String s = new String("hello"); 在內存中創建幾個對象,請說明

在內存中創建兩個對象, 一個在堆中創建, 一個是在char[] 中創建,char [] 中指向常量池中的"hello"

 

 

 

4: String StringBuffer, StringBuild 三者的對比

String 是不可變的字符序列  效率三者最差

StringBuffer 可變的字符序列  線程安全,效率三者中等
StringBuilder 可變的字符序列  線程不安全, 效率三者第一

三者的底層都是char [] 存儲

 

 

5: String的常用方法 (7鍾)

indexOf(String str) 求str在字符串的下標
charAt(int n) 求字符串中下標n的字符
replace(String str, String str1)  把字符串中str 替換為str1
contains(String str) 判斷字符串是否包含str
concat(String str) 把字符串與str進行拼接
toLowerCase() 字符串中所有的字符全部小寫
toUpperCase() 字符串中所有的字符全部大寫
replcaeFirst(String str, String str1) 把字符串中第一個Str 替換為 str1

 

6: 將一個字符串的其中一部分內容進行翻轉

public class StrExerOne {
    public static void main(String[] args) {
        String reverseStr = "qwertyu";
        ReverseStr reverseStr1 = new ReverseStr();
        System.out.println(reverseStr1.getReverse(reverseStr, 2, 5));

        ReverseStringBuilder reverseStringBuilder = new ReverseStringBuilder();
        System.out.println(reverseStringBuilder.getReverse(reverseStr, 2,5));
    }
}


// 第一種轉化為 char [] 
class ReverseStr {

    public String getReverse(String str, int start, int end) { // 要翻轉的字符串和要翻轉的下標開始和下標結束的
        char[] chars = str.toCharArray();
        for (int x = start, y = end; x < y; x++, y--) {  // 對要翻轉的內容進行翻轉
            char temp = chars[x];
            chars[x] = chars[y];
            chars[y] = temp;
        }
        return new String(chars);
    }

}


//第二種轉化為StringBuilder  為什么用StringBuilder 因為效率高不是線程安全
class ReverseStringBuilder {

    public String getReverse(String masterStr, int start, int end) {
        String strSub = masterStr.substring(start, end + 1);
        StringBuilder stringBuilder = new StringBuilder(strSub);
        String reverseStr = stringBuilder.reverse().toString();
        return masterStr.replace(strSub, reverseStr);
    }


}

 

 

 

7: 獲取一個字符串在另一個字符串中出現的次數。比如:獲取“ ab”在 “abkkcadkabkebfkabkskab” 中出現的次數

 

/*
獲取一個字符串在另一個字符串中出現的次數。
比如:獲取“ ab”在 “abkkcadkabkebfkabkskab” 中出現的次數

 */

import sun.jvm.hotspot.debugger.posix.elf.ELFSectionHeader;

public class StringContains {
    public static void main(String[] args) {
        String str = "abkkcadkabkebfkabkskab";

        ContainsStr containsStr = new ContainsStr();
        System.out.println(containsStr.containsStr(str, "ab"));  // 4


        ContainsStrTwo containsStrTwo = new ContainsStrTwo();
        System.out.println(containsStrTwo.getContainsStr(str, "ab"));  // 4


    }
}


// 第一種方法是匹配到之后然后把葯匹配的位置向后移動一個匹配字符的長度之后再進行匹配

class ContainsStr {

    public int containsStr(String masterStr, String subStr) {
        int mainLength = masterStr.length();
        int subLength = subStr.length();
        int count = 0; // 計數
        int index;
        if (masterStr.length() > subStr.length()) {
            while ((index = masterStr.indexOf(subStr)) != -1) {  //判斷主字符串中有要匹配的內容  indexOf的內容等於-1是沒有內容
                count++;
                masterStr = masterStr.substring(index + subLength);  // 就是從匹配的這個數的下標之后加上他本身之后就是獲取到 這個匹配到的內容之后的字符串了
            }
            return count;
        } else {
            return -1;
        }
    }

}




// 第二種方法是  從一開始就進行匹配 ,然后匹配完無論是不是正確都向后選取要匹配的字符長度進行匹配

// 就是要確保選取匹配的字符是在不停的向后移動位置

class ContainsStrTwo{

    public int getContainsStr(String masterStr, String subStr){
        int masterLength = masterStr.length();
        int subStrLength = subStr.length();
        int count = 0;
        int index = 0 ;  // 要匹配的位置
        while ((index = masterStr.indexOf(subStr, index)) != -1){  //先從第一次開始匹配, 下面不停的改變index的參數讓它每次都向后移動一個匹配字符串的長度
            count++;
            index += subStrLength;  // 改變匹配的位置
        }
        return count;
    }


}

 

 

8 :請給出下面的輸出內容

        String str1 = "老王";
        String str2 = "老王";
        String str3 = new String("老王");
        System.out.println(str1 == str2);  // 
        System.out.println(str1 == str3); // 
        System.out.println(str1.equals(str3));  // 
        str1 = "老張隔壁";
        str2 = "老張";
        String str4 = "隔壁";
        String str5 = "老張" + "隔壁";
        System.out.println(str1 == str5);  // 

        String str6 = (str2 + str4).intern();
        System.out.println(str1 == str6);//

 

true
false
true
true
true

 

9： String s = new String("xyz");創建了幾個String Object

答：兩個，一個字符對象，一個字符對象引用對象

 

10：是否可以繼承String類

 

答：String類是final類故不可以繼承

 

11 : String與StringBuffer的區別

答：String的長度是不可變的，StringBuffer的長度是可變的。如果你對字符串中的內容經常進行操作，特別是內容要修改時，
   那么使用StringBuffer，如果最后需要String，那么使用StringBuffer的toString()方法

 

12:判斷題：

1．用運算符“==”比較字符串對象時，只要兩個字符串包含的是同一個值，結果便為 true。（）
2．String 類字符串在創建后可以被修改。（）
3．方法 replace (String srt1, String srt2)將當前字符串中所有 srt1 子串換成 srt2子串。
4．方法compareTo在所比較的字符串相等時返回 0。（）
5．方法IndexOf((char ch,-1)返回字符ch在字符串中最后一次出現的位置。（）
6．方法startsWith()判斷當前字符串的前綴是否和指定的字符串一致。（）

 

1： false  因為有字符串常量和字符串對象 字符串常量放在常量池內 字符串對象放在堆中

2： false  不可以被修改 只可以重新賦值 原值不可以修改，只可以對指向的原值的內存區域重新分配新的內存區域，不可以對原值的內存區域修改

3：false 是把當前字符串內的所有str2全部替換為str1

4: true 前者值比后者值大時返回1  兩者相等返回0 后者比前者大返回-1. 兩者相等 故為0

5： false  indexOf() 返回的是char在String中第一次出現的位置

6： true  startWith(char ch) 是判斷ch是否是String的開端字符

 

13 ：選擇題

1.下面哪個選項正確地聲明了一個字符串數組：
　　A char str[] 
　　B char str[][]
　　C String str[] 
　　D String str[10] 
2. 請看下面的程序段：
　　public class class1{ 
　　　　public static void main(String a[]) {
　　　　　　int x [] = new int[8]; 
　　　　　　System .out .println(x [1]); 
　　　　}
　　 } 
當編譯和執行這段代碼時會出現：
    A 有一個編譯錯誤為“possible reference before assignment” 
    B 有一個編譯錯誤為“illegal array declaration syntax” 
　　C 有異常出現為“Null Pointer Exception”
　　D 正確執行並且輸出 0 
3．已知 String 對象 s="abcdefg"，則s.substring(2, 5)的返回值為____。
    A "bcde"  
    B "cde" 
    C "cdef"
    D "def" 
4.請看下面的代碼 String s = “people”; String t = “people”; String c[ ] = {“p”,”e”,”o”,”p”,”l” ,”e”}; 
下面哪一選項的語句返回值為真：
   A s .equals(t); 
   B t .equals(c); 
   C s==t; 
   D t .equals(new String(“people”)); 
   E t==c; 
5．已知 s 為一個 String 對象，s="abcdefg"，則s.charAt(1)的返回值為____。
    A a 
    B b 
    C f 
    D g 
6.請看下面的代碼 String s = “good”; 下面選項語句書寫正確的是：
　　A s += “student”; 
　　B char c = s[1]; 
　　C intlen = s .length; 
　　D String t = s.toLowerCase( ); 
7.正確創建一個含有 5 個元素的字符串數組的選項是：
　　A String s[ ] = new String[5]; for(int i=0;i<5;s[i++]=“”); 
　　B String s[ ]={“”, “”, “”, “”, “”}; 
　　C String s[5];
　　D String [5]s; 
8.請看下面的代碼
public class class1{ 
　　String str = new String("Girl"); 
　　char   ch[ ]={'d','b','c'}; 
　　public static void main(String args[ ]){
　　　　class1 x=new class1( );
　　　　x.change(x.str,x.ch);
　　　　System .out .println(x.str +" and "+x.ch[0]+x.ch[1]+x.ch[2]); 
} 
   public void change(String str,charch[ ]){
　　　　str="Boy"; 
       ch[0]='a'; 
   } 
}
該程序的輸出結果是：
　　A Boy and dbc
　　B Boy and abc 
　　C Girl and dbc 
　　D Girl and abc

 

1 ： c  。  a和b都不是String  d的寫法不對


2 : d 輸出0 因為數組時建立了一個長度為8的數組但是數組內的內容都沒有指定所以都是空

3: B, 因為字符串的截取subString()時左閉右開的所以2-5截取的時下標2到4的內容

4：A C, 因為s 和t的值都是存儲在常量池內然后常量池不允許存儲兩個相同的內，所以他們兩個==和equals()
        得到的內容都是相同的

5：B 因為charAt()內寫的時下標來獲取字符 indexOf()時字符來獲取下標所以 選擇B

6: A C D

7:B  其余幾種的寫法都是錯誤的

8：  Girl and abc  因為方法change的作用域內修改的內容在方法結束完就沒有了
    這個時候str的內容就又是Girl了 而char的內容在方法change修改其堆空間中的值時
    方法雖然關閉但是堆內存的地址值已經更改了

 

 

 14: 如何將String類型轉化Number類型？舉例說明String str = “123”;

答任意一個都對：
        Integer num1 = new Integer(str);
        或
        int num2 = Integer.parseInt(str);
        或
        Integer num3 = Integer.valueOf(str);

 

15：填空題

1．已知sb為StringBuffer的一個實例，且sb= "abcde "，則sB reverse()后sb的值為____。
2．已知sb為StringBuffer的一個實例，且sb= "abcde "，則sB delete(1,2)后sb的值為 ____。


1： edbda

2: acde

 

16:編程題

1．請編寫一個 Application 實現如下功能：接受命令行中給出的一個字母串，先將該串原樣輸出，
　　然后判斷該串的第一個字母是否為大寫，若是大寫則統計該串中大寫字母的個數，並將所有大寫字母輸出；
　　否則輸出信息串”第一個字母不是大寫字母!”。

 

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String strOne = scanner.nextLine();
        System.out.println(strOne);
        char strCh [] = strOne.toCharArray();
        char strStartOne = strCh[0];
        if((int)strStartOne >= 65 && (int)strStartOne <= 90){
            for (char chE: strCh) {
                if((int)chE >= 65 && (int)chE <= 90){
                    System.out.println(chE);
                }
            }
        }else {
            System.out.println("第一個字母不是大寫字母");
        }
    }

 

2．一個應用程序，接受用戶輸入的一行字符串，統計字符個數，然后反序輸出。

 

1： 

        Scanner scanner = new Scanner(System.in);
        String str= scanner.nextLine();
        System.out.println("字符串的長度為： "+str.length());
        StringBuffer stringBuffer = new StringBuffer(str);
        System.out.println(stringBuffer.reverse().toString());


2： 
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str= scanner.nextLine();
        System.out.println("字符串的長度為： "+str.length());

        char ch [] = str.toCharArray();
        String reverse = "";
        for (int  i =  ch.length-1; i >= 0; i--) {
            reverse += ch[i];
        }
        System.out.println(reverse);
    }

 

3.創建BigDecimalDemo類，在類中分別定義add(),sub(),mul()和div()方法實現加、減、乘、除運算，並輸出運算結果。要求除法，可以處理商的精度。

 

 

5. 模擬一個trim方法，去除字符串兩端的空格。
6. 將一個字符串進行反轉。將字符串中指定部分進行反轉。比如將“abcdefg”反轉為”abfedcg”
拓展：I am a student!   寫一個方法：實現輸出 !student a am I

7. 獲取一個字符串在另一個字符串中出現的次數。判斷str2在str1中出現的次數
8. 獲取兩個字符串中最大相同子串。
9. 對字符串中字符進行自然順序排序
10. 中國有句俗語叫“三天打魚兩天曬網”。如果從1990年1月1日起開始執行“三天打魚兩天曬網”。如何判斷在以后的某一天中是“打魚”還是“曬網”？

11.完成MathLib類，可以做加，減，乘，除等功能，其中加法不但可以做數字的加法，還可以做字符串的相加。
12. 任意給定的一串字母，統計字符串里面的大寫字母和小寫字母的個數。
13.根據傳入得路徑，獲取文件名。例如：D:\myfile\hello.java取出hello.java
14.根據傳入得路徑，獲取文件的類型名。例如：D:\myfile\hello.java取出.java
15. 求兩個日期之間相隔的天數
寫一個方法(例如：fun3("2010-09-20","2010-09-21") )，求輸入的字符串2010-09-20 與 2010-09-21 之間相隔的天數

16.編寫java程序，隨便輸入兩個單詞，兩個單詞之間以空格隔開，輸出時每個單詞的首字母變為大寫。如輸入：“hello java”，輸出為“Hello Java”
17.求出“hijavahehejavahejava”字符串里面包含幾個“java字符串。”
18.輸出字符串"ddejidsEFALDFfnef2357 3ed"里的大寫字母數，小寫英文字母數，非英文字母數
19.輸入一句5個字的話，然后將它逆序輸出。例如：
原數組：我愛你中國
逆序輸出：國中你愛我
提示：先聲明一個字符串數組，每個漢字作為字符串數組的一個元素，然后再從數組末尾開始循環輸出。

 

 

5：

public static String myTrim(String str){
    int start = 0;
    int end = str.length() - 1;
    while(start < end && str.charAt(start) == ' '){
        start++;
    }
    while(start < end && str.charAt(end) == ' '){
        end--;
    }
    if(start == end){
        return "";
    }
    return str.substring(start, end + 1);
}

 

6

public static String reverseString(String str,int start,int end){
    char[] c = str.toCharArray();//字符串--->字符數組
    return reverseArray(c,start,end);
    
}
public static String reverseArray(char[] c,int start,int end){
    for(int i = start,j = end;i < j;i++,j--){
        char temp = c[i];
        c[i] = c[j];
        c[j] = temp;
    }
    //字符數組--->字符串
    return new String(c);
}
//方式二：
public static String reverseString1(String str,int start,int end){
    String str1 = str.substring(0, start);
    for(int i = end;i >= start;i--){
        char c = str.charAt(i);
        str1 += c;
    }
    
    str1 += str.substring(end + 1);
    return str1;
}

 

7：

 獲取一個字符串在另一個字符串中出現的次數。判斷str2在str1中出現的次數

public static int getTime(String str1,String str2){
    int count = 0;
    int len;
    while((len = str1.indexOf(str2)) != -1){
        count++;
        str1 = str1.substring(len + str2.length());
    }
    
    return count;
}

8. 獲取兩個字符串中最大相同子串。

public static List<String> getMaxSubString(String str1,String str2){
    String maxStr = (str1.length() > str2.length())? str1 : str2;
    String minStr = (str1.length() < str2.length())? str1 : str2;
    int len = minStr.length();
    List<String> list = new ArrayList<>();
    for(int i = 0;i < len;i++){
        for(int x = 0,y = len - i;y <= len;x++,y++){
            String str = minStr.substring(x, y);
            if(maxStr.contains(str)){
                list.add(str);
            }
        }
        if(list.size() != 0){
            return list;
        }
    }
    return null;
}

 

9：

public static String sort(String str){
    char[] c = str.toCharArray();
    Arrays.sort(c);
    return new String(c);
}

 

10：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class GetFish {

    public static void main(String[] args) {
        String date1 = "1990/1/1"; // 開始“三天打魚兩天曬網”的日期
        String date2 = "1990/1/10"; // 手動輸入的日期
        long day = getQuot(date1, date2);// 傳入值計算時間差
        if (day % 5 == 0 || day % 5 == 4) {
            System.out.println("今天是休息日，可以曬曬網");
        } else {
            System.out.println("今天要工作，打魚了！");
        }

    }

    public static long getQuot(String time1, String time2) {
        long dayDistance = 0;
        SimpleDateFormat ft = new SimpleDateFormat("yyyy/MM/dd");
        try {
            Date date1 = ft.parse(time1);
            Date date2 = ft.parse(time2);
            dayDistance = date2.getTime() - date1.getTime();
            dayDistance = dayDistance / 1000 / 60 / 60 / 24 + 1;
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return dayDistance;
    }

}

 

13:

        String str = "D:\\myfile\\hello.java";
        String strCh [] = str.split("\\\\");
        String fileName = strCh[strCh.length-1];
        System.out.println(fileName);

 

14

        String str = "D:\\myfile\\hello.java";
        String strCh [] = str.split("[.]");
        String fileName = strCh[strCh.length-1];
        String file = ".";
        System.out.println(file.concat(fileName));

 

 

 

 

.