12--String类相关习题总结

第一题

反转键盘录入的字符串。（其实在StringBuilder中有reverse方法可以实现字符串反转）
代码实现，效果如图所示：

开发提示：

使用字符数组保存原始字符，利用Random类生成随机索引。

参考答案：

public class Test1 {
   public static void main(String[] args) {
       Scanner scanner = new Scanner(System.in);
       String next = scanner.next();
       System.out.println("录入的字符串:" + next);
       String s = reverseStr(next);
       System.out.println("反转的字符串:"+ s);
  }

   public static String reverseStr(String  str){
       String s = "";
       char[] chars = str.toCharArray();
       for (int i = chars.length - 1; i >= 0; i--) {
           s +=chars[i] ;
      }
       return s;
  }
}

第二题

键盘录入QQ号码，验证格式的正确性。
```
 必须是5—12位数字。
 0不能开头。
```
代码实现，效果如图所示：
参考答案：

public class Test2 {
   public static void main(String[] args) {
       //1.键盘输入一个qq号码字符串
       Scanner sc = new Scanner(System.in);
       String qq = sc.next();
       //2.调用checkQQ (String qq)方法内实现验证。
       boolean isOK = checkQQ(qq);
       //3.打印验证的结果
       System.out.println("这个QQ号码是否正确:" + isOK);
  }

   /*
    * 定义方法：checkQQ (String qq)方法内实现验证
    * 指定方法的名称：checkQQ
    * 指定方法的参数：String qq
    * 指定方法的返回值：boolean
    */
   public static boolean checkQQ(String qq){
       //1.验证字符串的长度5-12位之间；
       if (qq.length()<5 || qq.length()>12 ) {
           return false; //说明qq号码的长度不正确
      }
       //2.验证首位字符不能是字符0；只能是字符'1'--'9'
       if (qq.charAt(0) == '0') {
           return false;
      }
       //3.验证字符串中的每个字符都必须是数字字符‘0’-‘9’之间的字符
       for (int i = 0; i < qq.length(); i++) {
           char ch = qq.charAt(i);
           //判断字符是否在 数字字符‘0’-‘9’之间的字符
           if (ch<'0' || ch>'9') {
               return false;//说明qq号码中含有非数字字符
          }
      }
       //4.上述验证都通过了，说明qq号码是正确的
       return true;
  }
}

第三题

字符串查找。

 键盘录入一个大字符串，再录入一个小字符串。
 统计小字符串在大字符串中出现的次数。

代码实现，效果如图所示：
参考答案：

public class Test3 {
   /*
    * 分析以下需求，并用代码实现
       1.键盘录入一个大字符串,再录入一个小字符串
       2.统计小字符串在大字符串中出现的次数
       3.代码运行打印格式:
           请输入大字符串:woaiheima,heimabutongyubaima,wulunheimahaishibaima,zhaodaogongzuojiushihaoma
           请输入小字符串:heima
           控制台输出:小字符串heima,在大字符串woaiheima,heimabutongyubaima,wulunheimahaishibaima,zhaodaogongzuojiushihaoma中共出现3次
    */

   public static void main(String[] args) {
       Scanner sc = new Scanner(System.in);
       // 1.键盘录入一个大字符串,再录入一个小字符串
       System.out.print("请输入大字符串:");
       String big = sc.nextLine();
       System.out.print("请输入小字符串:");
       String small = sc.nextLine();
       // 2.统计小字符串在大字符串中出现的次数
       int count = getCount(big, small);
       // 3.代码运行打印格式:
       System.out.println("小字符串" + small + ",在大字符串中共出现" + count + "次");
  }

   /*
    * 方法功能：统计小字符串在大字符串中出现的次数
    * 参数：big 代表大字符串
    * 参数：small 代表小字符串
    * 返回值：小字符串在大字符串中出现的次数
    */
   public static int getCount(String big, String small) {
       int index = 0;
       int count = 0;
       /*
        * indexOf(String str, int fromIndex)
        * 该方法作用：从fromIndex位置开始查找，字符串str第一次出现的位置；若没找到，放回-1
        */
       while ((index = big.indexOf(small, index)) != -1) {
           index++;
           count++;
      }
       return count;
  }
}

