Java:HashMap<String,String> storing same value as key and value.?

I am getting this strange output in HashMap.

I have two ArrayList<String> one containing the key and another containing value.

My HashMap<String,String> will store only string as key and value pair. But key itself is getting stored in value. I have checked my value arraylist, it's printing the value. But during putting it's setting it as key itself.

Code snippet is:

public HashMap<String,String> getLstBarring()
    {
        ArrayList<String> temparrLst=setPreParameters(fetchPreDetails, 1);
        System.out.println("KEY"    +  temparrLst);

        ArrayList<String> tempArrLstId=setPreParameters(fetchPreDetails, 14);
        System.out.println("VALUE"      +tempArrLstId);
        int length=tempArrLstId.size();

        for(int index=0;index<length;index++)
        {
            System.out.println("VALUE IN KEY"   +  temparrLst.get(index));
            System.out.println("VALUE IN VALUE"   +   tempArrLstId.get(index));
            this.lstBarring.put(temparrLst.get(index), tempArrLstId.get(index));
        }
        System.out.println("INSIDE ODB....>>>>>>>>>>>>>>"   + lstBarring);

    return this.lstBarring;
    }

Problem is:

• 1st SOP is KEY-printing all the key correctly.
• 2nd SOP is VALUE-printing all the value correctly.
• 3rd SOP is VALUE IN KEY----printing all the values.
• 4th SOP is VALUE IN VALUE--printing all the values.

Hence after ever iteration I am getting value,value in HashMap whereas it should be key,value.

Here's look at my 开发者_StackOverflowMethod:-

public ArrayList<String> setPreParameters(HashMap<Integer,String> fetchPreDetails,int index)
    {   
        switch(index)
        {

        case 1:
        {
            arrLstData.clear();
            splittedString=fetchPreDetails.get(1).split(",");
            Collections.addAll(arrLstData, splittedString); 
            break;

        }

return arrLstData;

Please guide me as to where am I going wrong.

My guess is that either fetchPreDetails is a collection being mutated by setPreParameters() or else setPreParameters() is mutating some other shared state so that the collection referenced by your temparrLst is being changed on the second call to setPreParameters(). I.e.

List<String> strings = new ArrayList();
strings.add("a");
strings.add("b");
List<String> otherStrings = strings;
otherStrings.add("c");

I expect your code assumes that strings would contain "a" and "b" and that otherStrings would contain "a", "b", and "c". This isn't how object references work in Java. The line List<String> otherStrings = strings; makes both strings and otherStrings point to the same collection, and thus changes made using either name affect the same thing.

Edit: Your newly-posted code seems to prove my hypothesis. You have a variable called arrLstData that you clear, populate, and return on each call to setPreParameters(). You're returning the same collection every time you call this method. Therefore you just have multiple handles to the same collection instead of multiple collections. You need to create a new collection and return it each time you call setPreParameters().

Edit again: Maybe this will make it clearer. Here's what you're doing:

public static void main(String[] args) {
    Foo f = new Foo();
    List<String> list1 = f.getList("a", "b");
    System.out.println(list1);
    List<String> list2 = f.getList("c", "d");
    System.out.println(list2);
    System.out.println(list1);
}

static class Foo {
    private List<String> myList = new ArrayList<String>();
    public List<String> getList(String... strings) {
        myList.clear();
        myList.addAll(Arrays.asList(strings));
        return myList;
    }
}

Note that this exhibits exactly the behavior that you're describing, and the correct way to solve it is something like this:

public static void main(String[] args) {
    Foo f = new Foo();
    List<String> list1 = f.getList("a", "b");
    System.out.println(list1);
    List<String> list2 = f.getList("c", "d");
    System.out.println(list2);
    System.out.println(list1);
}

static class Foo {
    public List<String> getList(String... strings) {
        List<String> result = new ArrayList<String>();
        result.addAll(Arrays.asList(strings));
        return result;
    }
}

You are reusing the same List over and over at your setPreParameters Method.
The List in arrLstData is returned and stored in temparrLst, now you are clearing the the Lists content, putting new stuff in it and storing it to tempArrLstId.
Now the three variables all contain the very same list (they are not equals, its the same!).
There is only one List object at the whole example!

Its like you got a box and label it "A" on one side put stuff in it, label it "B" on another side and wondering why the box "B" is empty when you turn box "A" upside-down.

Did you maybe mean something like this?

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class GlobalsMess {

    private Map<String, String> lstBarring = new HashMap<String, String>();
    private Map<Integer, String> fetchPreDetails = new HashMap<Integer, String>();

    public GlobalsMess() {
        fetchPreDetails.put(1, "john,vikam,david");
        fetchPreDetails.put(14, "1,2,3");
    }

    public Map<String, String> getLstBarring() {

        List<String> tempKeys = setPreParameters(fetchPreDetails.get(1));
        System.out.println("KEY" + tempKeys);

        List<String> tempIds = setPreParameters(fetchPreDetails.get(14));
        System.out.println("VALUE" + tempIds);

        for (int index = 0; index < tempIds.size(); index++) {
            System.out.println("VALUE IN KEY" + tempKeys.get(index));
            System.out.println("VALUE IN VALUE" + tempIds.get(index));
            this.lstBarring.put(tempKeys.get(index), tempIds.get(index));
        }
        System.out.println("INSIDE ODB....>>>>>>>>>>>>>>" + lstBarring);

        return this.lstBarring;
    }

    public List<String> setPreParameters(String fetchPreDetailsValue) {
        List<String> arrLstData = new ArrayList<String>();
        Collections.addAll(arrLstData, fetchPreDetailsValue.split(","));
        return arrLstData;
    }

    public static void main(String[] args) {
        new GlobalsMess().getLstBarring();
    }
}

Output:

KEY[john, vikam, david]
VALUE[1, 2, 3]
VALUE IN KEYjohn
VALUE IN VALUE1
VALUE IN KEYvikam
VALUE IN VALUE2
VALUE IN KEYdavid
VALUE IN VALUE3
INSIDE ODB....>>>>>>>>>>>>>>{david=3, vikam=2, john=1}