表达能力比较差啊，回复了将近200个帖子啊。没有一个人明白我的意思的啊。我重新又整理了一下，同时感谢大家前面的参与啊。真心谢谢大家啊！

Question

需求：
 有一个从小到大排序的int型数据集，可以定义数据集显示的顺序，即规则。
 例如： 
 int [] iArray = {10,20,30};
 String rule = "3,2,1";
 //该规则意思是，第1个显示，数据集中第3个数据
                第2个显示，数据集中第2个数据
                第2个显示，数据集中第2个数据
 显示结果：30，20，10
 
需求1：
数据集中数据可能被第三方删除，但删除数据时，由于种种原因，无法删除规则中相关内容。但要求数据集内数据被删除时，还能按照规则正确显示。
例如：
 上例iArray中20被删除，数据集变为 {10,30};
 规则仍然是：String rule = "3,2,1";
 希望显示结果为：30，10需求2：
数据集可能被第三方改变，但是仍是从小到大排列，改变后和改变前数据一一对应，但要求数据集被改变时，还能按照规则正确显示。
例如：
  上例数据集变为 {10,30}后，被第三方改变，变为{100,300}，10对应100，30对应300
  规则仍然是：String rule = "3,2,1";
  希望显示结果为：300，100注：需求2，3可能同时出现，即数据集被删除后，又被该改变
public class adfadf { public static void main(String[] args) { int[] iArray = { 10, 20, 30 };
String order = "3,2,1";
order(iArray, order); int[] iArray2 = { 10, 30 };// 数据集变为，10，30
order = "3,2,1";// 规则不变
// 希望显示结果为：30，10 int[] iArray3 = { 100, 300 };// 被第三方改变，变为{100,300}，10对应100，30对应300
order = "3,2,1";// 规则不变
// 希望显示结果为：300，100
} public static void order(int[] iArray, String order) {
for (String o : order.split(","))
System.out.println(iArray[Integer.parseInt(o) - 1]);
} public static void order2(int[] iArray, String order) {
// .................
// 希望显示结果为：30，10
} public static void order3(int[] iArray, String order) {
// .................
// 希望显示结果为：300，100
}
}

Answer 1

在你的需求中，最终无法得知是数组中哪个被删除。所以
加入可以认为高位被删，则String[] orders = order.split(",");
for (String o : orders) {
    int io = Integer.parseInt(o);
    if (io < iArray.length) {
        System.out.println(iArray[io - 1]);
    }
}如果这个假设不成了，我认为这个程序就没法儿写了。
比如排序是3, 1, 2。可是你只有两个元素。
三种情况结果
认为删除元素是第一个 30, 10
认为是第二个 30，10
认为是第三个 则变成了 10, 30

Answer 2

String rules = "3,2,1";
int[] array = {10,20,30};
String[] rule = rules.split(",");
for(int i=0;i<rule.length;i++){
   System.out.print(array[Integer.parseInt(rule[i])-1]+",");
}

Answer 3

不知道我理解的对不对，不管数据集合怎么变，判断规则中的索引是否就行了吧？public static void main(String[] args){
int[] iArray1={10,20,30};
String order1 = "3,2,1"; int[] iArray2={10,30};
String order2 = "3,2,1";

int[] iArray3={100,300};
String order3 = "3,2,1";

System.out.print("完整数组：   ");
order(iArray1,order1);
System.out.print("数据集变为{10，30}：   ");
order(iArray2,order2);
System.out.print("数据集变为{100,300}：   ");
order(iArray3,order3); } public static void order(int[] iArray, String order) {
        for (String o : order.split(","))
{
int index=Integer.parseInt(o);
if(iArray.length<index)
continue;
System.out.print(iArray[index-1]+",");
}
System.out.println();
    }

Answer 4

我给补充一下 ，楼主的意思是  有一笔数据  拿到的时候是10，20，30，40，50，60，70.现在又role："7,6,5,4,3,1,2"那么我们在页面显示就是 70，60，50，40，30，10，20现在加入 这些数种的30，20，50被删除了  那么结果就是 将70，60，50，40，30，10，20这个种的30，20，50删除后的结果  。唯一的难点就是 删除后拿到的数据是10，40，60，70.此时我们还要根据role："7,6,5,4,3,1,2" 来取结果 结果必须是70，60，40，10 。同时在此同时有楼主说的第二种情况 原来的数字都变成的以前的10倍 但是对应的都是以前的那些结果。所以现在我们只用结果 来计算删除或修改后的结果 也已经变的不够现实再者如果单纯使用role的话 我们是不可能知道那个索引上的数据被删除了 出来的结果必然造成混乱。解决方案：1.数据删除的时候将其数据修改成一个你的业务中不可能出现的值 比如0，100000000等。规则呢一直按照你数据全的时候的规则走，只是页面显示的时候不显示不符合要求的数据 这样排序的数据在下次就能继续显示
2。不管你是XML文件还是数据库表存储这些数据也好 建议提供主键约束，而规则也使用主键排序就类似于 学生排序号后 删除了部分学生信息或是学生的年龄发生了变化 这个不会影响到排序结果
3.还没想到

