华为的一道java笔试题，望高手帮忙解答哈

Question

上个星期六去华为笔试了下，大部分题目还做的可以。有一道还真的没折耶，题目大致意思如下：
  给了个类,要求编写一段代码，给以下类型的数据排序（按index降序排）：
 public class A{
     public int index ; 
     public String str;
     public …… ；
}
条件：
1.数据量很大，要求性能够；
2.扩展性好：按其他数据类型（如 String str,……)排序的时候，不需要修改组件，以后还可能增加其他类型的数据。
（提示：可以调用现成的java.util包中的排序.)
我刚开始想用 类型传递（泛型），但面试官笑了笑、摇了摇头，说不是。高手们！给点啊……

Answer 1

core java 2 92页 可能是你需要的

Answer 2

关注~~~
类实现Comparator接口不就可以按自己的意思随便比较了。

Answer 3

A与B在这里就不用了.A改为Item类.现有集合类List ArrayList可以进行排序.现时使用Collections集合工具类对List集合予以排序.有两种方式.代码分别如下:
代码1(适合集合中的类没有实现Comparable接口的情况):
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
List<Item> ls=new ArrayList<Item>();
ls.add(new Item(1,"coynn"));
ls.add(new Item(3,"coynn"));
ls.add(new Item(2,"coynn"));
ls.add(new Item(9,"coynn"));
Collections.sort(ls,new Comparator<Item>(){
public int compare(Item o1, Item o2) {
// TODO Auto-generated method stub
int r= o1.index-o2.index;
r=-r;//这里由于是反序,所以取为负数,如果正序,请注释本行
return r;
}
});
}
}
class Item  {   
public int index ;  
    public String str;
public Item(int index, String str) {
super();
this.index = index;
this.str = str;
}
}
代码2(适合集合中的类已经实现了Comparable接口的情况):
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
List<Item> ls=new ArrayList<Item>();
ls.add(new Item(1,"coynn"));
ls.add(new Item(3,"coynn"));
ls.add(new Item(2,"coynn"));
ls.add(new Item(9,"coynn"));
Collections.sort(ls);
ls=null;
}
}
class Item implements Comparable<Item> {
public int index ;  
    public String str;
public Item(int index, String str) {
super();
this.index = index;
this.str = str;
}
public int compareTo(Item o) {
// TODO Auto-generated method stub
int r=this.index-o.index;
r=-r; //这里由于是反序,所以取为负数,如果正序,请注释本行
return r;
}
}从代码中可以看出.二者都使用了UTIL中相关类实现了题目所说排序.但是题目中还提到扩展性好.为此,建议使用第二种,这样,以后增加字段或者更换其他类型,只需要修改Item类所实现的compareTo方法即可.
当然,上述答案只代表我个人意见,请大家对我所给答案多多批评指正.

Answer 4

A与B在这里就不用了.A改为Item类.现有集合类List ArrayList可以进行排序.现时使用Collections集合工具类对List集合予以排序.有两种方式.代码分别如下:
代码1(适合集合中的类没有实现Comparable接口的情况):
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
List<Item> ls=new ArrayList<Item>();
ls.add(new Item(1,"coynn"));
ls.add(new Item(3,"coynn"));
ls.add(new Item(2,"coynn"));
ls.add(new Item(9,"coynn"));
Collections.sort(ls,new Comparator<Item>(){
public int compare(Item o1, Item o2) {
// TODO Auto-generated method stub
int r= o1.index-o2.index;
r=-r;//这里由于是反序,所以取为负数,如果正序,请注释本行
return r;
}
});
}
}
class Item  {   
public int index ;  
    public String str;
public Item(int index, String str) {
super();
this.index = index;
this.str = str;
}
}
代码2(适合集合中的类已经实现了Comparable接口的情况):
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
List<Item> ls=new ArrayList<Item>();
ls.add(new Item(1,"coynn"));
ls.add(new Item(3,"coynn"));
ls.add(new Item(2,"coynn"));
ls.add(new Item(9,"coynn"));
Collections.sort(ls);
ls=null;
}
}
class Item implements Comparable<Item> {
public int index ;  
    public String str;
public Item(int index, String str) {
super();
this.index = index;
this.str = str;
}
public int compareTo(Item o) {
// TODO Auto-generated method stub
int r=this.index-o.index;
r=-r; //这里由于是反序,所以取为负数,如果正序,请注释本行
return r;
}
}从代码中可以看出.二者都使用了UTIL中相关类实现了题目所说排序.但是题目中还提到扩展性好.为此,建议使用第二种,这样,以后增加字段或者更换其他类型,只需要修改Item类所实现的compareTo方法即可.
当然,上述答案只代表我个人意见,请大家对我所给答案多多批评指正.

