字符串中大小写都有，是小写的就转成大写，大写转小写！
我写了！几个都不对！
一个方式
for(int i = 0; i < str.length(); i++)  
  {
   char c = str.charAt(i);  
   if (!Character.isLowerCase(c))
   {
    String s = String.valueOf(c);
      s=s.toUpperCase();
   }  
   else
   {
    String s = String.valueOf(c);
     s=s.toLowerCase();
   }
  }  
  --------------------------------------------------------------------
  第二
  //转字符数组
                 char[] ch = str.toCharArray();
                 //遍历数组
                 for (int i = 0; i < ch.length; i++)
                 {
                         if(ch>=97 && ch<=122)
                        {
                              String s = String.valueOf(ch);  
                               s=s.toUpperCase();
                             char c=s.toChar();
                         }
                     else
                    {  
                               String s = String.valueOf(ch);
                               s=s.toLowerCase();
                               char c=s.toChar();
                      }
               }
     String arr= ch.toString();
     return arr;


求大神解释！正确写法！和原理

1.         public static String typeChange(String str){
   
2.                   char[] ch = str.toCharArray();
   
3.                
   
4.                   for (int i = 0; i < ch.length; i++)
   
5.           {
   
6.                   if(ch[i]>=97 && ch[i]<=122)
   
7.                  {
   
8.                        String s = String.valueOf(ch[i]);  
   
9.                         s=s.toUpperCase();
   
10.                       char c=s.charAt(0);
    
11.                       ch[i] = c;               //替换大小写
    
12.                   }
    
13.                       else
    
14.                      {  
    
15.                                 String s = String.valueOf(ch[i]);
    
16.                                 s=s.toLowerCase();
    
17.                                 char c=s.charAt(0);
    
18.                                 ch[i] = c;     //替换大小写
    
19.                        }
    
20.           }
    
21.                   
    
22.                   String arr= String.valueOf(ch);   //数组转换成字符串的形式
    
23.                   return arr;
    
24.         }

复制代码

1. public static String typeChange(String str) {
   
2.                 char[] ch = str.toCharArray();
   
3. 
   
4.                 for (int i = 0; i < ch.length; i++)
   
5.                 {
   
6.                         if (ch[i] >= 97 && ch[i] <= 122) //将A--->Z装换成a--->z
   
7.                         {
   
8.                                 ch[i] = (char) (ch[i] - 32);
   
9.                         }
   
10.                         else if (ch[i] >= 65 && ch[i] <= 90) //将a--->z装换成A--->Z
    
11.                         {
    
12.                                 ch[i] = (char) (ch[i] + 32);
    
13.                         }
    
14.                         else
    
15.                         {
    
16.                                 System.out.println("存在不合法字符！");//这句可以不写，
    
17.                         }
    
18.                 }
    
19.                 str = String.valueOf(ch);
    
20.                 return str;          //之所以把返回一个字符串，是因为String做参数，传递的是值，而不是引用。
    
21.         }

复制代码

public static String typeChange(String str){
                  char[] ch = str.toCharArray();//把接收的字符串转成字符数组
               
                  for (int i = 0; i < ch.length; i++)//遍历字符数组
          {
                  if(ch[i]>=97 && ch[i]<=122)//判断字符数组是否为小写
                 {
                       String s = String.valueOf(ch[i]);  
                        s=s.toUpperCase();//把小写转成大写
                      char c=s.charAt(0);
                      ch[i] = c;               //替换大小写
                  }
                      else
                     {  
                                String s = String.valueOf(ch[i]);
                                s=s.toLowerCase();//把大写转成小写
                                char c=s.charAt(0);
                                ch[i] = c;     //替换大小写
                       }
          }
                  
                  String arr= String.valueOf(ch);   //数组转换成字符串的形式
                  return arr;
        }

1. import java.io.BufferedReader;
   
2. import java.io.IOException;
   
3. import java.io.InputStreamReader;
   
4. 
   
