Java语法笔记（五）：字符串

ASCII码

每个常用字符都对应一个-128 ~ 127的数字，二者之间可以相互转化。注意：目前负数没有与之对应的字符。

import java.util.Scanner;

public class Main
{
    public static void main(String[] args)
    {
        char c = 'a';
        System.out.println((int)c);

        int a = 66;
        System.out.println((char) a);
    }
}

输出

97
B

常用ASCII值：’A’- ‘Z’是65 ~ 90，’a’ - ‘z’是97 - 122，0 - 9是 48 - 57。

字符可以参与运算，运算时会将其当做整数：

public class Main
{
    public static void main(String[] args)
    {
        int a = 'B' - 'A';
        System.out.println(a);

        int b = 'A' * 'B';
        System.out.println(b);

        int c = 'A' + 2;
        System.out.println(c);
    }
}

输出

1
4290
67

String类

String类的初始化

public class Main
{
    public static void main(String[] args)
    {
        String a = "Hello World";
        String b = "Mushoku ";
        String x = b;                       //存储在相同地址
        String c = b + "Tensei";            // String可以通过加号拼接
        System.out.println(c);

        String d = "My age is " + 18;       // int会被隐式转化成字符串"18"
        System.out.println(d);

        String str = String.format("My age is %d", 18);         //格式化字符串
        System.out.println(str);

        String money_str = "123.45";
        double money = Double.parseDouble(money_str);
        System.out.println(money);

        String age_str = "18";
        int age = Integer.parseInt(age_str);
        System.out.println(age);
    }
}

输出

Mushoku Tensei
My age is 18
My age is 18
123.45
18

输入与输出

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str1 = sc.next();  // 输入字符串，遇到空格、回车等空白字符时停止输入
        String str2 = sc.nextLine();  // 输入一整行字符串，遇到空格不会停止输入，遇到回车才会停止

        System.out.println(str1);  // 可以直接输出
        System.out.printf("%s\n", str2);  // 也可以格式化输出，用 %s 表示字符串
    }
}

其他变量转化为字符串

方式一：使用空字符串

public class Main
{
    public static void main(String[] args)
    {
        int money = 123;
        String money_str = "" + money;              //使用空字符串
        System.out.println(money_str);
    }
}

方式二：将基本类型定义为相应的对象后使用api:toString

public class Main
{
    public static void main(String[] args)
    {
        Integer money = 123;
        String money_str = Integer.toString(money);
        System.out.println(money_str);
    }
}

只读变量

Java中的String为只读变量，不能修改

public class Main
{
    public static void main(String[] args)
    {
        String a = "Hello ";
        a += "World";               // 会构造一个新的字符串
        System.out.println(a);
    }
}

String类的api

访问字符

Java中访问String中的字符只能使用api

public class Main
{
    public static void main(String[] args)
    {
        String str = "Hello World";
        for (int i = 0; i < str.length(); i ++)
        {
            System.out.println(str.charAt(i));
        }
    }
}

输出

H
e
l
l
o

W
o
r
l
d

常用api

涉及到替换的api不会改变原串，只会创建新串

• length()：返回长度
• split(String regex)：分割字符串
• indexOf(char c)、indexOf(String str)、lastIndexOf(char c)、lastIndexOf(String str)：查找第一次出现的下标，找不到返回-1
• equals()：判断两个字符串是否相等，注意不能直接用==
• compareTo()：判断两个字符串的字典序大小，负数表示小于，0表示相等，正数表示大于
• startsWith()：判断是否以某个前缀开头
• endsWith()：判断是否以某个后缀结尾
• trim()：去掉首尾的空白字符
• toLowerCase()：全部用小写字符
• toUpperCase()：全部用大写字符
• replace(char oldChar, char newChar)：替换字符
• replace(String oldRegex, String newRegex)：替换字符串
• substring(int beginIndex, int endIndex)：返回[beginIndex, endIndex)中的子串
• toCharArray()：将字符串转化成字符数组

