黑马程序员技术交流社区

标题: java笔试题 [打印本页]

作者: chenguoyu520    时间: 2015-11-9 22:43
标题: java笔试题
编写一个类,其中包含两个排序的方法sort(),参数不同,当键盘录入的是一串整数,就按照从小到大的顺序输出,如果键盘录入的是一个字符串,就将字符串反序输出

作者: 大自然的搬运工    时间: 2015-11-9 23:43
public class Test{
        public static void main (String[] args){
                Scanner scan = new Scanner(System.in);

                String line = scan.next();
                line = MySort.sorts(line);
                System.out.println(line);
               
                int num = scan.nextInt();
                num = MySort.sorts(num);
                System.out.println(num);
       
        }
}

class MySort{
        public static String sorts(String s){
                byte[] bytes = s.getBytes();
                Arrays.sort(bytes);
                for(int i = 0,j=bytes.length-1;i<j;i++,j--){
                        byte b = bytes[i];
                        bytes[i] = bytes[j];
                        bytes[j] = b ;
                }
                s = new String(bytes);
                return s;
        }
        public static int sorts(int x){
                String s = ""+x ;
                byte[] bytes = s.getBytes();
                Arrays.sort(bytes);
                s = new String(bytes);
                return new Integer(s);
        }

       
}
作者: 吃饭工作睡觉    时间: 2015-11-10 09:26
  1. public class Test {

  2.         public static void main(String[] args) {
  3.                 Scanner scanner = new Scanner(System.in);
  4.                 System.out.println("请问您输入的字符串还是数组:");
  5.                 System.out.println("\t1.字符串.");
  6.                 System.out.println("\t2.数组(请用空格分割数字).");
  7.                 int num = scanner.nextInt();
  8.                 //不能再接受数字后直接接受字符串,Enter键的输入数字时敲入。
  9.                 //又会被nextLine()读取。应该使用两个nextLine()
  10.                 scanner.nextLine();
  11.                 System.out.println("请输入数据:");
  12.                 String line = scanner.nextLine();
  13.                 System.out.println(line);
  14.                 switch(num){
  15.                 case 1:
  16.                         sort(line);
  17.                         break;
  18.                 case 2:
  19.                         String[] strArray = line.split(" ");
  20.                         int[] intArray = new int[strArray.length];
  21.                         for (int i = 0; i < strArray.length; i++) {
  22.                                 intArray[i] = Integer.parseInt(strArray[i]);
  23.                         }
  24.                         sort(intArray);
  25.                         break;
  26.                         default:
  27.                                 System.out.println("您输入的格式不对");
  28.                 }
  29.                
  30.         }
  31.         public static void sort(int[] arr){
  32.                 //调用Arrays的sort方法为数组排序
  33.                 Arrays.sort(arr);
  34.                
  35.                 //调用Arrays的toString()方法输出数组
  36.                 System.out.println(Arrays.toString(arr));
  37.         }
  38.        
  39.         public static void sort(String str){
  40.                 //讲字符串变为字符数组
  41.                 String[] arr = str.split("");
  42.                 //调用Arrays的sort方法为数组排序
  43.                 Arrays.sort(arr);
  44.                
  45.                 //调用Arrays的toString()方法输出数组
  46.                 System.out.println(Arrays.toString(arr));
  47.                
  48.         }
  49. }
复制代码

作者: 伍陶陶    时间: 2015-11-10 12:48
不错不错,这个题目有意义。
作者: 萧未然    时间: 2015-11-10 17:07
说一下哈,字符串的反向输出的简便方法
public static void sort(String str){
                 if(str==null){//非空判断,否者反转时会出现lNullPointerException
                        System.out.println("什么都输入");
                        return;
                 }
                StringBuilder sb=new StringBuilder(str);
                str=sb.reverse().toString();//反转
                System.out.println(str);
        }
