来转转。。。。。

1. public static String exChange() {
   
2.                 //创建scanner对象
   
3.                 Scanner s = new Scanner(System.in);
   
4.                 // 定义一个StringBuffer接收转换换句话说结果
   
5.                 while (true) {
   
6.                         //读取键盘输入内容
   
7.                         String str = s.nextLine();
   
8. 
   
9.                         StringBuffer sb = new StringBuffer();
   
10.                         // 判断字符是否为空
    
11. 
    
12.                         // for循环使用charAt()方法把字符串的每个字符遍历出来
    
13.                         for (int i = 0; i < str.length(); i++) {
    
14.                                 char c = str.charAt(i);
    
15.                                 // 判断是否是小写
    
16.                                 if (Character.isUpperCase(c)) {
    
17.                                         // 如果是小写就转换成大写并加入到StringBuffer中
    
18.                                         sb.append(Character.toLowerCase(c));
    
19.                                         // 判断是否是大写
    
20.                                 } else if (Character.isLowerCase(c)) {
    
21.                                         // 如果是大写就转换成小写并加入到StringBuffer中
    
22.                                         sb.append(Character.toUpperCase(c));
    
23.                                 }
    
24.                         }
    
25. 
    
26.                         // 返回转换后换句话说字符串
    
27.                         System.out.println(sb.toString());
    
28.                 }
    
29. 
    
30.         }

复制代码

1. public static void Test(){
   
2.                 Scanner s = new Scanner(System.in);
   
3.                 String str = s.nextLine();
   
4. //      定义一个StringBuffer接收转换换句话说结果
   
5.         StringBuffer sb = new StringBuffer();
   
6.         //判断字符是否为空
   
7.         if (str != null) {
   
8. //                for循环使用charAt()方法把字符串的每个字符遍历出来
   
9.                 for (int i = 0; i < str.length(); i++) {
   
10.                         char c = str.charAt(i);
    
11. //                        判断是否是小写
    
12.                         if (Character.isUpperCase(c)) {
    
13. //                                如果是小写就转换成大写并加入到StringBuffer中
    
14.                                 sb.append(Character.toLowerCase(c));
    
15. //                                判断是否是大写
    
16.                         } else if (Character.isLowerCase(c)) {
    
17. //                                如果是大写就转换成小写并加入到StringBuffer中
    
18.                                 sb.append(Character.toUpperCase(c));
    
19.                         }
    
20.                 }
    
21.         }
    
22. //        输出转换后换句话说字符串
    
23.         System.out.println(sb.toString());
    
24.         }

复制代码

        public static void transLetter()
        {
                InputStream in=System.in;
                BufferedReader buf=null;
                String s=null;
                try
                {
                        buf=new BufferedReader(new InputStreamReader(in));
                        while((s=buf.readLine())!=null)
                        {
                                char[]ch=s.toCharArray();
                                for(int x=0;x<ch.length;x++)
                                {
                                        if(ch[x]>='a'&&ch[x]<='z')
                                                ch[x]=(char) (ch[x]-32);
                                        else
                                                ch[x]=(char) (ch[x]+32);
                                }
                                for(char c:ch)
                                {
                                        System.out.print(c);
                                }
                                System.out.println();
                        }
                       
                }
                catch(IOException e)
                {
                        throw new RuntimeException();
                }
                finally
                {
                        try
                        {
                                if(buf!=null)
                                        buf.close();
                        }
                        catch(IOException e)
                        {
                                throw new RuntimeException();
                        }
                       
                }
               
        }

看看。。。。。。。。。。。。

package com.itheima;

import java.util.Scanner;

/**
*  编写程序，从键盘接收一个字符串，
*  对字符串中的字母进行大小写互转（大写字母转成小写，小写字母转成大写）。
*
* */
public class Test5 {
        public static void main(String[] args){
                System.out.println("请输入字符串：");
                Scanner sc =new Scanner(System.in);
                String str =sc.nextLine();
               
                caseConversion(str);
        }
       
        /**
         * 字符串大小写转换
         * */
        private static void caseConversion(String str) {  
        //将输入的字符串先转换成字符数组
                char[] ch =str.toCharArray();
                for(int i=0;i<ch.length;i++){
                        //遍历取出每个字符与大写字母的Hash值相比较，看是否为大写字母
                        if(ch[i]>=65 && ch[i]<=90){
                                //大写字母与其相对应的小写字母Hash值相差32
                                ch[i]+=32;
                        }else if(ch[i]>=97 && ch[i]<=122){
                                ch[i]-=32;
                        }
                        }
                //将转换后的字符数组，转换成字符串
                String s1=new String(ch, 0, ch.length);
                System.out.println(s1);
                }

}

1. package com.itheima;
   
2. 
   
3. import java.io.BufferedReader;
   
4. import java.io.IOException;
   
5. import java.io.InputStreamReader;
   
6. 
   
7. /**
   
8. * 题目：
   
9. * 7、编写程序，从键盘接收一个字符串，对字符串中的字母进行大小写互转（大写字母转成小写，小写字母转成大写）。
   
10. *
    
11. * 思路：
    
12. *1、将键盘作为源来获得一个字符串。
    
13. *2、将控制台作为目的来展示互转后的字符串。
    
14. *3、在过程中，对大写字母和小写字母做出相应的处理。
    
15. *
    
16. *步骤：
    
17. *1、键盘录入一系列的大写和小写子母。利用缓冲区来完成。
    
18. *2、对录入子母进行判断，将大写转成小写，小写转成大写，实验得到大小写字母的差值：32。
    
19. *3、将转换后的字符存入缓冲区，并打印，打印结束后，清空缓冲区。
    
20. *
    
21. */
    
22. public class test {
    
23. 
    
24.         public static void main(String[] args) {
    
25.                 BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
    
26.                 StringBuilder sb = new StringBuilder();                                        //定义缓冲区。
    
27.                 String line = null;                                                                                //定义字符串line。
    
28.                 try {                                                                                                        //对异常进行try catch 处理。
    
29.                         while ((line=bufr.readLine())!=null) {
    
30.                                 char[] chs = line.toCharArray();                                //将字符串转成数组。
    
31.                                 int count = 0;                                                                        //定义计数器，方便清空缓冲区。
    
32.                                 for(char ch : chs){                                                                //对数组进行for循环。
    
33.                                         if (ch<='z'&&ch>='a') {                                                //判断是否满足条件。
    
34.                                                 char ch1 = (char) ((char)ch-32);                //实验得来大小写差值，并进行转换。
    
35.                                                 sb.append(ch1);                                                        //将得到的字符存入到缓冲区。
    
36.                                                 count++;                                                                //计数器自增。
    
37.                                         }
    
38.                                         else if (ch<='Z'&&ch>='A') {
    
39.                                                 char ch1 = (char) ((char)ch+32);
    
40.                                                 sb.append(ch1);
    
41.                                                 count++;
    
42.                                         }
    
43.                                         else {                                                                                //如果不是字符，则继续循环。
    
44.                                                 continue;
    
45.                                         }
    
46.                                 }
    
47.                                 if("end".equals(line)){                                                        //定义结束标志。
    
48.                                         break;
    
49.                                 }
    
50.                                 System.out.println(sb);                                                        //打印转换后的字符串。
    
51.                                 sb.delete(0, count);                                                        //清空缓冲区。
    
52.                         }
    
53.                 } catch (IOException e) {                                                                //异常处理。
    
54.                         throw new RuntimeException("字符转换错误");
    
55.                 }
    
56.         }
    
57. 
    
58. }
    

复制代码

ni xuede zm 样了