这是我做的,觉得写得太麻烦了,有什么简单的方法吗?

1. //编写程序，从键盘接收一个字符串
   
2. //对字符串中的字母进行大小写互转（大写字母转成小写，小写字母转成大写）。
   
3. import java.util.Scanner;
   
4. class test8 {
   
5. 
   
6.         public static void main(String[] args) {
   
7. 
   
8.                 System.out.println("字母大小写互换，请输入后回车");
   
9.             Scanner sc = new Scanner(System.in);
   
10.             String val = sc.next();
    
11.                 System.out.println("转换如下");
    
12.                 val = run(val);
    
13.                 System.out.println(val);
    
14. 
    
15.         }
    
16.         //字母转换方法体
    
17.         public static String run(String str)
    
18.         {
    
19.                 char[] arrMin = new char[26];//小写字母数组
    
20.                 char[] arrMax = new char[26];//大写字母数组
    
21.                 char min = 'A';//定义大写字母
    
22.                 char max = 'a';//定义小宝字母
    
23.                 String s = "";//定义方法返回值
    
24.                 for (int i = 0;i < 26 ;i ++ )//字母循环写入数组
    
25.                 {
    
26.                         arrMin[i] = min;
    
27.                         arrMax[i] = max;
    
28.                         min += 1;
    
29.                         max += 1;
    
30.                 }
    
31.                 //循环对字符串进行转换,大写转小写,小写转大写
    
32.                 for (int i = 0;i < str.length() ;i ++ )
    
33.                 {
    
34.                         s += letter(arrMin,arrMax,str.charAt(i));
    
35.                 }
    
36.                 return s;
    
37.         }
    
38. 
    
39.         //字母大小写判断方法体
    
40.         public static char letter (char[] arrI,char[] arrA,char t)
    
41.         {
    
42.                 char str;//定义返回值
    
43.                 //如果在小写字母中数组中没有查找到,则查找大写字母数组
    
44.                 if (binarySearch(arrI,t) != -1)
    
45.                 {
    
46.                         str = arrA[binarySearch(arrI,t)];
    
47.                 }else if (binarySearch(arrA,t) != -1){
    
48.                         str = arrI[binarySearch(arrA,t)];
    
49.                 }else{
    
50.                         str = t;//如果大小写字母数组中都没有,则返回原字符
    
51.                 }
    
52.                 return str;
    
53.         }
    
54.         //二分查找
    
55.         public static int binarySearch(char[] arr,char val)
    
56.         {
    
57.                 int start = 0,end = arr.length - 1;
    
58. 
    
59.                 int mid = (start + end) >>> 1;
    
60. 
    
61.                 while (end >= start)
    
62.                 {
    
63.                         if (arr[mid] == val)
    
64.                         {
    
65.                                 return mid;
    
66.                         }
    
67.                         if (arr[mid] < val)
    
68.                         {
    
69.                                 start = mid + 1;
    
70.                                 mid = (start + end ) >>> 1;
    
71.                         }
    
72.                         if (arr[mid] > val)
    
73.                         {
    
74.                                 end = mid - 1;
    
75.                                 mid = (start + end ) >>> 1;
    
76.                         }
    
77.                 }
    
78.                 return -1;
    
79.         }
    
80. 
    
81. }
    

复制代码

我的第一反应就是ASCII码。

1. package com.heima.bbs;
   
2. 
   
3. import java.util.Scanner;
   
4. 
   
5. import javax.swing.text.ChangedCharSetException;
   
6. 
   
7. /**
   
8. * 从键盘接收一个字符串,对字符串中的字母进行大小写互转
   
9. */
   
