Why does this ArrayList act like a pointer?I thought all variables in java are refere

[blazedaces]

Before we begin let me say that I already found the solution to the problem, but I am still unable to explain why it solved the problem, so I am here to ask you experts why this java code produces the results I indeed see.

The two pairs of code I am going to show are meant to find all the prime factors of a number (it is not my original code, I took it from Project Euler, and I'm further using it solve a later, harder problem in the project, but that is not relevant).

I am going to post the first code and its corresponding incorrect result, then show the second code, its correct result, and I will lastly point out the only line that is different between the two.

The question I have for you guys, because I can't answer it, is why is the first result coming up this way? Why does the solution of changing that single line of code work?

The only explanation I can give is that for some reason if you initiate an ArrayList by saying ArrayList something = oldArrayList they are both pointing to the same ArrayList... I'm not satisfied with this answer because it doesn't make sense with the java structure I thought I knew.

So here we go:
First Code:

    public static void main(String[] args) {
        utils.print(allPrimeFactorsAndTheirPowers(10));
    }
 
    public static HashMap<Integer, Integer> allPrimeFactorsAndTheirPowers(int input) {
        ArrayList<Integer> primeFactors = new ArrayList<Integer>((int)Math.sqrt((double)input));
        ArrayList<Integer> powers = primeFactors;
        HashMap<Integer, Integer> factorsAndPowers = new HashMap<Integer,Integer>((int)Math.sqrt((double)input));
        int currentPower = 0;
 
        if (!isPrime(input)) {        
            int n = input;
 
            if(n % 2 == 0) {
                currentPower++;
                primeFactors.add(Integer.valueOf(2));
                n = n / 2;
                while(n % 2 == 0) {
                    currentPower++;
                    n = n / 2;
                }
                powers.add(Integer.valueOf(currentPower));
                currentPower=0;
            }
            int factor = 3;
            int maxFactor = (int)Math.sqrt((double) n);
            while(n > 1 && factor <= maxFactor) {
                if (n % factor == 0) {
                    currentPower++;
                    n = n / factor;
                    primeFactors.add(factor);
                    while(n % factor == 0) {
                        currentPower++;
                        n = n / factor;
                    }
                    maxFactor = (int)Math.sqrt((double)n);
                    powers.add(Integer.valueOf(currentPower));
                    currentPower=0;
                }
                factor = factor+2;
            } if (n != 1) {
                primeFactors.add(Integer.valueOf(n));
                powers.add(Integer.valueOf(1));
            }
        } else {
            primeFactors.add(Integer.valueOf(input));
            powers.add(Integer.valueOf(1));
        }
 
        for(int i = 0; i < primeFactors.size(); i++) {
            factorsAndPowers.put(primeFactors.get(i), powers.get(i));
        }
 
        return factorsAndPowers;
    }
 

Incorrect Result:
5 : 5
1 : 1
2 : 2


Second Code:

    public static void main(String[] args) {
        utils.print(allPrimeFactorsAndTheirPowers(10));
    }
 
    public static HashMap<Integer, Integer> allPrimeFactorsAndTheirPowers(int input) {
        ArrayList<Integer> primeFactors = new ArrayList<Integer>((int)Math.sqrt((double)input));
        ArrayList<Integer> powers = new ArrayList<Integer>((int)Math.sqrt((double)input));
        HashMap<Integer, Integer> factorsAndPowers = new HashMap<Integer,Integer>((int)Math.sqrt((double)input));
        int currentPower = 0;
 
        if (!isPrime(input)) {        
            int n = input;
 
            if(n % 2 == 0) {
                currentPower++;
                primeFactors.add(Integer.valueOf(2));
                n = n / 2;
                while(n % 2 == 0) {
                    currentPower++;
                    n = n / 2;
                }
                powers.add(Integer.valueOf(currentPower));
                currentPower=0;
            }
            int factor = 3;
            int maxFactor = (int)Math.sqrt((double) n);
            while(n > 1 && factor <= maxFactor) {
                if (n % factor == 0) {
                    currentPower++;
                    n = n / factor;
                    primeFactors.add(factor);
                    while(n % factor == 0) {
                        currentPower++;
                        n = n / factor;
                    }
                    maxFactor = (int)Math.sqrt((double)n);
                    powers.add(Integer.valueOf(currentPower));
                    currentPower=0;
                }
                factor = factor+2;
            } if (n != 1) {
                primeFactors.add(Integer.valueOf(n));
                powers.add(Integer.valueOf(1));
            }
        } else {
            primeFactors.add(Integer.valueOf(input));
            powers.add(Integer.valueOf(1));
        }
 
        for(int i = 0; i < primeFactors.size(); i++) {
            factorsAndPowers.put(primeFactors.get(i), powers.get(i));
        }
 
        return factorsAndPowers;
    }
 

Correct Result:
5 : 1
2 : 1

The only line that changes:
Incorrect Line of Code:

ArrayList<Integer> powers = primeFactors;

Correct Line of Code:

ArrayList<Integer> powers = new ArrayList<Integer>((int)Math.sqrt((double)input));

Your help and knowledge is much appreciated,
-blazed

[blazedaces]

I believe I found the answer:

"Array variables are references to a block of elements

When you declare an array variable, Java reserves only enough memory for a reference (Java's name for an address or pointer) to an array object. References typically require only 4 bytes. When an array object is created with new, a reference is returned, and that reference can then be assigned to a variable. When you assign one array variable to another, only the reference is copied. For example,

int[] a = new int[] {100, 99, 98}; // "a" references the array object.
int[] b; // "b" doesn't reference anything.

b = a; // Now "b" refers to the SAME array as "a"
b[1] = 0; // Also changes a[1] because a and b refer to the same array." - http://www.leepoint.net/notes-java/d...ys/arrays.html

I had no idea this was the case, but it explains another problem I was having with arrays this time, and it completely explains what happened above.

-blazed