Answer 5

那么点事 说这么多....
    public static int[] order(int[] iArray, final String order) {
int[] sortAsOrder = new int[iArray.length];
        int i = 0;
for (String o : order.split(",")){
            try{
sortAsOrder[i] = iArray[Integer.parseInt(o) - 1];
++i;
            }catch(ArrayIndexOutOfBoundsException e){
continue;
}catch (Exception e){
e.printStackTrace();
            }
}
return sortAsOrder;
}

Answer 6

   public static void main(String[] args) {
       int[] iArray = { 10, 20, 30 };
       String order = "3,2,1";
       
       int[] rArray={ 0, 0, 0}
       int[] rOrder={ 0, 0, 0}
       String[] iOrder=order.split(",");
       
       for(int i=0;i<iArray.length;i++)rArray[i]=iArray[Integer.parseInt(iOrder[i])-1];
       for(int i=0;i<rArray.length;i++)
       for(int j=0;j<iArray.length;j++)if(rArray[i]==iArray[j])rOrder[i]=j+1
       
       int rules=1;
       int[] iArray2 = { 10, 30 };
       order(iArray,iArray2,rArray,rOrder,rules);
        
       rules=10;
       int[] iArray3 = { 100, 300 };
       order(iArray,iArray3,rArray,rOrder,rules);
    }
   
   public static void order(int[] pArray, int[] iArray, int[] rArray, int[] order, int rules) {
        for(int i=0;i<rArray.length;i++)
        for(int j=0;j<iArray.length;j++)
        if(rArray[i]==iArray[j]* rules)System.out.println(pArray[order[j]-1]* rules);
    }

Answer 7

compile maybe error.modify it by yourself

Answer 8

有意见的可以提 但不要骂我哈 被骂怕了%>_<%

Answer 9

JAVA为什么放弃指针呢........

Answer 10

还是直接帮你写出代码吧，按照这个规则，我写的order2方法可以完全满足你的所有order和iArray[]
楼主的数据是理想数据，我写的这个
无论你的规则是什么，无论数据仓库变成什么，都会按规则输出,只要调用order2
比如：
int [] iArray = {150,50,380}; 
String rule = "1,3,2"; 
则输出50,380,150
然后数据被删除，iArray = {150,380};
rule不变
则输出150,380
其实，如果条件比较丰富，比如数据只是int，那11楼的方案1也是不错的import java.util.*;public class Rule { public static String String_order[]=null;
public static int Int_order[]=null;
    public static void main(String[] args) {        int[] iArray = { 10, 30, 20 };
        String order = "3,2,1";
        order2(iArray, order);        int[] iArray2 = { 10, 30 };// 数据集变为，10，30
        order = "3,2,1";// 规则不变
order2(iArray2,order);
        // 希望显示结果为：30，10        int[] iArray3 = { 100, 300 };// 被第三方改变，变为{100,300}，10对应100，30对应300
        order = "3,2,1";// 规则不变
order2(iArray3,order);
        // 希望显示结果为：300，100
    }    public static void order(int[] iArray, String order) {
        for (String o : order.split(","))
            System.out.println(iArray[Integer.parseInt(o)-1]);
    }    public static void order2(int[] iArray, String order) {
        // .................
        // 希望显示结果为：30，10
Map con = new HashMap();
StringBuffer s = new StringBuffer();
String_order=order.split(",");
int x =iArray.length;
Int_order = new int[x];
for(int i=0;i<x;i++){
Int_order[i]=Integer.parseInt(String_order[i]);
con.put(Int_order[i],i);
}
Arrays.sort(Int_order);
Arrays.sort(iArray);
for(int i=0;i<x;i++){
//System.out.println(i);
s.append(con.get(Int_order[i]));
if(i!=x-1){
s.append(",");
}
}
String orderResult = new String(s);
//System.out.println(orderResult);
for (String o : orderResult.split(",")){
            System.out.println(iArray[Integer.parseInt(o)]);
}    }    public static void order3(int[] iArray, String order) {
        // .................
        // 希望显示结果为：300，100
    }
}

Answer 11

楼上的....需求： 
有一个从小到大排序的int型数据集，可以定义数据集显示的顺序，即规则。 

Answer 12

你的扩展为什么不是这样的:  Object[] iArray = ....

