You should be running these tests in separate methods as the optimisation of the first loop can interfere with the optimisation of the second i.e. the second one can be slower, just because it is second.

I suggest you run both tests at least 10 (or for 2 seconds) and use System.nanoTime() which has higher resolution.

If you do this and you still run out of memory I suggest you increase the maximum memory size. If you are running 32-bit windows, the default is very low. You can increase it with -Xmx1g on the command line

If you run the following, you can see that GCs have the biggest impact which is not surprising as the problem most produces garbage

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class Collectionss {

    public static final int TO_ADD = 10000000;

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            long timeAL = timeAddToArrayList();
            long timeLL = timeAddsToLinkedList();
            System.out.printf("Time to add %,d Integer to ArrayList %.3f sec, LinkedList %.3f%n",
                    TO_ADD, timeAL / 1e9, timeLL / 1e9);
        }
    }

    private static long timeAddToArrayList() {
        long starttime = System.nanoTime();
        List<Integer> l1 = new ArrayList<Integer>();
        for (int i = 1; i <= TO_ADD; i++) {
            l1.add(i);
        }
        assert TO_ADD == l1.size();

        return System.nanoTime() - starttime;
    }

    private static long timeAddsToLinkedList() {
        long starttime = System.nanoTime();
        List<Integer> l2 = new LinkedList<Integer>();
        for (int i = 1; i <= TO_ADD; i++) {
            l2.add(i);
        }
        assert TO_ADD == l2.size();

        return System.nanoTime() - starttime;
    }
}

prints

Time to add 10,000,000 Integer to ArrayList 0.238 sec, LinkedList 1.326
Time to add 10,000,000 Integer to ArrayList 1.193 sec, LinkedList 0.971
Time to add 10,000,000 Integer to ArrayList 0.841 sec, LinkedList 0.048
Time to add 10,000,000 Integer to ArrayList 0.349 sec, LinkedList 1.128
Time to add 10,000,000 Integer to ArrayList 0.064 sec, LinkedList 0.048

However add System.gc() before each test and you get

Time to add 10,000,000 Integer to ArrayList 0.241 sec, LinkedList 2.130
Time to add 10,000,000 Integer to ArrayList 0.070 sec, LinkedList 0.072
Time to add 10,000,000 Integer to ArrayList 0.067 sec, LinkedList 0.053
Time to add 10,000,000 Integer to ArrayList 0.069 sec, LinkedList 0.048
Time to add 10,000,000 Integer to ArrayList 0.065 sec, LinkedList 0.051

You never increment j. You are incrementing ii and val inside the for loop where as I think you actually want to do it in the while loop. Try the example below.

    ArrayList<Integer> al = new ArrayList<Integer>(); 
    Random rand = new Random();
    int val=1;
    int ii =0;
    while(val < 400){
        for (int j = 0; j<ii; j++) {
            int pick = rand.nextInt(100);
            al.add(pick);
        }
        ii++;
        val++;
        System.out.println("Contents of al: " + al);
        al.clear();
        System.out.print("Array has been cleared: " + al);
    }

Your task would be much easier if you gave your variables meaningful names. e.g.

    ArrayList<Integer> al = new ArrayList<Integer>(); 
    Random rand = new Random();
    int lineNumber = 1;
    int lineLength = 0;
    while(lineNumber < 400){
        for (int randCount = 0; randCount < lineLength; randCount++) {
            int pick = rand.nextInt(100);
            al.add(pick);
        }
        lineLength++;
        lineNumber++;
        System.out.println("Contents of al: " + al);
        al.clear();
        System.out.print("Array has been cleared: " + al);
    }

Presumably the System.out.println call requires less memory than the s.add("Pradeep") call.

If s is an ArrayList for instance, the s.add call may cause the list to attempt to double up it's capacity. This is possibly a quite memory demanding operation, thus it is not very surprising that the JVM can continue executing even if it can't perform such relatively expensive task.

You need to increment your count

int count=0;
while (count<farray.size()){
    FartsNameArray.add(farray.get(count).name);
    count++;
}

You can also use a for loop too

for(int count = 0; count < farray.size(); count++) {
    FartsNameArray.add(farray.get(count).name);
}

Or a foreach

foreach(Farts f in farray){
    FartsNameArray.add(f.name);
}

You should update existing ArrayList elements with the set method. By adding to the ArrayList you are increasing its size so your loop never terminates since the end condition is for i to be equal to the size minus one. This condition is never met so your collection keeps growing until you run out of memory.

for(int i=0; i<al.size()-1; i++){
  tmp = al.get(i+1);
  al.set(i+1,al.get(i));     
  al.set(i, tmp) //assign the n+1 element to the n position
}

increase heap memory by

-Xms64m -Xmx256m

Look at your loop:

while(j<campos.length){
    nombres_reuniones.add(campos[j]);
}

How do you anticipate that ever finishing? You don't modify j. Given that you don't make any change to j after declaring it and assigning it a value of 0 right at the start, it would be much clearer as:

for (int j = 0; j < campos.length; j++) {
    nombres_reuniones.add(campos[j]);
}

Or better:

for (String item : campos) {
    nombres_reuniones.add(item);
}

Or even simpler:

nombres_reunions.addAll(Arrays.asList(campos));

Additionally, your earlier code can be simpler. Look at this:

String aux2 = null;
aux2 = aux.replace("[", "");
aux2= aux2.replace("]", "");

Why bother assigning aux2 an initial value of null which you then immediately overwrite? Additionally, you can easily chain the method calls. It would be neater as:

String aux2 = aux.replace("[", "").replace("]", "");

And in fact, you can just chain the whole of the string manipulation together from start to finish:

String[] campos = jsonReuniones.getString("nombres")
                               .replace("[", "")
                               .replace("]", "")
                               .split(",");
nombres_reunions.addAll(Arrays.asList(campos));

(I'd stop there, rather than inlining even that expression...)

If you use the -Xmx flag appropriately when running java (see here for more info), you can increase your Heap size. This will allow you to use more memory if needed, in a controlled way. To my knowledge, there is not a way of "asking" for more heap memory from within a program itself (similarly to running the sbrk() or mmap() syscalls in C)

As the answer I linked to says:

For example, starting a JVM like so will start it with 256MB of memory, and will allow the process to use up to 2048MB of memory:

java -Xmx2048m -Xms256m

Also, you can use "k", "m", or "g" for Kilobytes, Megabytes and Gigabytes respectively. You cannot exceed 1GB (Heap size, that is), however, unless you are using the 64-bit JVM.

If you do the math with your particular use-case, assuming 64-bit longs * 100000000 costs about 800MB of space.

You are trying to stuff a file with 468,000 lines into 5G of memory, and are running out of memory.

The data structure isn't the problem.

You need to change your approach and not do that. Process chunks of the file at a time, only extract the data you need, etc.

This may sound glib, but your problem is that your application needs a List of 2.5 million rows as HashMaps.

This is an absurd, unreasonable and frankly ridiculous requirement; I can't imagine what use such a data structure would be good for.

Change the application to not require it.