Answer 5

import java.util.Arrays;
public class ArrayTest { public static void main(String[] args){
String[] sa = new String[5] ;
sa[0] = "b" ;
sa[1]= "e";
sa[2] = "c" ;
sa[3] = "a" ;
sa[4] = "d" ;


Integer[] saint = new Integer[5] ;
saint[0] = 5 ;
saint[1] = 2 ;
     saint[2] = 3 ;
saint[3] = 1 ;
saint[4] = 4 ;

sa = (String[])sort(sa);

for(String i:sa){
System.out.println(i);
}

saint = (Integer[])sort(saint);
for(int i:saint){
System.out.println(i);
}

}



public static Object[] sort(Object[] obj){
Arrays.sort(obj);
return obj ;
}
}

Answer 6

俺认为注意三点：
    1、数量很大，那么这些数据以何种结构存储的？链式的，还是a chunk of memory？这关系到如何来表达排序好的结果集！（因为数据量很大，如果是顺序存的话，移位有点晕，考虑到索引哦）
    2、由于扩展性的问题，我们要定义一个接口，用来判断两个对象的大小。
    3、定义算法接口，确定排序算法。（最好用java已实现的算法哦，这个需要学习，太晕了！）
public abstract void sort(Collection collection,Comparable comparable) throws Exception;

Answer 7

其实是一个java自定义对象的排序问题.
可以参看
http://blog.csdn.net/caoyinghui1986/archive/2008/03/30/2229937.aspx
public class Demo{
 public static void main(String[] args){
  
  
  User u1 =new User("aaa",12);
  User u2 =new User("ddd",10);
  User u3 =new User("ccc",20);
  User u4 =new User("bbb",10);
  
  ArrayList arrayList = new ArrayList();
  arrayList.add(u1);
  arrayList.add(u2);
  arrayList.add(u3);
  arrayList.add(u4);
  
  Object[] users =arrayList.toArray();
  System.out.println ("排序前。");
  for (int i = 0; i<users.length; i++){
   System.out.println (users[i]);
  }
  System.out.println ("*******************************");
  System.out.println ("排序后。。");
  //把排序规则交给sort方法。该方法就回按照你自定义的规则进行排序
  
  java.util.Arrays.sort(users,new MyComparator());
  
  
  for (int i = 0; i<users.length; i++){
   System.out.println (users[i]);
  }
  
  
  
 }
}class User{
 String name;
 int age ;
 
 public User(String name,int age){
  this.name  = name;
  this.age = age; 
 }
 
 public String toString(){
  return name+":::"+age;
 }
 
}
class MyComparator implements Comparator{
 public  int compare(Object  obj1, Object obj2 ){
  User u1 = (User)obj1;
  User u2 = (User)obj2;
  if(u1.age>u2.age){
   return 1;
  }else if(u1.age<u2.age){
   return -1;
  }else{
   //利用String自身的排序方法。
   //如果年龄相同就按名字进行排序
   return u1.name.compareTo(u2.name);
  }
  
  
 }
} 

Answer 8

