We Keep Coding

Why we can't add element into a List to nth index before adding element to (n-1)th index even if initial capacity is provided

Suppose I declare an array of int with size 10, I can add an element to its 4th index, I can run the code without any exception.
int[] ar = new int[10];
ar[4] = 8;
System.out.println(Arrays.toString(ar)); //works fine
That's because when I say size as 10, that much memory space will be allocated for that array with initial value of its type kept in each index.
But the case is not same in List. Say I declare a list with an initial capacity of 10 and I try to add an element to its 4th index it gives
java.lang.IndexOutOfBoundsException: Index: 4, Size: 0
List<Integer> list = new ArrayList<Integer>(10);
list.add(4, 8); //exception
Of course the size of the list will return 0 even if initial capacity is given. Why is it not like Array, I think no memory is allocated for 10 elements for the list?
I was guessing that is there any way to fill List with default values once a capacity is given just like an array.

This is what the JavaDoc for ArrayList says about add(int index, E element):
throws IndexOutOfBoundsException - if the index is out of range (index < 0 || index > size())
The size is the number of elements currently stored, not the current capacity.
The fact that your car has the "capacity" to drive with 100 mph, that doesn't mean that you can magically get from 0 to 90 mph within 1 second ;-)
In other words: the answer is that size and capacity aren't the same. Capacity merely means: "that is the size this list can grow to before the underlying array needs to grow".

By now it should be clear that the initial capacity on the constructor is just a bit of memory management for the initial internal array. Without any semantical meaning.
When the actual size() overflows the array, the array is reallocated.
There is no such thing as a bulk allocation with initial elements. However there is:
List<Integer> list = Collections.nCopies(10, Integer.valueOf(0));
And the new Stream offers ways to dynamically generate lists.
You could do:
public <T> void add(List<T> list, int i, T obj) {
while (list.size() < i) {
list.add(null);
}
list.add(i, obj);
}
But it is immediately evident, that you'll introduce nulls which is unsafe and ugly,
requiring null checks.

As others have mentioned in their answers, in List<Integer> list = new ArrayList<Integer>(10), the 10 specifies the initial capacity.
Specifying the initial capacity is only an optional thing. You exercise that option only when you use the particular constructor that accepts an initial capacity as an argument. When you use other constructors, you don't have control over the initial capacity.
You specify n as the initial capacity if you want the first n additions to the list to be as efficient as possible -- otherwise, there is a possibility that the addition of each individual item to the list results in some costly internal re-sizing and re-copying into the re-sized internal area.
The above does not answer the question of why you are not allowed to add an item at position 8, when there is no item at position 7.
As some have answered, that's because the API doc says so.
That's one way to answer it. But why does the API doc say so? Why are things designed so?
Things are designed so, because:
Adding an item at position 8, when there is no item at position 7, results in a gap (before position 8).
As a programmer, you will then have to keep track of what an item's position is, among all possible positions (the full capacity). Currently, as a programmer, you only keep track of what the item's position is, among all added items. Now, wouldn't that be a programming nightmare?

ArrayList out of [duplicate]

I get a lot of IndexOutOfBoundsException from the any Arraylist I use. Most of the times it works fine but sometimes I get this annoying error on Arraylists i use on my project.
The main cause is always either
java.util.ArrayList.throwIndexOutOfBoundsException: Invalid index 3, size is 3
or
java.util.ArrayList.throwIndexOutOfBoundsException: Invalid index 0, size is 0
Help me understand the main cause of this error as no matter how many answers I've searched they don't completely help me.

java.util.ArrayList.throwIndexOutOfBoundsException: Invalid index 3,
size is 3
It means you have ArrayList which having 3 elements where you can get each element like 0,1,2 positions. And you are trying to read 4th element which does not exists into ArrayList.
java.util.ArrayList.throwIndexOutOfBoundsException: Invalid index 0,
size is 0
It means you have a empty ArrayList, and you are trying to read 1st element.
ArrayIndexOutOfBoundsException - Examples
An array-index out of bounds exception is a Java exception thrown due to the fact that the program is trying to access an
element at a position that is outside an array limit, hence the words "Out of bounds". In other words, the program is trying to
access an element at an index that is outside the array bounds. To understand array bounds, let us consider the following diagram:
The picture above contains an array that consists of 7 elements. Each element in the array has its own index/position. In Java, an index always starts with
0 and ends with the length of the array -1. For example, the array above consists of 7 elements, therefore it's indices start from 0 and end with 6 (7-1). Attempting
to access an element with an index less than 0 or more than 6 will cause Java to throw an ArrayIndexOutOfBoundsException.
Read more about ArrayIndexOutOfBoundsException - Examples, Causes & Fixes

