求一个二维数组排序的实现函数,马上结贴给分

Question

急需一个二维数组的排序实例函数/**
* @param rowdata  原数组
* @param keys     参照排序的列
*/
public Object[][] OrderBy(Object[][] rowdata,int[] keys) {
}//其实就是做一个类似Sql中Order by的功能,rowdata是查询结果集,keys是排序的列,可以多列一起排序

Answer 1

Object类型排序？！
而且没有升序还是降序的变量传进来：）

Answer 2

key 为什么要数组呢，一次有多列排序是吗？

Answer 3

2楼:........额.......可以加一个参数....作为升序和降序....3楼:是的 比如传入int{0,1},则是以0,1这两列一起排序

Answer 4

还有..可以把Object作为String类型来处理

Answer 5

To 5楼:其实就是做一个sql的Order by语句啊....select * from table1
order by x,y desc而@param   rowdata     原数组
就相当于 select * from table1 的结果集@param   keys      参照排序的列
相当于 x,y 的列位置,比如 int{0,2}

Answer 6

package com.print;
import java.util.*;import com.baleno.erp.dao.CompositorKeyInterceptor;public class format {
String[][] arr;
public Object[][] OrderBy(Object[][] rowdata, int[] keys,int tax) {
String[][] arr =(String[][]) rowdata;
int key=keys[0];
compositor(key,tax);
return arr;
}
//缺省(按COLUMN列升序)
public  void compositor(int column,int tax) {
Arrays.sort(arr, new TwoDimArrayComparator(column, tax));//按COLUMN列排序，TAX=-1降序，TAX=1升序
printArray(arr);

}
public static void printArray(String[][] arr) {
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j] + "\t");
}
System.out.println();
}
System.out.println("======================");
}
}class TwoDimArrayComparator implements Comparator {
private int keyColumn = 0;
private int sortOrder = 1;
public TwoDimArrayComparator() {
}
public TwoDimArrayComparator(int keyColumn) {
this.keyColumn = keyColumn;
}
public TwoDimArrayComparator(int keyColumn, int sortOrder) {
this.keyColumn = keyColumn;
this.sortOrder = sortOrder;
}
public int compare(Object a, Object b) {
if (a instanceof String[]) {
return sortOrder
* ((String[]) a)[keyColumn].compareTo(((String[]) b)[keyColumn]);
} else if (a instanceof int[]) {
return sortOrder
* (((int[]) a)[keyColumn] - ((int[]) b)[keyColumn]);
} else {
return 0;
}
}
}

Answer 7

package com.print;
import java.util.*;import com.baleno.erp.dao.CompositorKeyInterceptor;public class format {
String[][] arr;
public Object[][] OrderBy(Object[][] rowdata, int[] keys,int tax) {
String[][] arr =(String[][]) rowdata;
int key=keys[0];
compositor(key,tax);
return arr;
}
//缺省(按COLUMN列升序)
public  void compositor(int column,int tax) {
Arrays.sort(arr, new TwoDimArrayComparator(column, tax));//按COLUMN列排序，TAX=-1降序，TAX=1升序
printArray(arr);

}
public static void printArray(String[][] arr) {
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j] + "\t");
}
System.out.println();
}
System.out.println("======================");
}
}class TwoDimArrayComparator implements Comparator {
private int keyColumn = 0;
private int sortOrder = 1;
public TwoDimArrayComparator() {
}
public TwoDimArrayComparator(int keyColumn) {
this.keyColumn = keyColumn;
}
public TwoDimArrayComparator(int keyColumn, int sortOrder) {
this.keyColumn = keyColumn;
this.sortOrder = sortOrder;
}
public int compare(Object a, Object b) {
if (a instanceof String[]) {
return sortOrder
* ((String[]) a)[keyColumn].compareTo(((String[]) b)[keyColumn]);
} else if (a instanceof int[]) {
return sortOrder
* (((int[]) a)[keyColumn] - ((int[]) b)[keyColumn]);
} else {
return 0;
}
}
}

Answer 8

我一看到数组我就晕，尤其是2维数组，所有我很少用数组，尤其是在java中
如果楼主的接口可以改变的话，可以用list，map 等试试，我觉得应该是比较方便的个人感觉楼主好像不是在用面向对象。可把数据的一条记录对应一个类，比如Record.class
多条记录对应的就是list了，list里面放的就是Record对象了
至于对象的比较，要想通用就用反射吧 ,自己写一个Comparator 就可以了
Collections.sort(list,comparator);
具体代码楼主自己实现吧

Answer 9

package com.hs.jp.lys;import java.util.Arrays;
import java.util.Comparator;/**
 * GroupBy
 * @author linys
 * @extends ArraysComparator
 * @E-mail [email protected]
 * @version 1.0
 */
