Java 按数组中的值对对象列表进行排序；

我有一个

目录包含1000多个项目

对于列表中的每个项目，我都有
id
，以获得我使用的
categories.getId（）

我有一个数组
int[]sortedIdArr={4,53102403110,5,6,8,12}

我想对我的
类别
列表进行排序，并根据
id
分类方式进行排序。
我如何实现这一点

private void sortBrandsById(List<Brand> categories) {
    Collections.sort(categories, new Comparator<Brand>() {
        public int compare(Brand o1, Brand o2) {

        }
    });    
}

private void sortBrandsById（列表类别）{
Collections.sort（categories，newcomparator（）{
公共int比较（品牌o1、品牌o2）{
}
});    
}

我可以使用集合。排序吗？
是您可以使用集合。排序（）

使用
id对您的
品牌进行排序：

public int compare(Brand o1, Brand o2) {
   return o1.getId().compareTo(o2.getId());
}

使用id数组对您的
品牌进行排序
sortediarr
：

public int compare(Brand o1, Brand o2) {
   return o1.getId().compareTo(o2.getId());
}

实现
比较器
类：

class C implements Comparator<A> {

    int[] idOrder;

    public C(int[] idOrder) {
        super();
        this.idOrder = idOrder;
    }

    @Override
    public int compare(A o1, A o2) {

        Integer indexofO1 = Arrays.binarySearch(idOrder, o1.getId());
        Integer indexofO2 = Arrays.binarySearch(idOrder, o2.getId());
        return indexofO1.compareTo(indexofO2);
    }
}

测试示例：

int[] idOrder = new int [] {3,1,2};
List<A> list = new ArrayList<>();

list.add(new A(1));
list.add(new A(2));
list.add(new A(3));

System.out.println(list);
//Output : [A [id=1], A [id=2], A [id=3]]

Collections.sort(list, new C(idOrder));

System.out.println(list);
//Output : [A [id=3], A [id=1], A [id=2]]

int[]idOrder=newint[]{3,1,2}；
列表=新的ArrayList（）；
增加（新的A（1））；
增加（新的A（2））；
增加（新的A（3））；
系统输出打印项次（列表）；
//输出：[A[id=1]，A[id=2]，A[id=3]]
Collections.sort（list，newc（idOrder））；
系统输出打印项次（列表）；
//输出：[A[id=3]，A[id=1]，A[id=2]]
通常您会使用
集合.sort
，或者Java 8中的等效惯用法（如果适用），或者使用排序的
集合
，例如
树集

但是在本例中，您希望遵循预定义的顺序，该顺序由
sortedIdArr
数组指定

实现这一点的一种方法是使用链接的集合（例如
LinkedHashSet
）

然后迭代
sortedIdArr
数组，并在
列表中搜索具有给定ID的对象

如果找到，则将具有给定ID的
品牌
对象添加到您的
LinkedHashSet
，该对象将保留插入顺序

请注意，如果找不到ID，则您的
集合
将不会与数组完全“匹配”

使用Java 8的自封闭示例

package test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Optional;
import java.util.Set;


public class Main {

    // simplified Brand pojo
    static class Brand {
        int id;
        public Brand(int id) {
            this.id = id;
        }
        public int getId() {
            return id;
        }

        // for output clarity
        @Override
        public String toString() {
            return String.format("Brand: %d", id);
        }
    }

    public static void main(String[] args) throws Exception {

        // simplified ID list
        int[] sortedIdArr = {4,53,102};
        // "randomly" ordered Brand list
        final List<Brand> categories = new ArrayList<Brand>() {  
            {
                add(new Brand(1));
                add(new Brand(102));
                add(new Brand(53));
                add(new Brand(4));
                add(new Brand(0));
            }
        };
        // destination: linked set
        Set<Brand> linked = new LinkedHashSet<Brand>();
        // streaming the ID array in order
        Arrays.stream(sortedIdArr)
            .forEach((i) -> {
                // retrieving a Brand with same ID as the current
                // from the "randomly" ordered list
                Optional<Brand> toAdd = categories.stream()
                .filter((b) -> b.getId() == i)
                .findFirst();
                // making sure there's one
                if (toAdd.isPresent()) {
                    // adding to linked set
                    linked.add(toAdd.get());
                }
            }
        );
        System.out.println(linked);
    }

}