When your ArrayList size is 3, you can access the items at position 0 1 and 2.
If you try to access the item at position 3, it will throw an IndexOutOfBoundsException.
So when you iterate through Arraylist, your for loop should be like this
for(int i=0; i< list.size(); i++){
Object data = list.get(i);
}
Your condition must be i< list.size()

It is as simple as it gets.
java.util.ArrayList.throwIndexOutOfBoundsException: Invalid index 3,
size is 3
It says size is 3 and the index you are asking for is also 3. Array list start with 0 so the maximum index will be 2 if the size is 3.

java.util.ArrayList.throwIndexOutOfBoundsException: Invalid index 3, size is 3
this means your arraylist size = 3, but you want to access index = 3 in arraylist.
You need to know the index start at 0 in arraylist so that if your arraylist size = 3 that means you can access index from 0 to 2 like this
arraylist.get(0)
arraylist.get(1)
arraylist.get(2)

Size count starts from 1,2,3.....
Index count starts from 0,1,2....
When your arry list size is 1. you get value using 0 index. if u send index value 1. its throw exception.

Populate an array with unlimited index - Java

Is there a way to populate an array with unlimited indexes in java? I just want the program to keep appending to the array without any capacity.
I declared like this:
int arrInt[] = new int[]
But it says that it is missing dimension. So how can I do it?

Array in Java is static, ie. you have to declare its size while initializing. Hence the answer is 'no' and you are getting the correct message as you have not mentioned the dimension.

No, there isn't.
ArrayList serves that purpose (i.e. an array based list whose capacity increases over time automatically when adding elements to it).

Is there a way to populate an array with unlimited indexes in java?
NO
I just want the program to keep appending to the array without any
capacity.
Need to Use ArrayList
List<Object> arr = new ArrayList<Object>();
arr.add(obj1);
arr.add(obj2);
arr.add(obj3); .. so on
I declared like this - int arrInt[] = new int[]. But it says that it
is missing dimension.
Arrays will always complain to declare the size.

In java, arrays have a maximum number of elements equal to Integer.MAX_VALUE - 5. To get around this, try using a LinkedList which has an unimited number of elements. Since this is a list, you can modify the size whenever necessary in your code. Note that ArrayList also has a max number of elements of Integer.MAX_VALUE, so LinkedList is necessary if you truly need a list of unlimited size.
Resource: http://docs.oracle.com/javase/7/docs/api/java/util/LinkedList.html

Adding value to list initialize list size

I have below code:
Hashtable<Integer, List<Model>> map = new Hashtable<Integer, List<Model>>();
for (int i = 0; i < arraylistAssignment.size(); i++) {
List<Model> temp = null;
for (int j = 0; j < arraylistModel.size(); j++) {
if (arraylistAssignment.get(i).getId() == arraylistModel.get(j)
.getId()) {
if (temp == null)
temp = new ArrayList<Model>();// DEBUG POINT 1
temp.add(arraylistModel.get(j));
}// DEBUG POINT 2 AFTER ADD FUNCTION ABOVE
}
map.put(arraylistAssignment.get(i).getId(), temp);
}
In the above code at debug point 1 when when i hv intitilzed the temp variable , there the object size is 0 as showm below :
but as soon as i add i.e temp.add the size is 1 but objects create is 12 out of which 11 values are null as shown below ...i could not understand the reason for null values here can anyone plz exaplin ...m i initilzing wrong?

An ArrayList is a dynamic array, what means that it grows as elements are added. But it doesn't change its size "one by one". Its size grows a "reasonable" amount, so the operation of resizing the list is not repeated each time you add an element, because this would be inefficient.