作者: 杨洛神    时间: 2015-11-10 17:26
看看不错...
作者: tangqun    时间: 2015-11-10 20:18
输入整型数组则排序
输入字符串则反序,反序是不是说输入"abcdef",变成输出"fedcba"?
class A
{
    public static int[] Sort(int[] a)
    {
        for (int i = 0; i < a.Length; i++)
        {
            for (int j = i + 1; j < a.Length; j++)
            {
                if (a[i] > a[j])
                {
                    int temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                }
            }
        }
        return a;
    }
    public static String Sort(String a)
    {
        char[] c = a.ToCharArray();
        for (int i = 0; i < c.Length / 2; i++)
        {
            char temp = c[i];
            c[i] = c[c.Length - 1 - i];
            c[c.Length - 1 - i] = temp;
        }
        StringBuilder sb = new StringBuilder("");
        sb.Append(c);
        return sb.ToString();
    }
};
作者: gpalw    时间: 2015-11-10 21:07
又学到了,原来是这样子做。。
作者: +icer+    时间: 2015-11-10 21:54
学到老活到老.
作者: 744919632    时间: 2015-11-11 09:36
长知识了、
作者: jiao731097245    时间: 2015-11-11 16:46
  1. [code]import java.util.Scanner;
  2. class  Demo
  3. {
  4.         public static void main(String[] args)
  5.         {
  6.                 Scanner s=new Scanner(System.in);
  7.                 String str=s.next();
  8.                
  9.                 System.out.println(sort(str));
  10.         }
  11.         public static String sort(String str){
  12.                 //将字符串转换为字符数组
  13.                 char[] c=str.toCharArray();
  14.                 //定义标记,判断输入的是否为字符串
  15.                 boolean flag=false;
  16.                 //遍历数组,如果有一个不为整数时,则为字符串
  17.                 for(int i=0;i<c.length;i++){
  18.                         if(c[i]<'0'||c[i]>'9'){
  19.                                 flag=true;
  20.                                 break;
  21.                         }
  22.                 }
  23.                 //如果为字符串,通过StringBuilder的reverse将字符串进行反转
  24.                 if(flag)
  25.                         return new StringBuilder(str).reverse().toString();
  26.                 //传入的字符串为整数时,通过冒泡排序进行排序。或者通过Arrays的sort方法进行排序
  27.                 else
  28.                 {
  29.                         for(int x=0;x<c.length-1;x++){
  30.                                 for(int y=0;y<c.length-1-x;y++){
  31.                                         if(c[y]>c[y+1]){
  32.                                                 char temp=c[y];
  33.                                                 c[y]=c[y+1];
  34.                                                 c[y+1]=temp;
  35.                                         }
  36.                                 }
  37.                         }
  38.                         return new String(c);
  39.                 }
  40.         }
  41. }
复制代码
[/code]
作者: 洛荣神川    时间: 2015-11-11 22:48
学习中,长知识
作者: 小龙2015    时间: 2015-11-16 18:10
import java.util.Arrays;

public class Demo {
public static void main(String[] args) {
//  int [] objs={3,6,1,10,8};
//  objs=sort(objs);
  String[] objs={"b","a","c","h","d"};
  objs=sort(objs);
  
  for (int i = 0; i < objs.length; i++) {
   System.out.println(objs[i]+" ");
  }
}

public static int[] sort(int[] nums){
  Arrays.sort(nums);
  return nums;
}

public static String[] sort(String[] strs){
  for (int i = 0; i < strs.length; i++) {
   for (int j = 0; j < strs.length-i-1; j++) {
    if(strs[j].compareTo(strs[j+1])<1){
     String temp=strs[j];
     strs[j]=strs[j+1];
     strs[j+1]=temp;
    }
   }
  }
  return strs;
}
}
追问:
可不可以帮我注明一下
追答:
import java.util.Arrays;

public class Demo {
        public static void main(String[] args) {
                //数字已经测试过,没有问题
//                int [] objs={3,6,1,10,8};
//                objs=sort(objs);
                //随便建一个字符的数组
                String[] objs={"b","a","c","h","d"};
                objs=sort(objs);
                //打印
                for (int i = 0; i < objs.length; i++) {
                        System.out.println(objs[i]+" ");
                }
        }
       