第四题

替换某字符串中的某字符串。

 键盘录入一个srcStr字符串，再录入一个delStr字符串。
 删除该字srcStr符串中的所有delStr字符串。

代码实现，部分效果如图所示：

在这里插入图片描述

参考答案：

public class Test4 {
   public static void main(String[] args) {
       Scanner sc = new Scanner(System.in);
       // 1.键盘录入一个源字符串由字符串变量scrStr接收
       System.out.print("请输入源字符串:");
       String srcStr = sc.nextLine();
       // 2.键盘录入一个要删除的字符串由字符串变量delStr接收
       System.out.print("请输入要删除的字符串:");
       String delStr = sc.nextLine();
       // 3.删除该字scrStr符串中的所有delStr字符串（最终的字符串中不能包含delStr），要求打印删除后的结果以及删除了几个delStr字符串
       printCount(srcStr, delStr);
  }

   //删除该字scrStr符串中的所有delStr字符串（最终的字符串中不能包含delStr），要求打印删除后的结果以及删除了几个delStr字符串
   private static void printCount(String srcStr, String delStr) {
       //删除后的结果
       String resultStr = srcStr.replace(delStr, "");
       //删除了几个delStr字符串
       int count = (srcStr.length() - resultStr.length()) / delStr.length();

       System.out.println("源字符串中总共包含:"+ count +" 个 "+ delStr +" ,\r\n删除"+ delStr +"后的字符串为: "+ resultStr);
  }
}

第五题

生成一个随机100内小数，转换为保留两位小数的字符串，不考虑四舍五入的问题。
代码实现，效果如图所示：

在这里插入图片描述

参考答案：

public class Test5 {
   public static void main(String[] args) {
       double random = Math.random()*100;
       System.out.println("随机数为:");
       System.out.println(random);
       String str = random+"";
       int index = str.indexOf(".");
       //System.out.println(index);
       String substring = str.substring(0, index + 3);
       System.out.println("转换为:");
       System.out.println(substring);
  }
}

第六题

筛选字符串。

 定义ArrayList集合，存入多个字符串。
 长度大于5的字符串，打印删除后的集合。

代码实现，效果如图所示：

在这里插入图片描述

参考答案：

public class Test6 {
   public static void main(String[] args) {
       ArrayList<String> list = getArrayList();
       System.out.println("源字符串:");
       System.out.println(list);
       //删除集合中长度大于5的元素
       delStrsFromList01(list);
       System.out.println("删除后:");
       System.out.println(list);
  }

   //返回存储多个字符串的ArrayList集合
   private static ArrayList<String> getArrayList() {
       ArrayList<String> list = new ArrayList<>();
       list.add("bca");
       list.add("dadfa");
       list.add("dddaaa");
       list.add("你好啊");
       list.add("我来啦,你干嘛呢");
       list.add("别跑啊");
       return list;
  }

   //删除list集合中所有长度>5的字符串
   private static void delStrsFromList01(ArrayList<String> list) {
       //创建ArrayList集合对象
       ArrayList<String> newList =  new ArrayList<String>();
       //遍历原集合对象
       for(int i = 0;i<list.size();i++) {
           //获取当前元素
           String str = list.get(i);
           //如果str的长度大于等于5
           if(str.length()>5) {
               newList.add(str);//将str添加到新集合中
          }
      }
       //遍历新集合
       for(Object str : newList) {
           //因为新集合中的元素就是要删除的元素
           list.remove(str);
      }
  }
}

第七题

判断回文字符串。如果一个字符串，从前向后读和从后向前读，都是一个字符串，称为回文串，比如mom，dad，noon。
代码实现，效果如图所示：
参考答案：

public class Test7 {
   public static void main(String[] args) {
       Scanner scanner = new Scanner(System.in);
       String next = scanner.next();
       boolean p = isP(next);
       System.out.println(
               "回文数:" + p
      );
  }

   public static boolean isP(String str) {
       int start = 0;
       int end = str.length() - 1;
       while (start < end) {
           if (str.charAt(start) != str.charAt(end)) {
               return false;
          }
           start++;
           end--;
      }
       return true;
  }
}