1. 分割字符串

   import java.util.Scanner;
   import java.util.Arrays;
   
   public class Main
   {
       public static void main(String[] args)
       {
           String str = "Darling in the FranXX";
           String[] strs = str.split(" ");
           System.out.println(Arrays.toString(strs));
       }
   }

   输出

   [Darling, in, the, FranXX]

2. 查找字符、字符串第一次出现的位置

   import java.util.Scanner;
   import java.util.Arrays;
   
   public class Main
   {
       public static void main(String[] args)
       {
           String str = "Darling in the FranXX";
           System.out.println(str.indexOf('l'));
           System.out.println(str.indexOf("in"));
           System.out.println(str.indexOf("ln"));
       }
   }

   输出

   3
   4
   -1

3. 判断两个字符串是否相等

   import java.util.Scanner;
   import java.util.Arrays;
   
   public class Main
   {
       public static void main(String[] args)
       {
           String str = "Darling in the FranXX";
           System.out.println(str.equals("Darling in the FranXX"));
       }
   }

   输出

   true

4. 判断两个字符串的字典序大小

   import java.util.Scanner;
   import java.util.Arrays;
   
   public class Main
   {
       public static void main(String[] args)
       {
           String str = "Darling in the FranXX";
           System.out.println(str.compareTo("Darling in the FranXX"));
           System.out.println(str.compareTo("Aarling in the FranXX"));
           System.out.println(str.compareTo("Rarling in the FranXX"));
       }
   }

   输出

   0
   3
   -14

5. 判断是否以某个前缀开头

   import java.util.Scanner;
   import java.util.Arrays;
   
   public class Main
   {
       public static void main(String[] args)
       {
           String str = "Darling in the FranXX";
           System.out.println(str.startsWith("Dar"));
       }
   }

   输出

   true

6. 判断是否以某个后缀结尾

   import java.util.Scanner;
   import java.util.Arrays;
   
   public class Main
   {
       public static void main(String[] args)
       {
           String str = "Darling in the FranXX";
           System.out.println(str.endsWith("XX"));
       }
   }

   输出

   true

7. 去掉首尾的空白字符

   import java.util.Scanner;
   import java.util.Arrays;
   
   public class Main
   {
       public static void main(String[] args)
       {
           String str = " Darling in the FranXX\n";
           System.out.print(str.trim());
       }
   }

   输出

   Darling in the FranXX

8. 全部用小写字符

   import java.util.Scanner;
   import java.util.Arrays;
   
   public class Main
   {
       public static void main(String[] args)
       {
           String str = "Darling in the FranXX";
           System.out.println(str.toLowerCase());
       }
   }

   输出

   darling in the franxx

9. 全部用大写字符

   import java.util.Scanner;
   import java.util.Arrays;
   
   public class Main
   {
       public static void main(String[] args)
       {
           String str = "Darling in the FranXX";
           System.out.println(str.toUpperCase());
       }
   }

   输出

   DARLING IN THE FRANXX

10. 替换字符

    import java.util.Scanner;
    import java.util.Arrays;
    
    public class Main
    {
        public static void main(String[] args)
        {
            String str = "Darling in the FranXX";
            System.out.println(str.replace('X', 'x'));
        }
    }

    输出

    Darling in the Franxx

11. 替换字符串

    import java.util.Scanner;
    import java.util.Arrays;
    
    public class Main
    {
        public static void main(String[] args)
        {
            String str = "Darling in the FranXX";
            System.out.println(str.replace("FranXX", "franxx"));
        }
    }

    输出

    Darling in the franxx