public class GroupBy extends ArraysComparator{

public GroupBy(Object[][] array ){
   Arrays.sort(array, new ArraysComparator());
    }
public GroupBy(Object[][] array ,int keyColumn,int sortOrder ){
Arrays.sort(array, new ArraysComparator(keyColumn,sortOrder));
}
public GroupBy(Object[][] array ,int keyColumn){
Arrays.sort(array, new ArraysComparator(keyColumn));
} 
}class ArraysComparator implements Comparator {
    //设置缺省列
private int column = 0;
//设置缺省排序方式 （1：升序 -1：降序）
private int orderFlag = 1;

public ArraysComparator() {
}

public ArraysComparator(int keyColumn) {
this.column = keyColumn;
}

public ArraysComparator(int column, int sortOrder) {
this.column = column;
this.orderFlag = sortOrder;
}

public int compare(Object objOne, Object objTwo) {
if (objOne instanceof String[]) {
return orderFlag * ((String[]) objOne)[column].compareTo(((String[]) objTwo)[column]); } else if (objOne instanceof int[]) {
return orderFlag * (((int[]) objOne)[column] - ((int[]) objTwo)[column]);
} else {
return 0;
}
}
}
Test case
package com.hs.jp.lys;/**
 * TestGroupBy 
 * @author linys
 *
 */
public class TestGroupBy { /**
 * @param args
 */
public static void main(String[] args) { String[][] arr = {
{ "1", "A", "N" }, { "2", "O", "B" }, { "3", "P", "A" } 
}; // 缺省(按0列升序)
        new GroupBy(arr);
     printResult(arr);
        
// 按0列降序
new GroupBy(arr,0,-1);
printResult(arr); } public static void printResult(Object[][] obj) {
for (int i = 0; i < obj.length; i++) {
for (int j = 0; j < obj[i].length; j++) {
System.out.print(obj[i][j] + "\t");
}
System.out.println("\n");
}
System.out.println("======BY tolys======\n");
}
}

Answer 10

package com.test;import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;public class OrderBy { /**
 * 升序排列(倒序反过来就行)
 * 
 * @param rowdata
 *            数据
 * @param keys
 *            要求排序的列
 * @param compare
 *            比较器
 * @return
 * @throws IllegalArgumentException
 */
public Object[][] orderBy(Object[][] rowdata, int[] keys,
Comparator<Object> compare) throws IllegalArgumentException { if (keys == null || keys.length == 0) {
return rowdata;
} for (int i = 0, len = keys.length, len2 = rowdata[0].length; i < len; i++) {
if (keys[i] >= len2) {
throw new IllegalArgumentException("Illegal Arguments!");
}
} // 首先按第一个指定的列排序
Object[] temp = new Object[rowdata[0].length];// 临时交换用的变量
for (int i = 0, len = rowdata.length, firstSort = keys[0]; i < len; i++) {
for (int j = 0; j < len - i - 1; j++) {
if (compare.compare(rowdata[j][firstSort],
rowdata[j + 1][firstSort]) > 0) {
temp = rowdata[j];
rowdata[j] = rowdata[j + 1];
rowdata[j + 1] = temp;
}
}
}
// 按剩余指定的列排序
for (int i = 1, len = keys.length; i < len; i++) { int lastSorted = keys[i - 1];
List<int[]> needSecondSort = new ArrayList<int[]>(); // 找出需要二次排序的部分
for (int j = 0, len2 = rowdata.length; j < len2 - 1; j++) { if (compare.compare(rowdata[j][lastSorted],
rowdata[j + 1][lastSorted]) == 0) {
int[] equals = new int[2]; equals[0] = j;
equals[1] = j + 1; for (int k = j + 1; k < len2 - 1; k++) {
if (compare.compare(rowdata[k][lastSorted],
rowdata[k + 1][lastSorted]) == 0) {
equals[1] = k + 1;
} else {
break;
}
} j = equals[1];
needSecondSort.add(equals);
}
} // 进行二次排序
if (needSecondSort.size() > 0) {
for (Iterator itr = needSecondSort.iterator(); itr.hasNext();) {
int[] sec = (int[]) itr.next(); for (int m = sec[0]; m <= sec[1]; m++) {
for (int n = sec[0]; n < sec[1] - m + sec[0]; n++) {
if (compare.compare(rowdata[n][keys[i]],
rowdata[n + 1][keys[i]]) > 0) {
temp = rowdata[n];
rowdata[n] = rowdata[n + 1];
rowdata[n + 1] = temp;
}
}
}
}
} } return rowdata;
} public static void main(String[] args) {
String[][] rowdata = { { "2", "4", "8" }, { "2", "3", "8" },
{ "1", "5", "7" }, { "1", "5", "6" } }; System.out.println("****************before Sorted****************");
for (int i = 0, len = rowdata.length; i < len; i++) {
System.out.println(Arrays.toString(rowdata[i]));
} rowdata = (String[][]) new OrderBy().orderBy(rowdata, new int[] { 0, 1,
2 }, new Comparator<Object>() {
public int compare(Object o1, Object o2) {
String str1 = (String) o1;
String str2 = (String) o2;
if (str1.compareTo(str2) > 0) {
return 1;
} else if (str1.compareTo(str2) == 0) {
return 0;
} else {
return -1;
}
}
}); System.out.println("****************after Sorted****************");
for (int i = 0, len = rowdata.length; i < len; i++) {
System.out.println(Arrays.toString(rowdata[i]));
} }
}

Answer 11

结果:
****************before Sorted****************
[2, 4, 8]
[2, 3, 8]
[1, 5, 7]
[1, 5, 6]
****************after Sorted****************
[1, 5, 6]
[1, 5, 7]
[2, 3, 8]
[2, 4, 8]