题目：从键盘接收一个字符串，对字符串的字母进行大小写互转

import java.util.Scanner;

class  Test5

{
        public static void main(String[] args)
        {
                //从键盘接收一个字符串
                System.out.println("please input String:");
                Scanner scn  = new Scanner(System.in);
               
                //调用大小写互转的方法，返回后输出
                String s = CharTool.toChar(scn.next());
               
                scn.close();
               
                System.out.println(s);
        }
}

class CharTool
{
        public static String toChar(String stu)
        {
                StringBuffer sb = new StringBuffer();

                char[] ch = stu.toCharArray();
                for (int i  =0 ;i<=ch.length-1 ;i++)
                {
                        if (ch[i]>=65 && ch[i]<=90)
                        {
                                sb.append((char)(ch[i]+32));
                        }
                        else if (ch[i]>=97 && ch[i]<=122)
                        {
                                sb.append((char)(ch[i]-32));
                        }
                        else
                        {
                        System.out.println("error");
                        break;
                        }
                }
                return sb.toString();
        }
}

BufferedReader bufr = new BufferedReader(new InputStreamRreader(System.in))
String line = null;
while((line=bufr.readLine())!=null){
     if(line.equals("end"))
         break;
    System.out.println(line.toUpperCase);
}
bufr.close();
希望没写错

曲解题意了。不会·······

public class LowUp {
        public static void main(String[] args) throws IOException {
                BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
                String str = br.readLine();
                System.out.println(str);
                char[] arr = str.toCharArray();
                str ="";
                for (int i = 0; i < arr.length; i++) {
                        if (arr[i]>=97&&arr[i]<=122) {
                                arr[i] = (char)( arr[i]-32);
                        }else if (arr[i]>=65&&arr[i]<=90) {
                                arr[i] = (char)( arr[i]+32);
                        }
                        str+=arr[i];
                }
                System.out.println(str);
        }
}