12. 返回子串

    import java.util.Scanner;
    import java.util.Arrays;
    
    public class Main
    {
        public static void main(String[] args)
        {
            String str = "Darling in the FranXX";
            System.out.println(str.substring(1, 3));
        }
    }

    输出

    ar

    如果省略第二个参数则直接返回到末尾：

    import java.util.Scanner;
    import java.util.Arrays;
    
    public class Main
    {
        public static void main(String[] args)
        {
            String str = "Darling in the FranXX";
            System.out.println(str.substring(1));
        }
    }

    输出

    arling in the FranXX

13. 将字符串转化成字符数组

    import java.util.Scanner;
    import java.util.Arrays;
    
    public class Main
    {
        public static void main(String[] args)
        {
            String str = "Darling in the FranXX";
            char[] cs = str.toCharArray();
            System.out.println(Arrays.toString(cs));
            for (char c : cs)
                System.out.print(c);
        }
    }

    输出

    [D, a, r, l, i, n, g,  , i, n,  , t, h, e,  , F, r, a, n, X, X]
    Darling in the FranXX

StringBuilder、StringBuffer

String不能被修改，如果打算修改字符串，可以使用StringBuilder和StringBuffer。

StringBuffer线程安全，速度较慢；StringBuilder线程不安全，速度较快。

常用api:reverse()：翻转字符串

import java.util.Scanner;

public class Main
{
    public static void main(String[] args)
    {
        StringBuilder sb = new StringBuilder("Hello ");
        sb.append("World");
        System.out.println(sb);
    }
}

输出

Hello World

将每个字符变成它的下一个字符

import java.util.Scanner;

public class Main
{
    public static void main(String[] args)
    {
        StringBuilder sb = new StringBuilder("Hello ");
        sb.append("World");
        System.out.println(sb);

        for (int i = 0; i < sb.length(); i ++)
        {
            sb.setCharAt(i, (char)(sb.charAt(i) + 1));
        }
        System.out.println(sb);
    }
}

输出

Hello World
Ifmmp!Xpsme

翻转字符串

import java.util.Scanner;

public class Main
{
    public static void main(String[] args)
    {
        StringBuilder sb = new StringBuilder("Hello ");
        sb.append("World");
        System.out.println(sb);

        sb.reverse();
        System.out.println(sb);
    }
}

输出

Hello World
dlroW olleH

例题

1. 字符串长度

   给定一行长度不超过 100 的非空字符串，请你求出它的具体长度。

   输入格式

   输入一行，表示一个字符串。注意字符串中可能包含空格

   输出格式

   输出一个整数，表示它的长度。

   输入样例

   I love Beijing.

   输出样例

   15

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           String str = sc.nextLine();
   
           System.out.println(str.length());
       }
   }

2. 字符串中的数字个数

   输入一行字符，长度不超过 100，请你统计一下其中的数字字符的个数。

   输入格式

   输入一行字符。注意其中可能包含空格。

   输出格式

   输出一个整数，表示字数字字符的个数。

   输入样例

   I am 18 years old this year.

   输出样例

   2

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           String str = sc.nextLine();
           int k = 0;
           
           for (int i = 0; i < str.length(); i ++)
           {
               if (str.charAt(i) >= 48 && str.charAt(i) <= 57)
                   k ++;
           }
   
           System.out.println(k);
       }
   }