Answer 13

你的确应该加强语文了，一直说些与题目无关的事情，歪曲别人的意思
楼主的确说了：有一个从小到大排序的int型数据集
那我扩展到：任意混乱排序的int型数据集
难道有什么问题？你居然反问我为什么不用object，那我问你，你怎么回帖不用机器语言啊
对于你13楼的代码，你看过楼主的前2个帖子吗？有些规则是164532，要求输出结果集，楼主可没有说过，规则是一定降序，请你发言前仔细看下之前的帖子

Answer 14

/** ~~~~~~~~~~~~~郁闷
*/
public class Main {    public static void main(String[] args) throws Exception {
        //需求：
        Integer[] iArray = {10, 20, 30};
        String rule = "3,2,1";
        OrderList ol = new OrderList(getTemp(rule), iArray);
        System.out.println(ol);//结果:{30,20,10}
        System.out.println();        //需求1：
        ol.remove(1);
        System.out.println(ol);//结果:{30,10}
        System.out.println();        //需求2
        Integer b2 = (Integer) ol.getValue(0);
        ol.setValue(((Integer) ol.getValue(1)) * 10, 0);
        ol.setValue(b2 * 10, 1);
        System.out.println(ol);//结果:{300,100}
        System.out.println();
        
        ol.setValue(new Integer[]{100,300,900});//结果:{900,300,100}
        System.out.println(ol);
    }    static int[] getTemp(String order) {
        String[] orders = order.split(",");
        int[] iArray = new int[orders.length];
        int i = 0;
        for (String o : orders) {
            iArray[i++] = Integer.parseInt(o);
        }
        return iArray;
    }
}/**
 * 存放的最大容量为初始化时规则int[] order的个数
 * @author Administrator
 * @param <V>
 */
