The best algorithms for manipulating random access lists (such as - * ArrayList) can produce quadratic behavior when applied to - * sequential access lists (such as LinkedList). Generic list + * {@code ArrayList}) can produce quadratic behavior when applied to + * sequential access lists (such as {@code LinkedList}). Generic list * algorithms are encouraged to check whether the given list is an - * instanceof this interface before applying an algorithm that would + * {@code instanceof} this interface before applying an algorithm that would * provide poor performance if it were applied to a sequential access list, * and to alter their behavior if necessary to guarantee acceptable * performance. * *
It is recognized that the distinction between random and sequential - * access is often fuzzy. For example, some List implementations + * access is often fuzzy. For example, some {@code List} implementations * provide asymptotically linear access times if they get huge, but constant - * access times in practice. Such a List implementation + * access times in practice. Such a {@code List} implementation * should generally implement this interface. As a rule of thumb, a - * List implementation should implement this interface if, + * {@code List} implementation should implement this interface if, * for typical instances of the class, this loop: *
* for (int i=0, n=list.size(); i < n; i++)