        //用Arrays.sort()方法排序,默认从小到大
        public static int[] sort(int[] nums){
                Arrays.sort(nums);
                return nums;
        }
       
        //字符串排序,用冒泡排序,通过compareTo(str)方法进行比较,该方法是根据字典表的顺序进行比较,如果参数大于本值,则返回-1,如果相等返回0,大于返回1
        public static String[] sort(String[] strs){
                for (int i = 0; i < strs.length; i++) {
                        for (int j = 0; j < strs.length-i-1; j++) {
                                if(strs[j].compareTo(strs[j+1])<1){
                                        String temp=strs[j];
                                        strs[j]=strs[j+1];
                                        strs[j+1]=temp;
                                }
                        }
                }
                return strs;
        }

}
作者: chenguoyu520    时间: 2015-11-18 08:37
小龙2015 发表于 2015-11-16 18:10
import java.util.Arrays;

public class Demo {

哥们,别去百度,百度的和自己做出来的还是有区别的
作者: 一个人走天下    时间: 2015-11-20 16:55
学习了

作者: bbaijiajinger    时间: 2015-11-23 18:13
还看不太懂
作者: Weidan    时间: 2015-11-28 22:05
昨晚刚写的 给你 测试通过~
  1. package Test03;

  2. import java.util.Arrays;
  3. import java.util.Scanner;

  4. /**
  5. * 编写一个类,其中包含两个排序的方法sort(), 参数不同,当键盘录入的是一串整数,就按照从小到大
  6. * 的顺序输出,如果键盘录入的是一个字符串,就将字符串反序输出。
  7. *
  8. * @author Weidan
  9. *
  10. */
  11. public class Demo {
  12.         public static void main(String[] args) {
  13.                 //接收键盘输入
  14.                 Scanner sc = new Scanner(System.in);
  15.                 String input = sc.next();
  16.                 try {
  17.                         //若字符串可以转换为数字
  18.                         Integer.valueOf(input);
  19.                         //分割字符串成字符数组
  20.                         String[] inputStr = input.split("");
  21.                         //创建新数组
  22.                         int[] array = new int[inputStr.length];
  23.                         //把字符串的每个数字存入数组中
  24.                         for (int i = 0; i < array.length; i++) {
  25.                                 array[i] = Integer.valueOf(inputStr[i]);
  26.                         }
  27.                         //排序
  28.                         sort(array);
  29.                 } catch (NumberFormatException e) {
  30.                         //若不可以转换则直接反转输出
  31.                         System.out.println(sort(input));
  32.                 }
  33.         }

  34.         public static void sort(int[] array) {
  35.                 //冒泡排序
  36.                 for (int j = 0; j < array.length - 1; j++) {
  37.                         for (int i = 0; i < array.length - 1 - j; i++) {
  38.                                 if (array[i] > array[i + 1]) {
  39.                                         int temp = array[i];
  40.                                         array[i] = array[i + 1];
  41.                                         array[i + 1] = temp;
  42.                                 }
  43.                         }
  44.                 }
  45.                 //新增一个字符串
  46.                 String newStr = "";
  47.                 //把数组中的每个数字存入字符串中
  48.                 for (int i : array) {
  49.                         newStr += i;
  50.                 }
  51.                 //输出新字符串
  52.                 System.out.println(newStr);
  53.         }

  54.         public static String sort(String str) {
  55.                 //转换为char数组
  56.                 char[] strArray = str.trim().toCharArray();
  57.                 //创建新数组
  58.                 String reverseStr = "";
  59.                 //反向存储字符串
  60.                 for (int i = strArray.length - 1; i > -1; i--) {
  61.                         reverseStr += strArray[i];
  62.                 }
  63.                 ////返回值
  64.                 return reverseStr;
  65.         }
  66. }
复制代码

作者: VisionDo    时间: 2015-12-9 17:55
  1. package exp;

  2. import java.util.Scanner;
  3. import java.util.regex.Pattern;

