Why Does Arrayindexoutofboundsexception Occur and How to Avoid It in Android

What causes a java.lang.ArrayIndexOutOfBoundsException and how do I prevent it?

Your first port of call should be the documentation which explains it reasonably clearly:

Thrown to indicate that an array has been accessed with an illegal index. The index is either negative or greater than or equal to the size of the array.

So for example:

int[] array = new int[5];
int boom = array[10]; // Throws the exception

As for how to avoid it... um, don't do that. Be careful with your array indexes.

One problem people sometimes run into is thinking that arrays are 1-indexed, e.g.

int[] array = new int[5];
// ... populate the array here ...
for (int index = 1; index <= array.length; index++)
{
    System.out.println(array[index]);
}

That will miss out the first element (index 0) and throw an exception when index is 5. The valid indexes here are 0-4 inclusive. The correct, idiomatic for statement here would be:

for (int index = 0; index < array.length; index++)

(That's assuming you need the index, of course. If you can use the enhanced for loop instead, do so.)

How to fix java.lang.ArrayIndexOutOfBoundsException: length=0; index=-1

You can get Exception ArrayIndexOutOfBoundsException when you are trying to access an item at index that doesn't exist. Let's say you have array of 10 elements with indexs from 0 to 9. If you try to access the 11th index or more you will get ArrayIndexOutOfBoundsException.

NotesFragment.notes.set(noteId, String.valueOf(s)); NotesFragment.arrayAdapter.notifyDataSetChanged();

The first line above is trying to update an item in array at index noteId, you are getting this error because no item exits at that index.

Please make sure that item exist at index noteId, you can add a break point there and inspect the value of noteId

Android ArrayIndexOutOfBoundsException error length=12; index=-1

int secilen = rastgele.nextInt(resimsayi.size()-1)+1;
int secilenindex = secilen;

Replace everywhere similarly as above. This will avoid 0 when generating the number number.

Also, modify all the remove() statement as below :

resimsayi.remove(secilen);

instead of :

resimsayi.remove(resimsayi.indexOf(secilen));

How can i avoid ArrayIndexOutOfBoundsException in this case?

Maybe I don't understand the real problem, but what prevents you to check if the index is inside the array before accessing it in this case?

if (myIndex < myFirstStringArray.length) {
    System.out.println("Present");
} else {
    System.out.println("Not Present");
}

Couldn't figure out where the java.lang.ArrayIndexOutOfBoundsException: length=1; index=1 is coming from

'ArrayIndexOutOfBoundsException' is a 'runtime' exception ( its different from compile time exception and error). As per java docs:

Thrown to indicate that an array has been accessed with an illegal index. The index is either negative or greater than or equal to the size of the array.

Please see the 'stacktrace' of the exception (see logcat for the same), it will help you to locate the part of code responsible for this. Check the array boundations (you can either debug your application or print the array size and the index you are accessing and then resolve the same).
Index of array starts from 0, so if the array has been declared to be of size 'n' (to hold n elements) then make sure you access only indexes from 0 to n-1 (both inclusive) else you will get 'ArrayIndexOutOfBoundsException'

ArrayIndexOutOfBoundsException throws while Thread is working normally

your error is caused by this line

  if (position >= 0){
     itemIndicators.get(position-1).setSelected(true);
   }

you should edit your condition to position > 0 to avoid getting get(-1)

How can I avoid ArrayIndexOutOfBoundsException or IndexOutOfBoundsException?

What is java.lang.ArrayIndexOutOfBoundsException / java.lang.IndexOutOfBoundsException?

The JavaDoc curtly states:

Thrown to indicate that an array has been accessed with an illegal
index. The index is either negative or greater than or equal to the
size of the array.

What causes it to happen?

This exception means that you have tried to access an index in an
array or array backed list and that index does not exist.

Java uses 0 based indexes. That means all indexes start with 0 as
the index of the first element if it contains any elements.

The IndexOutOfBoundsException message is very explicit, and it usually takes the form of:

java.lang.IndexOutOfBoundsException: Index: 1, Size: 1

Where Index is the index that you requested that does not exist and Size is the length of the structure you were indexing into.

As you can see a Size: 1 means the only valid index is 0 and you were asking for what was at index 1.

For example, if you have an raw Array of objects or primitive types
the valid indexes are 0 to .length - 1, in the following example the valid indexes would be 0, 1, 2, 3,.

final String days[] { "Sunday", "Monday", "Tuesday" }
System.out.println(days.length); // 3
System.out.println(days[0]); // Sunday
System.out.println(days[1]); // Monday
System.out.println(days[2]); // Tuesday
System.out.println(days[3]); // java.lang.ArrayIndexOutOfBoundsException

This also applies to ArrayList as well as any other Collection classes that may be backed by an Array and allow direct access to the the index.

How to avoid the java.lang.ArrayIndexOutOfBoundsException / java.lang.IndexOutOfBoundsException?

When accessing directly by index:

This uses Guava to convert the raw primitive int[] array to an
ImmutableList<Integer>. Then it uses the Iterables class to safely
get the value at a particular index and provides a default value when
that index does not exist. Here I chose -1 to indicate an invalid
index value.

final List<Integer> toTen = ImmutableList.copyOf(Ints.asList(ints));
System.out.println(Iterables.get(toTen, 0, -1));
System.out.println(Iterables.get(toTen, 100, -1));

If you can't use Guava for some reason it is easy to roll your own function to do this same thing.

private static <T> T get(@Nonnull final Iterable<T> iterable, final int index, @Nonnull final T missing)
{
    if (index < 0) { return missing; }
    if (iterable instanceof List)
    {
        final List<T> l = List.class.cast(iterable);
        return l.size() <= index ? l.get(index) : missing;
    }
    else
    {
        final Iterator<T> iterator = iterable.iterator();
        for (int i = 0; iterator.hasNext(); i++)
        {
            final T o = iterator.next();
            if (i == index) { return o; }
        }
        return missing;
    }
}

When iterating:

Here is the idiomatic ways to iterate over a raw Array if you need
to know the index and the value:

This is susceptible to one off errors which are the primary causes
of an java.lang.ArrayIndexOutOfBoundsException:

Using a traditional for-next loop:

final int ints[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
for (int i = 0; i < ints.length; i++)
{
    System.out.format("index %d = %d", i, ints[i]);
}

Using an enhanced for-each loop:

Here is the idiomatic way to iterate over a raw Array with the
enhanced for loop if you do not need to know the actual index:

for (final int i : ints)
{
    System.out.format("%d", i);
    System.out.println();
}

Using a type safe Iterator<T>:

Here is the safe way to iterate over a raw Array with the enhanced
for loop and track the current index and avoids the possibility of
encountering an java.lang.ArrayIndexOutOfBoundsException.

This uses Guava to easily convert the int[] to something Iterable
every project should include it.

final Iterator<Integer> it = Ints.asList(ints).iterator();
for (int i = 0; it.hasNext(); i++)
{
    System.out.format("index %d = %d", i, it.next());
}

If you can not use Guava or your int[] is huge you can roll your own ImmutableIntArrayIterator as such:

public class ImmutableIntArrayIterator implements Iterator<Integer>
{
    private final int[] ba;
    private int currentIndex;

    public ImmutableIntArrayIterator(@Nonnull final int[] ba)
    {
        this.ba = ba;
        if (this.ba.length > 0) { this.currentIndex = 0; }
        else { currentIndex = -1; }
    }

    @Override
    public boolean hasNext() { return this.currentIndex >= 0 && this.currentIndex + 1 < this.ba.length; }

    @Override
    public Integer next()
    {
        this.currentIndex++;
        return this.ba[this.currentIndex];
    }

    @Override
    public void remove() { throw new UnsupportedOperationException(); }
}

And use the same code as you would with Guava.

If you absolutely must have the ordinal of the item the following is the safest way to do it.

// Assume 'los' is a list of Strings
final Iterator<String> it = los.iterator();
for (int i = 0; it.hasNext(); i++)
{
    System.out.format("index %d = %s", i, it.next());
}

This technique works for all Iterables. It is not an index parse, but it does give you the current position in the iteration even for things that do not have a native index.

The safest way:

The best way is to always use ImmutableLists/Set/Maps from Guava as
well:

final List<Integer> ili = ImmutableList.copyOf(Ints.asList(ints));
final Iterator<Integer> iit = ili.iterator();
for (int i = 0; iit.hasNext(); i++)
{
    System.out.format("index %d = %d", i, iit.next());
}

Summary:

1. Using raw arrays are difficult to work with and should be avoided in most cases. They are susceptible to sometimes subtle one-off errors which have plague new programmers even back to the days of BASIC

2. Modern Java idioms use proper type safe collections and avoid using raw array structures if at all possible.

3. Immutable types are preferred in almost all cases now.

4. Guava is an indispensable toolkit for modern Java development.

---

Related Topics