要求从键盘输入多个字符，如：输入we  are  at      the   b2b  web    要求编程实现：
每个单词首字母大写
多个空格只输出一个
数字与字符之间要用“_”间隔
即输出：
We Are At The B_2_b Web  希望大家帮忙看下吧！谢啦！

如果只是完成你提的条件的话只用红色标注的判断就足够了。主要是为了把可能的情况补全，

不然这种特定的情况程序下的什么意义！真是花了我好长时间，主要也是我这部分没学好的原因。

我分别用下面的几种情况试了下，你试试吧~~~亲
we  are  at      the   b2b  web
we  are  at      the   2b  web
we  are  at      the   22b  web
we  are  at      the   b22  web[code]public class Test_012
{
        public static void main(String args[]) {
                Scanner scan = new Scanner(System.in);// 从键盘接收数据
                System.out.print("输入数据：");
//                scan.useDelimiter("\b");// 修改定界符
               
                while(scan.hasNext())
                {
                        String str=scan.next();
                       
                        String firstLetter=str.substring(0,1).toUpperCase();//首字母大写
                       
                        String str2=firstLetter+str.substring(1);
                       
                        for(int i=0;i<str.length();i++)
                        {
                                if(str2.charAt(i)<57&&str2.charAt(i)>48)
                                {
                                       
                                        if(0==i&&(str2.charAt(i+1)>57||str2.charAt(i+1)<48))
                                        {
                                                str2=str2.substring(0,i+1)+"_"+str2.substring(i+1);
                                        }
                               
                                        //两边都是字母
                                        if(i!=0&&(str2.charAt(i-1)>57||str2.charAt(i-1)<48)&&(str2.charAt(i+1)>57||str2.charAt(i+1)<48))
                                        {
                                               
                                                str2=str2.substring(0,i)+"_"+
                                                         str2.charAt(i)+"_"+str2.substring(i+1);
                                                break;
                                        }                                       
                                        //右边是数字,左边是字母
                                        if(i!=0&&(str2.charAt(i+1)<57&&str2.charAt(i+1)>48)&&(str2.charAt(i-1)>57||str2.charAt(i-1)<48))
                                        {
                                                str2=str2.substring(0,i)+"_"+str2.substring(i);
                                                break;
                                        }
                                       
                                        //左边是数字,右边是字母
                                        if(i!=0&&(str2.charAt(i-1)<57&&str2.charAt(i-1)>48)&&(str2.charAt(i+1)>57||str2.charAt(i+1)<48))
                                        {
                                                str2=str2.substring(0,i+1)+"_"+str2.substring(i+1);
                                                break;
                                        }
                                }
                        }
                       
                        System.out.print(str2+" ");
                }
               
        }
}

下面是我写的代码用正则表达式，测试能行 供参考（没有考虑以数字开头或其他特殊字符情况）：

1. public class Test {
   
2.         public static void main(String[]args) throws ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchFieldException, Exception{
   
3. 
   
4.                 BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
   
5.                 BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
   
6.                 StringBuilder sbuider=new StringBuilder();
   
7.                 String line=null;
   
8.                 String line2=null;
   
9.                
   
10.                 while((line=br.readLine())!=null){
    
11.                
    
12.                         Pattern p2=Pattern.compile("([a-zA-Z])+(\\d+)([a-zA-Z])+");//正则表达式匹配前面是字符中间是数字后面是字母
    
13.                         Matcher m2=p2.matcher(line);
    
14.                         //把有数字的地方替换成_字母_的形式
    
15.                         while(m2.find()){
    
16.                                 line2=line.replaceAll(m2.group(2), "_"+m2.group(2)+"_");//将数值前后加上下划线，这里用到分组
    
17.                         }
    
18. 
    
19.                         Pattern p1=Pattern.compile("\\s+");
    
20.                    //按空白符号把字符串分为数组
    
21.             String[]arr=p1.split(line2);
    
22.             for(String s:arr){
    
23.                     s=s.substring(0,1).toUpperCase()+s.substring(1,s.length());
    
24.                     sbuider.append(s);
    
25.                     sbuider.append(" ");//添加一个空白符号
    
26.             
    
27.             }
    
28.             line2=sbuider.toString();
    
29. 
    
30.                         bw.write(line2);
    
31.                        
    
32.                                 bw.flush();
    
33.                        
    
34.                 }
    
35.                
    
36.        
    
37.                
    
38.                
    
39. 
    
40.                
    
41.                
    
42.         }
    
43. 
    
44. 
    
45. 
    
46. }

复制代码

没写录入：

1. public static void main(String[] args) throws Exception
   
2.         {
   
3.                 String s="we  are  at      the   b2b  web ";
   
4.                 s=s.replaceAll(" +"," ");
   
5.                 s=s.replaceAll("(\\w+)(\\d+)","$1_$2");
   
6.                 // s=s.replaceAll("\\b(\\w)|\\s(\\w)",String.toUpperCase(" $1"));
   
7.                 StringBuffer sb=new StringBuffer();
   
8.                 Pattern p=Pattern.compile("\\b(\\w)|\\s(\\w)");
   
9.                 Matcher m=p.matcher(s);
   
10.                 while(m.find()){
    
11.                         m.appendReplacement(sb,m.group().toUpperCase());
    
12.                 }
    
13.                 m.appendTail(sb);
    
14.                 System.out.println(sb);
    
15.    }

复制代码

我花了一下午终于写出来了，可能没大家的简单，希望大家能够提提意见啦！

1. 2.import java.util.Scanner;
   
2. import java.util.regex.Matcher;
   
3. import java.util.regex.Pattern;
   
4. 
   
