Develop Reference

How to enter values in arraylist without asking the size of the array?

I want to give input 4,5,6 to the arraylist then next time i want to enter 83,2,4,5 without asking the size of the array from the user,using the scanner class.The input would be given at the run time.How could it be done with the help of arraylist.Is there any other way to do it?

this may help:
Java ArrayList class uses a dynamic array for storing the elements. It inherits AbstractList class and implements List interface.
The important points about Java ArrayList class are:
Java ArrayList class can contain duplicate elements.
Java ArrayList class maintains insertion order.
Java ArrayList class is non synchronized.
Java ArrayList allows random access because array works at the index basis.
In Java ArrayList class, manipulation is slow because a lot of shifting needs to be occurred if any element is removed from the array list.
Each ArrayList instance has a capacity. The capacity is the size of the array used to store the elements in the list. It is always at least as large as the list size. As elements are added to an ArrayList, its capacity grows automatically. The details of the growth policy are not specified beyond the fact that adding an element has constant amortized time cost.
An application can increase the capacity of an ArrayList instance before adding a large number of elements using the ensureCapacity operation. This may reduce the amount of incremental reallocation.

Basic exsample:
ArrayList<Integer> collection=new ArrayList<Integer>();
collection.add(83);
collection.add(2);
collection.add(4);
collection.add(5);
OR dynamically
boolean endContition=false;
while (!endContition){
int element= readElement(); /*retrive element to add in some way*/
collection.add(element);
updateEndContition(); /*if someting happens swich endcondition*/
}
but pls try to be more specific when u ask!

Consider the following:
When the user is entering his input line, create a new ArrayList()
Lets say List list = new ArrayList();
Now, for each item in the input call list.add(/* user input here */);

About declaring a new List in Java

Let's suppose I want to declare a List of AbstractClass, and each of its elements must be mixed children of AbstractClass, called SubClass1 and SubClass2 (which are not abstract, by the way). But I also want it of a specific size.
So I declare
List <AbstractClass> list = new ArrayList <AbstractClass> (SIZE);
If I add elements the to list using
list.add(new SubClass1());
list.add(new SubClass2());
are they going to be added at the end of the array or starting from index=0?
In the first case, do I have to manually add elements with a loop, like this?
List <AbstractClass> list = new ArrayList <AbstractClass> (); //I've removed size
for(int i=0;i<SIZE;i++){
list.add(new SubClass1());
list.add(new SubClass2());
}

are they going to be added at the end of the array or starting from index=0?
Both. The SIZE argument to the ArrayList constructor determines its initial capacity, not its initial length. Once this ArrayList is constructed, it has a capacity of SIZE but a size of 0. The first element added will be index 0, the second will be index 1, and so on.
If you don't supply an initial capacity, there will a default initial capacity.
In the first case, do I have to manually add elements with a loop, like this?
No method calls in general have to be in any loop.

new ArrayList(SIZE) will not limit your list to SIZE element, but will just initialize its inner array responsible for storing elements to length equal to SIZE. But it doesn't mean that later this list will not be able to store more than SIZE elements, because it still can later create new larger array with old elements and use it internally.
In other words returned list is still resizeable. It is also empty at start (its size() is 0) so there is no reason for add to start adding elements on other indexes than 0.

The List interface is not intended for fixed size arrays: as answered here already. You can set an initial size however.
About adding: from the official Java 7 List docs:
The user of this interface has precise control over where in the list
each element is inserted.
add(E e) –
Appends the specified element to the end of this list.
add(int index, E element) –
Inserts the specified element at the specified index in this
list.
You can add multiple elements with addAll.

How does Java implement "growable array" internally? [duplicate]

What data structure does an ArrayList use internally?

Internally an ArrayList uses an Object[].
As you add items to an ArrayList, the list checks to see if the backing array has room left. If there is room, the new item is just added at the next empty space. If there is not room, a new, larger, array is created, and the old array is copied into the new one.
Now, there is more room left, and the new element is added in the next empty space.
Since people really like the source code:
/**
* The array buffer into which the elements of the ArrayList are stored.
* The capacity of the ArrayList is the length of this array buffer.
*/
private transient Object[] elementData;
Straight out of the JDK.

