字符串的案例代码

字符串的案例
　　A:模拟用户登录
　　B:字符串的遍历
　　C:统计字符串中大写、小写及数字字符的个数
　　D:把字符串的首字母转成大写，其他转成小写
　　E:把int数组拼接成一个指定格式的字符串输出
　　F:字符串反转
　　G:统计大串中小串出现的次数

A:模拟用户登录

 1 package cn.itcast_03;
 2 
 3 import java.util.Scanner;
 4 
 5 /*
 6  * 模拟登录,给三次机会,并提示还有几次。如果登录成功，就可以玩猜数字小游戏了。
 7  * 
 8  * 分析：
 9  *         A:定义用户名和密码。已存在的。
10  *         B:键盘录入用户名和密码。
11  *         C:比较用户名和密码。
12  *             如果都相同，则登录成功
13  *             如果有一个不同，则登录失败
14  *         D:给三次机会，用循环改进，最好用for循环。
15  */
16 public class StringTest2 {
17     public static void main(String[] args) {
18         // 定义用户名和密码。已存在的。
19         String username = "admin";
20         String password = "admin";
21 
22         // 给三次机会，用循环改进，最好用for循环。
23         for (int x = 0; x < 3; x++) {
24             // x=0,1,2
25             // 键盘录入用户名和密码。
26             Scanner sc = new Scanner(System.in);
27             System.out.println("请输入用户名：");
28             String name = sc.nextLine();
29             System.out.println("请输入密码：");
30             String pwd = sc.nextLine();
31 
32             // 比较用户名和密码。
33             if (name.equals(username) && pwd.equals(password)) {
34                 // 如果都相同，则登录成功
35                 System.out.println("登录成功,开始玩游戏");
36                 //猜数字游戏
37                 GuessNumberGame.start();
38                 break;
39             } else {
40                 // 如果有一个不同，则登录失败
41                 // 2,1,0
42                 // 如果是第0次，应该换一种提示
43                 if ((2 - x) == 0) {
44                     System.out.println("帐号被锁定，请与班长联系");
45                 } else {
46                     System.out.println("登录失败，你还有" + (2 - x) + "次机会");
47                 }
48             }
49         }
50     }
51     
52 }

B:字符串的遍历

 1 package cn.itcast_04;
 2 
 3 /*
 4  * 需求：遍历获取字符串中的每一个字符
 5  * 
 6  * 分析：
 7  *         A:如何能够拿到每一个字符呢?
 8  *             char charAt(int index)
 9  *         B:我怎么知道字符到底有多少个呢?
10  *             int length()
11  */
12 public class StringTest {
13     public static void main(String[] args) {
14         // 定义字符串
15         String s = "helloworld";
16 
17         // 原始版本
18         // System.out.println(s.charAt(0));
19         // System.out.println(s.charAt(1));
20         // System.out.println(s.charAt(2));
21         // System.out.println(s.charAt(3));
22         // System.out.println(s.charAt(4));
23         // System.out.println(s.charAt(5));
24         // System.out.println(s.charAt(6));
25         // System.out.println(s.charAt(7));
26         // System.out.println(s.charAt(8));
27         // System.out.println(s.charAt(9));
28 
29         // 只需要我们从0取到9
30         // for (int x = 0; x < 10; x++) {
31         // System.out.println(s.charAt(x));
32         // }
33 
34         // 如果长度特别长，我不可能去数，所以我们要用字符串的求长度功能。
35         for (int x = 0; x < s.length(); x++) {
36             // char ch = s.charAt(x);
37             // System.out.println(ch);
38             // 仅仅是输出，我就直接输出了。
39             System.out.println(s.charAt(x));
40         }
41     }
42 }

