Should List<Object>.add(index, listElement) work if the index is at the upper bound?

Question

Here is a very simple test that fails with a

System.ListException: List index out of bounds: 0

Sample code:

List<integer> intList = new List<integer>();
intList.add(0, 2);

This seems very odd to me, shouldn't it just put the integer 2 into the currently empty list? The exception occurs whenever the index parameter equals the current list size. I'd expect the exception if the index was greater than the current list size or less than zero.

Now when I want to insert something at the start of the list I need to first check if the list is empty. E.g.

public void someMethod(List<integer> existingList) {
    // Existing code ...
    integer intToPrepend = 1;

    // Insert at start of the list
    if(existingList.isEmpty()) {
        existingList.add(intToPrepend);
    } else {
        existingList.add(0, intToPrepend);
    }
}

Should it be possible to use add(Integer, Object) to append an element to the end of a list?

---

Part of my confusion probably comes from my .NET background and the following C# not throwing an ArgumentOutOfRangeException.

List<int> intList = new List<int>();
intList.Insert(0, 2);

Answer 1

It'd be nice if it added it, but I think you hit the nail on the head with:

I'd expect the exception if the index was greater than the current list size or less than zero.

If it was greater than the list size then it'd definitely be out of bounds, but with zero-based counting then it'd be out of bounds if it's equal to the size also.

| 0 | 1 | 2 | <-Size is 3 but 3 would be OOB

I guess both set() and add() assume the index specified already exists. Whether you should be able to add to a list this way comes down to the specification of the class and method, though personally I think you should expect it to function the way it does.

If it automatically allocated space in memory for the case when index is 0, then it should also do that when the index is 100,000 and as such programmer mistakes could lead to vast swathes of wasted memory. It'd probably just be size * sizeof(reference)) and not catastrophic, but I think the reasoning is valid.

Answer 2

listInstance.add(Integer, Object) method is for adding new value at existing position index. e.g;

This won't give exception:

List <integer> i = new List<integer>();

i.add(0);
i.add(0,1);

But this:

List <integer> i = new List<integer>();
i.add(0,1); // there is no index `0`

Because at this point list size is 0. So there should not be any index position to filled or replace. As you add an element to the list it size become 1 means it now have position index start from 0. So 0 is open to replace/add or remove.

However after adding element at 0 position its next index position is open to fill because new position has been allocated to shifted item and list size is increased by 1.

List <integer> i = new List<integer>();

i.add(0);
i.add(0,1);
i.add(1,1);
i.add(2,1);

We can add element to the next position to the current max index only.

If you want add element to last position:

Integer lastEle = i.size()-1; 
if(lastEle != -1)
{
   i.add(lastEle ,25);
}

Answer 3

I got around this by declaring the list like this:

List<SObject> objects = new SObject[1];
objects.add(0, element);

After declaring the list with at least a size of one the .add(0, element) adds the element at the first index. Keep in mind that the list will contain a null object at the end. Which I guess you could remove, but in my case, the list is of SelectOption and the null object doesn't show in the dropdown options.

Hope it helps.

Answer 4

I think here you wanna use Set method

http://www.salesforce.com/us/developer/docs/apexcode/Content/apex_System_List_set.htm