Java：ArrayList <HashMap<Integer,Integer> &gt;

Question

Is there a better approach to do the below in Java, without using external libraries.

I need to model group/child (tree like) structure of int (primitive). In Json

[{1,1}, {1,2}, {2,1},{3,1}]

I need to support addition/removal of elements (element is a pair {group, child} ) without duplication.

I am thinking of, keeping a data structure like.

ArrayList<HashMap<Integer,Integer>>

To add.

Iterate through ArrayList, check HashMap key and value against the value to insert, and insert if not exist.

To delete:

Iterate through ArrayList, check HashMap key and value against the value to delete, and delete if exist.

Is there a better data structure/approach with standard library.

---

As per one of the answer below, I made a class like this. Please let me know anything to watchout. I am expecting (and going to try out) arraylist would handle add/remove correctly by using the equal method in KeyValue class. thanks.

 static class KeyValue {
        int groupPos;
        int childPos;

        KeyValue(int groupPos, int childPos) {
            this.groupPos = groupPos;
            this.childPos = childPos;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;

            KeyValue keyValue = (KeyValue) o;

            if (childPos != keyValue.childPos) return false;
            if (groupPos != keyValue.groupPos) return false;

            return true;
        }

        @Override
        public int hashCode() {
            int result = groupPos;
            result = 31 * result + childPos;
            return result;
        }
    }

Answer 1

If I understand what you're trying to do, this may be simpler:

TreeMap<Integer,TreeSet<Integer>>
  or
HashMap<Integer,HashSet<Integer>>

So, rather than

[{1,1}, {1,2}, {2,1}, {3,1}]

you'd have

[{1, {1, 2}},
 {2, {1}},
 {3, {1}}]

Note that all 4 of the above classes automatically handles eliminating duplicates.

To add:

TreeMap<Integer, TreeSet<Integer>> map;
TreeSet<Integer> set = map.get(group);
if (set == null) // create it if it doesn't exist
{
  set = new TreeSet<Integer>();
  map.put(group, set);
}
set.add(child);

To remove:

TreeMap<Integer, TreeSet<Integer>> map;
TreeSet<Integer> set = map.get(group);
set.remove(child);
if (set.isEmpty()) // remove it if it is now empty
  map.remove(group);

Answer 2

You may write a class with name KeyValue with two properties to hold group and child. Add KeyValue Objects to ArrayList . For CRUD operations, you may implement equals and compare in your KeyValue pair class.

Answer 3

Instead of HashMap , use a class called Pair with two fields {group,child} which will implement Comparable interface. Then implement/override its equals() , hashCode() and compareTo() methods. Then use either a List<Pair> or Set<Pair> depending on your needs to hold them. Having compareTo() implemented gives you the flexibility to sort Pairs easily too.

Answer 4

I am new to the Data Structure world but I think we can use this based on the assumption that no two Set Objects will be similar

Set validSet=new HashSet(); // Use Generics here

HashSet will provide a constant time for add/delete/contains

SomeObject{
     Integer parent ;
     Integer child;
     //define equals method based on your requirement
}

Answer 5

Going By your Question i think that You want to show this line

[{1,1}, {1,2}, {2,1},{3,1}]

as

Group 1-> 1 , 2 (from first two pair)
Group 2-> 1(from third pair)
Group 3-> 1 (from fourth pair)

The data structure that suites most for storing this hierarchy is :

Map<Integer,Set<Integer>> map = new HashMap<Integer,Set<Integer>>();

Where the key part of map stores the group Number. And the value part of map is storing TreeSet which stores the children of that group.
As Example of code:

import java.util.HashMap;
import java.util.ListIterator;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
class  TreeLike
{
    public static void main(String[] args) 
    {
        Map<Integer,Set<Integer>> map = new HashMap<Integer,Set<Integer>>();
        int groups[] = {1,2,3,4,5,6,7};
        //To add new group in map
        for (int i = 0 ; i < groups.length; i++)
        {
            Set<Integer> child = new TreeSet<Integer>();
            child.add(1);child.add(2);child.add(3);child.add(4);child.add(5);
            map.put(groups[i],child);
        }
        //To add new child(8) to a group (say group 1)
        Set<Integer> child = map.get(1);
        if (child != null)
        {
            child.add(8);
            map.put(1,child);
        }

        //To remove a child (say child 4) from group 3
        child = map.get(3);
        if (child != null)
        {
            child.remove(4);
            map.put(1,child);
        }
        //To Iterate through all trees
        Set<Map.Entry<Integer,Set<Integer>>> entrySet = map.entrySet();
        Iterator<Map.Entry<Integer,Set<Integer>>> iterator = entrySet.iterator();
        while (iterator.hasNext())
        {
            Map.Entry<Integer,Set<Integer>> entry = iterator.next();
            int group = entry.getKey();
            Set<Integer> children = entry.getValue();
            System.out.println("Group "+group+" children-->"+children);
        }
    }
}