Hi,

I'm working on a reader and rriter for Excel files. The reader works fine. It 
shows the table correctly in my JTable. But after saving it under a new name 
and open this file, the last column is gone. However Excel shows all the 
columns, none is missing for the first time. When I repeat the procedure even 
in Excel the last column is missing. In the JTable is the column which was the 
previous last one also gone (2 are missing now.. and so on). I thought it was a 
bug in my code. So I terminated the Java application after saving for the first 
time, but after restarting the programm an open the saved file, the last column 
ist still not there. Can anybody tell me if this is my mistake or a bug? (I 
attached my code.)

thanks

------------------------------------------------------------------
import org.apache.poi.poifs.filesystem.POIFSFileSystem;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.TableModel;

import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;

public class WorkbookReader
{
	private	ArrayList tableName = new ArrayList();
	private	ArrayList sheet = new ArrayList();
	private TableSheet ts[];


	public WorkbookReader(String wbName) {
		try {
			File file = new File(wbName);
			readXls(file);
		} catch (IOException exc) {
			System.out.println(exc);
		}

	}
	
	public WorkbookReader(File wbName) {
		try {
			readXls(wbName);
		} catch (IOException exc) {
			System.out.println(exc);
		}

	}

	private void readXls(File file) throws IOException{
		String s;
		HSSFSheet sh;
		HSSFRow rw;
		HSSFCell cell;

		short lastCell;
		int rows;

		FileInputStream	fis = new FileInputStream(file);
		POIFSFileSystem fs = new POIFSFileSystem(fis);
		HSSFWorkbook wb = new HSSFWorkbook(fs);


		int sheets = wb.getNumberOfSheets();
		for(int i = 0; i < sheets; i++) {
			//Name des Tabellenblattes
			s = wb.getSheetName(i);
			//Arbeitsblatt
			sh = wb.getSheetAt(i);
			//Anzahl der Spalten mit Werten
			rows = sh.getPhysicalNumberOfRows();
			//Wenn das Arbeitsblatt Werte enthält
			//addiere es zu den ArrayListen
			if(rows > 0) {
				tableName.add(s);
				sheet.add(sh);
			}
		}
		fis.close();

		//Instanzen der Klasse TableSheet erzeugen
		sheets = sheet.size();
		ts = new TableSheet[sheets];

		//ArrayListe für Arbeitblätter auslesen
		for(int i = 0; i < sheets; i++) {

			ArrayList cells = new ArrayList();
			sh = (HSSFSheet) sheet.get(i);
			rows = sh.getPhysicalNumberOfRows();

			int maxCol = 0;

			for(int j = 0; j < rows; j++) {

				rw = sh.getRow(j);
				lastCell = rw.getLastCellNum();
				System.out.println(lastCell);
				//den größten Wert für die Anzahl der Spalten 
speichern
				if(lastCell > maxCol) maxCol = lastCell;

				for(int k = 0; k < lastCell; k++) {
					cell = rw.getCell((short) k);
					int cellType;
					if(cell == null) {
						cellType = 3;
					}
					else {
						cellType = cell.getCellType();
					}
					//Zellentyp ermitteln und Inhalt der 
Zelle auslesen
					switch(cellType)
					{
					case HSSFCell.CELL_TYPE_NUMERIC:
						Double bigDbl = new Double
(cell.getNumericCellValue());
						cells.add(bigDbl);
						break;
					case HSSFCell.CELL_TYPE_BOOLEAN:
						Boolean bigBol = new Boolean
(cell.getBooleanCellValue());
						cells.add(bigBol);
						break;
					case HSSFCell.CELL_TYPE_STRING:
						cells.add
(cell.getStringCellValue());
						break;
					case HSSFCell.CELL_TYPE_FORMULA:
						cells.add
(cell.getStringCellValue());
						break;
					default:
						cells.add("");
					}
				}
			}

			//die Spalten bekommen eine aufsteigende nummerische 
Überschrift
			Object colNames[] = new Object[maxCol];
			for(int m = 0; m < maxCol; m++) {
				Integer bigInt = new Integer(m);
				colNames[m] =  bigInt.toString();
			}

			//Tabellenname auslesen
			String tn = (String) tableName.get(i);

			//die Daten werden nun den Instanzen zugeordnet
			ts[i] = new TableSheet(cells, colNames , tn);
		}
	}