public static String exChange(String str) {
//        定义一个StringBuffer接收转换换句话说结果
                StringBuffer sb = new StringBuffer();
                //判断字符是否为空
                if (str != null) {
//                        for循环使用charAt()方法把字符串的每个字符遍历出来
                        for (int i = 0; i < str.length(); i++) {
                                char c = str.charAt(i);
//                                判断是否是小写
                                if (Character.isUpperCase(c)) {
//                                        如果是小写就转换成大写并加入到StringBuffer中
                                        sb.append(Character.toLowerCase(c));
//                                        判断是否是大写
                                } else if (Character.isLowerCase(c)) {
//                                        如果是大写就转换成小写并加入到StringBuffer中
                                        sb.append(Character.toUpperCase(c));
                                }
                        }
                }
//                返回转换后换句话说字符串
                return sb.toString();

你们回答的都不对啊，是键盘录入一个字符串 ，将录入的字符串中的大小写字母互转，就是输入的大写变小写，输入的小写变大写

public class Test {
        public static void main(String[] args) {
                Scanner sc = new Scanner(System.in);
                String sinput = null;
                while (!"quit".equals(sinput = sc.nextLine())) {
                        System.out.println(swapCase(sinput));
                }
                sc.close();
        }
        /**
         * 大小写互换
         * @param src
         * @return
         */
        public static String swapCase(String src) {
                Matcher matcher = Pattern.compile("([a-z]+)|([A-Z]+)").matcher(src);
                StringBuffer result = new StringBuffer();
                while (matcher.find()) {
                        String s = null;
                        if ((s = matcher.group(1)) != null) {
                                //小写组转大写
                                matcher.appendReplacement(result, s.toUpperCase());
                        } else if ((s = matcher.group(2)) != null) {
                                //大写组转小写
                                matcher.appendReplacement(result, s.toLowerCase());
                        }
                }
                matcher.appendTail(result);
                return result.toString();
        }
}

/*
        将从键盘输入的字符串中的大小写字母互转
*/

import java.util.Scanner;

class StringUpperLetter
{
        public static void main(String[] args)
        {
                // 创建一个Scanner对象用来从键盘输入
                Scanner input = new Scanner(System.in);

                // 定义一个字符串
                String str = "";                // 存储输入字符串
                String str1 = "";                // 转换后的字符串

                // 提示输入一串字符串
                System.out.print("请输入一串字符串：");
                str = input.nextLine();
               
                if (str!=null){                        // 判断字符串是否为空
                        for (int i = 0; i < str.length(); i++){                        // 遍历字符串
                                char c = str.charAt(i);                                // 提取单个字符
                                if (Character.isUpperCase(c)){                        // 如果是字符为大写则转换为小写并将转化后的字符添加到新的字符串中
                                        str1 += Character.toLowerCase(c);         
                                }
                                else if (Character.isLowerCase(c)){                // 如果是字符为小写则转换为大并将转化后的字符添加到新的字符串中
                                        str1 += Character.toUpperCase(c);
                                }
                                else
                                        str1 += c;                                // 如果为其他字符则照原来的样子添加进新的字符串
                        }
                }
                System.out.println(str1);                                        // 打印转化后的字符串
        }
}

1. package demo;
   
2. import java.util.*;
   
3. public class Demo {
   
4. 
   
5.         /**
   
6.          * @param args
   
7.          */
   
8.         public static void main(String[] args) throws Exception{
   
9.                 // TODO Auto-generated method stub
   
10.                 Scanner s = new Scanner(System.in);
    
11.                 String line = null;
    
12.                 while ((line = s.nextLine()) != "over") {
    
13.                         char[] a = line.toCharArray();
    
14.                         for (int i = 0; i < a.length; i++) {
    
15.                                 if (a[i] >= 'a' && a[i] <= 'z')
    
16.                                         a[i] -= 32;
    
17.                                 else if (a[i] >='A' && a[i] <= 'Z')
    
18.                                         a[i] += 32;
    
19.                                 System.out.print(a[i]);
    
20.                         }
    
21.                        
    
22.                 }
    
23.         }
    
24. }

复制代码

重来

1. package demo;
   
2. import java.util.*;
   
3. public class Demo {
   
4. 
   
5.         /**
   
6.          * @param args
   
7.          */
   
8.         public static void main(String[] args) throws Exception{
   
9.                 // TODO Auto-generated method stub
   
10.                 Scanner s = new Scanner(System.in);
    
11.                 String line = null;
    
12.                 while ((line = s.nextLine()) != null) {
    
13.                         char[] a = line.toCharArray();
    
14.                         for (int i = 0; i < a.length; i++) {
    
15.                                 if (a[i] >= 'a' && a[i] <= 'z')
    
16.                                         a[i] -= 32;
    
17.                                 else if (a[i] >='A' && a[i] <= 'Z')
    
18.                                         a[i] += 32;
    
19.                                 System.out.print(a[i]);
    
20.                         }                       
    
21.                 }
    
22.         }
    
23. }

复制代码

1. package HeimaBBS;
   
2. 
   
3. import java.io.BufferedReader;
   
4. import java.io.IOException;
   
5. import java.io.InputStreamReader;
   
6. import java.util.regex.Matcher;
   
7. import java.util.regex.Pattern;
   
8. /**
   
9. * 问题说明：将控制台输入的字符转换（输入：abcdABCD）转换为（ABCDabcd）输出
   
10. *
    
11. */
    
12. public class RexTest {
    
13.         public static void main(String[] args) throws IOException{
    
14.                 BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
    
15.                 String str = bf.readLine();
    
16.                 String reg = "[a-zA-Z]";//正则表达是，只取一个英文字符
    
17.                 Pattern p = Pattern.compile(reg);//获取正则对象
    
18.                 Matcher m = p.matcher(str);//获取匹配器
    
19.                
    
20.                 while(m.find()){//查找到匹配的字符
    
21.                         char[] c = m.group().toCharArray();//获取到一个字符将其转换为只有一个字符的字符数组                       
    
22.                         if(c[0]>='a' && c[0]<='z'){//判断大小写
    
23.                                 System.out.print(String.valueOf(c[0]).toUpperCase());
    
24.                         }else{
    
25.                                 System.out.print(String.valueOf(c[0]).toLowerCase());
    
26.                         }
    
27.                 }
    
28.         }
    
29. }
    

复制代码

卖艺人 发表于 2014-9-3 21:12
/*
        将从键盘输入的字符串中的大小写字母互转
*/

这个好像可以！

import java.util.Scanner;

/*
*
*
*/
public class Test4 {
        public static void main(String[] args) {
                Scanner sc=new Scanner(System.in);
                System.out.println("请输入字符串：");
                String s=sc.nextLine();                 //接受字符串
                char[] ch=s.toCharArray();            //转换成字符数组
                StringBuilder st=new StringBuilder();//创建字符串对象
                for(int x=0;x<ch.length;x++)      //遍历数组并转换
                {
                        if(ch[x]>='a'&& ch[x]<='z')
                        {String ss=Character.toString(ch[x]);
                                st.append(ss.toUpperCase());
                        }else
                        {String ss=Character.toString(ch[x]);
                                st.append(ss.toLowerCase());
                        }
                }
                String s1=new String(st);   //转换成字符串
                System.out.println(s1);   //打印字符串
        }

}

import java.util.Scanner;

/*
*
*
*/
public class Test4 {
        public static void main(String[] args) {
                Scanner sc=new Scanner(System.in);
                System.out.println("请输入字符串：");
                String s=sc.nextLine();
                char[] ch=s.toCharArray();
                StringBuilder st=new StringBuilder();
                for(int x=0;x<ch.length;x++)
                {
                        if(ch[x]>='a'&& ch[x]<='z')
                        {String ss=Character.toString(ch[x]);
                                st.append(ss.toUpperCase());
                        }else
                        {String ss=Character.toString(ch[x]);
                                st.append(ss.toLowerCase());
                        }
                }
                String s1=new String(st);
                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. * 第7题：编写程序，从键盘接收一个字符串，
   
9. *                 对字符串中的字母进行大小写互转（大写字母转成小写，小写字母转成大写）。
   
10. * @author longchao
    
11. */
    
12. /*
    
13. * 思路：
    
14. *         1，分成两个静态方法，一个用于接收键盘录入；一个用于字母大小写互转。
    
15. *         2，键盘接收字符串用：BufferedReader(new InputStream(System.in)
    
16. *         3，将接收到了字符串存为字符串数组，对字符数组进行大小写转换并转成字符串输出
    
17. * */
    
18. public class Test7 {
    
19.         public static void main(String[] args) {
    
20. //                trans("sdKLLJKiojLKJijoLKJ7$#%^87klj0?334..");
    
21.                 try {
    
22.                         //调用接收键盘录入方法，并把接收的数组传给trans进行大小写转换
    
23.                         trans(keyboardIn());
    
24.                 } catch (IOException e) {
    
25.                         e.printStackTrace();
    
26.                 }
    
27.         }
    
28.        
    
29.         //字母大小写转换方法
    
30.         public static void trans(String str){
    
31.                 System.out.println("您输入的数据为："+str);
    
32.                
    
33.                 //将字符串变数组
    
34.                 char[] chs = str.toCharArray();
    
35.                
    
36.                 //遍历数组
    
37.                 for (int i = 0; i < chs.length; i++) {
    
38.                         //如果字符为小写字母，则转为大写字母
    
39.                         if(Character.isLowerCase(chs[i])){
    
40.                                 chs[i]=Character.toUpperCase(chs[i]);
    
41.                        
    
42.                         //如果字符为大写字母，则转为小写字母       
    
43.                         }else if(Character.isUpperCase(chs[i])){
    
44.                                 chs[i]=Character.toLowerCase(chs[i]);
    
45.                         }
    
46.                 }
    
47.                
    
48.                 //将转换后的字符重新封装成字符串
    
49.                 String s = new String(chs);
    
50.                
    
51.                 System.out.println("转换后的数据为："+s);
    
52.                
    
53.         }
    
54.        
    
55.        
    
56.         //接收键盘录入方法
    
57.         public static String keyboardIn() throws IOException{
    
58.                 System.out.println("请输入数据，将为您进行字母大小写转换，如果想退出此程序，请输入：over");
    
59.                 BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
    
60.                
    
61.                 for(String line = null;(line=bufr.readLine())!=null;){
    
62.                         if("over".equals(line))
    
63.                                 break;
    
64.                         else
    
65.                                 return line;
    
66.                 }
    
67.                 return "";
    
68.         }
    
69. 
    
70. }
    

复制代码

1. import java.util.*;
   
2. class  TransformDemo
   
3. {
   
4.         //需求：将键盘录入的字符串大小写互转。
   
5.         public static void main(String[] args)
   
6.         {
   
7.                 System.out.println(transStr());
   
8.         }
   
9.         public static String transStr()
   
10.         {
    
11.                 //获取键盘录入的字符串
    
12.                 Scanner sc=new Scanner(System.in);
    
13.                 String str=sc.next();
    
14.                 //定义正则表达式，要求字符串必须全是字母
    
15.                 String reg="[a-zA-Z]+";
    
16.                 char[] ch=str.toCharArray();
    
17.                 //如果字符串满足reg，将字符串转换为字符数组
    
18.                 if(str.matches(reg))
    
19.                         ch=str.toCharArray();
    
20.                 else
    
21.                 {
    
22.                         return "请输入只带大小写字母的字符串";
    
23.                 }
    
24.                 //遍历满足条件后，String转换成的字符数组
    
25.                 for(int i=0;i<ch.length;i++)
    
26.                 {
    
27.                         //判断大小写，以及大小写转换
    
28.                         if(65<=ch[i] && ch[i]<=90)
    
29.                                 ch[i]=(char)(ch[i]+32);
    
30.                         else
    
31.                                 ch[i]=(char)(ch[i]-32);
    
32.                 }
    
33.                 //将字符数组封装成字符串对象
    
34.                 str=new String(ch);
    
35.                 return str;
    
36. 
    
37.         }
    
38. }

复制代码

是不显示你键盘输入的内容直接显示转换后的结果吧

来转转。。。。。看看。。。。

来转转。。。。。