5. /**
   
6. * 思路：
   
7. *         1. 替换空格
   
8. *         2. 构建一个StringBuilder，用于存储从原字符串中截取的子字符串
   
9. *         3. 创建一个匹配数字的Matcher
   
10. *         4. 每匹配到一次执行以下四步
    
11. *             4.1. 截取上一次匹配处到这次匹配处之间的字符串，append到
    
12. StringBuilder对象中
    
13. *             4.2. 如果匹配到的数字前面有没有空格，则将一个"_"append到
    
14. StringBuilder对象中
    
15. *             4.3. 将匹配到的数字append到StringBuilder对象中
    
16. *             4.4. 如果匹配到的数字后面有没有空格，则将一个"_"append到
    
17. StringBuilder对象中
    
18. *         5. 将剩下的字符串截取出来append到StringBuilder对象中
    
19. *         6. 创建一个存储最终结果的StringBuilder对象
    
20. *         7. 以空格为分割，切割替换空格和数字之后的字符串
    
21. *         8. 将每一个切割出来的子字符串转换为字符数组，判断第一个字符是否为小写
    
22. 字母，如果是，
    
23. *             则转换为大写字母，然后将该字符数组存储到存储最终结果的
    
24. StringBuilder对象中
    
25. * @author wlxxsj
    
26. *
    
27. */
    
28. public class WordDemo {
    
29.     public static void main(String[] args) {
    
30.         Scanner sc = new Scanner(System.in);
    
31.         String srcWord = sc.nextLine();
    
32.         sc.close();
    
33.         
    
34.         //1. 替换空格
    
35.         srcWord = srcWord.replaceAll(" {2,}", " ");
    
36.         
    
37.         //2. 构建一个StringBuilder，用于存储从原字符串中截取的子字符串
    
38.         StringBuilder numReplaced = new StringBuilder();
    
39.         
    
40.         //3. 创建一个匹配数字的Matcher
    
41.         Pattern p = Pattern.compile("\\d+");  
    
42.         Matcher m = p.matcher(srcWord);
    
43.         
    
44.         //4. 替换数字
    
45.         int startIndex = 0;
    
46.         int matchedStartIndex = 0, matchedEndIndex = 0;
    
47.         while (m.find()) {
    
48.             matchedStartIndex = m.start();
    
49.             matchedEndIndex = m.end();
    
50.             //4.1. 截取上一次匹配处到这次匹配处之间的字符串，append到
    
51. StringBuilder对象中
    
52.             numReplaced.append(srcWord.substring(startIndex, matchedStartIndex));
    
53.             //4.2. 如果匹配到的数字前面有没有空格，则将一个"_"append到
    
54. StringBuilder对象中
    
55.             if (matchedStartIndex > 0 && srcWord.charAt(matchedStartIndex-1) != '
    
56. ') {
    
57.                 numReplaced.append("_");
    
58.             }
    
59.             //4.3. 将匹配到的数字append到StringBuilder对象中
    
60.             numReplaced.append(m.group());
    
61.             //4.4. 如果匹配到的数字后面有没有空格，则将一个"_"append到
    
62. StringBuilder对象中
    
63.             if (matchedEndIndex < srcWord.length() && srcWord.charAt
    
64. (matchedEndIndex) != ' ') {
    
65.                 numReplaced.append("_");
    
66.             }
    
67.             startIndex = matchedEndIndex;
    
68.         }
    
69.         
    
70.         //5. 将剩下的字符串截取出来append到StringBuilder对象中
    
71.         numReplaced.append(srcWord.substring(matchedEndIndex, srcWord.length()));
    
72.         
    
73.         srcWord = numReplaced.toString();
    
74.         
    
75.         //6. 创建一个存储最终结果的StringBuilder对象
    
76.         StringBuilder target = new StringBuilder();
    
77.         
    
78.         //7. 以空格为分割，切割替换空格和数字之后的字符串
    
79.         String[] srcs = srcWord.split(" ");
    
80.         
    
81.         //8. 将每个单词转换为字符数组，然后把第一个字符搞成大写
    
82.         for (String src : srcs) {
    
83.             char[] chs = src.toCharArray();
    
84.             char ch = chs[0];
    
85.             if (ch >= 97 && ch <= 122) {
    
86.                 chs[0] -= 32;
    
87.             }
    
88.             target.append(chs);
    
89.             target.append(" ");
    
90.         }
    
91.         
    
92.         System.out.println(target.toString());
    
93.     }
    
94. }

复制代码

之前我的程序不够全面，现改写了（录入仍未写，楼上有不少例子）：

1. import java.util.regex.Pattern;
   
2. import java.util.regex.Matcher;
   
3. public class Test {
   
4.         public static void main(String[] args) throws Exception
   
5.         {
   
6.                 String s="we  are  at      the   b2b  web 2aT22f5p 2m2";
   
7.                 s=s.replaceAll(" +"," ");    //多个空格只输出一个
   
8.                 s=s.replaceAll("([A-Za-z])(\\d)","$1_$2"); //左字符+右数字用"_"间隔
   
9.                 s=s.replaceAll("(\\d)([A-Za-z])","$1_$2");  //左数字+右字符用"_"间隔
   
10.                 StringBuffer sb=new StringBuffer();
    
11.                 Pattern p=Pattern.compile("\\b\\w|\\s\\w"); //首字母大写
    
12.                 Matcher m=p.matcher(s);
    
13.                 while(m.find()){
    
14.                         m.appendReplacement(sb,m.group().toUpperCase());
    
15.                 }
    
16.                 m.appendTail(sb);
    
17.                 System.out.println(sb);
    
18.    }
    
19. }

复制代码

输出：We Are At The B_2_b Web 2_aT_22_f_5_p 2_m_2