[Java] java笔试题

编写一个类，其中包含两个排序的方法sort（）,参数不同，当键盘录入的是一串整数，就按照从小到大的顺序输出，如果键盘录入的是一个字符串，就将字符串反序输出

大自然的搬运工 · 大自然的搬运工

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);
}

}

吃饭工作睡觉 · 吃饭工作睡觉

public class Test {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请问您输入的字符串还是数组：");
System.out.println("\t1.字符串.");
System.out.println("\t2.数组(请用空格分割数字).");
int num = scanner.nextInt();
//不能再接受数字后直接接受字符串，Enter键的输入数字时敲入。
//又会被nextLine()读取。应该使用两个nextLine()
scanner.nextLine();
System.out.println("请输入数据:");
String line = scanner.nextLine();
System.out.println(line);
switch(num){
case 1:
sort(line);
break;
case 2:
String[] strArray = line.split(" ");
int[] intArray = new int[strArray.length];
for (int i = 0; i < strArray.length; i++) {
intArray[i] = Integer.parseInt(strArray[i]);
}
sort(intArray);
break;
default:
System.out.println("您输入的格式不对");
}
}
public static void sort(int[] arr){
//调用Arrays的sort方法为数组排序
Arrays.sort(arr);
//调用Arrays的toString()方法输出数组
System.out.println(Arrays.toString(arr));
}
public static void sort(String str){
//讲字符串变为字符数组
String[] arr = str.split("");
//调用Arrays的sort方法为数组排序
Arrays.sort(arr);
//调用Arrays的toString()方法输出数组
System.out.println(Arrays.toString(arr));
}
}

复制代码

伍陶陶 · 伍陶陶

不错不错，这个题目有意义。

萧未然 · 萧未然

说一下哈，字符串的反向输出的简便方法
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);
      }

杨洛神 · 杨洛神

看看不错...

tangqun · tangqun

输入整型数组则排序
输入字符串则反序，反序是不是说输入"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 · gpalw

又学到了，原来是这样子做。。

+icer+ · +icer+

学到老活到老.

744919632

长知识了、

jiao731097245 · jiao731097245

[code]import java.util.Scanner;
class Demo
{
public static void main(String[] args)
{
Scanner s=new Scanner(System.in);
String str=s.next();
System.out.println(sort(str));
}
public static String sort(String str){
//将字符串转换为字符数组
char[] c=str.toCharArray();
//定义标记，判断输入的是否为字符串
boolean flag=false;
//遍历数组，如果有一个不为整数时，则为字符串
for(int i=0;i<c.length;i++){
if(c[i]<'0'||c[i]>'9'){
flag=true;
break;
}
}
//如果为字符串，通过StringBuilder的reverse将字符串进行反转
if(flag)
return new StringBuilder(str).reverse().toString();
//传入的字符串为整数时，通过冒泡排序进行排序。或者通过Arrays的sort方法进行排序
else
{
for(int x=0;x<c.length-1;x++){
for(int y=0;y<c.length-1-x;y++){
if(c[y]>c[y+1]){
char temp=c[y];
c[y]=c[y+1];
c[y+1]=temp;
}
}
}
return new String(c);
}
}
}

复制代码

[/code]

洛荣神川 · 洛荣神川

学习中，长知识

小龙2015 · 小龙2015

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 · chenguoyu520

小龙2015 发表于 2015-11-16 18:10
import java.util.Arrays;

