打印任何类型的ArrayList元素的一般方法

Question

For practicing purposes I am trying to write a general method to display the elements of an ArrayList by calling its .toString() method. Let's please assume .toString() does what I want it to do.

I came up with this solution below where my input ArrayList is of type Object :

public void printArralyList(ArrayList<Object> list){
    for(Object o:list){
        System.out.print(o.toString());
    }
    System.out.println();
}

However it would not work!

printArralyList(new ArrayList<Integer>(Arrays.asList(1,2,3,5,8,13,21)));

The compilation error I get is

    The method printArralyList(ArrayList<Object>) is not applicable
 for the arguments (ArrayList<Integer>

how can I address that?

Answer 1

An ArrayList<Integer> is not an ArrayList<Object> , even though an Integer is an Object .

You need a wildcard in your method's parameter, because you don't care what type the generic type parameter is.

public void printArralyList(ArrayList<?> list){

Incidentally, you can have your method take a List instead of an ArrayList , and there would be no need to wrap the return of Arrays.asList in an ArrayList :

public void printArralyList(List<?> list){

and

printArralyList(Arrays.asList(1,2,3,5,8,13,21));

would work.

Answer 2

You dont need Generics or wildcard. All you need is a simple method which does not specify any type for the argument so that you can pass in an ArrayList of anytime.

public void printArralyList(ArrayList list){
    for (Object o:list){
        System.out.print(o.toString());
    }
    System.out.println();
}

Answer 3

The reason for the error was explained by rgettman in https://stackoverflow.com/a/21996188/

However, if it is for practicing purposes, you should consider practicing polymorphism and programming to an interface

public static void printIterable(Iterable<?> iterable)
{
    for (Object object : iterable)
    {
        System.out.print(object);
    }
    System.out.println();
}

This can be used with an ArrayList<Integer> parameter, as well as with an LinkedHashSet<JComponent> , or anything else that implements the Iterable interface....

Answer 4

Answering your question.

The declaration ArrayList does not equal to ArrayList. Even if an Integer is delivered from Object in type hierarchy.

Important thing to remember is that when you declare Collection<String> myStrings , you tell to compiler, that to variable myString can be assigned only instances of class that are created upon String type and are Collections.

 Collection<Object> myObjects; 

 myObjects = new ArrayList<String>(); //Exception
 myObjects = new HashSet<String>(); //Exception
 myObjects = new HashSet<Object>(); //Valid
 myObjects = new ArrayList<Object>(); //Valid
 myObjects = new ArrayList<Integer>(); //Exception

To solve problems like that, java provide set of Wildcars that allow you to pass this.

There are three type of will card that support various variances .

 <? extends T> - Covariance
 <? super T>   - Contravariance
 <?>           - Invariance/

The rule about them is called PECS

As we want to consume the list elements, to remove the compilations errors you should use Covariance.

Collection<? extends Object> myObjects; 

 myObjects = new ArrayList<String>(); //Valid
 myObjects = new HashSet<String>(); //Valid
 myObjects = new HashSet<Object>(); //Valid
 myObjects = new ArrayList<Object>(); //Valid
 myObjects = new ArrayList<Integer>(); //Valid

As in Java every class is delivered from object so <? extends> <? extends> is functionally equal to <?> , and that is what rgettman has proposed as answer

The collection framework in Java is supported with generics . You should get familiar with them to fully benefit from the framework.

A different way to solve is is to benefit from generic methods like this:

public static <T> void printList<Iterable<T> iterable) {

    for(T element : iterable){
        System.out.printf("%s ",element);
    }
    System.out.println();
} 

Why static ?

The call to static method are faster and this method is not related to any class member.

What is ?

This is declaration of an generic method . It allow you to define the value for generic parameter. And Java is so keen that it can extract it by itself is most cases in version 7.

If you call the method with Iterable<String> then the value of T will be String if Iterable then `Integer'.

Why Iterable ?

The Iterable is a simple interface that allows you to use for-each look . This mean you will be able to iterate through all object that classes definition implements it.

Why printf ?

The printf function use Formatter , the benefits from it are two - In case when instance of element is assigned with null, you will not get null pointer exception that will occur if you call it o.toString() .

What is missing ?

In that implementation is still missing two things - The input validation - The proper output format that will separate the elements with a coma.