第八题

校验密码是否合法。

 必须至少8个字符。
 必须至少2个大写字符。
 必须只有字母和数字。

代码实现，效果如图所示：
参考答案：

public class Test8 {
   public static void main(String[] args) {
       String s = "qweRY123";
       System.out.println(s+" 密码是否合法:"+isV(s));
  }

   public static boolean  isV(String pwd){
       if (pwd.length()<8){
           return false;
      }

       int countA = 0;
       char[] chars = pwd.toCharArray();
       for (int i = 0; i < chars.length; i++) {
           char ch  = chars[i];
           // 2个 大写字符
           if (ch >='A' && ch<='Z'){
               countA++;
          }

           // 字母数字
           if ((ch < '0'|| ch>'9') && (ch < 'A'|| ch>'Z')&&(ch < 'a'|| ch>'z')) {

               return false;
          }
      }
       if (countA < 2) {
           return false;
      }
       return true;
  }
}

第九题

模拟用户登录。

 定义用户类，属性为用户名和密码。
 使用集合存储多个用户对象。
 录入用户和密码，对比用户信息，匹配成功登录成功，否则登录失败。
 登录失败时，当用户名错误，提示没有该用户。
 登录失败时，当密码错误时，提示密码有误。

代码实现，效果如图所示：
参考答案：

public class Test10 {
   static ArrayList<User> list = new ArrayList<>();
   static {
       list.add(new User("jack", "1234"));
       list.add(new User("rose", "5678"));
       list.add(new User("tom", "0000"));
       for (int i = 0; i < list.size(); i++) {
          list.get(i).show();
      }
  }
   public static void main(String[] args) {
       Scanner sc = new Scanner(System.in);
       System.out.println("请输入用户名");
       String username = sc.nextLine();
       System.out.println("请输入密码");
       String password = sc.nextLine();
       User  u = new User(username,password);
       String login = login(u);
       System.out.println("登录结果:"+login);
  }

   public static String login(User  user){
      String msg  = "";
       String n = user.getUsername();
       String p = user.getPwd();
       for (int i = 0; i < list.size(); i++) {
           User u  = list.get(i);
           String name = u.getUsername();
           String pwd = u.getPwd();
           if(name.equals(n)) {
               if (pwd.equals(p)) {
                   return "登录成功";
              }else {
                 // 密码错误
                  return  "密码错误";
              }
          }else{
               msg = "用户名不存在"; //用户名不匹配
             continue;
          }
      }
       return msg ;
  }
}

class User{
   private String username;
   private String pwd;

   public User() {
  }

   public User(String username, String pwd) {
       this.username = username;
       this.pwd = pwd;
  }

   public String getUsername() {
       return username;
  }

   public void setUsername(String username) {
       this.username = username;
  }

   public String getPwd() {
       return pwd;
  }

   public void setPwd(String pwd) {
       this.pwd = pwd;
  }

   public void show() {
       System.out.println(username+"-"+pwd);
  }
}

第十题

简述StringBuilder类与String类的区别。

  答：String类的对象内容不可改变，所以每当进行字符串拼接时，
 	 总是会在内存中创建一个新的对象，所以经常改变内容的字符串
 	 最好不要用String，因为每次生成对象都会对系统性能产生影响。
 	 
     StringBuilder又称为可变字符序列，是JDK5.0中新增加的一个类，
     它是一个类似于String的字符串缓冲区，通过某些方法调用可以改
     变该序列的长度和内容。即它是一个容器，容器中可以装很多字符
     串，并且能够对其中的字符串进行各种操作。它的内部拥有一个数
     组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新
     内容，StringBuilder会自动维护数组的扩容。

第十一题

分别使用String的 +=和StringBuilder的append方法对字符串做100000次拼接，计算String拼接100000次花费时间与StringBuilder拼接100000次所花费时间并打印。

public class StringBuilder01 {