C:统计字符串中大写、小写及数字字符的个数

 1 package cn.itcast_04;
 2 
 3 /*
 4  * 需求：统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
 5  * 举例：
 6  *         "Hello123World"
 7  * 结果：
 8  *         大写字符：2个
 9  *         小写字符：8个
10  *         数字字符：3个
11  * 
12  * 分析：
13  *         前提：字符串要存在。
14  *         A:定义三个统计变量
15  *             bigCount = 0
16  *             smallCount = 0
17  *             numberCount = 0
18  *         B:遍历字符串，得到每一个字符。
19  *             length()和charAt()结合
20  *         C:判断该字符到底是属于那种类型的？
21  *             大：bigCount++
22  *             小：smallCount++
23  *             数字：numberCount++
24  * 
25  *             这道题目的难点就是如何判断某个字符是大的，还是小的，还是数字的?
26  *             ASCII码表：
27  *                 0    48
28  *                 A    65
29  *                 a    97
30  *             虽然，我们按照数字的这种比较是可以的，但是想多了，有比这还简单的
31  *                 char ch = s.charAt(x);
32  * 
33  *                 if(ch>='0' && ch<='9') numberCount++
34  *                 if(ch>='a' && ch<='z') smallCount++
35  *                 if(ch>='A' && ch<='Z') bigCount++
36  *        D:输出结果。
37  *
38  * 练习：把给定字符串的方式，改进为键盘录入字符串的方式。
39  */
40 public class StringTest2 {
41     public static void main(String[] args) {
42         // 定义一个字符串
43         String s = "Hello123World";
44 
45         // 定义三个统计变量
46         int bigCount = 0;
47         int smallCount = 0;
48         int numberCount = 0;
49 
50         // 遍历字符串，得到每一个字符。
51         for (int x = 0; x < s.length(); x++) {
52             char ch = s.charAt(x);
53 
54             // 判断该字符到底是属于那种类型的
55             if (ch >= 'a' && ch <= 'z') {
56                 smallCount++;
57             } else if (ch >= 'A' && ch <= 'Z') {
58                 bigCount++;
59             } else if (ch >= '0' && ch <= '9') {
60                 numberCount++;
61             }
62         }
63 
64         // 输出结果。
65         System.out.println("大写字母" + bigCount + "个");
66         System.out.println("小写字母" + smallCount + "个");
67         System.out.println("数字" + numberCount + "个");
68     }
69 }

D:把字符串的首字母转成大写，其他转成小写

 1 package cn.itcast_05;
 2 
 3 /*
 4  * 需求：把一个字符串的首字母转成大写，其余转为小写。(只考虑英文大小写字母字符)
 5  * 举例：
 6  *         helloWORLD
 7  * 结果：
 8  *         Helloworld
 9  * 
10  * 分析：
11  *         A:先获取第一个字符
12  *         B:获取除了第一个字符以外的字符
13  *         C:把A转成大写
14  *         D:把B转成小写
15  *         E:C拼接D
16  */
17 public class StringTest {
18     public static void main(String[] args) {
19         // 定义一个字符串
20         String s = "helloWORLD";
21 
22         // 先获取第一个字符
23         String s1 = s.substring(0, 1);
24         // 获取除了第一个字符以外的字符
25         String s2 = s.substring(1);
26         // 把A转成大写
27         String s3 = s1.toUpperCase();
28         // 把B转成小写
29         String s4 = s2.toLowerCase();
30         // C拼接D
31         String s5 = s3.concat(s4);
32         System.out.println(s5);
33 
34         // 优化后的代码
35         // 链式编程
36         String result = s.substring(0, 1).toUpperCase().concat(s.substring(1).toLowerCase());
37         System.out.println(result);
38     }
39 }

E:把int数组拼接成一个指定格式的字符串输出

 1 package cn.itcast_07;
 2 
 3 /*
 4  * 需求：把数组中的数据按照指定个格式拼接成一个字符串
 5  * 举例：
 6  *         int[] arr = {1,2,3};    
 7  * 输出结果：
 8  *        "[1, 2, 3]"
 9  * 分析：
10  *         A:定义一个字符串对象，只不过内容为空
11  *         B:先把字符串拼接一个"["
12  *         C:遍历int数组，得到每一个元素
13  *         D:先判断该元素是否为最后一个
14  *             是：就直接拼接元素和"]"
15  *             不是：就拼接元素和逗号以及空格
16  *         E:输出拼接后的字符串
17  * 
18  * 把代码用功能实现。
19  */
20 public class StringTest2 {
21     public static void main(String[] args) {
22         // 前提是数组已经存在
23         int[] arr = { 1, 2, 3 };
24 
25         // 写一个功能，实现结果
26         String result = arrayToString(arr);
27         System.out.println("最终结果是：" + result);
28     }
29 
30     /*
31      * 两个明确： 返回值类型：String 
32      * 参数列表：int[] arr
33      */
34     public static String arrayToString(int[] arr) {
35         // 定义一个字符串
36         String s = "";
37 
38         // 先把字符串拼接一个"["
39         s += "[";
40 
41         // 遍历int数组，得到每一个元素
42         for (int x = 0; x < arr.length; x++) {
43             // 先判断该元素是否为最后一个
44             if (x == arr.length - 1) {
45                 // 就直接拼接元素和"]"
46                 s += arr[x];
47                 s += "]";
48             } else {
49                 // 就拼接元素和逗号以及空格
50                 s += arr[x];
51                 s += ", ";
52             }
53         }
54 
55         return s;
56     }
57 }

