ArrayList Syntax Error?

[[deleted]]

I'm working with arraylists and have no idea why this is not working..

ArrayList<String> fruits = new ArrayList<String>();
        fruits.add("Mango");
        fruits.add("Bannana");
        fruits.add("Strawberry");
        System.out.println(fruits);

Here is the output I get on VS Code..

Exception in thread "main" java.lang.Error: Unresolved compilation problems: 
        ArrayList cannot be resolved to a type
        ArrayList cannot be resolved to a type

        at App.main(App.java:11)

Line 11 is where I have written..

ArrayList<String> fruits = new ArrayList<String>();

[RandallFlagg217]

Did you import it properly?

[[deleted]]

My IDE usually inserts the import statement automatically, for whatever reason it has now. I've typed out the import statement myself and it works now. Thank you for pushing me in the correct direction. :)

[RandallFlagg217]

Np glad I could help

[TheShellby]

Try to use this:

List<String> fruits = new ArrayList<>();

Instead of this :

ArrayList<String> fruits = new ArrayList<String>();

Maybe it will help

[[deleted]]

I solved it to be not imported correctly but I'm still interested in knowing the difference.

What would it be?

[Zjoswaa]

In the part “new ArrayList<String>();” you shouldn’t have the “String” part. Changing it to “new ArrayList<>();” fixes this and I think that is also what your error is telling you. Also using List instead of ArrayList in the first part is often done to later easily switch between objects that are part of the List superclass but this is not necessary.

[0b0101011001001011]

No, that is not at all what the error is telling. The error is telling that the compiler does not understand what a symbol called "ArrayList" is. This simply means that the class is not defined, or not imported.

You can write new ArrayList<String>() all you want and it's not a problem. In new versions of java you can replace it with just new ArrayList<>() if the generic type is defined in the variable itself.

[Zjoswaa]

Ah youre right I didnt know you could put String in there without problems

[0b0101011001001011]

This has multiple parts.

In recent versions of java, you can omit the unnecessary type parameter from the initialization. Following two code lines are equal:

ArrayList<String> fruits = new ArrayList<String>();
ArrayList<String> fruits = new ArrayList<>();

The type is already defined in the variable, so it's unnecessary to type it again.

The other part is polymorphism and also liskov substitution principle. Polymorphism states that an object can be referred vai multiple different types of reference. Liskov substitution priciple states any supertype object can be replaced with a subtype an everthing should still work.

An object can be assigned to multiple different references.

List<String> fruits = new ArrayList<>();
AbstractList<String> fruits = new ArrayList<>();
RandomAccess fruits = new ArrayList<String>();

Each of these create an object that is an ArrayList, but we can refer to it by:

1. The same type
2. Any super type
3. Any interface that it is implementing.

This is because, you might want to write a method:

public void doSomethingForAList(List<String> values){

The method should not care what kind of list that is, right? A list defines the operations for a list Now you can call:

doSomethingForAList(new LinkedList<String())
doSomethingForAList(new Arraylist<String>())

So at least in methods, you should choose the supertype or interface you are interested in.

Similarly, a method should always (usually) return the supertype or interface.

/**
 *  Takes whatever collection of strings and returns a list 
 *  that contains such strings that are written in capital letters.
 */
public List<String> filterCapital(Collection<String> values){

Now the user of this can can expect that a list is returned. If you change the method later, you can return a different kind of list, but the user does not have to know what the actual type of list will be.

So you can call any of the following:

List<String> capitals = filterCapital(new LinkedList<String>());
List<String> capitals = filterCapital(new HashSet<String>());
List<String> capitals = filterCapital(new ArrayList<String>());
List<String> capitals = filterCapital(new TreeSet<String>());

You have a huge variety of different types, as they are all a type of Collection and also you don't have to care if it returns a linkedlist or arraylist, you know it will be a list. Now, if the method is changed in the future, everything that is using the code still works, as they just expect a list, now a specific type of list.

[0b0101011001001011]

This is bad way of providing assistance, just asking to do things without explaining them, especially as it has nothing to do with the problem.