3. 循环相克令

   循环相克令是一个两人玩的小游戏。

   令词为“猎人、狗熊、枪”，两人同时说出令词，同时做出一个动作——猎人的动作是双手叉腰;狗熊的动作是双手搭在胸前;枪的动作是双手举起呈手枪状。

   双方以此动作判定输赢，猎人赢枪、枪赢狗熊、狗熊赢猎人，动作相同则视为平局。

   现在给定你一系列的动作组合，请你判断游戏结果。

   输入格式

   第一行包含整数 T，表示共有 T 组测试数据。

   接下来 T 行，每行包含两个字符串，表示一局游戏中两人做出的动作，字符串为 Hunter, Bear, Gun 中的一个，这三个单词分别代表猎人，狗熊和枪。

   输出格式

   如果第一个玩家赢了，则输出 Player1。

   如果第二个玩家赢了，则输出 Player2。

   如果平局，则输出 Tie。

   输入样例

   3
   Hunter Gun
   Bear Bear
   Hunter Bear

   输出样例

   Player1
   Tie
   Player2

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           int t = sc.nextInt();
           while (t -- > 0)
           {
               String a = sc.next();
               String b = sc.next();
               if (a.equals("Hunter"))
               {
                   if (b.equals("Bear"))
                       System.out.println("Player2");
                   else if (b.equals("Gun"))
                       System.out.println("Player1");
                   else
                       System.out.println("Tie");
               }
               else if (a.equals("Bear"))
               {
                   if (b.equals("Gun"))
                       System.out.println("Player2");
                   else if (b.equals("Hunter"))
                       System.out.println("Player1");
                   else
                       System.out.println("Tie");
               }
               else
               {
                   if (b.equals("Hunter"))
                       System.out.println("Player2");
                   else if (b.equals("Bear"))
                       System.out.println("Player1");
                   else
                       System.out.println("Tie");
               }
           }
       }
   }

4. 字符串加空格

   给定一个字符串，在字符串的每个字符之间都加一个空格。

   输出修改后的新字符串。

   输入格式

   共一行，包含一个字符串。注意字符串中可能包含空格。

   输出格式

   输出增加空格后的字符串。

   输入样例

   3
   test case

   输出样例

   t e s t   c a s e

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           String str = sc.nextLine();
           for (int i = 0; i < str.length(); i ++)
           {
               System.out.printf("%c ", str.charAt(i));
           }
       }
   }

5. 替换字符

   给定一个由大小写字母构成的字符串。

   把该字符串中特定的字符全部用字符 # 替换。

   请你输出替换后的字符串。

   输入格式

   输入共两行。

   第一行包含一个长度不超过 30 的字符串。

   第二行包含一个字符，表示要替换掉的特定字符。

   输出格式

   输出共一行，为替换后的字符串。

   输入样例

   hello
   l

   输出样例

   he##o

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           String str = sc.nextLine();
           String rep = sc.nextLine();
           System.out.println(str.replace(rep, "#"));
       }
   }

6. 字符串插入

   有两个不包含空白字符的字符串 str 和 substr，str 的字符个数不超过 10，substr 的字符个数为 3。（字符个数不包括字符串结尾处的 \0。）

   将 substr 插入到 str 中 ASCII 码最大的那个字符后面，若有多个最大则只考虑第一个。

   输入格式

   输入包括若干行，每一行为一组测试数据，格式为

   str substr

   输出格式

   对于每一组测试数据，输出插入之后的字符串。

   输入样例

   abcab eee
   12343 555

   输出样例

   abceeeab
   12345553

   解
   方法一：转化为字符数组

   import java.util.Scanner;
   import java.util.Arrays;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           while (sc.hasNext())
           {
               String str = sc.next();
               String substr = sc.next();
   
               char[] cs = str.toCharArray();
               char[] subcs = substr.toCharArray();
               int k = 0;
               char c = cs[0];
   
               for (int i = 0; i < str.length(); i ++)
               {
                   if (cs[i] > c)
                   {
                       k = i;
                       c = cs[i];
                   }
               }
   
               for (int i = 0; i <= k; i ++)
                   System.out.print(cs[i]);
                   System.out.print(subcs);
               for (int i = k + 1; i < str.length(); i ++)
                   System.out.print(cs[i]);
               System.out.println();
           }
           
       }
   }

   方法二：使用substring()输出子串

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
   
           while (sc.hasNext())
           {
               String str = sc.next();
               String substr = sc.next();
               int k = 0;
               for (int i = 0; i < str.length(); i ++)
               {
                   if (str.charAt(i) > str.charAt(k))
                       k = i;
               }
   
               System.out.println(str.substring(0, k + 1) + substr + str.substring(k + 1));
           }
       }
   }