    public static void main(String[] args) {

        //使用System的currentTimeMillis()方法获取当前操作系统的毫秒值,作用程序执行的开始时间,使用start变量接收

        long start = System.currentTimeMillis();

        //需要测试执行性能的代码

        //testString(); //消耗时间: 29295毫秒

        testStringBuilder();//消耗时间:6毫秒

        //使用System的currentTimeMillis()方法获取当前操作系统的毫秒值,作用程序执行的结束时间,使用end变量接收

        long end = System.currentTimeMillis();

        //计算代码执行花费的时间 end - start,输出代码执行消耗的时间

        System.out.println("所花费的时间为:"+(end-start));

    }


    //写一个静态方法: testString(),在该方法中

    public static void  testString(){

        //定义一个字符串 str,内容随意

        String str = "hello";

        //写一个循环100000次for循环,在循环中写上

        for(int i = 0; i<100000;i++){

      //str +=”随机内容” ; 这里不要写str += (str+”xxx”) 这样会导致堆内存溢出错误.

            str += "world";

        }

    }

    //写一个静态方法:testStringBuilder(),在方法中

    public static void testStringBuilder(){

        //创建一个StringBuilder对象sb,初始内容与testString()中的字符串相同

        StringBuilder sb = new StringBuilder("hello");

        //写一个循环100000次for循环,在循环中写上

        for(int i = 0; i<100000;i++){

            //调用sb.append()方法,传入的内容与testString()方法中+=后面的内容一样

            sb.append("world");

        }

        //循环结束调用sb.toString()方法转换为字符串

        String newStr = sb.toString();

    }

}

第十二题

分析以下需求，并用代码实现：

(1)定义数字字符串数组{"010","3223","666","7890987","123123"}；
(2)判断该数字字符串数组中的数字字符串是否是对称(第一个数字和最后一个数字相等，第二个数字和倒数第二个数字是相等的，依次类推)的，并逐个输出；
(3)如：010 是对称的，3223 是对称的，123123 不是对称的；
(4)最终打印该数组中对称字符串的个数。

注：判断对称可用reverse(),将此字符序列用其反转形式取代。

public class StringBuilderTest02 {
    public static void main(String[] args) throws IOException {
        //定义数字字符串数组
        String[] str = {"010","3223","666","7890987","123123"};
        SBTest(str);
    }

    public static void SBTest(String[] str) {
        int count = 0;
        //遍历定义的字符串数组
        for (String string : str) {
            //创建StringBuilder对象
            StringBuilder sb = new StringBuilder(string);
            //调用reverse()方法，将遍历的数字进行反转，然后用equals()方法对比是否与原数字相同
            if (sb.reverse().toString().equals(string)) {
                count++;
                System.out.println(string + "是对称的");
            }
        }
        System.out.println("总数为" + count);
    }

第十三题

分析以下需求，并用代码实现：

       (1)打印由7，8，9三个数组成的三位数，要求该三位数中任意两位数字不能相同；
       (2)打印格式最后的三位数字以空格分隔，如789 798 879 897 978 987。

注：要求使用StringBuilder来完成

public class StringBuilderTest03 {

    public static void main(String[] args) throws IOException, Exception {

        SBTest();

    }


    public static void SBTest() {

        //定义由7、8、9组成的字符串

        String s = "789";

        //创建StringBuilder对象

        StringBuilder sb = new StringBuilder();

        //采用嵌套for循环，遍历字符串

        for (int i = 0; i < 3; i++) {

            //遍历字符串s，把字符依次添加到StringBuilder内，组成一个元素

            for (int j = 0; j < s.length(); j++) {

                sb.append(s.charAt(j));

            }

            //当StringBuilder内元素为一个和两个时，需要加空格来隔开元素

            if (i != 2) {

                sb.append(" ");

            }

            //把字符串s的第一个元素切割，添加到字符串末位，组成新的字符串

            s = s.substring(1).concat(s.substring(0, 1));

        }

        // 把StringBuilder内元素反转，组成新的数字

        s = sb.toString() + " " + sb.reverse().toString();

        System.out.println(s);

    }

}

12--String类相关习题总结

第一题

第二题

第三题

第四题

第五题

第六题

第七题

第八题

第九题

第十题

第十一题

第十二题

第十三题

猜你喜欢