passing a Factory to a method to create a generic instance

The two nearly identical methods, loadGuests and loadRooms, I would like 
to consolidate by passing in a Factory.  However, I haven't found much 
do***entation on what that looks like.

Guest and Room implement Factory, but that's just part of the picture.

public Guest new() {return new Guest());}    //in Guest.java
public Room new() {return new Room());}      //in Room.java

Is the idea to make a single method, outside of Room and Guest, which 
returns an instance of, well, type <T>?

But, how?  I understand that one approach is to pass a Factory to 
FileUtils.load(), which is fine, but how is that Factory instance first 
created?  Where's it created, in the driver which invokes FileUtils.load
()?

Here's what I have, it's just the top method which I'm working on right 
now:

thufir@[EMAIL PROTECTED]
 
thufir@[EMAIL PROTECTED]
 
thufir@[EMAIL PROTECTED]
 cat src/a00720398/interfaces/
Factory.java

package a00720398.interfaces;


public interface Factory <T>{
        T make();
}
thufir@[EMAIL PROTECTED]
 
thufir@[EMAIL PROTECTED]
 cat src/a00720398/util/
FileUtil.java
/**
 * FileUtil.java
 */

package a00720398.util;

im****t java.util.*;
im****t java.io.*;
im****t a00720398.data.*;
im****t a00720398.interfaces.*;


public abstract class FileUtil {

        public static <E> List<E> load(File file) {
                List<E> foos = new ArrayList<E>();
                List<String> lines = getLines(file);
                for(String line : lines){
        //              <E> foo = new <E>();  //how do I pass in a 
		//				      //factory to return an "E"?
                }
                return new ArrayList<E>();
        }

        /*
        a00720398/util/FileUtil.java:31: cannot find symbol
        symbol  : class T
        location: class a00720398.util.FileUtil
                public static void factoryTest(Factory<T> factory) {}
                                                       ^
        1 error */
        public static void factoryTest(Factory<T> factory) {} //

/**

interface Factory<T> { T make();}
public <T> Collection<T> select(Factory<T> factory, String statement) {
     Collection<T> result = new ArrayList<T>();
     /* run sql query using jdbc 
     for (/* iterate over jdbc results  ) {
        T item = factory.make();
        /* use reflection and set all of item’s fields from sql results 
        result.add(item);
     }
     return result;
}
You can call this either as
select(new Factory<EmpInfo>(){ public EmpInfo make() {
                                        return new EmpInfo();
                                 }}
    , ”selection string”);


        public static <T> factory<T>(T type) {
                return new List<T>(type);
        }



        @[EMAIL PROTECTED]
 http://www.ibm.com/developerworks/java/library/j-
djc02113.html

        Utilities.make(Integer(0))  //called from driver
        <T extends Object> public static <T> factory (T first) {
                return ew List<T>(first);
        }


class Utilities {
   <T extends Object> public static List<T> make(T first) {
     return new List<T>(first);
   }
}

*/

        //this method is a repaid of loadGuests
        public static List<Room> loadRooms(File file) {
                List<Room> rooms = new ArrayList<Room>();
                List<String> lines = getLines(file);

                for (String line : lines) {
                        List<String> tokens = getTokens(line);
                        Room room = new Room();
                        System.out.println(rooms);
                }

                return rooms;
        }

        public static List<Guest> loadGuests(File file) {
                List<Guest> guests = new ArrayList<Guest>();
                List<String> lines = getLines(file);

                for (String line : lines) {
                        List<String> tokens = getTokens(line);
                        Guest guest = new Guest(tokens);
                        System.out.println(guest);
                }
                return guests;
        }

        private static List<String> getTokens (String string){
                List<String> tokens = new ArrayList<String>();
                Scanner lineScanner = new Scanner(string);
                while (lineScanner.hasNext()){
                        String token = lineScanner.next();
                        tokens.add(token);
                }
                return tokens;
        }

        private static Guest newGuest(String string) {
                List<String> guestData = getTokens(string);
                Guest guest = new Guest(guestData);
                return guest;
        }

        private static List<String> getLines(File file) {
                List<String> lines = new ArrayList<String>();
                try {
                        Scanner scanner = new Scanner(file);
                        while (scanner.hasNextLine()) {
                                String line = scanner.nextLine();
                                Scanner lineScanner = new Scanner(line);
                                lineScanner.useDelimiter("\n");
                                while (lineScanner.hasNextLine()) {
                                        String oneLine = lineScanner.next
();
                                        lines.add(oneLine);
                                }
                        }
                } catch (FileNotFoundException e) {
                        e.printStackTrace();
                }
                return lines;
        }
}
thufir@[EMAIL PROTECTED]
 




thanks,

Thufir