final class OrderList<V extends java.lang.Comparable>/* implements IsMeList, java.io.Serializable */ {    /**
     * 数据,升序
     */
    java.lang.Comparable[] tem;
    /**
     * 数据长度
     */
    int len;
    /**
     * 排序规则,每个数 > 0
     */
    int[] order;    public OrderList(int[] order) throws Exception {
        this(order, null, -1, -1);
    }    public OrderList(V[] v) throws Exception {
        this(getOrder(v), v);
    }    public OrderList(int[] order, V[] v) throws Exception {
        this(order, v, 0, v.length);
    }    public OrderList(int[] order, V[] t, int s, int len) throws Exception {
        if (order == null || order.length < 1) {
            throw new Exception("is not null");
        }
        if (t == null || t.length < 1 || s < 0 || len < 0 || s > t.length - 1 || s + len > t.length || len > order.length) {
            this.len = 0;
            this.order = new int[order.length];
            System.arraycopy(order, 0, this.order, 0, order.length);
            tem = new java.lang.Comparable[order.length];
        } else {
            this.len = len;
            this.order = new int[order.length];
            System.arraycopy(order, 0, this.order, 0, order.length);
            tem = new java.lang.Comparable[order.length];
            if (t != null && t.length > 0) {
                System.arraycopy(t, s, tem, 0, len);
                java.util.Arrays.sort(tem);//排序
            }
            for (int i = 0, im = order.length; i < im; i++) {
                this.order[i]--;
            }
        }
    }    private void setOrder() {
    }    public boolean isEmpty() {
        return order == null || len == 0;
    }    public boolean isFill() {
        return order != null && len == order.length;
    }    public int length() {
        return len;
    }    /**
     * 添加
     * @param v
     */
    public synchronized void add(V v) throws Exception {
        if (v == null || isFill()) {
            throw new Exception("is null or fill");
        }
        tem[len] = v;
        for (int i = len; i > 0; i--) {
            if (tem[i].compareTo(tem[i - 1]) < 1) {
                java.lang.Comparable b = tem[i];
                tem[i] = tem[i - 1];
                tem[i - 1] = b;
            } else {
                break;
            }
        }
        len++;
    }    /**
     * 修改值
     * @param v
     * @param index
     * @throws java.lang.Exception
     */
    public synchronized void setValue(V v, int index) throws Exception {
        if (index < 0 || index + 1 > len || v == null) {
            throw new Exception("is or over tem len");
        }
        int[] neworder = getNewOrder();
        tem[neworder[index]] = v;
        java.lang.Comparable c[] = new java.lang.Comparable[len];
        System.arraycopy(tem, 0, c, 0, len);
        java.util.Arrays.sort(c);
        System.arraycopy(c, 0, tem, 0, len);
    }    public int indexof(V v) throws Exception {
        return indexof(v, 0);
    }    /**
     * 从index位置开始查找v的位置
     * @param v
     * @param index
     * @return
     * @throws java.lang.Exception
     */
    public int indexof(V v, int index) throws Exception {
        if (index < 0 || index + 1 > len || v == null) {
            throw new Exception("is or over tem len");
        }
        int[] neworder = getNewOrder();
        for (int i = index, im = len; i < len; i++) {
            if (v.equals(tem[neworder[i]])) {
                return i;
            }
        }
        return -1;
    }    /**
     * 删除第index个
     * @param index
     * @return
     */
    public synchronized V remove(int index) {
        int[] neworder = getNewOrder();
        V v = (V) tem[neworder[index]];
        for (int i = neworder[index]; i < len - 1; i++) {
            tem[i] = tem[i + 1];
        }
        len--;
        return v;
    }    /**
     * 设置值
     * @param v
     * @throws java.lang.Exception
     */
    public synchronized void setValue(V[] v) throws Exception {
        if (v == null || v.length < 1 || v.length > order.length) {
            throw new Exception("is not null or over tem");
        }
        java.lang.Comparable[] c = new java.lang.Comparable[v.length];
        System.arraycopy(v, 0, c, 0, v.length);
        java.util.Arrays.sort(c);//排序
        System.arraycopy(c, 0, tem, 0, v.length);
        len = v.length;
    }    public V getValue(int index) throws Exception {
        if (index < 0 || index > len) {
            throw new Exception("is not null or over tem");
        }
        return (V) tem[getNewOrder()[index]];
    }    /**
     * 得到排序规则
     * @return
     */
    public int[] getOrder() {
        int[] o = new int[order.length];
        System.arraycopy(order, 0, o, 0, order.length);
        for (int i = 0; i < order.length; i++) {
            o[i]++;
        }
        return o;
    }    /**
     * 返回 现有数据长度的排序规则
     * @return
     */
    private int[] getNewOrder() {
        int[] neworder = new int[len];//除最高位的新规则
        for (int i = 0, j = 0, b = 0; i < len; i++) {
            while ((b = order[j++]) >= len) {//去高位
            }
            neworder[i] = b;
        }
        return neworder;
    }    /**
     * 得到存储的值
     * @return
     */
    public V[] getStorValue() {
        Object[] o = new Object[len];
        System.arraycopy(tem, 0, o, 0, len);
        return (V[]) o;
    }    @Override
    public String toString() {
        String str = "规则:{";
        int[] neworder = getNewOrder();
        int im = len;
        for (int i = 0, ii = order.length; i < ii; i++) {
            str += (order[i] + 1);
            if (i < ii - 1) {
                str += ",";
            }
        }
        str += "},实际用到的规则:{";
        for (int i = 0; i < im; i++) {
            str += (neworder[i] + 1);
            if (i < im - 1) {
                str += ",";
            }
        }
        str += "}\n结果:{";
        for (int i = 0; i < im; i++) {
            str += tem[neworder[i]].toString();
            if (i < im - 1) {
                str += ",";
            }
        }
        return str + "}";
    }    @Override
    public OrderList<V> clone() {
        OrderList ol = null;
        try {
            ol = new OrderList(this.order, (V[]) tem);
        } catch (Exception ex) {
            Logger.getLogger(OrderList.class.getName()).log(Level.SEVERE, null, ex);
        }
        return ol;
    }    /**
     * 得到规则为order 内容为this
     * @param order
     * @return
     */
    public OrderList<V> getOrderList(int[] order) {
        OrderList ol = null;
        try {
            ol = new OrderList(order, (V[]) tem);
        } catch (Exception ex) {
            Logger.getLogger(OrderList.class.getName()).log(Level.SEVERE, null, ex);
        }
        return ol;
    }    /**
     * 得到v的排序规则
     * @param v
     * @return
     */
    public static <V extends java.lang.Comparable<V>> int[] getOrder(V[] v) {
        if (v == null || v.length < 1) {
            return null;
        }
        Comparable[] ct = new Comparable[v.length];
        System.arraycopy(v, 0, ct, 0, v.length);
        java.util.Arrays.sort(ct);
        int[] or = new int[v.length];
        for (int i = 0; i < v.length; i++) {
            for (int j = 0; j < v.length; j++) {
                if (v[i].equals(ct[j])) {
                    or[i] = j /*+ 1*/;
                    break;
                }
            }
        }
        return or;
    }
}

Answer 15

：{100,300}，规则仍为："2,1,3",那么结果要显示成什么？
要显示成100，300就知道变化的数会跟以前的数一一对应。也是按照从小到大排列。
例如： 
  上例数据集变为 {10,30}后，被第三方改变，变为{100,300}，10对应100，30对应300 
  规则仍然是：String rule = "3,2,1"; 
  希望显示结果为：300，100