我该如何解决泛型实例化问题？

Question

I am making a CSV parser for 3 files (like "city_id";"country_id";"region_id";"name") and I am faced with a generic instantiation problem. Is there any way how can I solve it and stick to DRY? ( I saw that an answer may be to take a T in the constructor but I don`t see how I can use it properly in my situation).

public static <T> List<T> csvParcer(String filePath) {
    List<T> cities = new ArrayList<>();
    String line;
    String[] dividedLine;
    try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
        reader.readLine();
        while ((line = reader.readLine()) != null) {
            dividedLine = line.replace("\"", "").replace(";", " ").split(" ");
            cities.add(new T(dividedLine[0], dividedLine[1], dividedLine[2], dividedLine[3]));
        }
        return cities;
    } catch (IOException ex) {
    }
    return null;
}

Answer 1

Here's the DRYest version I can come up with, using Java 8.

public static <T> List<T> parseCsvFile(String filePath, Function<String[], T> mapper) {
    return Files.lines(new File(filePath).toPath())
                .map(s -> s.replace("\"", "").split(";"))
                .map(mapper)
                .collect(Collectors.toList());
}

Use like so.

List<Foo> foos = parseCsvFile("foos.csv", columns -> {
    return new Foo(columns[0], columns[1], columns[2], columns[3]);
});

Answer 2

Why it doesn't work

The thing that doesn't work in Java is the new T(...) instantiation of a generically-given class. You can only use the new keyword with a specific class name.

At run time, your csvParcer() method doesn't even know which class was used for T , for the JVM, T will be replaced by Object . So there's no way for your method to know which class to instantiate. You need to pass something into your method that allows you to instantiate the class you want for that given situation.

Solution with reflection

One approach is to add a parameter to your method naming the class you want to instantiate:

public static <T> List<T> csvParcer(String filePath, Class<T> tClazz) {
    List<T> cities = new ArrayList<>();
    String line;
    String[] dividedLine;
    try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
        reader.readLine();
        while ((line = reader.readLine()) != null) {
            dividedLine = line.replace("\"", "").replace(";", " ").split(" ");

            Constructor<T> myConstructor = tClazz.getConstructor(String.class, String.class, String.class);
            T object = myConstructor.newInstance(dividedLine[0], dividedLine[1], dividedLine[2], dividedLine[3]);

            cities.add(object);
        }
        return cities;
    } catch (Exception ex) {
        throw new RuntimeException("Error reading " + filePath, ex);
    }
}

[By the way, I changed the error handling to throw an exception if my method couldn't correctly read and parse the file, as that's the preferred way to tell my caller that he can't get a result.]

Disadvantage is that you waste runtime performance (not noticable compared to the reading of a CSV text file) and you don't get compile-time errors if the class you need doesn't have a public constructor that accepts exactly four strings.

Solution with factory objects

That's the approach that Leo already proposed, you pass in an object that encapsulates the instance creation - a "factory" object, and you need one for every different T class that you want to get from your CVS reader. Leo rewrote your example using the elegant Java-8 streams coding style, but it's also possible in the classic style, closer to your original idea. First we need an interface for the factory:

public interface TFactory<T> {
    T create(String arg0, String arg1, String arg2, String arg3);
}

The parser method looks like:

public static <T> List<T> csvParcer(String filePath, TFactory<T> factory) {
    List<T> cities = new ArrayList<>();
    String line;
    String[] dividedLine;
    try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
        reader.readLine();
        while ((line = reader.readLine()) != null) {
            dividedLine = line.replace("\"", "").replace(";", " ").split(" ");

            T object = factory.create(dividedLine[0], dividedLine[1], dividedLine[2], dividedLine[3]);

            cities.add(object);
        }
        return cities;
    } catch (Exception ex) {
        throw new RuntimeException("Error reading " + filePath, ex);
    }
}

And you use it like this example:

private void example() {
    TFactory<City> cityFactory = new TFactory<City>() {
        @Override
        public City create(String arg0, String arg1, String arg2, String arg3) {
            return new City(arg0, arg1, arg2, arg3);
        }
    };
    List<City> cities = csvParcer("C:\\temp\\cities.csv", cityFactory);
} 

Having four explicit String arguments makes the code more verbose than using a String[] array, but gives you additional compile-time safety.