Java HashMap content seems to change without changing it

Question

I have a problem concerning a HashMap in Java. To explain the problem in a detailed way, i will first post some code you can refer to.

public void BLASTroute(String args[]) throws IOException, InterruptedException{
            ...
            correctMapping CM = new correctMapping();
            CM.correctMapping(RB.BLASTresults, exists);
            CalculateNewConsensusSequence CNCS = 
                new CalculateNewConsensusSequence();
            char[] consensus = CNCS.calculateNewConsensusSequence(
                CM.newSeq, CM.remindGaps, EMBLreaderReference.sequence, exists);

            HashMap<Integer, ArrayList<String>> gapsFused = 
                new HashMap<Integer, ArrayList<String>>();
            for (Integer i : CM.remindGaps.keySet()) {
                ArrayList<String> newList = CM.remindGaps.get(i);
                gapsFused.put(i, newList);
            }

            GenerateGeneLists GGL = new GenerateGeneLists(
                EMBLreaderReference, CM.newSeq, gapsFused, exists, 
                GQList, allMappedPositions);
            System.out.println(CM.remindGaps.hashCode());
            gapsFused=GGL.generateGeneListSNP(gapsFused);
            System.out.println(CM.remindGaps.hashCode());
            System.out.println(gapsFused.hashCode());
            GGL.generateGeneListFrameShift(gapsFused);

        }

The following occurs:

in my class correctMapping, i fill a global variable called remindGaps. I use it later in some functions, and nothing happens/everything works as expected.

