Thread: Memory issues..?

"java.lang.OutOfMemoryError: Java heap space
at java.util.Arrays.copyOf(Arrays.java:2245)
at java.util.Arrays.copyOf(Arrays.java:2219)
at java.util.ArrayList.grow(ArrayList.java:213)
at java.util.ArrayList.ensureCapacityInternal(ArrayLi st.java:187)
at java.util.ArrayList.add(ArrayList.java:428)
at TestStudent.insertStudent(TestStudent.java:80)
at TestStudent.main(TestStudent.java:133)"

The error is saying that you have run out of memory. It also suggests that an array list was "growing" ie you were adding something to the list at the time. In general - having figured out the general sort of thing that is going wrong you read down the stack trace until you hit a line of your code: that's usually a good place to begin hunting for the bug.

In this case it's "TestStudent.insertStudent(TestStudent.java:80 )". Unfortunately the code you posted for that method is mangled (it won't compile as you posted it.)

Yes, the problem was a for loop that wasnt stopping in the correct spot, so I changed it to a for each loop like the rest of the methods have. But now it throws another error:
"java.util.ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification(Arr ayList.java:819)
at java.util.ArrayList$Itr.next(ArrayList.java:791)
at TestStudent.insertStudent(TestStudent.java:77)
at TestStudent.main(TestStudent.java:135)"

Also, the code would not compile because I somehow got a random 5 in there. But now I have edited it in my original post so that it will compile, and also has the change that I made to the method in question - insertStudent(); and should throw that error.

for(Student k : a)
{
 
    if(k.getName().equals(s))
    {
        a.add(c, new Student(n, q, w, e, r, t));
    }
    c++;
}

The ConcurrentModificationException occurs because as you iterate over a you add something to that array list. That is you add something to the list you are supposed to be iterating over.

Try the other form of iteration instead:

int sz = a.size();
for(int ndx = 0; ndx < sz; ndx++)
{
    Student s = a.get(ndx);
    // etc
}

You might find that the index ndx can take the place of c.

Alright that works, however it inserts the same person twice?

this code

 
 public static void insertStudent(List<Student> a, String s, String n, int q, int w, int e, int r, int t)
    {
        int sz = a.size();
        for(int c = 0; c < sz; c++)
        {
            Student g = a.get(c);
 
            if (g.getName().equals(s))
            {
                a.add(c, new Student(n, q, w, e, r, t));
            }
 
    }    
        System.out.println("Inserting " + n + ": " + q + ", " + w + ", " + e + ", " + r + ", " + t + ", " + "before " + firstName(s) + ":");
   }"

Also, if you cant do that, why does this method work?

public static void deleteStudent(List<Student> a, String s)
    {
        int c = 0;
        for(Student q : a)
        {
            if (q.getName().equals(s))
            {
                a.remove(c);
            }
            c++;
        }
 
        System.out.println("Removing " + s + ":");
    }

however it inserts the same person twice?

It can only insert two people if g.getName().equals(s) is true twice. Try printing the index c and the corresponding student g each time around the loop to see why this is.

why does this method work?

"work", I don't know. I don't really have the time to see what it *does* do and under what cirumstances (not saying that's an uninteresting question) - so I'll just accept how the API documents the behaviour: "The iterators returned by this class's iterator and listIterator methods are fail-fast: if the list is structurally modified at any time after the iterator is created, in any way except through the iterator's own remove or add methods, the iterator will throw a ConcurrentModificationException. Thus, in the face of concurrent modification, the iterator fails quickly and cleanly, rather than risking arbitrary, non-deterministic behavior at an undetermined time in the future.

"Note that the fail-fast behavior of an iterator cannot be guaranteed as it is, generally speaking, impossible to make any hard guarantees in the presence of unsynchronized concurrent modification. Fail-fast iterators throw ConcurrentModificationException on a best-effort basis. Therefore, it would be wrong to write a program that depended on this exception for its correctness: the fail-fast behavior of iterators should be used only to detect bugs".

I am assuming that the enhanced for loop uses the iterator() method. Frankly I can't see any "unsynchronized concurrent modification" going on, but I'll just accept that the class's iterators *are* mostly "fail fast" but that you *cannot* rely on this.

Haha well that makes sense.. kind of.. It works for now! But after doing what you suggested, i am utterly confused. After the program runs each method (insertStudent, deleteStudent ect.) it prints the whole list of Students. And in the one right before the insertStudent method is called is printed as:

"

Name 01 02 03 04 05
---------------------------------------------------------------
Mark Kennedy: 70 80 90 100 90
Maz Gerard: 80 85 90 85 80
Jean Smith: 60 79 89 99 100
Betty Boop: 85 80 95 88 89
Mike Kappa: 0 0 0 90 90
"

Now, when the insertStudent method is told to print c and g each time in the loop, heres what shows up:


"0
Mark Kennedy: 70 80 90 100 90
1
Maz Gerard: 80 85 90 85 80
2
Jean Smith: 60 79 89 99 100
3
Betty Boop: 85 80 95 88 89
4
Betty Boop: 85 80 95 88 89
"

As you can see, number 4 should have been "Mike Kappa", but for some reason the method reads 2 Betty Boop's. Then the really confusing part is when it prints the List of Students:

"Name 01 02 03 04 05
---------------------------------------------------------------
Mark Kennedy: 70 80 90 100 90
Maz Gerard: 80 85 90 85 80
Jean Smith: 60 79 89 99 100
Lily Mu: 85 95 70 0 100
Lily Mu: 85 95 70 0 100
Betty Boop: 85 80 95 88 89
Mike Kappa: 0 0 0 90 90
"

There are 2 Lily Mu's. Why? I have no idea.

"0
Mark Kennedy: 70 80 90 100 90
1
Maz Gerard: 80 85 90 85 80
2
Jean Smith: 60 79 89 99 100
3
Betty Boop: 85 80 95 88 89
4
Betty Boop: 85 80 95 88 89
"

As predicted the loop is seeing Betty Boop twice. And, hence I guess, adding Lily Mu twice which explains the other output.

If you can't see why, you need to step through the code one line at a line: round and round the loop keeping track of the loop counter, c. A debugger is good at "stepping" through code like this. Or you can use plenty of System.out.println(). Either way you need to be aware of what the value of each variable is at each step.

public static void insertStudent(List<Student> a, String s, String n, int q, int w, int e, int r, int t)
{
    int sz = a.size();
    for(int c = 0; c < sz; c++)
    {
        Student g = a.get(c);
        System.out.println("At top of loop");
        System.out.println("    c=" + c + " name=" + g.getName());
 
        if (g.getName().equals(s))
        {
            System.out.println("Found match");
            System.out.println("    Before student added: a.get(c).getName()=" + a.get(c).getName());
            a.add(c, new Student(n, q, w, e, r, t));
            System.out.println("    After student added: a.get(c).getName()=" + a.get(c).getName());
        }
 
    }    
    System.out.println("Inserting " + n + ": " + q + ", " + w + ", " + e + ", " + r + ", " + t + ", " + "before " + firstName(s) + ":");
}

Ohhhh I see. It adds the new Student in, but pushes Betty Boop up so that it sees it twice. So I should do a c++ after it inserts the new Student.

Well done. I'm glad you've got it figured out.

Thanks a lot for your help!