7. 只出现一次的字符

   给你一个只包含小写字母的字符串。

   请你判断是否存在只在字符串中出现过一次的字符。

   如果存在，则输出满足条件的字符中位置最靠前的那个。

   如果没有，输出 no。

   输入格式

   共一行，包含一个由小写字母构成的字符串。

   数据保证字符串的长度不超过 100000。

   输出格式

   输出满足条件的第一个字符。

   如果没有，则输出 no。

   输入样例

   abceabcd

   输出样例

   e

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           String str = sc.next();
           int[] cnt = new int[26];
   
           for (char c : str.toCharArray())
               cnt[c - 'a'] ++;
           
           for (char c : str.toCharArray())
               if (cnt[c - 'a'] == 1)
               {
                   System.out.println(c);
                   return;
               }
           System.out.println("no");
       }
   }

习题

1. 字符串匹配

   给定两个长度相同的字符串 a 和字符串 b。

   如果在某个位置 i 上，满足字符串 a 上的字符 a[i] 和字符串 b 上的字符 b[i] 相同，那么这个位置上的字符就是匹配的。

   如果两个字符串的匹配位置的数量与字符串总长度的比值大于或等于 k，则称两个字符串是匹配的。

   现在请你判断给定的两个字符串是否匹配。

   输入格式

   第一行包含一个浮点数 k，第二行包含字符串 a，第三行包含字符串 b。

   输入的字符串中不包含空格。

   输出格式

   如果两个字符串匹配，则输出 yes。

   否则，输出 no。

   输入样例

   0.4
   abcde
   xbacd

   输出样例

   no

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           double k = sc.nextDouble();
           String a = sc.next();
           String b = sc.next();
           int num  = 0;
           
           for (int i = 0; i < a.length(); i ++)
           {
               if ((a.charAt(i)) == (b.charAt(i)))
                   num ++;
           }
   
           if (num >= k * a.length())
               System.out.printf("yes");
           else
               System.out.printf("no");
       }
   }

2. 忽略大小写比较字符串大小

   一般我们用 strcmp 可比较两个字符串的大小，比较方法为对两个字符串从前往后逐个字符相比较（按 ASCII 码值大小比较），直到出现不同的字符或遇到 \0 为止。

   如果全部字符都相同，则认为相同；如果出现不相同的字符，则以第一个不相同的字符的比较结果为准。

   但在有些时候，我们比较字符串的大小时，希望忽略字母的大小，例如 Hello 和 hello 在忽略字母大小写时是相等的。

   请写一个程序，实现对两个字符串进行忽略字母大小写的大小比较。

   输入格式

   输入为两行，每行一个字符串，共两个字符串。注意字符串中可能包含空格。

   数据保证每个字符串的长度都不超过 80。

   输出格式

   如果第一个字符串比第二个字符串小，输出一个字符 <。

   如果第一个字符串比第二个字符串大，输出一个字符 >。

   如果两个字符串相等，输出一个字符 =。

   否则，输出 no。

   输入样例

   Hello
   hello

   输出样例

   =

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           String a = sc.nextLine();
           String b = sc.nextLine();
           int k = (a.toUpperCase()).compareTo(b.toUpperCase());
           if (k > 0) System.out.println(">");
           else if (k < 0) System.out.println("<");
           else System.out.println("=");
       }
   }

3. 去掉多余的空格

   输入一个字符串，字符串中可能包含多个连续的空格，请将多余的空格去掉，只留下一个空格。

   输入格式

   共一行，包含一个字符串。

   输出格式

   输出去掉多余空格后的字符串，占一行。

   输入样例

   Hello      world.This is    c language.

   输出样例

   Hello world.This is c language.

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           while(sc.hasNext())
           {
               String str = sc.next();
               System.out.printf("%s ", str);
           }
       }
   }