10. public class Demo7 {
    
11. 
    
12.         public static void main(String[] args) {
    
13. 
    
14.                 System.out.println("请输入一串字母：");
    
15.                 Scanner sc = new Scanner(System.in);
    
16.         String inputStr = sc.nextLine();
    
17.         String outputStr = convert(inputStr);
    
18.         System.out.println(inputStr+"\n大小写转换后：\n"+outputStr);
    
19.         
    
20.         }
    
21.         public static String convert(String sourceStr){
    
22.                 char[] targetStr = new char[sourceStr.length()];
    
23.                 for(int i=0;i<sourceStr.length();i++){
    
24.                         int ascii = (int)sourceStr.charAt(i);//得到字母对应的ascii码
    
25.                         if(ascii>=97){//小写
    
26.                                 targetStr[i] = (char)(ascii-32);
    
27.                         }else if(ascii>=65){//大写
    
28.                                 targetStr[i] = (char)(ascii+32);
    
29.                         }
    
30.                 }
    
31.                 return String.valueOf(targetStr);
    
32.         }
    
33. 
    
34. }
    

复制代码

我用的是正则表达式将大小写的字符范围划到拉regx1和regx2里，然后分别读取从键盘输入的字符串，判断其大小写，并将其转换。如果对正则表达式不太了解，你可以上网查找下资料。希望对你有帮助。下面是我的代码，你可以参考下：
import java.util.Scanner;


public class Test {

        /**
         * @param args
         */
        public static void main(String[] args) {
                // TODO Auto-generated method stub
        String arry;
        String result="";
        //获取键盘输入的字符串
                Scanner sc = new Scanner(System.in);
        arry=sc.nextLine();
        //用正则表达式设定字符串范围
        String regx1="[a-z]";
        String regx2="[A-Z]";
        for(int i=0;i<arry.length();i++)
        {
                String sub=arry.substring(i, i+1);
                //判断是否是小写字母，是则转换为大写
                if(sub.matches(regx1))
                {
                        sub=sub.toUpperCase();
                        result+=sub;
                }
                //判断是否是小写字母，是则转换为小写
                else if(sub.matches(regx2))
                {
                        sub=sub.toLowerCase();
                        result+=sub;
                }
                //其他类型则直接输出
                else
                {
                        result+=sub;
                }
        }
        System.out.println(result);
        }
}

1. 
   
2. class Test{
   
3. 
   
4.     public static void main(String[] args) {
   
5. 
   
6.             System.out.println("字母大小写互换，请输入后回车");
   
7.                 Scanner sc = new Scanner(System.in);
   
8.                 String val = sc.next();
   
9.             System.out.println("转换如下");
   
10.             val = run(val);
    
11.             System.out.println(val);
    
12. 
    
13.     }
    
14.     //字母转换方法体
    
15.     public static String run(String str)
    
16.     {
    
17.             StringBuilder sb = new StringBuilder();
    
18.             for(int i=0;i<str.length();i++){
    
19.                     if(Character.isLowerCase(str.charAt(i))){  //判断第i个位置上的字符是否为小写
    
20.                             sb.append(Character.toUpperCase(str.charAt(i)));  //转化为大写追加到sb末尾
    
21.                     }
    
22.                     else if(Character.isUpperCase(str.charAt(i))){
    
23.                             sb.append(Character.toLowerCase(str.charAt(i)));
    
24.                     }
    
25.             }
    
26.         return sb.toString();
    
27.     }
    
28. }

复制代码

好吧，我就不混分了。
你想方便的话就使用io接受键盘录入，
然后想要改变大小写快可以：
1.使用String api
2.查ASCII表 A -->a 加32
                    a -->A 减32.

源码就自己写了。

大小写都有自己的编码区间，判断一个字符在哪个区间，再将编码加减以改变其大小写形式

写的都不错

/*
* 思路：
* 1.对一个字符串进行转换，那么必须要先从键盘中接收数据，所以要用到输入流
* 2.在输入后，要想对字符串中的字母进行大小写互转，那么就必须加入一个方法，来实现这个功能。
* 3.大小写字母转换，必须从String类型转换到Char[]类型，然后再进行判断
* 4.对于一般的其他字符如数字，汉字，就不用进行处理，直接打印输出即可
*  
*/  
public class Test6 {  
  
