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
documentation 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@arrakis:~/bcit-comp2611-project1$
thufir@arrakis:~/bcit-comp2611-project1$
thufir@arrakis:~/bcit-comp2611-project1$ cat src/a00720398/interfaces/
Factory.java

package a00720398.interfaces;

public interface Factory <T>{
        T make();
}
thufir@arrakis:~/bcit-comp2611-project1$
thufir@arrakis:~/bcit-comp2611-project1$ cat src/a00720398/util/
FileUtil.java
/**
 * FileUtil.java
 */

package a00720398.util;

import java.util.*;
import java.io.*;
import a00720398.data.*;
import 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 item2"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();
                                 }}
    , 2\selection string2\);

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

        @see 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@arrakis:~/bcit-comp2611-project1$

thanks,

Thufir