旧Java版本的命令式习惯用法

for (int i: sortedIdArr) {
    for (Brand b: categories) {
        // assuming no nulls
        if (b.getId() == i) {
            linked.add(b);
            break;
        }
    }
}

您可以使用
Collections.sort（…）
进行排序，但我强烈建议在列表中有这么多项的情况下，不要使用
Comparator
方法

您可以在
列表类别
上有一个循环，并将它们添加到名为tempMap的
HashMap中。然后使用它按
sortedIdArr
数组的顺序查找它们。按如下方式更改排序方法：

private void sortBrandsById(List<Brand> categories, int [] sortedIdArr) {
    HashMap<Integer,Brand> tempMap = new HashMap<Integer, Brand>(categories.size());
    for (int i = 0; i < categories.size(); i++) {
        tempMap.put(categories.get(i).getId(), categories.get(i));
    }
    categories = new ArrayList<Brand>(sortedIdArr.length);
    for (int i = 0; i < sortedIdArr.length; i++) {
        categories.add(tempMap.get(sortedIdArr[i]));
    }
}

private void sortBrandsById（列表类别，int[]sortediarr）{
HashMap tempMap=newhashmap（categories.size（））；
对于（int i=0；i

这种排序方式是从顺序
O（n）
开始的，用于创建
tempMap
+
O（n）
以重新创建
类别
列表。虽然HashMap的get/put操作不能保证使用
O（1）
，但是java体面的哈希实现非常好而且可靠。因此，总的复杂度不能大于
O（n）
。至少它比
O（n^2）
好得多。时间复杂性非常重要，我认为你找不到比非常接近
O（n）
复杂性更好的方法

希望这会有所帮助。
您可以使用以下代码（您需要Apache commons lang jar，否则必须遍历数组以查找索引）

private static void sortBrandsById（列表类别，int[]数组）{
Collections.sort（categories，newcomparator（）{
公共int比较（品牌o1，品牌o2）{
返回ArrayUtils.indexOf（array，o1.getId（））-ArrayUtils.indexOf（array，o2.getId（））；
}
});    
}

如果您能够将预定义的排序顺序放在列表中而不是数组中，这将更加容易。
在
sortedIdArr
中检查两个ID的索引，并比较这些索引。如果
o1id
的索引小于
o2id
，那么它应该返回
1
，
-1
的索引，如果相等，则返回
0
。他希望按照
sorteddarr
中ID的顺序对类别列表进行排序。您的方法按品牌的id属性以升序方式对列表进行排序。它与
sortedIdArr
.Thks gays.中列出的ID顺序无关。。我更新了我的答案以解决sortedIdArr问题：）。。您可以检查它是否是一种很好的方法，但避免使用Java8是真的吗？我在android中使用这段代码，目前java 8存在问题。@VLeonovs如果你在android上，你可以忘记java 8习惯用法，是的：）但是你可以相对容易地将其转换为java 6样式的方法-请参阅我的编辑。
private void sortBrandsById(List<Brand> categories, int [] sortedIdArr) {
    HashMap<Integer,Brand> tempMap = new HashMap<Integer, Brand>(categories.size());
    for (int i = 0; i < categories.size(); i++) {
        tempMap.put(categories.get(i).getId(), categories.get(i));
    }
    categories = new ArrayList<Brand>(sortedIdArr.length);
    for (int i = 0; i < sortedIdArr.length; i++) {
        categories.add(tempMap.get(sortedIdArr[i]));
    }
}

private static void sortBrandsById(List<Brand> categories,int[] array) {


            Collections.sort(categories, new Comparator<Brand>() {
                public int compare(Brand o1, Brand o2) {                            

    return ArrayUtils.indexOf(array,o1.getId())-ArrayUtils.indexOf(array,o2.getId());
                }
            });    
        }