Seeking refactoring advice

Question

I'm trying to refactor the code in my small JSP/servlet-based application, and I'm at a standstill because I can't decide on the best of several approaches to take. I'd like to settle on a definite public API so that any further refactoring can be done as painlessly as possible, but in order to do this, I need to make a decision. Please read further if you would like to help me out, I appreciate it.
MY SITUATION:
In my application, I have a class that contains a reference to an ArrayList. Let's call it MyList. MyList is essentially a wrapper around that ArrayList, I thought this would be a good idea since I can always change to another Collection implementation if I find a good reason to (better performance, etc). Currently, MyList also contains a method called toHtml(), which generates an HTML table representing the contents of the ArrayList (actually it contains detailed info on each item in the ArrayList, but that's beside the point).
MY THOUGHTS:
At first it seemed like a good idea to have the toHtml() method in MyList, because anywhere I'm using a MyList instance, I can quickly generate an HTML representation of the list. And if I need a differently-formatted HTML representation, I can always create a new method that generates the output differently, using the same information. But then I wondered if I should refactor and create a new class, MyListHtmlDisplay. The purpose of this would be to keep all display logic out of MyList. If I need to generate an HTML representation of a MyList instance, I can just pass a MyList instance to MyListHtmlDisplay and use one of its methods to generate the display.
The reason I thought this would be a good idea was that it makes MyList a little more versatile, I can use it in a non-HTML version of my application (and it is very likely that I will be writing a Swing client to complement the JSP/servlet application I have already started). Obviously HTML display methods are extra baggage if I'm going to use the MyList class in a non-HTML application.
MY QUESTION:
If anyone can suggest which of the following make the most sense from a design standpoint -- I am not very well-schooled in OO design -- that would be great.
1. Should I create a MyListHtmlDisplay class that uses static methods? I would create a method for each kind of HTML representation of a MyList and pass the MyList as an argument to the static method. This solution does not seem very object-oriented, but sounds like a workable solution.
2. Should I create a MyListHtmlDisplay class whose constructor accepts a MyList instance as an argument? I would instantiate a MyListHtmlDisplay object in my application and pass in the MyList, then call any methods that I might need which can use the MyList to generate the HTML output.
3. Or would it be best to just leave things as they are, where MyList contains any methods necessary to display its contents? This keeps things simple, though I may end up with methods that I do not need later on if using MyList elsewhere.
Please don't limit yourself to one of the above choices if you have a better idea. Thanks in advance for your suggestions.

Answer 1

MY SITUATION:
In my application, I have a class that contains a
reference to an ArrayList. Let's call it
MyList. MyList is essentially a wrapper around
that ArrayList, I thought this would be a good idea
since I can always change to another Collection
implementation if I find a good reason to (better
performance, etc). So, why dont you just use the List interface instead of ArrayList? No need to create your own class.
1. Should I create a MyListHtmlDisplay
class that uses static methods? No. Create a MyListHtmlDisplay class that takes some formatting parameters in it's constructor and then implement a method called display(List list) or similar that does the actual formatting. This way you can easily create an interface that only contains the display(List list) method and you can have different implementing classes that displays the list in different formats.
3. Or would it be best to just leave things as
they are, where MyList contains any methods necessary
to display its contents? This keeps things simple,
though I may end up with methods that I do not need
later on if using MyList elsewhere.There is no general rule where to put methods like this. My approach is to first determine the interface I want to have towards an object. I try to keep this interface as small and clean as possible. I always create an interface, not a base class. I always access objects through this interface, not the implementation.
When I want to perform a method on an object implementing this interface, I first check if I can perform the operation using only the interface. If this is the case, I usually put the method in a separate class as this enhances the separation of concerns, simplifies the design and reduces dependencies between classes. If it can't be done using only the interface, I add a new method to the interface.
Hope this helps some!