Java: Sorting multiple ArrayLists synchronously or a single mapped ArrayList

Question

I've only started learning Java about 3 months ago and this is my first post here, so please bear with me.

I have multiple ArrayLists built from parsed XML that are directly related to each other in order. The arrays are later put into a single mapped ArrayList (groupData) to be read with a SimpleAdapter which creates the list in the Android GUI.

What I want to do is sort the list in alphabetical order based on one array (arr_title) and the other arrays stay in synchronized order to it. It doesn't matter where the sorting happens as long as the final displayed list is sorted. I expect it would be best to sort the mapped array once it's built. The simpler or easier to understand the code the better, but don't want the sorting to go very slow either. I have about 140 objects per array, but that could expand considering the XML is pulled from the web.

I've spent hours searching Google and tried a number of things with little progress. Collections.sort(arr_title) will sort the one array as I want it, but then the other arrays don't match up and doing the same thing to the other arrays obviously just sorts them individually as I don't want. I've noticed mention of using the TreeMap type and Comparator for similar sorting, but couldn't figure out how to use them in this case probably because the examples didn't provide a big enough picture for me to understand.

The sample below is where most of the stuff happens after the separate arrays are created.

List<Map<String, String>> groupData = new ArrayList<Map<String, String>>();
Map<String, String> group;

int item = 0;
do {
    group = new HashMap<String, String>();
    group.put("title", arr_title.get(item));
    group.put("desc", arr_desc.get(item));
    group.put("num", Integer.toString(arr_num.get(item)));
    groupData.add(group);
    item++;
} while (item < arr_num.size());

SimpleAdapter adapter = new SimpleAdapter(this, groupData, android.R.layout.simple_list_item_2, new String[] {"title", "desc", "num"}, new int[]{android.R.id.text1, android.R.id.text2});
setListAdapter(adapter);

Answer 1

It sounds to me like you've make a classic beginner mistake (for which you can be forgiven): not thinking enough in terms of objects.

Java's an object-oriented language. It sounds to me like your multiple lists of related items should really be a single List of objects that each contain their set of the items you're currently putting into multiple lists. Then you can sort that List of Objects using a Comparator any way you wish. All the related attributes are nicely encapsulated inside their object, where they belong. They stay together no matter how you sort them.

Objects are all about encapsulation and information hiding.

Answer 2

Welcome to SO.

First of all, there are Java conventions to name the variables. Have a look at the Naming conventions

Secondly, Java is an Object Oriented Language, so you have to change your mind a little bit about how you approach problems.

In this particular case, you want all the data scattered among 3 arrays to be together. Well, create a class for it.

public class Data implements Comparable{
 private String title;
 private String desc;
 private int num;
 public Data(String title, String desc, int num){
  //set the private fields here
}
//You may want to write some setters and getters here for individual fields.

public int compareTo(Object o){
//here you compare an item with other item. Remember to cast the object o to Data.
// Read http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Comparable.html to know what to return
}

}

And then in your main class:

int item = 0;
do {
    Data group = new Data(arr_title.get(item),arr_desc.get(item),arr_num.get(item);
    groupData.add(group);
    item++;
} while (item < arr_num.size());
Collections.sort(groupData);

Last but not least, there are better ways to iterate through a set in Java. Read about Iterators. It's a much secure and cleaner way to go through an array or a set.

Answer 3

I finally figured it out! Thanks to a bigger project coming across a similar issue essentially forcing me to get this solved. Everything outside this sample is mostly the same as it was at the original post apart from some changed variable names. I'm not sure if this is the best way to do it, but it gets the job done at a very acceptable speed and I can actually understand how it works.

ArrayList<HashMap<String, String>> list = new ArrayList<HashMap<String, String>>();
// Put separated item details in a HashMap for each item,
// then insert it in sorted order to list.
for(int n = 0; n < arrayTitle.size(); n++) {
    HashMap<String, String> item = new HashMap<String, String>();
    item.put("title", arrayTitle.get(n));
    item.put("desc", arrayDesc.get(n));     
    try {
        int c, i = 0;
        do {
            // Compare new title with titles existing in list 
            // from beginning to end or until title is found that it goes before.
            c = arrayTitle.get(n).compareTo(list.get(i).get("title"));
            i++;
        } while (c > 0 & i < list.size());
        i--;
        if(c > 0) {
            // New item goes after all others currently in list.
            list.add(item);
        } else if (c < 0) {
            // New item goes before an item already in list.
            list.add(i, item);
        }
    } catch (Exception e) {
        // If nothing in list to compare with, add first item.
        list.add(item);
    }
}       
SimpleAdapter adapter = new SimpleAdapter(this, list, android.R.layout.simple_list_item_2, new String[] {"title", "desc"}, new int[]{android.R.id.text1, android.R.id.text2});
setListAdapter(adapter);