Use of dispose() and finalize()

Question

Hello everyone (first post ever). I have a question about a program that I'm currently working on that doesn't seem to be releasing system resources. Here's a brief description of my program and my problem:
Program Description: It's a widget that queries a news file every couple of minutes to check if the file was updated. If it was updated, then the taskbar icon flashes and signals the user to click on it to open a window showing them the news.
Problem: The main use of this program will be just sitting in the taskbar waiting and checking to see if there are any updates. However, after a user opens the window, the memory usage obviously spikes to show the content of the window. After the window is closed, the memory stays allocated and never seems to go back down to it's memory usage when it was just sitting in the taskbar. I have the window set to dispose on close and have fiddled around with adding finalize() and dispose() statements in a couple of different places. I also don't call anything from this class in any of my other classes.
Here is my Window.class, where I'm hoping the problem is. Thanks.
package mainFiles;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;
// The part of the program that displays the main window of the widget
public class Window extends JFrame implements ActionListener, WindowListener {
     private static final long serialVersionUID = 1L;
     // Declare the global variables used in the method
     private JButton updateButton;
     // The default constructor of the window
     public Window() {
          // Create the container for holding the content of the widget
          JFrame mainWindow = new JFrame();
          mainWindow.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
          this.centerWindow(mainWindow, 475, 350);
          mainWindow.addWindowListener(this);
          // Customize the look of the JFrame a little bit
          mainWindow.setIconImage(new ImageIcon("system/images/tray_inactive.gif").getImage());
          mainWindow.setTitle("Widget Text");
          mainWindow.setResizable(false);
          // Create the home panel of the widget
          WindowBackground homePanel = new WindowBackground();
          mainWindow.setContentPane(homePanel);
          homePanel.setLayout(new BoxLayout(homePanel, BoxLayout.X_AXIS));
          // Create the left side of the window
          JPanel leftPanel = new JPanel();
          leftPanel.setOpaque(false);
          leftPanel.setPreferredSize(new Dimension(104,324));
          homePanel.add(leftPanel);
          // Add a spacer to the left panel from the top
          leftPanel.add(Box.createRigidArea(new Dimension(104,16)));
          // Add the update button to the left side of the widget
          updateButton = new JButton("Refresh");
          updateButton.addActionListener(this);
          leftPanel.add(updateButton);
          // Create the right side of the window
          JPanel rightPanel = new JPanel();
          rightPanel.setOpaque(false);
          rightPanel.setPreferredSize(new Dimension(365,324));
          homePanel.add(rightPanel);
          // Add a spacer to the right panel from the top
          rightPanel.add(Box.createRigidArea(new Dimension(365,16)));
          // Create the scrollpane which allows the news to be scrolled up and down
          JScrollPane contentScrollPane = new JScrollPane(Content.mainPanel, JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
                    JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
          contentScrollPane.getViewport().setOpaque(false);
          contentScrollPane.setOpaque(false);
          contentScrollPane.setEnabled(true);
          // Set the size of the scrollpane, then add it to the right panel
          contentScrollPane.setPreferredSize(new Dimension(356,290));
          rightPanel.add(contentScrollPane);
          // Create an empty border around the scrollpane to remove the border
          Border empty = new EmptyBorder(0,0,0,0);
          contentScrollPane.setBorder(empty);
          contentScrollPane.setViewportBorder(empty);
          // Whenever the window is opened, update the tray icon to inactive
          Widget.updateIconToInactive();
          // Show the window to the user
          mainWindow.setVisible(true);
     // If the main window of the widget is closed, then give the user the ability to make a new one
     public void windowClosing(WindowEvent event) {
          // Set the window to no longer being active
          Widget.windowActive = false;
          // *** This doesn't seem to work
          this.removeAll();
          System.gc();
     // For centering the window on the user's desktop
     public void centerWindow(JFrame window, int width, int height) {
          // Set the size of the window to the size wanted
          window.setSize(width, height);
          // Get the two sizes and compute the average size between them
          Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
          Dimension windowSize = window.getSize();
          int x = (screenSize.width / 2) - (windowSize.width / 2);
          int y = (screenSize.height / 2) - (windowSize.height / 2);
          // Set the location to the center of the screen
          window.setLocation(x, y);
     // Whenever a new WindowBackground is created, paint the background image on it
     public class WindowBackground extends JPanel {
          private static final long serialVersionUID = 1L;
          // Paint the background on the panel
          public void paintComponent(Graphics g) {
               ImageIcon background = new ImageIcon("system/images/bg_window.gif");
               background.paintIcon(this, g, 0, 0);
     // For responding to actions performed in the interface
     public void actionPerformed(ActionEvent event) {
          // If the user pushes the manual update button, then check for new updates
          if (event.getSource() == updateButton)
               Content.check();
     // Although these aren't used, they must be included in the class
     public void windowActivated(WindowEvent arg0) {}
     public void windowClosed(WindowEvent arg0) {}
     public void windowDeactivated(WindowEvent arg0) {}
     public void windowDeiconified(WindowEvent arg0) {}
     public void windowIconified(WindowEvent arg0) {}
     public void windowOpened(WindowEvent arg0) {}
}

Answer 1

I'll try to describe it in some more detail:
When the program first starts up, memory usage is around 9K to 11K, since the only task it has is to check an external file every five minutes to see if it's been updated. If there is an update, then the icon blinks which alerts the user that there is an update available. When they click on the icon, a window pops up displaying the news. Memory usage at this points run up to about 25K. Now this is where the problem comes in. After the window is closed, it should be disposed. Now, from what I understand, that means that the Garbage Collector should destroy it at some point and release the memory that's being used. However, many hours after the window has been closed, the memory usage is still at 25K. I just don't understand why it isn't using 9K-11K at that point.
The main reason I care so much about memory usage is because this is a program that is going to be running in the background while users play PC games. It's mainly to get in touch with each other and tell each other when an event is happening in a specific game.