	public TableSheet[] getTableSheets() {
		return ts;
	}

	public TableSheet getTableSheet(int index) {
		return ts[index];
	}

	public int getNumberOfTableSheets() {
		return ts.length;
	}
}

--------------------------------------------------------------------------
import java.io.*;
import org.apache.poi.hssf.usermodel.*;
import org.apache.poi.poifs.filesystem.*;

public class WorkbookWriter{

	public WorkbookWriter(TableSheet ts[], String wbName){
		try {
			File file = new File(wbName);
			writeXls(ts, file);
		} catch (IOException exc) {
			System.out.println(exc);
		}
	}

	public WorkbookWriter(TableSheet ts[], File wbName){
		try {
			writeXls(ts, wbName);
		} catch (IOException exc) {
			System.out.println(exc);
		}
	}



	private void writeXls(TableSheet ts[], File file) throws IOException{
		HSSFWorkbook wb = new HSSFWorkbook();
		HSSFSheet sheet[] = new HSSFSheet[ts.length];

		//erzeuge so viele Tabellen, wie das Array 'ts' lang ist
		for(int i = 0; i < ts.length; i++){
			sheet[i] = wb.createSheet(ts[i].getTableName());
			//lese Objekte aus der Tabelle
			Object data[][] = ts[i].getRowDatas();
			//erzeuge Zeilen
			HSSFRow row[] = new HSSFRow[data.length];
			for(int j = 0; j < data.length; j++) {
				row[j] = sheet[i].createRow((short)j);
				//erzeuge Zellen
				HSSFCell cell[] = new HSSFCell[data[j].length];
				for(int k = 0; k < data[j].length; k++) {
					cell[k] = row[j].createCell((short)k);
					//ermitteln des ObjectTyps
					Object o = data[j][k];
					String s = getObjectType(o);
					if(s.endsWith("Double")) {
						Double d = (Double)o;
						cell[k].setCellValue
(d.doubleValue());
					}
					else if(s.endsWith("Boolean")) {
						Boolean b = (Boolean)o;
						cell[k].setCellValue
(b.booleanValue());
					}
					else {
						cell[k].setCellValue(o.toString
());					
					}
				}
			}
		}

		FileOutputStream fileOut = new FileOutputStream(file);
		wb.write(fileOut);
		fileOut.close();
	}

	private String getObjectType(Object o) {
		Class c = o.getClass();
		String s = c.getName();
		return s;
	}
}

---------------------------------------------------------------------
import java.util.*;
import javax.swing.table.*;

class TableSheet extends AbstractTableModel {
	private Object data[][];
	private Object colName[];
	private String tableName;
	private int cols;
	private int rows;

	public TableSheet() {
	}

	public TableSheet(Object data[][], Object columnNames[], String 
tableName) {
		setData(data, columnNames, tableName);
	}

	public TableSheet(ArrayList dataList, Object columnNames[], String 
tableName) {
		setData(dataList, columnNames, tableName);
	}

	public void setData(Object data[][], Object columnNames[], String 
tableName) {
		this.data = data;
		colName = columnNames;
		this.tableName = tableName;
	}

	public void setData(ArrayList dataList, Object columnNames[], String 
tableName) {
		Object d[] = dataList.toArray();
		colName = columnNames;
		this.tableName = tableName;
		readDatas(d);
	}