It uses an Object[], and makes a bigger array when the array gets full.
You can read the source code here.

ArrayList uses an Array of Object to store the data internally.
When you initialize an ArrayList, an array of size 10 (default capacity) is created and an element added to the ArrayList is actually added to this array. 10 is the default size and it can be passed as a parameter while initializing the ArrayList.
When adding a new element, if the array is full, then a new array of 50% more the initial size is created and the last array is copied to this new array so that now there are empty spaces for the new element to be added.
Since the underlying data-structure used is an array, it is fairly easy to add a new element to the ArrayList as it is added to the end of the list. When an element is to be added anywhere else, say the beginning, then all the elements shall have to move one position to the right to create an empty space at the beginning for the new element to be added. This process is time-consuming (linear-time). But the Advantage of ArrayList is that retrieving an element at any position is very fast (constant-time), as underlying it is simply using an array of objects.

ArrayList has the basic data structure:
private transient Object[] elementData;
When we actually create an ArrayList the following piece of code is executed:
this.elementData = new Object[initial capacity];
ArrayList can be created in the two ways mentioned below:
List list = new ArrayList();
The default constructor is invoked and will internally create an array of Object with default size 10.
List list = new ArrayList(5);
When we create an ArrayList in this way, constructor with an integer argument is invoked and
create an array of Object with default size 5.
Inside the add method there is check whether the current size of filled elements is greater/equal to the maximum size of the
ArrayList then it will create new ArrayList with the size new arraylist = (current arraylist*3/2)+1 and copy the data from old to
new array list.

It uses an array, and a couple of integers to indicate the first value - last value index
private transient int firstIndex;
private transient int lastIndex;
private transient E[] array;
Here's an example implementation.

Typically, structures like ArrayLists are implemented by a good old fashioned array defined within the class and not directly accessible outside the class.
A certain amount of space is initially allocated for the list, and when you add an element that exceeds the size of the array, the array will be reinitialized with a new capacity (which is typically some multiple of the current size, so the framework isn't constantly re-allocating arrays with each new entry added).

The Java platform source code is freely available. Here's an extract:
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
/**
* The array buffer into which the elements of the ArrayList are stored.
* The capacity of the ArrayList is the length of this array buffer.
*/
private transient E[] elementData;
.
.
.
}

ArrayLists use arrays to hold the data. Once the number of elements exceeds the allocated array it copies the data to another array, probably double the size.
A (minor) performance hit is taken when copying the array, it's therefore possible to set the size of the internal array in the constructor of the array list.
Furthermore it implements java.util.Collection and and java.util.list, and it's is therefore possible to get the element at a specified index, and iterable (just like an array).

It uses an Object[]. When the array is full it creates a new array which is 50% bigger in size and copies current elements to new array. It happens automatically.

as i understand is that
ArrayList class implements List interface and
(as interface only extends other interface)
List interface extends Collection interface.
while talking about arraylist when we initialize in memory it reserve by default space 10 > and create array of Integer which you normally use. when this this array is full then the another array of interger is created which is greater then default size.
List<Integer> list = new ArrayList<>();
now in memory as => Integer[] list = new Integer[10];
now suppose that you enter 1,2,3,4,5,6,7,8,9,10 array is full now and what happen when you enter 11 in the memory another array of Integer is created which is greater then by default and all element in old array is copied in new array. Internally arraylist user Object[] array.
thats how arrayList work

Basic Data Structure which is used in an ArrayList is –
private transient Object[] elementData;
So, going by declaration it’s an array of Object.
When we actually create an arrayList following piece of code is executed –
this.elementData=new Object[initial capacity];
When we create an ArrayList, default constructor is invoked and will internally create an array of Object with default size, which is 10. Now, As we all know that unlike normal arrays, the size of the ArrayList grows dynamically. But how its size grows internally?
So what happens internally is a new Array is created with size 1.5 x currentSize and the data from old Array is copied into this new Array. Every time when it reaches ArrayList at maximum capacity then copy and destroy previous array make new array with new capacity (1.5 x old capacity).
For more details your can read my blog here.