  4. /**
  5. *
  6. * 编写一个类,其中包含两个排序的方法sort()参数不同
  7. * 当键盘录入的是一串整数,就按照从小到大的顺序输出
  8. * 如果键盘录入的是一个字符串,就将字符串反序输出
  9. *
  10. *
  11. */

  12. public class MySort {

  13.         public static void main(String[] args) {
  14.        
  15.                 Scanner sc = new Scanner(System.in);
  16.                 String str = "";
  17.                 System.out.print("请输入字符串:");
  18.                 str = sc.next();
  19.                 if(IsNum(str))
  20.                         SortNum(str.toCharArray());
  21.                 else
  22.                         SortStr(str);
  23.         }

  24.         /**
  25.          *
  26.          * @param ch 待排序的char型数组
  27.          */
  28.         private static void SortNum(char[] ch){
  29.                 char temp;
  30.                 for(int i =0; i <ch.length-1; i++){
  31.                         for(int j = i+1; j<ch.length;j++){
  32.                                 if(Integer.valueOf(ch[i])>Integer.valueOf(ch[j])){
  33.                                         temp = ch[i];
  34.                                         ch[i] = ch[j];
  35.                                         ch[j] = temp;
  36.                                         }
  37.                         }
  38.                 }
  39.                 System.out.print("排序后:");
  40.                 for(char c:ch){
  41.                         System.out.print(c+" ");
  42.                 }
  43.                
  44.         }
  45.        
  46.         /**
  47.          *
  48.          * @param str 待反序的字符串
  49.          */
  50.         private static void SortStr(String str){
  51.                 char[] ch = str.toCharArray();
  52.                 int i = ch.length;
  53.                 System.out.print("反序后:");
  54.                 while(i-->0){
  55.                         System.out.print(ch[i]);
  56.                 }
  57.                
  58.                 /*
  59.                  * 题目要求编写函数实现反序操作
  60.                  * 其实是用StringBuffer或者StringBuilder
  61.                  * StringBuilder sb = new StringBuilder();
  62.                  * sb.append(str);
  63.                  * sb.reverse();
  64.                  * 即可实现反序
  65.                  *
  66.                  */
  67.                
  68.                
  69.         }
  70.        
  71.        
  72.         /**
  73.          *
  74.          * @param str 用户输入的字符串
  75.          * @return 是否为数字串
  76.          */
  77.         private static boolean IsNum(String str){
  78.                 String std = "^.*.*[^0-9].*.*$";
  79.                 /*
  80.                  * 以任意字符开头   ^.*
  81.                  * 间隔任意字符后  .*
  82.                  * 包含除0-9以外的字符  [^0-9]
  83.                  * 间隔任意字符后  .*
  84.                  * 以任意字符结尾  .*$
  85.                  */
  86.                 Pattern p = Pattern.compile(std);
  87.                 boolean IsMatch = p.matcher(str).matches();
  88.                 if(!IsMatch)
  89.                         return true;
  90.                 else
  91.                         return false;               
  92.         }
  93.        
  94. }
复制代码

作者: Mykey    时间: 2015-12-14 22:16
大神啊,求带走啊.
作者: 青菜市场    时间: 2015-12-19 08:43
这里面有可能有你的想要的答案,你的问题不明确,题中一串整数是指没带空格的单个整数么?package com.ithenma.answer;

import java.util.Arrays;
import java.util.Scanner;

public class Test_String {
        /**
         * 编写一个类,其中包含两个排序的方法sort(),参数不同, 当键盘录入的是一串整数,就按照从小到大的顺序输出,
         * 如果键盘录入的是一个字符串,就将字符串反序输出
         */
        public static void main(String[] args) {
                Scanner sc = new Scanner(System.in);
                System.out.println("请输入");
                String string = null;
//                判断键盘录入的是纯数字还是字符串并对其做不同的排序  还是有问题里面如果有多个小数 会报异常
                if (sc.hasNextDouble()) {
                        string = sc.nextLine();
                        sortInt(string);
                } else {
                        string = sc.nextLine();
                        sortStr(string);
                }
        }
//        输入为字符串时调用的方法
        public static void sortStr(String string) {
//        如果字符串里有空格 就已用空格切割出一个字符串数组并反序排列字符串数组并输出
                String[] arr = string.split(" " + "+");   
                if (arr.length != 1) {
                        sortS(arr);
                        System.out.println(Arrays.toString(arr));
                } else {
//        若字符串没有空格就视为单个字符串,并对其反序排列并输出
                        char[] cs = string.toCharArray();
                        sort(cs);
                        System.out.println(new String(cs));
                }
        }
// 输入为数字时调用的方法
        public static void sortInt(String string) {
//                如果数字里有空格 就已用空格切割出一个整数数字数组并反序排列字符串数组并输出
                String[] arr = string.split(" " + "+");
                if (arr.length != 1) {
                        int[] arrint = intOf(arr);
                        System.out.println(Arrays.toString(sort(arrint)));
                } else {
                        char[] c = string.toCharArray();
                        Arrays.sort(c);
                        System.out.println(new String(c));
                }
        }
       