4. 信息加密

   在传输信息的过程中，为了保证信息的安全，我们需要对原信息进行加密处理，形成加密信息，从而使得信息内容不会被监听者窃取。

   现在给定一个字符串，对其进行加密处理。

   加密的规则如下：

   • 字符串中的小写字母，a 加密为 b，b 加密为 c，…，y 加密为 z，z 加密为 a。
   • 字符串中的大写字母，A 加密为 B，B 加密为 C，…，Y 加密为 Z，Z 加密为 A。
   • 字符串中的其他字符，不作处理。
     请你输出加密后的字符串。

   输入格式

   共一行，包含一个字符串。注意字符串中可能包含空格。

   输出格式

   输出加密后的字符串。

   输入样例

   Hello! How are you!

   输出样例

   Ifmmp! Ipx bsf zpv!

   解
   

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           
           String str = sc.nextLine();
           StringBuilder sb = new StringBuilder(str);
   
           for (int i = 0; i < sb.length(); i ++)
           {
               if ((sb.charAt(i) >= 65 && sb.charAt(i) <= 90) || (sb.charAt(i) >= 97 && sb.charAt(i) <= 122))
               {
                   if (sb.charAt(i) == 'z')
                       sb.setCharAt(i, 'a');
                   else if (sb.charAt(i) == 'Z')
                       sb.setCharAt(i, 'A');
                   else
                       sb.setCharAt(i, (char)(sb.charAt(i) + 1));
               }
                   
           }
           System.out.printf("%s ", sb);
       }
   }

5. 输出字符串

   给定一个字符串 a，请你按照下面的要求输出字符串 b。

   给定字符串 a 的第一个字符的 ASCII 值加第二个字符的 ASCII 值，得到 b 的第一个字符；

   给定字符串 a 的第二个字符的 ASCII 值加第三个字符的 ASCII 值，得到 b 的第二个字符；

   …

   给定字符串 a 的倒数第二个字符的 ASCII 值加最后一个字符的 ASCII 值，得到 b 的倒数第二个字符；

   给定字符串 a 的最后一个字符的 ASCII 值加第一个字符的 ASCII 值，得到 b 的最后一个字符。

   输入格式

   输入共一行，包含字符串 a。注意字符串中可能包含空格。

   数据保证字符串内的字符的 ASCII 值均不超过 63。

   输出格式

   输出共一行，包含字符串 b。

   输入样例

   1 2 3

   输出样例

   QRRSd

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           String a = sc.nextLine();
           char[] b = new char[100];
   
           for (int i = 0 ; i < a.length() - 1; i++)
           {
               b[i] = (char)(a.charAt(i) + a.charAt(i + 1));
           }
           
           b[a.length() - 1] = (char)(a.charAt(a.length() - 1) + a.charAt(0));
   
           for (int i = 0; i < a.length(); i ++)
               System.out.print(b[i]);
       }
   }

6. 单词替换

   输入一个字符串，以回车结束（字符串长度不超过 100）。

   该字符串由若干个单词组成，单词之间用一个空格隔开，所有单词区分大小写。

   现需要将其中的某个单词替换成另一个单词，并输出替换之后的字符串。

   输入格式

   输入共 3 行。

   第 1 行是包含多个单词的字符串 s;

   第 2 行是待替换的单词 a(长度不超过 100);

   第 3 行是 a 将被替换的单词 b(长度不超过 100)。

   输出格式

   共一行，输出将 s 中所有单词 a 替换成 b 之后的字符串。

   输入样例

   You want someone to help you
   You
   I

   输出样例

   I want someone to help you

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           String str = sc.nextLine();
           String a = sc.next();
           String b = sc.next();
           String[] strs = str.split(" ");
           for (String s : strs)
           {
               if (s.equals(a))
                   System.out.printf("%s ", b);
               else
                   System.out.printf("%s ", s);
           }
   
       }
   }

