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:myfilehello.java取出hello.java
14.根据传入得路径，获取文件的类型名。例如：D:myfilehello.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));

.