	private void readDatas(Object d[]) {
		cols = colName.length;
		rows = d.length/cols;
		data = new Object[rows][cols];

		for(int i = 0; i < data.length; i++) {
			for(int j = 0; j < data[i].length; j++) {
				data[i][j] = d[(cols*i)+j];
			}
		}
	}

	public Object[][] getRowDatas() {
		return data;
	}

	public Object[] getColumnNames() {
		return colName;
	}

	public String getColumnName(int columnIndex) {
		String s = (String) colName[columnIndex];
		return s;
	}

	public int getRowCount() {
		return data.length;
	}

	public int getColumnCount() {
		return cols;
	}

	public Object getValueAt(int rowIndex, int colIndex) {
		return data[rowIndex][colIndex];
	}

	public String getTableName() {
		return tableName;
	}
}

--------------------------------------------------------------
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;

public class WorkBookTest extends JFrame implements ActionListener{
	private WorkbookReader wbReader;
	private WorkbookWriter wbWriter;
	private JList list;
	private JTable table;
	private JButton load, save;

	private class MyMouseListener extends MouseAdapter {

		public void mouseClicked(MouseEvent e) {
			showTableContents(e);
		}

		public void mousePressed(MouseEvent e) {
			showTableContents(e);
		}
	}

	public WorkBookTest() {
		super("Test Java-Excel");
		setResizable(false);
		addWindowListener(
		        new WindowAdapter() {
			        public void windowClosing(WindowEvent e) {
				        System.exit(0);
			        }
		        });

		Container cp = getContentPane();

		table = new JTable();
		table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

		list = new JList();
		list.addMouseListener(new MyMouseListener());

		load = new JButton("load XLS-File");
		save = new JButton("save XLS-File");
		load.addActionListener(this);
		save.addActionListener(this);
		save.setEnabled(false);

		JScrollPane scroll_1 = new JScrollPane(list);
		JScrollPane scroll_2 = new JScrollPane(table);

		JPanel pan_1 = new JPanel(new BorderLayout());
		JPanel pan_2 = new JPanel(new FlowLayout());

		pan_2.add(load);
		pan_2.add(save);

		pan_1.add("Center", scroll_1);
		pan_1.add("South", pan_2);

		cp.add("West", pan_1);
		cp.add("Center", scroll_2);

	}

	private boolean showIoDialog(boolean showOpen) {
		boolean ok = false;
		JFileChooser chooser = new JFileChooser();
		FileFilter filter = new FileFilter();
		filter.addType("xls");
		filter.setDescription("MS-Excel-Dateien (*.xls)");
		chooser.setFileFilter(filter);

		if(showOpen) {
			int returnVal = chooser.showOpenDialog(this);
			if (returnVal == JFileChooser.APPROVE_OPTION) {
				wbReader = new WorkbookReader
(chooser.getSelectedFile());
				ok = true;
			}
		}
		else {
			int returnVal = chooser.showSaveDialog(this);
			if (returnVal == JFileChooser.APPROVE_OPTION) {
				wbWriter = new WorkbookWriter
(wbReader.getTableSheets(), chooser.getSelectedFile());
				ok = true;
			}
		}
		return ok;
	}

	public void actionPerformed(ActionEvent e) {
		if(e.getSource() == load) {
			if(showIoDialog(true)) {
				Object listData[] = new Object
[wbReader.getNumberOfTableSheets()];

				for(int i = 0; i < listData.length; i++) {
					TableSheet ts = wbReader.getTableSheet
(i);
					listData[i] = ts.getTableName();
				}

				list.setListData(listData);
				save.setEnabled(true);
			}
		}
		else
			showIoDialog(false);
	}



	private void showTableContents(MouseEvent e) {
		if(!e.isPopupTrigger()) {
			int index = list.getSelectedIndex();
			table.setModel(wbReader.getTableSheet(index));
		}
	}

	public static void main(String args[]) {
		WorkBookTest wbt = new WorkBookTest();
		wbt.pack();
		wbt.show();
	}
}