Thread: JTable memory consumption

Could you post your code? It's possible you have something somewhere that's creating a lot of objects but aren't de-referencing them so the can be garbage collected.

here is the table model class:

package in.tune.gui.table;
 
import in.tune.data.DataHandler;
 
import javax.swing.table.AbstractTableModel;
 
public class JBTableModel extends AbstractTableModel {
 
	private static final long serialVersionUID = 1L;
 
	private static int[] enabledColumns = {2, 0, 1, 3, 11, 12};
	private static Column[] enabledColumns2 = {new Column(2), new Column(0), new Column(1), new Column(3), new Column(11), new Column(12)};
 
	private static String[] columnNames = {"Album", "Artist", "Title", "Year", "Arranger", "Comment", "Disk", "Total Disks",
		"Genre", "Language", "Rating", "Track", "Total Tracks"};
 
	@Override
	public String getColumnName(int col)
	{
		return columnNames[enabledColumns[col]];
	}
 
	public int getRowCount()
	{
		return DataHandler.getList().size();
	}
 
	public int getColumnCount()
	{
		return enabledColumns.length;
	}
 
	public Object getValueAt(int row, int col)
	{
		return enabledColumns2[col].getData(row);
	}
 
	@Override
	public boolean isCellEditable(int row, int col)
	{
		return false;
	}
 
	@Override
	public void setValueAt(Object value, int row, int col)
	{
		//note: never do anything here or in edit cells. The tag editor will be in a separate window. ~Daniel Centore
	}
 
}

The DataHandler class:

package in.tune.data;
 
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
 
/**
 * Handles the collection of all our songs
 * 
 * @author Daniel Centore
 *
 */
public class DataHandler implements Serializable {
 
	private static final String dataFile = "./songs.ser";
 
	private static DataHandler instance = new DataHandler();
	private List<Song> list = Collections.synchronizedList(new LinkedList<Song>());	//the main collection. Synchronized with Collections.
	private List<String> data = Collections.synchronizedList(new LinkedList<String>());	//collection of data Strings. this will be used to reference to rather than storing every string
 
	/**
	 * Returns a reference to a clone of s if available, otherwise adds s to database and returns it
	 * @param s - a string
	 * @return - reference
	 */
	public static String getString(String s)
	{
		int i = Collections.binarySearch(instance.data, s);
		if(i >= 0)
		{
			return instance.data.get(i);
		}
		else
		{
			instance.data.add(s);
			Collections.sort(instance.data);
			return s;
		}
	}
 
	/**
	 * Returns the main song list
	 * @return
	 */
	public static List<Song> getList()
	{
		return instance.list;
	}
 
	public static void save()
	{
		FileOutputStream fos = null;
		ObjectOutputStream out = null;
		try {
			fos = new FileOutputStream(dataFile);
			out = new ObjectOutputStream(fos);
			out.writeObject(instance);
			out.close();
		} catch(IOException ex) {
			ex.printStackTrace();
		}
	}
 
	public static void load()
	{
		FileInputStream fis = null;
		ObjectInputStream in = null;
		try
		{
			fis = new FileInputStream(dataFile);
			in = new ObjectInputStream(fis);
			instance = (DataHandler)in.readObject();	//possible dangerous?
			in.close();
		} catch(IOException ex) {
			ex.printStackTrace();
		} catch(ClassNotFoundException ex) {
			ex.printStackTrace();
		}
	}
 
}

And finally the Song class:

package in.tune.data;
 
import java.io.File;
import java.io.Serializable;
import java.util.LinkedList;
 
import org.jaudiotagger.audio.AudioFile;
import org.jaudiotagger.audio.AudioFileIO;
import org.jaudiotagger.audio.AudioHeader;
 
/**
 * Class representing a song
 * 
 * @author Daniel Centore
 *
 */
public class Song implements Serializable {
 
	private static final long serialVersionUID = 1L;
 
	boolean isSong = false;		//set to true if it is
 
	LinkedList<String> tags = new LinkedList<String>();		//list of tags. Folllows order in ReadTags
	File location = null;
 
	/**
	 * Returns the length of the song in seconds
	 * @return -1 if audio file could not be read
	 */
	public int getTrackLength()
	{
		AudioFile af;
		try {
			af = AudioFileIO.read(location);
			AudioHeader i = af.getAudioHeader();
 
			return i.getTrackLength();
		} catch (Exception e) {
			System.err.println("Error: audio file not found? Stack trace: ");
			e.printStackTrace();
		}
 
		return -1;
	}
 
	/**
	 * Inits a song at the location f
	 * @param f
	 */
	public Song(File f)
	{
		location = f;
		isSong = ReadTags.updateTags(tags, location);
	}
 
	/**
	 * Inits a Song at the String s (file path)
	 * TODO: add samba share support (via library or auto mounting?)
	 * @param s
	 */
	public Song(String s)
	{
		this(new File(s));
	}
 
	@Override
	public String toString()
	{
		return "Song [tags=" + tags + "]";
	}
 
	/**
	 * Returns the tags
	 * @return
	 */
	public LinkedList<String> getTags()
	{
		return tags;
	}
 
}

Edit: sorry forgot about this last class you may need:

package in.tune.gui.table;
 
import in.tune.data.DataHandler;
 
import java.util.GregorianCalendar;
 
/**
 * Class representing a single column of the data table
 * 
 * @author Daniel Centore
 *
 */
public class Column {
 
	private int col;	//the column its representing
 
	/**
	 * inits a column at column col
	 * 
	 * @param _col
	 */
	public Column(int _col)
	{
		col = _col;
	}
 
	/**
	 * returns a String of data in the column
	 * @param row - the row its in. Row 0 is the 1st row of DATA (not titles)
	 * @return - the data
	 */
	public String getData(int row)
	{
		switch(col)
		{
		case -1:
			return formatSecs(DataHandler.getList().get(row).getTrackLength());
 
		default:
			return DataHandler.getList().get(row).getTags().get(col);
		}
	}
 
	/**
	 * Returns a
	 * @param secsIn
	 * @return
	 */
	public static String formatSecs(int secs)		//TODO: finish this
	{
		GregorianCalendar g = new GregorianCalendar();
		g.setTimeInMillis(secs * 1000);
 
		int hours = g.get(GregorianCalendar.HOUR_OF_DAY);
		int mins = g.get(GregorianCalendar.MINUTE);
		int seconds = g.get(GregorianCalendar.SECOND);
 
		return hours+"";
	}
 
}