7. 字符串中最长的连续出现的字符

   求一个字符串中最长的连续出现的字符，输出该字符及其出现次数，字符串中无空白字符（空格、回车和 tab），如果这样的字符不止一个，则输出第一个。

   输入格式

   第一行输入整数 N，表示测试数据的组数。

   每组数据占一行，包含一个不含空白字符的字符串，字符串长度不超过 200。

   输出格式

   共一行，输出最长的连续出现的字符及其出现次数，中间用空格隔开。

   输入样例

   2
   aaaaabbbbbcccccccdddddddddd
   abcdefghigk

   输出样例

   d 10
   a 1

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           int n = sc.nextInt();
           while (n -- > 0)
           {
               String str = sc.next();
               int cnt = 0;
               char c = str.charAt(0);
               for (int i = 0; i < str.length(); i ++)
               {
                   int j = i;
                   while (j < str.length() && str.charAt(j) == str.charAt(i))
                       j ++;
   
                   if (j - i > cnt)
                   {
                       cnt = j - i;
                       c = str.charAt(i);
                   }
               }
               System.out.printf("%c %d\n", c, cnt);
           }
       }
   }

8. 最长单词

   一个以. 结尾的简单英文句子，单词之间用空格分隔，没有缩写形式和其它特殊形式，求句子中的最长单词。

   输入格式

   输入一行字符串，表示这个简单英文句子，长度不超过 500。

   输出格式

   该句子中最长的单词。如果多于一个，则输出第一个。

   输入样例

   I am a student of Peking University.

   输出样例

   University

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           String max = "";
           while (sc.hasNext())
           {
               String str = sc.next();
               if (str.endsWith("."))
                   str = str.substring(0, str.length() - 1);
               if (str.length() > max.length())
               {
                   max = str;
               }
           }
           System.out.println(max);
       }
   }

9. 倒排单词

   编写程序，读入一行英文(只包含字母和空格，单词间以单个空格分隔)，将所有单词的顺序倒排并输出，依然以单个空格分隔。

   输入格式

   输入为一个字符串（字符串长度至多为 100）。

   输出格式

   输出为按要求排序后的字符串。

   输入样例

   I am a student

   输出样例

   student a am I

   解

   import java.util.Scanner;
   
   public class Main
   {
       public static void main(String[] args)
       {
           Scanner sc = new Scanner(System.in);
           String str = sc.nextLine();
           String[] strs = str.split(" ");
   
           for (int i = strs.length - 1; i >= 0; i --)
           {
               System.out.printf("%s ", strs[i]);
           }
       }
   }

10. 字符串移位包含问题

    对于一个字符串来说，定义一次循环移位操作为：将字符串的第一个字符移动到末尾形成新的字符串。

    给定两个字符串 s1 和 s2，要求判定其中一个字符串是否是另一字符串通过若干次循环移位后的新字符串的子串。

    例如 CDAA 是由 AABCD 两次移位后产生的新串 BCDAA 的子串，而 ABCD 与 ACBD 则不能通过多次移位来得到其中一个字符串是新串的子串。

    输入格式

    共一行，包含两个字符串，中间由单个空格隔开。

    字符串只包含字母和数字，长度不超过 30。

    输出格式

    如果一个字符串是另一字符串通过若干次循环移位产生的新串的子串，则输出 true，否则输出 false。

    输入样例

    AABCD CDAA

    输出样例

    true

    解

    import java.util.Scanner;
    
    public class Main
    {
        public static void main(String[] args)
        {
            Scanner sc = new Scanner(System.in);
            String str = sc.next();
            String s = sc.next();
            if(str.length() < s.length())
            {
                String tmp = s;
                s = str;
                str = tmp;
            }
    
            Boolean isPart = false;
    
            for (int i = 0; i < str.length(); i ++)
            {
                str = str.substring(i, str.length()) + str.substring(0, i);
                if (str.indexOf(s) != -1)
                {
                    System.out.println("true");
                    return;
                }
            }
            System.out.println("false");
        }
    }