1.待排序的类
public class Item
{
private int index;
private String str1;
private String str2;

public Item(int index, String str1, String str2)
{
super();
this.index = index;
this.str1 = str1;
this.str2 = str2;
}
public int getIndex()
{
return index;
}
public void setIndex(int index)
{
this.index = index;
}
public String getStr1()
{
return str1;
}
public void setStr1(String str1)
{
this.str1 = str1;
}
public String getStr2()
{
return str2;
}
public void setStr2(String str2)
{
this.str2 = str2;
}

}
2.自定义排序类
public class DefineComparator implements Comparator
{
public int compare(Object o1, Object o2)
{
Item item1;
Item item2;
if(o1 instanceof Item && o2 instanceof Item)
{
item1=(Item)o1;
item2=(Item)o2;
if(item1.getIndex()>item2.getIndex())
{
return 1;
}
else if(item1.getIndex()==item2.getIndex())
{
return 0;
}
else
{
return -1;
}
}
return 0;
}
}
3.客户代码
public class MainEnter
{
public static void main(String[] args)
{
Item item1=new Item(2,"item1","item12");
Item item2=new Item(1,"item2","item22");
Item item3=new Item(4,"item3","item32");
List list=new ArrayList();
list.add(item1);
list.add(item2);
list.add(item3);
Collections.sort(list, new DefineComparator());
Iterator it=list.iterator();
int i=1;
while(it.hasNext())
{
System.out.println(i+++" : "+((Item)it.next()).getIndex());
}
}
}
4.说明：
1.这里自定义DefineComparator，通过Collections.sort(List,Comparator)实现排序，当需求有变需要按照str1或str2等排序时，只有重新定义一个Comaprator----SecondDefComparator,而不用修改Item或原来的排序器DefineComparator,然后修改客户端代码，只有就基本满足了程序设计的一个重要原则---开闭原则，即可以通过增加新类方便的扩充新功能，满足新需求而不用修改原来的代码。
2.如果我们采用让Item实现Comaparable接口，则在想采用新的排序规则时，必须修改Item里的 comareTo(Object o)方法，这样就违反了开闭原则，所以感觉应该用Comparator，而不是Comparable.
不周之处，请高手指正！谢谢！

Answer 9

建议你看看apache的common collection包里有jdk容器的扩展，那个可以满足你的需要

Answer 10

做个compare函数，　用快速排序

Answer 11

A与B在这里就不用了.A改为Item类.现有集合类List ArrayList可以进行排序.现时使用Collections集合工具类对List集合予以排序.有两种方式.代码分别如下: 
代码1(适合集合中的类没有实现Comparable接口的情况): 
public class Test { 
public static void main(String[] args) { 
// TODO Auto-generated method stub 
List <Item> ls=new ArrayList <Item>(); 
ls.add(new Item(1,"coynn")); 
ls.add(new Item(3,"coynn")); 
ls.add(new Item(2,"coynn")); 
ls.add(new Item(9,"coynn")); 
Collections.sort(ls,new Comparator <Item>(){ 
public int compare(Item o1, Item o2) { 
// TODO Auto-generated method stub 
int r= o1.index-o2.index; 
r=-r;//这里由于是反序,所以取为负数,如果正序,请注释本行 
return r; 
} 
}); 
} 
} 
class Item  {    
public int index ;   
    public String str; 
public Item(int index, String str) { 
super(); 
this.index = index; 
this.str = str; 
} 
} 
代码2(适合集合中的类已经实现了Comparable接口的情况): 
public class Test { 
public static void main(String[] args) { 
// TODO Auto-generated method stub 
List <Item> ls=new ArrayList <Item>(); 
ls.add(new Item(1,"coynn")); 
ls.add(new Item(3,"coynn")); 
ls.add(new Item(2,"coynn")); 
ls.add(new Item(9,"coynn")); 
Collections.sort(ls); 
ls=null; 
} 
} 
class Item implements Comparable <Item> { 
public int index ;   
    public String str; 
public Item(int index, String str) { 
super(); 
this.index = index; 
this.str = str; 
} 
public int compareTo(Item o) { 
// TODO Auto-generated method stub 
int r=this.index-o.index; 
r=-r; //这里由于是反序,所以取为负数,如果正序,请注释本行 
return r; 
} 
} 从代码中可以看出.二者都使用了UTIL中相关类实现了题目所说排序.但是题目中还提到扩展性好.为此,建议使用第二种,这样,以后增加字段或者更换其他类型,只需要修改Item类所实现的compareTo方法即可. 
当然,上述答案只代表我个人意见,请大家对我所给答案多多批评指正.