给大家分享个面试题，挺简单能写出来的新手来试试

Question

对字符串"100,10,1,0,15,20"中的数字进行升序排列，请实现下列代码中的sort方法。
public class Test1 {
public static String sort(String args){
}
public static void main(String[] args) {
String s = "100,10,1,0,15,20";
System.out.print(sort(s));//输出0,1,10,15,20,100,
}

Answer 1

用String类的split方法分割每个数值成字符串数组
然后将每个数值 用Integer.valueOf(String s)的方法转换成整形，保存到一个整形数组中，然后对数字进行排序

Answer 2

public static String sort(String args) {
String returnValue = "";
String[] atrArr = args.split(",");
for (int i = 0; i < atrArr.length; i++) {
for (int j = i + 1; j < atrArr.length; j++) {
if (Integer.valueOf(atrArr[i]) > Integer.valueOf(atrArr[j])) {
String temp = atrArr[j];
atrArr[j] = atrArr[i];
atrArr[i] = temp; }
}
}
for (String s : atrArr) {
returnValue += s + ",";
}
return returnValue.substring(0, returnValue.length() - 1);
} public static void main(String[] args) {
String s = "100,10,1,0,15,20";
System.out.print(sort(s));// 输出0,1,10,15,20,100,
}

Answer 3

呵呵 转换成整形数组之后 可以直接用array这个工具类来sort排序了

Answer 4

import java.util.*;public class Test1 
{
public static String sort(String args)
{       String copy[] = new String[6];
    copy[0] = args.substring(0,3);    
    copy[1] = args.substring(4,6);     
    copy[2] = args.substring(7,8);         
    copy[3] = args.substring(9,10);          
    copy[4] = args.substring(11,13);     
    copy[5] = args.substring(14,16);
    
    int []array = new int[6];
    for(int i=0; i<copy.length; i++)
    {
     array[i] = Integer.parseInt(copy[i]);
    }
    Arrays.sort(array);    for(int i=0; i<copy.length; i++)
   {
    copy[i] = String.valueOf( array[i]);
   }
 return copy[0]+","+copy[1]+","+copy[2]+","+copy[3]+","+copy[4]+","+copy[5]+".";


}
public static void main(String[] args) 
{
String s = "100,10,1,0,15,20";
System.out.print(sort(s));//输出0,1,10,15,20,100,
}
}

Answer 5

我加了头文件import java.util.*;我真是新手，写这个程序用了半天功夫，有些知识我没有学到，用百度查了数字与字符串之间的转换，楼主一定要多给我分呀。

Answer 6

果然是新手，精神可嘉 呵呵 写完程序之后 再想想有没有别的实现方法 参考下别人的思路 对比下自己的 有助于自己的提高的 
你用 substring来分割字符串 如果第一个数字不是三位数 而只是两位数呢，你的程序就崩了

Answer 7

Arrays.sort(s.split(","), new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.length() == o2.length() ? o1.compareTo(o2) : o1.length - o2.length;
}
});

Answer 8

static String sort(String args) {
if(args == null || args.isEmpty() || !args.contains(",")) {
return args;
}
String[] strArr = args.split(",");
int[] intArr = new int[strArr.length];
for(int i = 0;i < strArr.length;++i) {
intArr[i] = Integer.valueOf(strArr[i]);
}
Arrays.sort(intArr);
StringBuffer sb = new StringBuffer();
for(int i = 0;i < intArr.length;++i) {
sb.append(intArr[i]);
if(i != intArr.length - 1) {
sb.append(",");
}
}
return sb.toString();
}

Answer 9

public class Test1 {
public static String sort(String args) {
String[] temp = args.split(",");
int[] src = new int[temp.length];
for (int i = 0; i < temp.length; i++) {
src[i] = Integer.parseInt(temp[i]);
}
int[] srcD = bubbleSort(src);
String ans = "";
for (int i : srcD) {
ans += i + " ";
}
return ans;
} public static int[] bubbleSort(int[] src) {//冒泡排序法，你也可以用其他排序方法来代替
for (int i = 1; i < src.length; i++) {
for (int j = 0; j < src.length - i; j++) {
if (src[j] > src[j + 1]) {
swap(src, j, j + 1);
}
}
}
return src;
} public static void swap(int[] src, int i, int j) {//交换两个值
src[i] = src[i] + src[j];
src[j] = src[i] - src[j];
src[i] = src[i] - src[j];
} public static void main(String[] args) {
String s = "100,10,1,0,15,20";
System.out.print(sort(s));// 输出0,1,10,15,20,100,
}
}

