1

Objects in ArrayList<CustomObject> array A are unsorted:

ID: [6, 3, 2, 5, 4, 1]

From another part of a program I received array B. Need to sort objects in array A by property int ID in the way array B is sorted: 

[3, 6, 4, 5, 1, 2]

So array A should be finally sorted like:

[3, 6, 4, 5, 1, 2]

So the objects in array A are sorted by ID exactly like items in array B are.

What would be the best way to implement it?

Improve this question
10
  • What is benchmark ordering? Commented Dec 13, 2015 at 3:40
  • @cricket_007, the final look of the order I need to achieve Commented Dec 13, 2015 at 3:41
  • Are you trying to sort with respect to something? What is your comparison function? Your result is not ascending or descending, so it will be difficult to get what you are looking for. Commented Dec 13, 2015 at 3:42
  • @cricket_007, yeap, it's not just asc or desc or something... it's an array of identificators I received from another function and need to apply them to sort Objects in ArrayList. So this ArrayList is sorted by it's ID field in the way the array is set Commented Dec 13, 2015 at 3:45
  • Say I received an array of "Apple", "Orange" and "Banana" and put them in my bag in this order. But Mom came and said "Hey, you should put them like: "Orange" -> "Apple" -> "Banana". Commented Dec 13, 2015 at 3:48

3 Answers 3

Reset to default
3

Try this.

    List<CustomObject> a = Arrays.asList(
        new CustomObject(6),
        new CustomObject(3),
        new CustomObject(2),
        new CustomObject(5),
        new CustomObject(4),
        new CustomObject(1)
    );
    System.out.println(a);
    int[] b = {4, 6, 5, 3, 1, 2};
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < b.length; ++i)
        map.put(b[i], i);
    // for Java8
    // Collections.sort(a, (l, r) -> map.get(l.id) - map.get(r.id));
    Collections.sort(a, new Comparator<CustomObject>() {
        @Override
        public int compare(CustomObject l, CustomObject r) {
            return map.get(l.id) - map.get(r.id);
        }
    });
    System.out.println(a);
Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

thanks, seems to be a solution. But could you please rework it without using lambdas? Android does not complie on Java 1.8, that's a pity cricket_007 removed my Android tags from the question
How does " (l, r) -> map.get(l.id) - map.get(r.id) " work??
@saka1029 wrong 2nd argument type. Found: ...CustomObject, required java.util.Comparator<? super java.lang.Integer> on sort function
Is 1st argument type List<CustomObject>?
Finally worked exactly like was suggested, thanks a lot!
0

This may helpful to you :

public static void main(String[] args) {
    HashMap<Integer, Integer> myMap = new HashMap();
    int arrayA[] = {6, 3, 2, 5, 4, 1};
    int arrayB[] = {3, 6, 4, 5, 1, 2};
    for (int i = 0; i < arrayA.length; i++) {
        if (myMap.containsKey(arrayA[i])) {
            int pValue = myMap.get(arrayA[i]);
            pValue++;
            myMap.put(arrayA[i], pValue);
        } else if (!myMap.containsKey(arrayA[i])) {
            myMap.put(arrayA[i], 1);
        }
    }
    int l = 0;
    for (int i = 0; i < arrayB.length; i++) {
        if (myMap.containsKey(arrayB[i])) {
            int pValue = myMap.get(arrayB[i]);
            for (int k = 0; k < pValue; k++) {
                arrayA[l++] = arrayB[i];
            }
        }
    }
    System.out.println(Arrays.toString(arrayA));

}

Out-put :

[3, 6, 4, 5, 1, 2]
Improve this answer

1 Comment

Duplicate contains on the same element is needlessly costly.
0

Approach

  1. First create a comparator object initialize it with the required arrayOrder
  2. Call the Collection.sort with the comparator object

I understand that this could be an over kill for a simple solution mentioned above. but I have tried to exploit Comparator interface from the java.utils

import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;

class CustomerCompartor implements Comparator<Customer> {
    @SuppressWarnings("rawtypes")
    ArrayList arrayOrder;

    @SuppressWarnings("unchecked")
    public CustomerCompartor(Integer[] arrayOrderInt) {
        this.arrayOrder = new ArrayList(Arrays.asList(arrayOrderInt));

    }

    public int compare(Customer cust1, Customer cust2) {

        int cust1Order = this.arrayOrder.indexOf(cust1.getId());
        int cust2Order = this.arrayOrder.indexOf(cust2.getId());
        return cust1Order - cust2Order;
    }
}

class Customer {

    int id;

    public Customer(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

public class ArrayOrder {
    public static void main(String[] args) {
        List<Customer> customerArray = new ArrayList<Customer>();

        customerArray.add(new Customer(1));
        customerArray.add(new Customer(2));
        customerArray.add(new Customer(3));
        customerArray.add(new Customer(4));
        customerArray.add(new Customer(5));
        customerArray.add(new Customer(6));

        for (Customer cust : customerArray) {
            System.out.println(cust.getId());
        }

        Integer[] arrayOrder = new Integer[] { 3, 6, 4, 5, 1, 2 };

        CustomerCompartor comparator = new CustomerCompartor(arrayOrder);
        Collections.sort(customerArray, comparator);

        for (Customer cust : customerArray) {
            System.out.println(cust.getId());
        }

    }
}
Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.