The reason for null values is because that's how ArrayLists work on the inside. They start off with a blank array inside, and as you add things they resize themselves as they see fit. The reason the array is larger than the number of objects you put in is because it'd be highly inefficient to resize the array every time you added something, so instead the ArrayList implementers just made the inner array start off at a certain size and approximately double in size every time it needs to be resized. They track how many elements you put in by tracking a separate size variable.
So in other words, you're initializing things just fine. Don't worry about the internals of the ArrayList -- if you look at the internal size variable, you'll see that it is 1, just as you expect.

ArrayList is a data structure in the Collections framework which is built on top of arrays I.e. It's implementation is done with the help of arrays. Since size is to be defined in arrays, it initializes size to be 10 at first. When you add values, it becomes the 11th item.
Now you might wonder how is this dynamic and how it works, well when size is reached to its limit it creates a new array double the size, copies the old stuff and discards the prev array. Would recommend you to take a look at the implementation.
To the user, it looks like dynamic but when you look through debugger you would see nulls. Array STARTS at 0 to 10 which makes it 11 elements and your newly added item becomes 12th but for public api, it's still the first element.
Check here for complete implementation of ArrayList: link

From Java Dokumentation:
http://docs.oracle.com/javase/7/docs/api/java/util/ArrayList.html
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.
Default capacity is somehow 12 in your case, even though it should be 10.

Understand Arraylist IndexOutOfBoundsException in Android

I get a lot of IndexOutOfBoundsException from the any Arraylist I use. Most of the times it works fine but sometimes I get this annoying error on Arraylists i use on my project.
The main cause is always either
java.util.ArrayList.throwIndexOutOfBoundsException: Invalid index 3, size is 3
or
java.util.ArrayList.throwIndexOutOfBoundsException: Invalid index 0, size is 0
Help me understand the main cause of this error as no matter how many answers I've searched they don't completely help me.

java.util.ArrayList.throwIndexOutOfBoundsException: Invalid index 3,
size is 3
It means you have ArrayList which having 3 elements where you can get each element like 0,1,2 positions. And you are trying to read 4th element which does not exists into ArrayList.
java.util.ArrayList.throwIndexOutOfBoundsException: Invalid index 0,
size is 0
It means you have a empty ArrayList, and you are trying to read 1st element.
ArrayIndexOutOfBoundsException - Examples
An array-index out of bounds exception is a Java exception thrown due to the fact that the program is trying to access an
element at a position that is outside an array limit, hence the words "Out of bounds". In other words, the program is trying to
access an element at an index that is outside the array bounds. To understand array bounds, let us consider the following diagram:
The picture above contains an array that consists of 7 elements. Each element in the array has its own index/position. In Java, an index always starts with
0 and ends with the length of the array -1. For example, the array above consists of 7 elements, therefore it's indices start from 0 and end with 6 (7-1). Attempting
to access an element with an index less than 0 or more than 6 will cause Java to throw an ArrayIndexOutOfBoundsException.
Read more about ArrayIndexOutOfBoundsException - Examples, Causes & Fixes

When your ArrayList size is 3, you can access the items at position 0 1 and 2.
If you try to access the item at position 3, it will throw an IndexOutOfBoundsException.
So when you iterate through Arraylist, your for loop should be like this
for(int i=0; i< list.size(); i++){
Object data = list.get(i);
}
Your condition must be i< list.size()

It is as simple as it gets.
java.util.ArrayList.throwIndexOutOfBoundsException: Invalid index 3,
size is 3
It says size is 3 and the index you are asking for is also 3. Array list start with 0 so the maximum index will be 2 if the size is 3.

java.util.ArrayList.throwIndexOutOfBoundsException: Invalid index 3, size is 3
this means your arraylist size = 3, but you want to access index = 3 in arraylist.
You need to know the index start at 0 in arraylist so that if your arraylist size = 3 that means you can access index from 0 to 2 like this
arraylist.get(0)
arraylist.get(1)
arraylist.get(2)

Size count starts from 1,2,3.....
Index count starts from 0,1,2....
When your arry list size is 1. you get value using 0 index. if u send index value 1. its throw exception.