表像java數據結構

Question

我需要實現一些類似於表的數據結構，在Java中存儲這樣的信息：

+--------+-------+-----+
|  sij   |   i   |  j  |
+--------+-------+-----+
|   45   |   5   |  7  |
+--------+-------+-----+ 
|   33   |   1   |  6  |
+--------+-------+-----+ 
|   31   |   0   |  9  |
+--------+-------+-----+ 
|   12   |   8   |  2  |
+--------+-------+-----+ 

我必須能夠通過sij參數對表進行排序。 我已經使用ArrayList和HashMap進行了一些測試，但是我不能讓它們運行良好。

Answer 1

Google guava庫中有一個通用的TreeBasedTable類， TreeBasedTable您的要求。 它還提供了許多其他有用的實用方法，其用法顯示在用戶指南中 。

來自TreeBasedTable文檔：

表的行鍵和列鍵按其自然順序或提供的比較器排序的表的實現。

用法示例：

RowSortedTable<Vertex, Vertex, Double> weightedGraph = TreeBasedTable.create();
weightedGraph.put(v2, v3, 4.0);
weightedGraph.put(v1, v2, 20.0);

System.out.println( weightedGraph.rowKeySet() ); // prints [v1, v2]

Answer 2

你是什​​么意思：

我必須能夠通過sij參數對其進行排序

有什么不對：

Object [][] data

編輯

好吧，只是猜測你需要的是一個“StrangeDataStructure”來保存數組，並幫助你按第一列排序，那么你唯一需要的就是這樣：

class Structure {
    Object [][] data;
    Object [] indexColumn; // the sij?
}

就是這樣：你應該添加一個指示方向的排序方法，並使用“indexColumn”排序

我覺得這很簡單（如果我理解你的“問題” ）

你知道嗎？ 我要實現它。

//時間過去了......

這里是：

import java.util.Comparator;
import java.util.Arrays;

public class StrangeStructure {

    private Integer [][] data;
    private Integer [] sij; // what is sij anyway?

    public StrangeStructure( Integer [][] matrix  ) {
        data = matrix;
        sij = new Integer[ data.length ];
        for( int i = 0 ; i < data.length ; i++ ) {
            sij[i] = data[i][0];
        }
    }

    public void sort( Direction direction  ) {

        Comparator sijComparator  = new DataComparator( direction, true );
        Comparator dataComparator = new DataComparator( direction, false );

        Arrays.sort( sij, sijComparator );
        Arrays.sort( data, dataComparator  );

    }

    public static void main( String [] args ) {

        StrangeStructure s =  
            new StrangeStructure( new Integer[][]{
                                  { 45, 5, 7 }, 
                                  { 33, 1, 6 }, 
                                  { 31, 0, 9 }, 
                                  { 12, 8, 2 }    
                            });

        System.out.printf("Original:\n%s", s );       

        s.sort( Direction.MIN_TO_MAX );  
        System.out.printf("Min to max:\n%s", s );       

        s.sort( Direction.MAX_TO_MIN );  
        System.out.printf("Max to min\n%s", s );       

    }


    public String toString() {
        StringBuilder b = new StringBuilder();
        for( Integer [] row : data ) {
            for( int i : row ) {
                b.append( i+",");
            }
            b.append("\n");
        }
        return b.toString();

    }

}
class DataComparator implements Comparator {

    private Direction direction;
    private boolean isSij;

    public DataComparator( Direction d, boolean isSij ) {
        this.direction = d;
        this.isSij = isSij;
    }

    public int compare( Object one , Object two  ) {
        if( isSij ){
            return doCompare( direction, (Integer) one, (Integer) two );
        } else {
            return doCompare( direction, ((Integer[])one)[0], ((Integer[])two)[0]);
        }
    }
    public int doCompare( Direction d, int one, int two  ) {
        int a = ( d == Direction.MIN_TO_MAX? one: two );
        int b = ( d == Direction.MIN_TO_MAX? two: one ) ;
        return a - b;
    }
    public boolean equals( Object o ) {
        return false;
    }
}



enum Direction{
    MIN_TO_MAX,
    MAX_TO_MIN
}

輸出：

Original:
45,5,7,
33,1,6,
31,0,9,
12,8,2,
Min to max:
12,8,2,
31,0,9,
33,1,6,
45,5,7,
Max to min
45,5,7,
33,1,6,
31,0,9,
12,8,2,

Answer 3

閱讀關於如何使用表的Swing教程中的部分。 本教程將介紹如何創建表以及如何向表中添加排序功能。

如果您只需要存儲數據但不顯示數據，則可以使用二維數組或列表列表。 然后，您可以使用Column Comparator進行排序。

編輯：添加了演示ColumnComparator使用的代碼

import java.util.*;

public class SortSIJ
{
    public static void main(String args[])
    {
        Object[] data = new Object[4];
        data[0] = new Integer[] {45, 5, 7};
        data[1] = new Integer[] {33, 1, 6};
        data[2] = new Integer[] {31, 0, 9};
        data[3] = new Integer[] {12, 8, 2};

        ColumnComparator cc = new ColumnComparator(0);
//      cc.setAscending( false );

        Arrays.sort(data, cc);

        for (Object row: data)
        {
            Integer[] theRow = (Integer[])row;
            System.out.println( Arrays.asList(theRow) );
        }
    }
}

我也同意創建一個Object來存儲3個變量的建議。 在這種情況下，您可以使用可在上述鏈接中找到的BeanComparator 。

Answer 4

您可以使用Apache的MultiValueMap ，以便使用一個鍵鏈接多個值。

Answer 5

一種選擇是創建一個包含3個變量的新對象，然后創建這些對象的數組/樹，並按所需的參數排序。

Answer 6

這是一種方法：創建一個名為Row的對象來保存每一行，然后創建一個java.util.HashMap，其鍵是Integer sij，其值是相應的Rows。

public class Example
{
  public static class Row
  {
    public Integer sij;
    public Integer i;
    public Integer j;
    public Row(Integer sij, Integer i, Integer j)
    {
      this.sij = sij;
      this.i = i;
      this.j = j;
    }
  }

  public static void main(String[] args)
  {
    Row r1 = new Row(45, 5, 7);
    Row r2 = new Row(33, 1, 6);
    Row r3 = new Row(31, 0, 9);
    Row r4 = new Row(12, 8, 2);
    Map<Integer, Row> map = new TreeMap<Integer, Row>();
    map.put(r1.sij, r1);
    map.put(r2.sij, r2);
    map.put(r3.sij, r3);
    map.put(r4.sij, r4);
    for ( Row row : map.values() ) {
        System.out.println("sij: " + row.sij + " i: " + row.i + " j: " + row.j);
    }
  }
}

當它運行時它產生：

sij: 12 i: 8 j: 2
sij: 31 i: 0 j: 9
sij: 33 i: 1 j: 6
sij: 45 i: 5 j: 7

Answer 7

如果我理解你的問題，你只需要一個Comparable類來代表一行。

public static class Row
implements Comparable<Row> {
  public Row(int sij, int i, int j) {
    this.sij = sij;
    this.i = i;
    this.j = j;
  }

  public int compareTo(Row other) {
    return Integer.valueOf(sij).compareTo(other.sij);
  }

  public final int sij;
  public final int i;
  public final int j;
}

然后，您可以使用Row實例填充List ，並使用Collections.sort進行排序。