How to add int to ArrayList over different functions

Question

How do you make this work? it says cannot find vaiable AL in function addint. how do I add int to Arraylist over different functions?

/**
 * Constructor
 */
public Player()
{
    ArrayList<int> AL = new ArrayList();
}

public void addint(int C){
    AL.add(C);
}

Answer 1

You declared the variable AL inside the constructor (a local variable) and it is out of scope in the addInt method.

Declare AL outside of the constructor, but within the class. Also, use Integer, not the primitive type int for the generic type parameter. (Primitive types are not allowed as generic type parameters.)

public class Player
{
    // Declare it here.
    private ArrayList<Integer> AL;

    public Player()
    {
        // Initialize it here.
        AL = new ArrayList<Integer>();
    }
    // Now you can access `AL` in your methods.
    public void addint(int C){
        AL.add(C);
    }
}

Answer 2

You should define the ArrayList<Integer> AL (not ArrayList<int>, you can't use primitive types in generics) as field of your class, you're currently defining it as parameter in your class constructor. Also, remember to always program to interfaces, not to class implementations, so declare the variable as List<Integer> instead.

public class Player {
    private List<Integer> AL;
    public Player() {
        AL = new ArrayList<Integer>();
    }
    public void addint(int C){
        AL.add(C);
    }
}

More info:

• What does it mean to "program to an interface"?
• Why can Java Collections not directly store Primitives types?

Answer 3

The simplest way is:

public class Player {
    private final List<Integer> al = new ArrayList<Integer>();

    public void addint(int c){
        al.add(c);
    }
}

• The variable must be reachable.
• You don't need a constructor for this case, but you can if you want to.
• We usually tend to referernce the interface List as it makes it easier to change the implementation later (check Joshua Bloch book)
• You can't use primitive types as generics, but you can add a primitive to the list thanks to autoboxing.
• You can use new ArrayList<>(); since Java7.
• You should rather follow Java variable naming conventions. Uppercase generally means constants.

Answer 4

You need to specify a field, and use <Integer> rather than <int>:

/**
 * Constructor
 */
ArrayList<Integer> AL;
public Player()
{
    this.AL = new ArrayList<Integer>();
}

public void addint(int C){
    this.AL.add(C);
}

Answer 5

In java you cannot use primitives like int in generics. You have to use Integer which is a wrapper class for int

ArrayList<Integer> AL = new ArrayList<Integer>();  

Also it seems that AL should be a member variable if you want it to work correctly not declared inside the constructor. I think this is what you want:

public class Player {
    private List<Integer> AL;
    public Player() {
        AL = new ArrayList<Integer>();
    }
    public void addint(int C){
        AL.add(C);
    }
}

Answer 6

1. You need to use the Wrapper class Integer instead of int while defining that ArrayList.

   ArrayList<Integer> AL = new ArrayList<Integer>();
   

2. Make the ArrayList<Integer> AL an instance variable . Currently it is a local variable.