Answer 10

public static void sort(String args){
String[] str = args.split(",");//分割字符串
//声明一个整形数组，用来存储分割后的字符串
int[] arr = new int[6];
    for(int i = 0;i<str.length;i++){
     arr[i] = (int)Integer.parseInt(str[i]);
    }
    //冒泡排序
    for(int x =arr.length-1;x>0;x--){
     for(int y = 0;y<x;y++){
     int temp =0;
     if(arr[y]>arr[y+1]){
     temp = arr[y];
     arr[y]=arr[y+1];
     arr[y+1]=temp;
    
     }
     }
    }
    //循环便利整形数组
    for(int i =0;i<arr.length;i++){
     System.out.println(arr[i]);
    }
} /**
 * @param args
 */
public static void main(String[] args) {
// TODO Auto-generated method stub
String s = "100,10,1,0,15,20";
sort(s);

Answer 11

public class Test1 {
public static String sort(String args){
  StringBuffer value = "";
  int[] nums = args.split(",");
  nums = Arrays.sort(nums);
  for(int i : nums) {
    value.append(i + ",");
  }
  return value;   
}
public static void main(String[] args) {
  String s = "100,10,1,0,15,20";
  System.out.print(sort(s));//输出0,1,10,15,20,100,
}

Answer 12

借助8楼哥们的思路：import java.util.Arrays;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;public class Test1 {

public static void main(String[] args) 
{
String s = "100,10,1,0,15,20";
String[] arr = s.split(",");
TreeSet<String> set = new TreeSet<String>(new MyComparator());
for(int i=0;i<arr.length;i++)
{
set.add(arr[i]);
}
Iterator<String> iterator = set.iterator();
while(iterator.hasNext())
{
String os = iterator.next();
System.out.println(os);
}
}
}
class MyComparator implements Comparator<String>
{
public int compare(String o1, String o2) 
{
return o1.length()==o2.length()?o1.compareTo(o2):o1.length()-o2.length();
}

}

Answer 13

String str = "1,5,4,22,6,32,56,742,44";
String[] group = str.split(",");
Arrays.sort(group, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.length() == o2.length() ? o1.compareTo(o2):o1.length() - o2.length();
}
});
System.out.println(Arrays.toString(group).replaceAll("\\[|\\]| ", ""));

Answer 14

花了好长时间去写，写得不好，丢人了，但是还是想贴出来，要不就白写了，运行结果正确！(*^__^*) 嘻嘻……
import java.util.ArrayList;
import java.util.List;public class StringSort
{
public static void main(String[] args)
{
String s = "100,10,1,0,15,20";
System.out.print(sort(s));

}

public static String sort(String s)
{
char[] ch = s.toCharArray();
List<Integer> list1 = new ArrayList<Integer>();
List<Integer> list2 = new ArrayList<Integer>();

//获得所有","的位置
for (int i=0; i<s.length(); i++)
{
if (',' == ch[i])
{
list1.add(i);
}
}
int n = 0;
int m = 0;
Integer temp;

//获得字符串中的数字
for (int j=0; j<list1.size(); j++)
{

if (0 == j)
{
m = list1.get(j);
String str = new String(ch,n,m-n);
temp = new Integer(Integer.parseInt(str));
list2.add(temp);
n = m + 1;
}
else if (j>0 && j<list1.size()-1)
{
m = list1.get(j);
String str = new String(ch,n,m-n);
temp = new Integer(Integer.parseInt(str));
list2.add(temp);
n = m + 1;
}
else
{
m = list1.get(j);
String str = new String(ch,n,m-n);
temp = new Integer(Integer.parseInt(str));
list2.add(temp);
n = m + 1;
String last = new String(ch,n,ch.length-n);
Integer lastTemp = new Integer(Integer.parseInt(last));
list2.add(lastTemp);
}

}

//使用冒泡排序
for (int k=list2.size(); k>2; k--)
{
for (int q=0; q<k-1; q++)
{
if (list2.get(q) > list2.get(q+1))
{
int tem = list2.get(q);
list2.set(q, list2.get(q+1));
list2.set(q+1, tem);
}
}
}

StringBuffer strb = new StringBuffer();
for (int p=0; p<list2.size(); p++)
{
strb.append(list2.get(p));
if (list2.size()-1 != p)
{
strb.append(',');
}
}

String string = new String(strb);

return string;
}
}