    public static void main(String[] args) throws Exception{  
        transStream();  
  
    }  
    public static void transStream(){  
        BufferedReader br = null;  
        BufferedWriter bw = null;  
        try {  
            //键盘录入  
            br = new BufferedReader(new InputStreamReader(System.in));  
            //屏幕输出  
            bw = new BufferedWriter(new OutputStreamWriter(System.out));  
            String line = null;  
            while((line=br.readLine())!=null){  
                if("over".equals(line))  
                    break;  
                bw.write(wordChange(line));  
                bw.newLine();  
                bw.flush();  
            }  
        } catch (Exception e) {  
            //简单处理  
            e.printStackTrace();  
        }finally{  
            try {  
                br.close();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
         
         
         
    }  
    //字符转换，只对大小写字母进行转化  
    public static String wordChange(String line){  
        char[] ch = line.toCharArray();  
        //加入StringBuilder对字母进行增加  
        StringBuilder sb = new StringBuilder();  
        for(int i =0;i<ch.length;i++){  
            //加入判断，因为大写字母+32就是小写字母  
            if(ch[i]>='A'&&ch[i]<='Z'){  
                ch[i]+=32;  
                sb.append(ch[i]);  
            ////加入判断，因为小写字母-32就是大写字母  
            }else if(ch[i]>='a'&&ch[i]<='z'){  
                ch[i]-=32;  
                sb.append(ch[i]);  
            }else{  
                //对其他字母不进行判断  
                sb.append(ch[i]);  
            }  
        }  
        return sb.toString();  
    }  
  
}  

package com.itheima;

import java.io.*;

public class Test8 {
        /**
         * 8、 编写程序，从键盘接收一个字符串，对字符串中的字母进行大小写互转（大写字母转成小写，小写字母转成大写）。
         */
        public static void main(String[] args){
                InputStream is = new DataInputStream(System.in);
                BufferedReader br = new BufferedReader(new InputStreamReader(is));
                String str;
                        try {
                                str = br.readLine();
                                StringBuffer strB = new StringBuffer(str);
                                for(int i=0;i<strB.length();i++){
                                        if(strB.charAt(i)<='Z'&&strB.charAt(i)>='A'){
                                                strB.setCharAt(i,Character.toLowerCase(strB.charAt(i)));
                                        }else if(strB.charAt(i)<='z'&&strB.charAt(i)>='a'){
                                                strB.setCharAt(i,Character.toUpperCase(strB.charAt(i)));
                                        }
                                }
                                System.out.println(strB);
                               
                        } catch (IOException e) {
                                e.printStackTrace();
                        }
                       
        }
}

都很牛逼啊。。。。。。

这么多大神啊！

前方在哪里？期望与各位大神相会。。。

来来看看大神怎么解

niucha ,,,

之前对于toUpperCase方法和toLowerCase方法有点不知道怎么判断，在看来油油油菜花的代码后瞬间明白了。赞一个

public static void main(String[] args) {
                        Scanner sc = new Scanner(System.in);
                        System.out.println("请输入字符串");
                        String str = sc.nextLine();        
                        for (int i = 0; i <str.length(); i++) {    //遍历
                                char c = str.charAt(i);    //获得每个字符
                                if(c>='a'&&c<='z'){           
                                        //判断小写,直接切割拼接  ,链式编程
                                        str = str.substring(0,i).concat(str.substring(i,i+1).toUpperCase().concat(str.substring(i+1)));
                                }else if(c >='A'&&c<='Z') {
                                        //判断大写,方法同上.
                                        str = str.substring(0,i).concat(str.substring(i,i+1).toLowerCase().concat(str.substring(i+1)));
                                }
                        }
                        System.out.println(str);  
        }
此方法简单  更好理解