F:字符串反转

 1 package cn.itcast_07;
 2 
 3 import java.util.Scanner;
 4 
 5 /*
 6  * 字符串反转
 7  * 举例：键盘录入”abc”        
 8  * 输出结果：”cba”
 9  * 
10  * 分析：
11  *         A:键盘录入一个字符串
12  *         B:定义一个新字符串
13  *         C:倒着遍历字符串，得到每一个字符
14  *             a:length()和charAt()结合
15  *             b:把字符串转成字符数组
16  *         D:用新字符串把每一个字符拼接起来
17  *         E:输出新串
18  */
19 public class StringTest3 {
20     public static void main(String[] args) {
21         // 键盘录入一个字符串
22         Scanner sc = new Scanner(System.in);
23         System.out.println("请输入一个字符串：");
24         String line = sc.nextLine();
25 
26         /*
27         // 定义一个新字符串
28         String result = "";
29 
30         // 把字符串转成字符数组
31         char[] chs = line.toCharArray();
32 
33         // 倒着遍历字符串，得到每一个字符
34         for (int x = chs.length - 1; x >= 0; x--) {
35             // 用新字符串把每一个字符拼接起来
36             result += chs[x];
37         }
38 
39         // 输出新串
40         System.out.println("反转后的结果是：" + result);
41         */
42 
43         // 改进为功能实现
44         String s = myReverse(line);
45         System.out.println("实现功能后的结果是：" + s);
46         sc.close();
47     }
48 
49     /*
50      * 两个明确： 返回值类型：String 
51      * 参数列表：String
52      */
53     public static String myReverse(String s) {
54         // 定义一个新字符串，只不过内容为空
55         String result = "";
56 
57         // 把字符串转成字符数组
58         char[] chs = s.toCharArray();
59 
60         // 倒着遍历字符串，得到每一个字符
61         for (int x = chs.length - 1; x >= 0; x--) {
62             // 用新字符串把每一个字符拼接起来
63             result += chs[x];
64         }
65         return result;
66     }
67     
68 }

G:统计大串中小串出现的次数

 1 package cn.itcast_07;
 2 
 3 /*
 4  * 统计大串中小串出现的次数
 5  * 举例：
 6  *         在字符串"woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun"
 7  * 结果：
 8  *         java出现了5次
 9  * 
10  * 分析：
11  *         前提：是已经知道了大串和小串。
12  * 
13  *         A:定义一个统计变量，初始化值是0。
14  *         B:先在大串中查找一次小串第一次出现的位置索引。
15  *             a:如果索引是-1，说明不存在了，就返回统计变量。
16  *             b:如果托索引不是-1，说明存在，统计变量++。
17  *         C:把刚才的索引+小串的长度作为开始位置截取上一次的大串，返回得到一个新的字符串，并把该字符串的值重新赋值给大串。
18  *         D:回到B。
19  */
20 public class StringTest5 {
21     public static void main(String[] args) {
22         // 定义大串
23         String maxString = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
24         // 定义小串
25         String minString = "java";
26 
27         // 写功能实现
28         int count = getCount(maxString, minString);
29         System.out.println("java" + "在大串中出现了：" + count + "次");
30     }
31 
32     /*
33      * 两个明确： 返回值类型：int 参数列表：两个字符串
34      */
35     public static int getCount(String maxString, String minString) {
36         // 定义一个统计变量，初始化值是0。
37         int count = 0;
38         
39         /*
40         // 先在大串中查找一次小串第一次出现的索引位置。
41         int index = maxString.indexOf(minString);
42 
43         // 先在大串中查找一次小串第一次出现的位置。
44         int index = maxString.indexOf(minString);
45         // 索引不是-1，说明存在，统计变量++。
46         while (index != -1) {
47             count++;
48             // 把刚才的索引+小串的长度作为开始位置截取上一次的大串，返回得到一个新的字符串，并把该字符串的值重新赋值给大串。
49             // int startIndex = index + minString.length();
50             // maxString = maxString.substring(startIndex);
51             maxString = maxString.substring(index + minString.length());
52             // 继续查
53             index = maxString.indexOf(minString);
54         }*/
55 
56         int index;
57         // 先查，赋值，判断
58         while ((index = maxString.indexOf(minString)) != -1) {
59             count++;
60             maxString = maxString.substring(index + minString.length());
61         }
62 
63         return count;
64     }
65 
66 }

posted @ 2018-02-27 23:44 黑泽君阅读(277) 评论(0) 编辑收藏举报

刷新页面返回顶部

Bruce

字符串的案例代码