Then, i make a copy of the HashMap called gapsFused (i don't know if this has something to do with my problem).

Now comes the interesting part: In the class GenerateGeneLists, i don't do a thing with the remindGaps HashMap.

However, after the function generateGeneListSNP is performed, remindGaps changed! I'll post the code for you as well, so that you can help me better:

public GenerateGeneLists(EMBL_reader EMBLreaderReference,
           HashMap<String,ArrayList<String>> newSeq,
           HashMap<Integer,ArrayList<String>> gapsFused, File exists,
           ArrayList<GeneQualifier> GQlist, 
           HashMap<Integer,Integer> allMappedPositions) 
throws InterruptedException{
     this.EMBLreaderReference=EMBLreaderReference;
     this.newSeq=newSeq;
     //this.gapsFused=gapsFused;
     this.exists=exists;
     this.GQlist=GQlist;
     this.allMappedPositions=allMappedPositions;
     for (GeneQualifier GQ : this.GQlist){
        startlist.add(GQ.start);
        stoplist.add(GQ.stop);
        startMap.put(GQ.start,GQ);
    }
}

public HashMap<Integer,ArrayList<String>> generateGeneListSNP(
           HashMap<Integer,ArrayList<String>> gapsFused) 
throws IOException{
    File GQSNP = new File (exists+"/GQsnp.txt");
    BufferedWriter SNP = new BufferedWriter(new FileWriter(GQSNP));
    SNP.write("#Gene_start\tGene_stop\tlocus_tag\tproduct" + 
              "\tputative_SNP_positions(putative_changes)\n");
    HashMap<GeneQualifier,ArrayList<Integer>> GQreminder = 
        new HashMap<GeneQualifier,ArrayList<Integer>>();
    for (String s : newSeq.keySet()){
        ArrayList<String> blub = newSeq.get(s);
        char[] qrySeq = blub.get(0).toCharArray();
        char[] refSeq = blub.get(1).toCharArray();
        int start = Integer.valueOf(blub.get(2));
        int stop = Integer.valueOf(blub.get(3));
        for (int i=0;i<refSeq.length;i++){
            if (qrySeq[i]!=refSeq[i]&&qrySeq[i]!='-'&&qrySeq[i]!='.'){
                if (mismatchList.containsKey(start+i)){
                    ArrayList<Character> blah = mismatchList.get(start+i);
                    blah.add(qrySeq[i]);
                    mismatchList.put(start+i, blah);
                }
                else {
                    ArrayList<Character> blah = new ArrayList<Character>();
                    blah.add(qrySeq[i]);
                    mismatchList.put(start+i,blah);
                }
            }
            else if (qrySeq[i]!=refSeq[i]&&(qrySeq[i]=='-'||qrySeq[i]=='.')){
                if (!gapsFused.containsKey(start+i)){
                    ArrayList<String> qwer = new ArrayList<String>();
                    qwer.add(String.valueOf(qrySeq[i]));
                    gapsFused.put(start+i,qwer);
                }
                else {
                    ArrayList<String> qwer = gapsFused.get(start+i);
                    qwer.add(String.valueOf(qrySeq[i]));
                    gapsFused.put(start+i,qwer);
                }
                if (!deletionPositionsAndCount.containsKey((start+i))){
                    int count = 1;
                    deletionPositionsAndCount.put(start+i, count);
                }
                else {
                    int count = deletionPositionsAndCount.get(start+i);
                    count = count+1;
                    deletionPositionsAndCount.put(start+i, count);
                }
            }
        }
    }
    for (Integer a : mismatchList.keySet()){
        for (int i=0;i<startlist.size();i++){
            int start = startlist.get(i);
            int stop = stoplist.get(i);
            if (a>=start && a<=stop){
                GeneQualifier GQ = startMap.get(start);
                if (!GQreminder.containsKey(GQ)){
                    ArrayList save = new ArrayList<Integer>();
                    save.add(a);
                    GQreminder.put(GQ,save);
                }
                else {
                    ArrayList save = GQreminder.get(GQ);
                    save.add(a);
                    GQreminder.put(GQ,save);
                }
                break;
            }
        }
    }
    for (GeneQualifier GQ : GQreminder.keySet()) {
        ArrayList<Integer> save = GQreminder.get(GQ);
        int start = GQ.start;
        int stop = GQ.stop;
        String locus_tag = 
            GQ.geneFeatures.get("locus_tag").get(0).replace("\n", "");
        String product = 
            GQ.geneFeatures.get("product").get(0).replace("\n", "");
        SNP.write(start + "\t" + stop + "\t" + locus_tag + 
                  "\t" + product + "\t");
        boolean end = false;
        for (int i = 0; i < save.size(); i++) {
            if (i==save.size()-1) end=true;

            int posi = save.get(i);
            SNP.write(posi + "(");
            ArrayList<Character> mismatches = mismatchList.get(posi);
            for (int j = 0; j < mismatches.size(); j++) {
                char snipp = mismatches.get(j);
                if (j == mismatches.size() - 1) {
                    SNP.write(snipp + ")");
                } else {
                    SNP.write(snipp + ",");
                }
            }
            if (end == false){
                SNP.write(",");
            }
        }
        SNP.write("\n");
    }
    SNP.close();
    return gapsFused;
}

As you can see, remindGaps is not used in this class, but still it undergoes changes. Do you have an idea why this is the case?

What I tested is, whether remindGaps changes if i manually change gapsFused (the made copy of the first HashMap). This is not the case, so i don't think that the copying process went wrong (for example only points to the other HashMap or references it).

I would really appreciate your ideas and help in order to solve this problem.

As I see it, your example seems overly verbose to be approached by the "casual" user. You should spend some time narrowing it down to the most relevant code sections. In any case, it is not self contained. — Luca Geretti
– Luca Geretti, Commented Jun 20, 2012 at 11:11
you are probably right, I just wanted to clearly point out, where the problem is and what happens in that particular area. Because I have thought long about it and nearly searched the whole net, I am eager for at least an idea. However, if nobody will write in about 15 minutes, I will cut down the code. Thanks for your advice. — user1365291
– user1365291, Commented Jun 20, 2012 at 11:14

legendofawesomeness · Accepted Answer · 2012-06-20 11:16:38Z

3

You have to remember that in Java all objects are passed as reference. So, when you did:

ArrayList<String> newList = CM.remindGaps.get(i);

you basically pointed newList to the same list as contained in the remindGaps map. Now, even though you work with the gapsFused, any changes to its values effect the same underlying list in the memory - to which both remindGaps and gapsFused are pointing.

Change your copy code to the following and see if it makes a difference:

ArrayList<String> newList = new ArrayList<String>(CM.remindGaps.get(i));

By doing this, you are creating a new list that newList will be pointing to and thus the changes will be encapsulated.

answered Jun 20, 2012 at 11:16

legendofawesomeness

2,9212 gold badges21 silver badges32 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

user1365291 Over a year ago

Thank you very much, I had to be snow blind not to get that.

JB Nizet · Accepted Answer · 2012-06-20 11:17:50Z

Your code is very long and hard to read (mainly because it doesn't respect Java naming conventions), but my guess is that your problem comes from the fact that your copy of the map simply copies the ArrayList references from one map to another:

HashMap<Integer, ArrayList<String>> gapsFused = new HashMap<Integer, ArrayList<String>>();
for (Integer i : CM.remindGaps.keySet()) {
    ArrayList<String> newList = CM.remindGaps.get(i);
    gapsFused.put(i, newList);
}

In the above code, you don't create any new list. You just store the same lists in another map. If you need a new list, the code should be:

Map<Integer, List<String>> gapsFused = new HashMap<Integer, List<String>>();
for (Integer i : CM.remindGaps.keySet()) {
    List<String> newList = new ArrayList<STring>(CM.remindGaps.get(i));
    gapsFused.put(i, newList);
}

pgras · Accepted Answer · 2012-06-20 11:18:21Z

Without analyzing all your code:

HashMap<Integer, ArrayList<String>> gapsFused = new HashMap<Integer, ArrayList<String>>();
for (Integer i : CM.remindGaps.keySet()) {
    ArrayList<String> newList = CM.remindGaps.get(i);
    gapsFused.put(i, newList);
}

After this code gapFused will contain entries that are copies of the entries of remindGaps, therefore those entries will reference the same objects (key and values). So if you add or remove entries in one Map it will have no effect on the other, but if you change a value accessing it through one Map you will see the change also accessing it through the other map (for example remingGaps.get(1).add("hello")).

The name "newList" used in your code is confusing because it is not a new list, just a reference on an existing one...

John B · Accepted Answer · 2012-06-20 11:18:52Z

0

Since the value of the Map is an ArrayList and you are doing just a shallow copy (meaning the new Map has a reference to the same Lists as are in the first Map) and changes to the lists in the second map would be reflected in the first map. To avoid this you would need to make deep copies of the lists when you create the new Map.

answered Jun 20, 2012 at 11:18

John B

33.1k8 gold badges80 silver badges100 bronze badges

Collectives™ on Stack Overflow

Java HashMap content seems to change without changing it

4 Answers 4

1 Comment

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

1 Comment

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related