        public static int[] sort(int[] arrint) {
                for (int i = 0; i < arrint.length; i++) {
                        for (int j = 0; j < arrint.length - i - 1; j++) {
                                if (arrint[j] > arrint[j + 1])
                                        swap(arrint, j, j + 1);
                        }
                }
                return arrint;
        }
       
        public static void sort(char[] cs) {
                for (int i = 0; i < cs.length; i++) {
                        for (int j = 0; j < cs.length - i - 1; j++) {
                                if (cs[j] < cs[j + 1])
                                        swap(cs, j, j + 1);
                        }
                }
        }

        private static void sortS(String[] arr) {

                for (int i = 0; i < arr.length; i++) {
                        for (int j = 0; j < arr.length - i - 1; j++) {
                                int num = arr[j].compareTo(arr[j + 1]);
                                if (num < 0)
                                        swap(arr, j, j + 1);
                        }
                }
        }

        private static int[] intOf(String[] arr) {
                int[] arrI = new int[arr.length];
                for (int i = 0; i < arr.length; i++) {
                        arrI[i] = Integer.valueOf(arr[i]);
                }
                return arrI;
        }

        private static void swap(int[] arr, int j, int i) {
                int temp = arr[j];
                arr[j] = arr[i];
                arr[i] = temp;
        }

        private static <T> void swap(T[] arr, int j, int i) {
                T temp = arr[j];
                arr[j] = arr[i];
                arr[i] = temp;
        }

        private static void swap(char[] arr, int j, int i) {
                char temp = arr[j];
                arr[j] = arr[i];
                arr[i] = temp;
        }

}



作者: furuigang    时间: 2016-1-17 12:21
import java.util.Arrays;
import java.util.Scanner;

public class GetSort {
        public static void main(String[] args) {
                Scanner sc = new Scanner(System.in);
                String str = sc.next();
                boolean flag = Reverse.isNum(str);
                if (flag) {
                        Reverse.sort(str.toCharArray());
                } else {
                        Reverse.sort(str);
                }
        }
}

class Reverse {

        private Reverse() {
        }

        // 判断键盘录入的内容是否为整数
        public static boolean isNum(String str) {
                for (int i = 0; i < str.length(); i++) {
                        if (str.charAt(i) < '0' || str.charAt(i) > '9')
                                return false;
                }
                return true;
        }

        // 整数从小到大顺序输出
        public static void sort(char[] c) {
                Arrays.sort(c);
                System.out.println(c);
        }

        // 字符串反序输出
        public static void sort(String str) {
                System.out.println(new StringBuffer(str).reverse().toString());
        }
}

代码块1.png (28.96 KB, 下载次数: 40)

代码块1.png

代码块2.png (29.95 KB, 下载次数: 16)

代码块2.png

作者: DK寒    时间: 2016-1-21 23:48
看看回复就学到了好多啊




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2