Relationship between objects and information stored in a database

Question

I've got a question that's pretty broad... but maybe someone can help with it.
I'm writing a couple of classes, one called "Customer" and the other "Store". Store can contain any number of customers, which it keeps in an array. A customer object has name and address fields, as well as an array of the current movies the customer has checked out. A third "Driver" class has the main method which calls the other two classes. When a new customer is created, it is put into the array in an object of store, and written to disk in a file named with the customer's ID number.
My question is, I'm not really sure how objects tie in with the actual database on the hard disk. For example, if I run the program once and add 3 customers, all three get written to disk, and exist in memory as objects. However, when I exit the program, I lose all 3 of those objects from the array of customers in the store object.
So, when I run the program a second time, the array is gone, though the customer information remains on disk. I have methods to delete/add customer objects to an object of store, but those don't do me any good without the array in memory. I thought that I could just load all data from disk, and put them back into the array, but isn't that inefficient if the database is very large? Is there a better way to deal with this?
I hope that was reasonably clear. I'd appreciate any help. Thanks.

Answer 1

i would make the store a manager of the customer objects whose
responsibilities include read and writing the objects as well as caching
them.
here is some sample code for this.
public class Customer(){
  int id;
  /* the id field is the unique identifier for each Customer.
     this field should probably be our primary key in our database
     table. you don't have to use a number but whatever it is it
     needs to be unique */      
  boolean updated;
  public Customer(int customerId){
    id = customerId;
    updated = false;
  public int getCustomerId(){
    return id;
  /* if the customer object has been changed and needs to flushed back
     to the database this returns true. */
  public boolean needsFlushing(){
    return updated;
  /* and your other methods go here... */
}and now for the Store...
public class Store{
  private Customer[] cache;
  public Store(){
    cache = new Customer[10];
    /* here i have hard coded as 10, you could change this or for more
       flexibility use a Vector or such. */
  /* spin through the cache and return the matching customer. if the
     customer is not in the cache load it in the database. */
  public Customer getCustomer(int customerId)throws SQLException{
    for(int j=0;j<cache.length;j++){
      if((cache[j]!=null)&&(cache[j].getCustomerId()==customerId)){
        return cache[j];
    Customer c = loadCustomer(customerId);
    addToCache(c);
    return c;
  public void addCustomer(Customer c)throws SQLException{
    /* adds a new (non-existing customer) */
    saveCustomer(c);
    addToCache(c);
  public void close()throws SQLException{
    /* flushes back any updated customers */
    for(int j=0;j<cache.length;j++){
      if((cache[j]!=null)&&(cache[j].needsFlushing())){
        saveCustomer(cache[j]);
    cache = null;   
  private Customer loadCustomer(int customerId)throws SQLException{
    /* here would be code for loading a customer object from the
       database that matches the customerId. */
    return new Customer(customerId);//temporary 
  private void saveCustomer(Customer c)throws SQLException{
    /* here would be the code for saving the customer c into the
       database */
  private void addToCache(Customer c){
    /* this method adds the customer c to the cache. it may have to
       to remove an older customer from the cache to do this. i leave
       the algorithm for deciding this up to you */