5. /**
   
6. * 第七题： 编写程序，从键盘接收一个字符串，对字符串中的字母进行大小写互转（大写字母转成小写，小写字母转成大写）。
   
7. *
   
8. * 思路：
   
9. * 1， 接收键盘录入需要用到标准输入流System.in；
   
10. * 2， 字符串大小写转换要用Character类中的isLowerCase(),isUpperCase(),toUpperCase()和toLowerCase();
    
11. *
    
12. *
    
13. * @author DevLover
    
14. *
    
15. */
    
16. public class Test7
    
17. {
    
18.         public static void main(String[] args) throws Exception
    
19.         {
    
20.                 // 创建字符串读取流缓冲区，读取键盘录入
    
21.                 BufferedReader bufr =
    
22.                                 new BufferedReader(new InputStreamReader(System.in));
    
23. 
    
24.                 try
    
25.                 {
    
26.                         //接收键盘录入的字符串
    
27.                         String str = bufr.readLine();
    
28.                         //将字符串转换成字节数组
    
29.                         char[] ch = str.toCharArray();
    
30.                        
    
31.                         int x = 0;
    
32.                         char c;
    
33.                         while(x < ch.length)
    
34.                         {
    
35.                                 c = ch[x];
    
36.                                 if (Character.isLowerCase(c))
    
37.                                         //如果该字符是小写，则执行此语句
    
38.                                         System.out.print(Character.toUpperCase(c));
    
39.                                 else
    
40.                                         //如果该字符是大写，则执行此语句
    
41.                                         System.out.print(Character.toLowerCase(c));
    
42.                                
    
43.                                 x++;
    
44.                         }
    
45.                        
    
46.                         System.out.println();
    
47.                 }
    
48.                 catch (IOException e)
    
49.                 {
    
50.                         e.printStackTrace();
    
51.                 }
    
52.                
    
53.                 bufr.close();
    
54.         }
    
55. }
    

复制代码

我以前做的题中有做过这个判断，思想就是先把这个字符A转换成大写得到B，然和用A和B比较，如果B和A相等，那么说明A原来是大写的，就转换才小写的。否则是小写的，就转换成大写的。

这里A和B不是字符，是对象。

我醉了，不要相信

/*
         * 建立方法获取键盘输入
         */
        private static void solve() {
                Scanner scanner = new Scanner(System.in);
                String str = scanner.next();
                exChange(str);
        }

        /*
         * 建立大小写的转换方法
         */
        private static void exChange(String str){  
            StringBuffer sb = new StringBuffer();  
            if(str!=null){  
                for(int i=0;i<str.length();i++){  
                    char c = str.charAt(i);  
                    if(Character.isUpperCase(c)){  
                        sb.append(Character.toLowerCase(c));  
                    }else if(Character.isLowerCase(c)){  
                        sb.append(Character.toUpperCase(c));   
                    }  
                }  
            }  
             
            print(sb.toString());  
        }  
我也把写的贴出来吧，欢迎拍砖，大家共同进步嘛

1. public static void main(String[] args) {
   
2.                 // 创建键盘读取流对象
   
3.                 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
   
4.                 String line = null;
   
5.                 try {
   
6.                         while ((line = br.readLine()) != null) {
   
7.                                 // 将读入的字符串转变成字符数组
   
8.                                 char[] c = line.toCharArray();
   
9.                                 // 循环遍历字符数组
   
10.                                 for (int i = 0; i < c.length; i++) {
    
11.                                         if ('a' <= c[i] && c[i] <= 'z') {
    
12.                                                 // 将小写转换成大写
    
13.                                                 c[i] = (char) (c[i] + ('A' - 'a'));
    
14.                                         } else if ('A' <= c[i] && c[i] <= 'Z') {
    
15.                                                 // 将大写转换成小写
    
16.                                                 c[i] += ('a' - 'A');
    
17.                                         }
    
18.                                 }
    
19.                                 System.out.println(new String(c));
    
20.                         }
    
21.                 } catch (IOException e) {
    
22.                         e.printStackTrace();
    
23.                 }
    
24.         }

复制代码

这是我之前写的，供楼主参考.

亲，如问题已解决请将分类的未解决改为已解决。

以后的问题贴也要及时更改分类哦~


保持队形，谢谢合作