How to store number of elements exceeding the range of integers

Question

I am given a problem in which I have to store a list of N numbers in an array and then sort it ,
and then I have to add the numbers at alternative positions and output the sum.
The problem is the constraint of N i.e 0 <= N <= 10¹¹ so I have to declare the N as double type variable here is my code :

ArrayList<Double> myList = new ArrayList<Double>();
myList.add(number);
.....
Collections.sort(myList);
String tempNo = "";
for(double i = 0 ; i < myList.size() ; i=i+2){
tempNo = myStringWayToAdd(tempNo , myList(i)+"");  // Since the sum will exceed the limit of double I have to add the numbers by help of Strings
}

But the problem is that the get(int) method takes an int not double. Is there any other way I can solve the problem? , and Is it even allowed to store number of elements that exceed int range?
Any help will be highly appreciated. Thank you in Advance.

---

Edit 1 : I can use Strings instead of double in ArrayList and then add up the numbers but my problem is that i need to store N elements which can exceed the range of Integers

Answer 1

Ah, I misunderstood the question. So we have to store something that is significantly larger than the capacity of int.

Well, we can do this by dividing and conquering the problem. Assuming this is theoretical and we have unlimited memory, we can create a SuperArrayList.

'Scuse my bad generics, no compiler.

public class SuperArrayList<E>() {
    private ArrayList<ArrayList<E>> myList;
    private int squareRoot;
    private double capacity;
    public SuperArrayList(double capacity) {
        this.capacity = capacity;
        squareRoot = Math.ceil(Math.sqrt(capacity)); //we create a 2d array that stores the capacity
        myList = new ArrayList<ArrayList<E>>(); 
        for(int i = 0; i < squareRoot; i++) {
            myList.add(new ArrayList<E>());
        }
    }

    public E get(double index) {
        if(index >= capacity || index < 0) {
            //throw an error
        }
        else {
            return myList.get((int) capacity / squareRoot).get(capacity % squareRoot);
        }       
    }
}

As an alternative to squareRoot, we can do maxValue and add additional arraylists of length maxvalue instead.

Answer 2

You could use LinkedList because it does not have a size limit (although odd things may begin to happen up there). You should also be able to use BigInteger for your numbers if the numbers themselves could get huge (you don't seem to state).

    // LinkedList can hold more than Integer.MAX_VALUE elements,
    List<BigInteger> myList = new LinkedList<>();
    // Fill it with a few numbers.
    Random r = new Random();
    for (int i = 0; i < 1000; i++) {
        myList.add(BigInteger.probablePrime(10, r));
    }
    // Sort it - not sure if Collections.sort can handle > Integer.MAX_VALUE elements but worth a try.
    Collections.sort(myList);
    // Start at 0.
    BigInteger sum = BigInteger.ZERO;
    // Add  every other one.
    boolean addIt = false;
    for (BigInteger b : myList) {
        if (addIt) {
            sum = sum.add(b);
        }
        addIt = !addIt;
    }

I am not sure if Collections.sort can handle a list of numbers that big, let alone whether it will succeed in sorting within the age of the universe.

You may prefer to consider a database but again you might even have probelms there with this many numbers.

Answer 3

boolean add = true;
for (Double doubleNum : myList) {
    if (add) {   
        tempNo = myStringWayToAdd(tempNo , doubleNum+"");
    }
   add = !add;
}

Using this way, you won't have to use index.