Instantiating an ArrayList of ArrayLists

I want to instantiate an ArrayList of ArrayLists (of a generic type). I have this code:
private ArrayList<ArrayList<GameObject>> toDoFlags;
toDoFlags = new ArrayList<ArrayList<GameObject>>(2);
Am I doing this right? It compiles, but when I look at the ArrayList, it has a size of 0.

You're doing it right. The reason it has zero length is because you haven't added anything to it yet.
The "2" you pass is the initial capacity of the array that backs the ArrayList. But the size() method of the ArrayList doesn't return the initial capacity of its backing array... it returns the number of actual elements in the list.
Customarily, you shouldn't be using the initialCapacity parameter. It's a performance optimization when you have large ArrayLists. By allocating a lot of space explicitly, you save the time it would take to re-allocate as you add more and more items to the list. But in this case you probably don't have an extremely large list.
Also, instead of using an ArrayList of ArrayLists, you should consider writing a class to store your data.

ArrayLists expand as you add to them. The integer capacity argument just sets the initial size of the backing array. Setting the capacity to two doesn't mean that there are two elements in the ArrayList, but rather that two elements can be added to the ArrayList before it has to declare a larger internal array.

Adding a element of Generic type <T> to an arrayList of LinkedList's

I want to make a hash table class in java where I store the key,value pairs in an ArrayList of Linked List's. I do this by declaring
ArrayList<LinkedList<T>> storage = new ArrayList();
I then want to create a linkList object that I can use to then create a new linked list inside of each index of the arrayList. I do this by declaring:
LinkedList<T> list = new LinkedList<T>();
Then I have my add function set up to add elements to the first index of the LinkedList that is inside the Hashed key index of the arrayList as such:
public void add(K key, T value){
int arrayListIndex = (key.hashCode()) % this.initialCapacity;
System.out.println(arrayListIndex); //This tells us where we access the Array List;
if (hashBrown.get(arrayListIndex) == null){
hashBrown.add(arrayListIndex, list);
hashBrown.get(arrayListIndex).addFirst(value);
}
}
Everytime I run this code I receive an error where my index is 7 and my size is 0. This causes an error:
Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 7, Size: 0
at java.util.ArrayList.rangeCheck(ArrayList.java:571)
at java.util.ArrayList.get(ArrayList.java:349)
at FastHashtable.add(FastHashtable.java:72)
at FastHashtable.main(FastHashtable.java:145)
I am unable to track down where this index out of bounds error is coming from can anyone offer advice. I am fairly new at working with ArrayLists which makes me think my original declaration of the arrayList is incorrect.

You are confusing an ArrayLists capacity with its size. From the Oracle Java documentation:
Each ArrayList instance has a capacity. The capacity is the size of the array used to store the elements in the list. It is always at least as large as the list size. As elements are added to an ArrayList, its capacity grows automatically. The details of the growth policy are not specified beyond the fact that adding an element has constant amortized time cost.
Instead, you should be looking at creating a plain array (e.g. Object[] a = new Object[maxSize]) in which you can actually assign objects (linked lists in this case) at arbitrary index values. If you only want to store linked lists, create a LinkedList<T>[] array.

You cannot add to a list at index 7 if there are 0 elements in it. You can only add at the end (with the add method without index) or at a position that is no larger than the current list's size().
When the list is empty and you add something at index 7, what do you expect the list to contain at the first position then, and what at index 6? (I once created a subclass of list to fill everything up to the index with null when the addition index is larger than the list size, but this behaviour is not universal enough to be part of List's semantics.
[edit in response to comment here and to praseodym's answer]
You could simply fill the (array) list with nulls replace those with a linked list when the respective position is first accessed. (Be sure to use set and not add, though, which is probably what you want above as well.)
Alternatively, you could create an array of the desired size (that will be full of nulls by default) and "wrap" it into a (non-resizable) list via Arrays.asList. You have to ignore an "unchecked conversion" warning then, however (not that you could avoid warnings when using an array). Also, I suggest you read "Program to an interface, not an implementation".