Refactoring List<Foo> to FooList

Question

I have a number of collections of classes which I need to refactor into new classes. I'm using Java with either Eclipse or Netbeans. Currently I create the new class FooList with a delegate List<Foo> and then follow all the places where the code fails to compile. Is there a way to do this without breaking the code (and preferably a single operation)?

EDIT I have the following type of construct:

public static List<Foo> Bar.createFooList(String s)

and List<Foo> gets used frequently elsewhere and it makes sense as a business object FooList. I have done this manually by:

public class FooList {
    private List<Foo> fooList;
    public FooList(String s) {
        createList(s);
    }
    private void createList(String s) {//...}
    public int size() {return fooList.size();}
}

FooList will also have methods beyond List. For example the present:

Bar.normalize(List<Foo> fooList);

would then become

fooList.normalize();

Where another function needs the methods of List I used the Source|Generate Delegate Methods option in Eclipse to generate those methods in FooList (as with size() above).

I can see the attraction @JonSkeet of implementing List<Foo> but I can't see how to change all my code automatically.

Answer 1

Is there any reason not to make FooList implement List<Foo>?

Answer 2

You have List<Foo> which is an expressive representation of the list of Foes. The only reason I can see for get ridding of the List<Foo> is to limit or to control some access List operations.

In case of limit - you can't inherit from List<Foo> and in general there is no good cases to inherit List except of custom List for custom algorithms creation.

As I understand Foo is some business object. ListOfFoo in this case has to remain as business object and not as List.

In case of control - do delegation as you do. Eclipse or Netbeans are your friends in this process.

But think again. List<Foo> is already a good looking peace of information. It is not the same as C++ std::list<Foo> which you have to wrap either way.

Answer 3

I just tried this out in IntelliJ, and didn't see anything that a direct refactor. But this may do it:

1. Create your FooList like so:

   public abstract class BarList implements List<Bar> {}

2. Do a global search and replace of "List<Foo>" with your "FooList".

3. Now you are off to the races.

You can now use the refactorings you have available, like (IntelliJ's) "Replace Constructor with Factory Method", etc.

Does that work?