trouble with LinkedHashMap

[Alan Shiers]

Hi Guys,

Hoping someone can see where I messed up. I've created the test class below to which the output is:

id: 40
HID : 1
NAME : sports
id: 40
HID : 4
NAME : sewing
temp.size(): 2
HID/4
NAME/sewing

The final output should be:

HID/1
NAME/sports
HID/4
NAME/sewing

This has me puzzled. temp.size() should be 4 NOT 2. It is clear from the println statements that my nested for loop in method getArrayFieldValues(...) is finding id 40 twice and putting the necessary values into the LinkedHashMap. But by the time it is done, it would seem the first two entries into the hashmap get overwritten or something leaving only the last two entries. I think this is one of those "can't see the forest for the trees" things. I need an extra pair of eyes to show me where I went wrong. Please advise.

Alan

import java.util.*;

public class test
{
  Field[] fields = null;
  
  public static void main(String[] args)
  {
     test t = new test();
     t.init();
  }
  
  private void init()
  {
     fields = new Field[2];
     fields[0] = new Field("HID");
     fields[1] = new Field("NAME");
  
    String[][] data = new String[][]
	{{"40","1","sports"},
	 {"41","1","sports"},
	 {"44","1","sports"},
	 {"39","2","crafts"},
	 {"38","3","photography"},
	 {"40","4","sewing"},
	 {"43","4","sewing"},
	 {"41","5","models"},
	 {"43","6","reading"}};
	 
	 ArrayList<LinkedHashMap<String,Object>> hobbies = getArrayFieldValues("40",data);
	 LinkedHashMap<String,Object> temp = null;
	 for(int i = 0; i < hobbies.size(); i++)
	 {
	   temp = hobbies.get(i);
	   for (Map.Entry<String, Object> entry : temp.entrySet())
       {
         System.out.println(entry.getKey() + "/" + entry.getValue());
       }
	   
	 }	 
  }
  
  private ArrayList<LinkedHashMap<String,Object>> getArrayFieldValues(String id, String[][] data)
  {
	  
	  ArrayList<LinkedHashMap<String,Object>> list = new ArrayList<LinkedHashMap<String,Object>>();
	  int index = 0;
	  LinkedHashMap<String,Object> temp = new LinkedHashMap<String,Object>();
	  for(int i = 0; i < data.length; i++)
	  {
		  if(id.equals(data[i][0]))
		  {		
              System.out.println("id: " + id);		  
			  for(int j = 1; j < data[0].length; j++)
			  {
			    System.out.println(fields[index].getName() + " : " + data[i][j]);
			    temp.put(fields[index].getName(),data[i][j]);
			    index++;			    
			  }
			  index = 0;//reset
			  
		  }
	  }
	  System.out.println("temp.size(): " + temp.size());
	  list.add(temp);
	  return list;
  }
}

public class Field
{
  private String name = "";
  private String value = "";

  public Field(String n)
  {
    name = n;
  }
  public Field(String n, String v)
  {
    name = n;
    value = v;
  }

  public void setName(String value)
  {
    name = value;
  }

  public String getName()
  {
    return name;
  }

  public void setValue(String v)
  {
    value = v;
  }

  public String getValue()
  {
    return value;
  }

  
}

[Jeff Verdegan]

I'm not going to try to read or understand that code, but whenever the problem is, "There are fewer than there should be, and the originals are getting overwritten," it means you're not creating a new object somewhere that you should be, and the original is being overwritten because you're telling it to.

For example:

Foo foo = new Foo();

foo.setX(1);
map.put("a", foo);

foo.setX(2);
map.put("b", foo);

Here we have just one Foo object, we create it, set its X to 1, put a reference to it it into the map, set its X to 2, and put another reference to it into the map. Both entries (key="a" and key="b') point to the same Foo object for their value.

A common mistake is to think that map.put() somehow makes a copy of the key and/or value. It doesn't. Just like any method call, it just passes a reference, and the map stores that reference. Objects in Java are not copied unless some code explicitly copies them, such as by calling clone(), or a copy constructor, or System.arraycoyp(). And when you're calling a method, if its docs don't explicitly state that it copies the object, then assume it doesn't.

[Alan Shiers]

The example you provide certainly makes sense, however, in my case, I'm not changing values on any object. A 2D String array is being presented and all the values are fixed. The array contains 2 rows with "40" showing up in the zeroeth element. I'm scanning column 0 for matches to the id passed to the method getArrayFieldValues(...). I'm associating field names with the values in the array's columns 1 and 2 and putting them into the hashmap. My understanding was that everytime you call the put() method on the hashmap, you add a new set of key:value pairs to the map. Which is what I thought I was doing. So I must have written my code in a strange way because the output is not what I expected. I expected 4 separate entries into the hashmap, instead I get 2. I fail to see my mistake. Can you help out further?

Alan

[Jeff Verdegan]

Alan Shiers wrote:My understanding was that everytime you call the put() method on the hashmap, you add a new set of key:value pairs to the map.

Yes, but you can build a map with 1,000,000 keys and one single value object. That's what I showed in my code, and that's what it sounds like you're doing. Calling put() does not copy any objects or create any new objects. If you call put() twice, and both your get() calls give the same result, even though you think they should be different, then you have merely changed the contents of a single object and re-used it for both put() calls.

You say you're not changing the values in an object. Are you doing something like

map.put(key1, array);
array[something] = somethignElse;
map.put(key2, array);

?

If so, then you are changing the values in an array object, and both put() calls are putting references to that same array for their values, so any change made to that array will be seen by both keys

If these explanations don't fit what you're doing, then I'm afraid I can't help you, since I don't feel like digging into your code or trying to understand the specifics of your map of lists of whatever.