Answer 15

public class Test1 {
public static List<Integer> sort(String args){
String[] string=args.split(",");
List<Integer> list = new ArrayList<Integer>();
for (String string2 : string) {
list.add(Integer.parseInt(string2));
}
Collections.sort(list);
return list; }
public static void main(String[] args) {
String s = "100,10,1,0,15,20";
System.out.print(sort(s));//输出0,1,10,15,20,100,
}
}
八楼是高手，这个还是看思维，这种题也就是练习题而已，实际项目中肯定不会是这样的，字符串里存这种内容，这个题的实际案例可以理解为典型的xml解析，或者是协议交互的参数解析等实际内容（比如以|分割的字符串等等）

Answer 16

String实现了Comparable接口，直接 return o1.compareTo(o2)就可以了

Answer 17

String实现了Comparable接口，直接 return o1.compareTo(o2)就可以了不对  String实现的compareTo  2 > 11  所以需要自定义  先比较长度

Answer 18

String实现了Comparable接口，直接 return o1.compareTo(o2)就可以了不对  String实现的compareTo  2 > 11  所以需要自定义  先比较长度
刚去看了下源码String实现的是先逐位对比，然后才去比较长度以前不知道在哪里看的一个实现是先比较长度后逐位对比的，，搞混了

Answer 19

String实现了Comparable接口，直接 return o1.compareTo(o2)就可以了不对  String实现的compareTo  2 > 11  所以需要自定义  先比较长度
刚去看了下源码String实现的是先逐位对比，然后才去比较长度以前不知道在哪里看的一个实现是先比较长度后逐位对比的，，搞混了
而且String的实现还没做空判断  我觉得我写过的大部分都要用所谓的策略模式去实现Comparator

Answer 20

String实现了Comparable接口，直接 return o1.compareTo(o2)就可以了不对  String实现的compareTo  2 > 11  所以需要自定义  先比较长度
刚去看了下源码String实现的是先逐位对比，然后才去比较长度以前不知道在哪里看的一个实现是先比较长度后逐位对比的，，搞混了
而且String的实现还没做空判断  我觉得我写过的大部分都要用所谓的策略模式去实现ComparatorStringUtils

Answer 21

单机试了一下：直接可以排序
public class Num {
public static void main(String[] args) {
String str = "100,10,1,0,15,20";
String[] num = str.split(",");
TreeSet<Integer> set = new TreeSet<Integer>();
for(int i=0;i<num.length;i++){
set.add(Integer.parseInt(num[i]));
}
Iterator<Integer> ItNum = set.iterator();
while(ItNum.hasNext()){
System.out.print(ItNum.next()+"  ");
}
}
}

Answer 22

呵呵 ，我也是新手这道题花了好久的时间，不过挺开心的。
思路就是将字符转换成整数型数组，然后调用本身的sort（）；方法进行排序。import java.util.*;public class Demo { public static void main(String[] args) {
String s = "100,10,1,0,15,20";



System.out.println(sort(s));
} private static String sort(String s) {

String[] tar = s.split(","); 
List<Integer> haha = new ArrayList<Integer>();
for(String a : tar)
{
haha.add(new Integer(a));
}
Integer[] heihei = new Integer[tar.length];

haha.toArray(heihei);
Arrays.sort(heihei);

StringBuffer sb  = new StringBuffer();

for(int x :heihei)
{
sb.append(x);
sb.append(",");
}

return sb.toString();
}}

Answer 23

import java.util.*;public class Demo { public static void main(String[] args) {
String s = "100,10,1,0,15,20";



System.out.println(sort(s));
} private static String sort(String s) {

//切割字符串撑字符数组tar
String[] tar = s.split(","); 
//建立名为haha的ArrayList
List<Integer> haha = new ArrayList<Integer>();
//将 tar依次放入ArraLyist里面，在放入的时候把string类型转化为int类型
for(String a : tar)
{
haha.add(new Integer(a));
}
//建立和tar长度相同的int型数组heihei，用于接收ArrayList里面的参数
Integer[] heihei = new Integer[tar.length];
//调用ArrayList里面的方法，将ArrayList里面的元素放入heihei
haha.toArray(heihei);
//调用整数数组的排序方法
Arrays.sort(heihei);

StringBuffer sb  = new StringBuffer();

for(int x :heihei)
{
sb.append(x);
sb.append(",");
}

return sb.toString();
}