public class Demo {

哥们，别去百度，百度的和自己做出来的还是有区别的

一个人走天下 · 一个人走天下

学习了

bbaijiajinger · bbaijiajinger

还看不太懂

Weidan · Weidan

昨晚刚写的给你测试通过~

package Test03;
import java.util.Arrays;
import java.util.Scanner;
/**
* 编写一个类，其中包含两个排序的方法sort（）, 参数不同，当键盘录入的是一串整数，就按照从小到大
* 的顺序输出，如果键盘录入的是一个字符串，就将字符串反序输出。
*
* @author Weidan
*
*/
public class Demo {
public static void main(String[] args) {
//接收键盘输入
Scanner sc = new Scanner(System.in);
String input = sc.next();
try {
//若字符串可以转换为数字
Integer.valueOf(input);
//分割字符串成字符数组
String[] inputStr = input.split("");
//创建新数组
int[] array = new int[inputStr.length];
//把字符串的每个数字存入数组中
for (int i = 0; i < array.length; i++) {
array[i] = Integer.valueOf(inputStr[i]);
}
//排序
sort(array);
} catch (NumberFormatException e) {
//若不可以转换则直接反转输出
System.out.println(sort(input));
}
}
public static void sort(int[] array) {
//冒泡排序
for (int j = 0; j < array.length - 1; j++) {
for (int i = 0; i < array.length - 1 - j; i++) {
if (array[i] > array[i + 1]) {
int temp = array[i];
array[i] = array[i + 1];
array[i + 1] = temp;
}
}
}
//新增一个字符串
String newStr = "";
//把数组中的每个数字存入字符串中
for (int i : array) {
newStr += i;
}
//输出新字符串
System.out.println(newStr);
}
public static String sort(String str) {
//转换为char数组
char[] strArray = str.trim().toCharArray();
//创建新数组
String reverseStr = "";
//反向存储字符串
for (int i = strArray.length - 1; i > -1; i--) {
reverseStr += strArray[i];
}
////返回值
return reverseStr;
}
}

复制代码

VisionDo · VisionDo

package exp;
import java.util.Scanner;
import java.util.regex.Pattern;
/**
*
* 编写一个类，其中包含两个排序的方法sort（）参数不同
* 当键盘录入的是一串整数，就按照从小到大的顺序输出
* 如果键盘录入的是一个字符串，就将字符串反序输出
*
*
*/
public class MySort {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str = "";
System.out.print("请输入字符串：");
str = sc.next();
if(IsNum(str))
SortNum(str.toCharArray());
else
SortStr(str);
}
/**
*
* @param ch 待排序的char型数组
*/
private static void SortNum(char[] ch){
char temp;
for(int i =0; i <ch.length-1; i++){
for(int j = i+1; j<ch.length;j++){
if(Integer.valueOf(ch[i])>Integer.valueOf(ch[j])){
temp = ch[i];
ch[i] = ch[j];
ch[j] = temp;
}
}
}
System.out.print("排序后：");
for(char c:ch){
System.out.print(c+" ");
}
}
/**
*
* @param str 待反序的字符串
*/
private static void SortStr(String str){
char[] ch = str.toCharArray();
int i = ch.length;
System.out.print("反序后：");
while(i-->0){
System.out.print(ch[i]);
}
/*
* 题目要求编写函数实现反序操作
* 其实是用StringBuffer或者StringBuilder
* StringBuilder sb = new StringBuilder();
* sb.append(str);
* sb.reverse();
* 即可实现反序
*
*/
}
/**
*
* @param str 用户输入的字符串
* @return 是否为数字串
*/
private static boolean IsNum(String str){
String std = "^.*.*[^0-9].*.*$";
/*
* 以任意字符开头 ^.*
* 间隔任意字符后 .*
* 包含除0-9以外的字符 [^0-9]
* 间隔任意字符后 .*
* 以任意字符结尾 .*$
*/
Pattern p = Pattern.compile(std);
boolean IsMatch = p.matcher(str).matches();
if(!IsMatch)
return true;
else
return false;
}
}

复制代码

Mykey · Mykey

大神啊,求带走啊.

青菜市场 · 青菜市场

这里面有可能有你的想要的答案，你的问题不明确，题中一串整数是指没带空格的单个整数么？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;
}

}

帐号		自动登录	找回密码
密码			加入黑马

[Java] java笔试题

23 个回复

点评