我有一个JTable，其中有几个客户帐户的操作。
我想计算每个帐户的每个帐户的累计余额。在我的JTable中，我有一列（字符串类型），其中有一个帐户列表，另一列（int类型），其中有很多操作。
我如何能够检索帐户列表并计算每个帐户的累计交易余额？
答案 0 :(得分：0)
我有解决问题的方法
int nombreDeLignes = model.getRowCount();
double cumul=0;
String numcompte=null; // une valeur qui n'existe nulle part
for(int i=0; i<nombreDeLignes; i++) {
String numcompteLigne = model.getValueAt(i, 4).toString();
if ( numcompte==null || !numcompte.equals(numcompteLigne) ) {
numcompte = numcompteLigne;
cumul=0;
}
cumul+= (int) model.getValueAt(i, 5);
model.setValueAt(cumul, i, 9);
}
答案 1 :(得分：0)
以下是用于创建合并数据和创建小计
的代码 public enum AggregatorType {
SUM, AVG, DISPLAY, LABEL
}
public class DataRow {
private final Object[] values;
private final boolean totalRow;
public DataRow(Object[] values, boolean totalRow) {
this.values = values;
this.totalRow = totalRow;
}
public Object[] getValues() {
return values;
}
public boolean isTotalRow() {
return totalRow;
}
public static Object[] getvalues(Object obj) {
if (obj instanceof DataRow) {
return ( (DataRow) obj).getValues() ;
} else if (obj instanceof Object[]) {
return (Object[]) obj;
} else {
return new Object[] { obj};
}
}
}
public class Aggregator {
private final int column;
private final String prefix;
private final String subfix;
private final AggregatorType type;
public Aggregator( int column,AggregatorType type)
{
this(column,type,null);
}
public Aggregator( int column,AggregatorType type,String prefix)
{
this(column,type,prefix,null);
}
public Aggregator( int column,AggregatorType type,String prefix,String subfix)
{
this.column=column;
this.type=type;
this.prefix=prefix;
this.subfix=subfix;
}
public int getColumn() {
return column;
}
public AggregatorType getType() {
return type;
}
public Object aggregate( List<?> objects) {
Object object = null;
switch(this.type) {
case SUM : object = total(objects); break;
case AVG : object = avg(objects); break;
case LABEL: object = ""; break;
default: object = display(objects); break;
}
if( object != null && ( prefix != null || subfix != null )) {
return ( prefix == null ? "" : prefix.toString() ) +
object.toString() +
( subfix == null ? "" : subfix.toString() );
} else {
return object;
}
}
public Object display( List<?> objects) {
return DataRow.getvalues(objects.get(0))[column];
}
public Object total( List<?> objects) {
double total = 0.0;
for( Object object : objects ) {
Object[] objA = DataRow.getvalues(object);
Object value = objA[column];
if( value instanceof Number ) {
total += ( ( Number ) value ).doubleValue();
}
}
return total;
}
public Object avg( List<?> objects) {
double total = 0.0;
int count = 0;
for( Object object : objects ) {
Object[] objA = DataRow.getvalues(object);
Object value = objA[column];
if( value instanceof Number ) {
total += ( ( Number ) value ).doubleValue();
count++;
}
}
return count > 0 ? ( total / count ) : 0.0;
}
}
import java.util.List;
public class SubTotalCreator {
private final int columnIndex;
private final boolean grandTotal;
private final List<Aggregator> aggregatorList;
public SubTotalCreator(int index, List<Aggregator> aggregatorList) {
this(index, false, aggregatorList);
}
public SubTotalCreator(int index, boolean grandTotal, List<Aggregator> aggregatorList) {
this.aggregatorList = aggregatorList;
this.columnIndex = index;
this.grandTotal = grandTotal;
}
public boolean canCreateSubTotal(Object[] object1, Object[] object2) {
return !object1[columnIndex].equals(object2[columnIndex]);
}
public Object[] createSubTotal(List<?> subList) {
Object[] obj = DataRow.getvalues(subList.get(0));
int length = obj.length;
Object[] subtotal = new Object[length];
for (Aggregator aggregator : aggregatorList) {
Object value = aggregator.aggregate(subList);
subtotal[aggregator.getColumn()] = value;
}
return subtotal;
}
public int getColumnIndex() {
return columnIndex;
}
public boolean isGrandTotal() {
return grandTotal;
}
public List<Aggregator> getAggregatorList() {
return aggregatorList;
}
}
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
public class Consolidator {
private final List<SubTotalCreator> list;
private final Comparator<Object[]> comparator;
private List<Object[]> objects;
private List<DataRow> rows;
public Consolidator(Comparator<Object[]> comparator, List<SubTotalCreator> list) {
this.comparator = comparator;
this.list = list;
}
public List<Object[]> getSummary() {
List<Object[]> list = new ArrayList<>();
for (int index = 0; index < rows.size(); index++) {
DataRow row = rows.get(index);
if (row.isTotalRow()) {
list.add(row.getValues());
}
}
return list;
}
public Object[][] getAllRowAsArray() {
Object[][] list =new Object[rows.size()][];
for (int index = 0; index < rows.size(); index++) {
DataRow row = rows.get(index);
list[index]=row.getValues();
}
return list;
}
public List<Object[]> getAllRows() {
List<Object[]> list = new ArrayList<>();
for (int index = 0; index < rows.size(); index++) {
DataRow row = rows.get(index);
list.add(row.getValues());
}
return list;
}
public List<Object[]> getObjects() {
return objects;
}
public List<DataRow> getRows() {
return rows;
}
public void setObjects(Object[][] objects) {
List<Object[]> list = new ArrayList<>();
for (int index = 0; index < objects.length; index++) {
list.add(objects[index]);
}
setObjects(list);
}
public void setObjects(List<Object[]> objects) {
this.objects = objects;
}
private void createDataRow() {
List<DataRow> list = new ArrayList<>();
for (int index = 0; index < objects.size(); index++) {
list.add(new DataRow(objects.get(index), false));
}
this.rows = list;
}
public void consolidate() {
objects.sort(comparator);
createDataRow();
computeSubTotal();
computeGrandTotal();
}
public void computeSubTotal() {
for (SubTotalCreator creator : list) {
if (!creator.isGrandTotal()) {
computeSubTotal(creator);
}
}
}
public void computeGrandTotal() {
for (SubTotalCreator creator : list) {
if (creator.isGrandTotal()) {
computeSubTotal(creator);
}
}
}
public void computeSubTotal(SubTotalCreator creator) {
List<?> list = null;
if (!creator.isGrandTotal()) {
ArrayList<DataRow> subList = new ArrayList<DataRow>();
DataRow prevDataRow = null;
for (int index = 0; index < rows.size(); index++) {
DataRow dataRow = rows.get(index);
if (dataRow.isTotalRow())
continue;
if (prevDataRow != null) {
boolean flag = creator.canCreateSubTotal(prevDataRow.getValues(), dataRow.getValues());
if (flag) {
DataRow subTotal = new DataRow(creator.createSubTotal(subList), true);
rows.add(index, subTotal);
subList.clear();
index++;
}
}
subList.add(dataRow);
prevDataRow = dataRow;
}
list = subList;
} else {
list = objects;
}
DataRow subTotal = new DataRow(creator.createSubTotal(list), true);
rows.add(subTotal);
}
public static void print(Object[][] objects) {
for (Object[] objA : objects) {
System.out.println(Arrays.asList(objA));
}
}
public static void print(List<Object[]> objects) {
for (Object[] objA : objects) {
System.out.println(Arrays.asList(objA));
}
}
public static void main(String[] str) {
Object[][] accountDetails = new Object[][] { { "Abhi", 20 }, { "Abhi", 200 }, { "Sekar", 100 }, { "Abhi", 45 },
{ "Sekar", 120 }, { "Abhi", 35 }, { "Abhi", 40 }, { "Sekar", 500 } };
Comparator<Object[]> comparator = new Comparator<Object[]>() {
public int compare(Object[] obj1, Object[] obj2) {
return ((String) obj1[0]).compareTo((String) obj2[0]);
}
};
List<SubTotalCreator> list = new ArrayList<SubTotalCreator>();
List<Aggregator> aggregatorList = new ArrayList<Aggregator>();
aggregatorList.add(new Aggregator(0, AggregatorType.DISPLAY, null, " 's Total"));
aggregatorList.add(new Aggregator(1, AggregatorType.SUM));
SubTotalCreator creator = new SubTotalCreator(0, aggregatorList);
list.add(creator);
List<Aggregator> grandAggList = new ArrayList<Aggregator>();
grandAggList.add(new Aggregator(0, AggregatorType.LABEL, "Grand Total"));
grandAggList.add(new Aggregator(1, AggregatorType.SUM));
SubTotalCreator creator2 = new SubTotalCreator(0, true, grandAggList);
list.add(creator2);
Consolidator consolidator = new Consolidator(comparator, list);
consolidator.setObjects(accountDetails);
System.out.println("Before Consolidate ");
print(consolidator.getObjects());
consolidator.consolidate();
System.out.println("After Consolidate ");
print(consolidator.getAllRows());
System.out.println("After Consolidate Summary Alone ");
print(consolidator.getSummary());
JFrame frame = new JFrame("test");
JTable table = new JTable( consolidator.getAllRowAsArray(),new String[] {"Name" ,"Amount"});
frame.getContentPane().add( new JScrollPane(table),BorderLayout.CENTER);
frame.setSize( 400,400);
frame.setVisible( true);
}
}