We Keep Coding

java.util.ArrayList length and size different?

I'm getting periodic crash reports on the following line of code:
myList.get(myList.size() - 1)
Which wouldn't be that interesting if not for the stack trace:
java.lang.ArrayIndexOutOfBoundsException: length=22; index=-1
java.util.ArrayList.get ArrayList.java:439
com.myapp.ope.api.ApiManager$2.onResponse ApiManager.java:215
retrofit2.DefaultCallAdapterFactory$ExecutorCallbackCall$1.lambda$onResponse$0$DefaultCallAdapterFactory$ExecutorCallbackCall$1 DefaultCallAdapterFactory.java:89
retrofit2.-$$Lambda$DefaultCallAdapterFactory$ExecutorCallbackCall$1$hVGjmafRi6VitDIrPNdoFizVAdk.run Unknown Source:6
Which seems to imply myList has a length of 22. So how is the index calculated at -1 (which means .size() would have reported 0)?

The ArrayList in Java 8 only checks if the index is greater than its size, throwing an IndexOutOfBoundsException if so. Otherwise array[index] is used to access the desired element of the array used to store the list elements. This will throw an ArrayIndexOutOfBoundsException if the index is out of range, using the length of the array in the message. The array will be substituted by larger one if needed, but it will never be changed to a smaller one - so it is normal that the array is larger than required.
In Java 9, the index check was changed: it uses Objects.checkIndex(), which checks both limits and uses the size of the list for the Exception message.

ArrayList is backed by an array internally and it dynamically adjusts internal array as needed and size variable is maintained as you add elements ( increments as you add elements and decrements as you delete elements).
say at some point underlying array of ArrayList is with the length 22 (could be empty array, i.e. no elements stored), when you try to access it with -1 index, it will throw the java.lang.ArrayIndexOutOfBoundsException
*try printing list size before accessing the list as well to see if the size is coming as 0 or not

declaring a column length of 0 in a 2d array

I was just wondering if it was legal to declare a 2d ragged array with one or more of the columns having a length of 0. If it was legal, what will it actually do?

The answer is yes, it is possible. But then there's another question, why would you consider doing this? The reason I ask this is think about what you're trying to do here. An array in which the columns are of length 0 is technically an empty 2D array. I will, however, show how to do what you're asking and what will happen.
int[][] arr = new int[2][0]; //initializing a 2x0 array, which is 2 rows of size 0
or if you're trying to make a jagged array
int[][] arr = { {},{2} }; //this is a 2d array in which the first row has zero columns and the second row has one column
But what happens when you try operating on this array? You surprisingly won't get a compiler error, but you will get a runtime error. Suppose I added this line of code and tried running the program,
arr[0][0] = 1;
The error I would get is this,
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException:
because I can't access any elements in a 2d array with columns of size 0.

Need help finding values of arrays

I'm not understanding why these values continue to decrease by increments of 2.
Because the second loop ends at half of the original array length.

I ran your code just fine. The first loop creates the array and assigns it the values of i * 2. 'i' iterates between 0 and 10, creates the even numbers between 0 and 10*2.
The second loop iterates through half of the values, switching the largest value with the smallest value. It successfully reverses the array. No errors found, good job.

What is confusing here? In the first loop, you assign values 0, 2, 4,....,18 to array[0], array[1], ..., array[9]. The second loop you basically just reverse the array by swapping values of array[0] with array[9], array[1] with array[8],...etc. So 18, 16, ...0 are correct

Yes. But I'm not understanding why the values continue to decrease by
2 after 10. Since the second loop stops at half, shouldn't it start
going back up from 10 to 12 and so forth till 18? – fer0n 3 hours ago
This would be true if you removed this line:
array [array.length – 1 - i] = array[i];

The reason why I was not understanding this problem was because I wasn't fully understanding the meaning of arrays. Remember that array[#] is the position within a certain array; the # at that position will not always equal to the value at that position.
The first loop sets the positions from 0 to 9 with values multiplied by 2.
Then, the second array is where they swap the values WITHIN these positions.
For example, array[8] does not mean that the int temp equals 8. This simply means that position 8 within the array will be EQUAL to the array[1] from the very first array. Then, we set that original array position equal to the temp value, which is AT position 8.
Now, to understand why it continues to decrease its increment by 2 after 10 since the second loop has ended at position 4, one must look at this line:
array [array.length – 1 - i] = array[i];
For example, when array[9] = array[0], you place the value of 18 from temp into position 0. But you have to look at this line TWICE. The position of array at 9 will equal to the value of 0 because 0 is the value at position of array [0].

In Java: Assigning array elements to variables outside of the array

Fairly new to stackoverflow, but I've found that a lot of the answers here thoroughly explain why something is supposed to happen - and not happen.
I'm doing my own Java practice and ran into a question asking me to:
Assume that the array arr has been declared . Write a statement
that assigns the next to last element of the array to the
variable x , which has already been declared .
I get how to assign each individual element one by one in a for-loop, but I don't get how to individually pick one element out and assign it without touching the other elements.
-And no, this is not a homework assignment; it's my own study during my summer break.
Thanks - NP

I get how to assign each individual element one by one in a for-loop, but I don't get how to individually pick one element out and assign it without touching the other elements.
Note that the question asks for you to assign x to the array element, not the other way around (i.e. it will look like x = ...). As for how you'd do that, recall that you can access an array element at 0-based index i via array[i], so now it comes down to accessing the second-to-last element, meaning we need the index of that element.
Since arrays indexes are 0-based, the index of the last element should be one less than the length of the array. In Java terms: array.length - 1. Therefore, the index of the second-to-last element should be one less than that: array.length - 2. Therefore, the element we're after is array[array.length - 2]. Hopefully you can take it from here.

What about this?
x = arr[arr.length - 2];

You can choose an element from an array in the same way you choose from a for loop:
int x = arr[arr.length - 2]
You need to write -2 because of the way elements are stored starting at 0.

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.