Java 基于对另一个ArrayList的排序对ArrayList进行排序

我在一个类（

GlobalDataHolder.cardNameAndDescription

）中有一个

ArrayList（）

），我想按字母顺序对它进行排序，但在对前面提到的

ArrayList（）进行排序时，我也想对
ArrayList（）
（
UserBoxGlbImageAdapter.mGLBIcons
）进行排序

旁注：两个数组的大小均为3（0-2）

我正在编写自己的自定义compare（）方法来完成此操作，但我没有实现我所寻找的。当我单击运行排序代码的按钮时，除非我单击按钮3次，否则无法实现正确的顺序，尽管
字符串数组列表
确实按字母顺序排序。所以我想我只需要按照数组大小的多少对数组进行排序（大约3倍）

总之，字符串和整数数据的顺序应该是相同的，因为它们依赖于它的另一个，但我不能让这两个数组都工作

这些都不管用。有人能告诉我第二个数组的排序有什么问题吗？这是我的密码：

public class SortingDialog extends DialogFragment {

@NonNull
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    // Create a builder to make the dialog building process easier
    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
    builder.setTitle("Sorting Dialog");
    builder.setSingleChoiceItems(R.array.sorting_options, 0,
            new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialogInterface, int i) {
                    if (i == 1) {
                        Toast.makeText(getActivity(), "2nd option Clicked", Toast.LENGTH_SHORT).show();
                        if (getActivity().getSupportFragmentManager().findFragmentByTag("GLOBAL_FRAGMENT") != null) {
                            sortGlobalListsBasedOnNameAndDesc();
                        }
                    }
                    for (int j = 0; j < GlobalDataHolder.cardNameAndDescription.size(); j++) {
                        Log.v("card_names", GlobalDataHolder.cardNameAndDescription.get(j));
                    }
                }
            });
    builder.setPositiveButton("OK", new DialogInterface.OnClickListener() {
        @Override
        public void onClick(DialogInterface dialogInterface, int i) {
            createToast();
            dismiss();
        }
    });
    builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
        @Override
        public void onClick(DialogInterface dialogInterface, int i) {
            dismiss();
        }
    });
    return builder.create();
}

private void sortGlobalListsBasedOnNameAndDesc() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
        GlobalDataHolder.cardNameAndDescription.sort(new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                int id1 = GlobalDataHolder.cardNameAndDescription.indexOf(s1);
                int id2 = GlobalDataHolder.cardNameAndDescription.indexOf(s2);

                if (s1.equals(s2)) {
                    return 0;
                } else if (s1.compareToIgnoreCase(s2) > 0) { //s1 is greater
                    //Collections.swap(UserBoxGlbImageAdapter.mGLBIcons,id2,id1);
                    swap(UserBoxGlbImageAdapter.mGLBIcons,id2,id1);
                    swap(GlobalDataHolder.cardNameAndDescription,id2,id1);
                    Log.d("case1","Called 1 time");
                    return 1;
                } else if (s1.compareToIgnoreCase(s2) < 0) { //s1 is smaller
                    //Collections.swap(UserBoxGlbImageAdapter.mGLBIcons,id1,id2);
                    swap(UserBoxGlbImageAdapter.mGLBIcons,id1,id2);
                    swap(GlobalDataHolder.cardNameAndDescription,id1,id2);
                    Log.d("case2","Called 1 time");
                    return -1;
                } else {
                    return 0;
                }
            }
        });
    }
}

private void swap(List list,int objIndex1, int objIndex2) {
    for (int i=0;i < list.size(); i++) {
        Collections.swap(list,objIndex1,objIndex2);
        UserBoxGlbImageAdapter.refreshFragmentView(UserBoxGLBFragment.getUserBoxAdapter());
    }
}

private void createToast() {
    Toast.makeText(getActivity(), "Cards sorted based on AVG Stats", Toast.LENGTH_SHORT).show();
}
}

公共类排序对话框扩展了DialogFragment{
@非空
@凌驾
创建对话框上的公共对话框（Bundle savedInstanceState）{
//创建一个生成器，以简化对话框的生成过程
AlertDialog.Builder=新建AlertDialog.Builder（getActivity（））；
builder.setTitle（“排序对话框”）；
builder.setSingleChoiceItems（R.array.sorting_选项，0，
新建DialogInterface.OnClickListener（）{
@凌驾
公共void onClick（DialogInterface，inti）{
如果（i==1）{
Toast.makeText（getActivity（），“单击第二个选项”，Toast.LENGTH_SHORT.show（）；
if（getActivity（）.getSupportFragmentManager（）.findFragmentByTag（“全局_片段”）！=null）{
SortGlobalListBasedOnNameandDesc（）；
}
}
对于（int j=0；j=Build.VERSION\u code.N）{
GlobalDataHolder.cardNameAndDescription.sort（新的比较器（）{
@凌驾
公共整数比较（字符串s1、字符串s2）{
int id1=GlobalDataHolder.cardname和description.indexOf（s1）；
int id2=GlobalDataHolder.cardname和description.indexOf（s2）；
如果（s1等于（s2））{
返回0；
}如果（s1.compareToIgnoreCase（s2）>0）{//s1大于
//swap（UserBoxGlbImageAdapter.mGLBIcons，id2，id1）；
交换（UserBoxGlbImageAdapter.mGLBIcons，id2，id1）；
掉期（GlobalDataHolder.CardName和Description，id2，id1）；
Log.d（“案例1”，“被叫1次”）；
返回1；
}else如果（s1.compareToIgnoreCase（s2）<0）{//s1更小
//swap（UserBoxGlbImageAdapter.mGLBIcons，id1，id2）；
交换（UserBoxGlbImageAdapter.mGLBIcons，id1，id2）；
交换（GlobalDataHolder.CardName和Description，id1，id2）；
日志d（“案例2”，“调用1次”）；
返回-1；
}否则{
返回0；
}
}
});
}
}
专用无效交换（列表列表，int-objIndex1，int-objIndex2）{
对于（int i=0；i
对索引列表而不是列表本身进行排序并不困难。从此，您可以轻松地重新排列列表

public class Test {
    List<String> testStrings = Arrays.asList(new String[]{"One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten"});
    List<Integer> testNumbers = Arrays.asList(new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10});

    static <T extends Comparable<T>> List<Integer> getSortOrder(List<T> list) {
        // Ints in increasing order from 0. One for each entry in the list.
        List<Integer> order = IntStream.rangeClosed(0, list.size() - 1).boxed().collect(Collectors.toList());
        Collections.sort(order, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                // Comparing the contents of the list at the position of the integer.
                return list.get(o1).compareTo(list.get(o2));
            }
        });
        return order;
    }

    static <T> List<T> reorder(List<T> list, List<Integer> order) {
        return order.stream().map(i -> list.get(i)).collect(Collectors.toList());
    }

    public void test() {
        System.out.println("The strings: " + testStrings);
        List<Integer> sortOrder = getSortOrder(testStrings);
        System.out.println("The order they would be if they were sorted: " + sortOrder + " i.e. " + reorder(testStrings, sortOrder));
        List<Integer> reordered = reorder(testNumbers, sortOrder);
        System.out.println("Numbers in alphabetical order of their names: " + reordered);
    }

    public static void main(String[] args) {
        new Test().test();
        System.out.println("Hello");
    }
}

公共类测试{
List testStrings=Arrays.asList（新字符串[]{“一”、“二”、“三”、“四”、“五”、“六”、“七”、“八”、“九”、“十”}）；
List testNumbers=Arrays.asList（新的整数[]{1,2,3,4,5,6,7,8,9,10}）；
静态列表getSortOrder（列表列表）{
//整数从0递增。列表中的每个条目对应一个整数。
List order=IntStream.rangeClosed（0，List.size（）-1）.boxed（）.collect（Collectors.toList（））；
Collections.sort（order，newcomparator（）{
@凌驾
公共整数比较（整数o1，整数o2）{
//比较整数位置处的列表内容。
返回list.get（o1）.compareTo（list.get（o2））；
}
});
退货单；
}
静态列表重新排序（列表、列表顺序）{
returnorder.stream（）.map（i->list.get（i））.collect（Collectors.toList（））；
}
公开无效测试（）{
System.out.println（“字符串：“+testStrings”）；
List sortOrder=getSortOrder（testStrings）；
System.out.println（“如果对它们进行排序，它们的顺序是：“+sortOrder+”，即“+reorder（testStrings，sortOrder））；
列表重新排序=重新排序（TestNumber，sortOrder）；
System.out.println（“按名称字母顺序排列的数字：”+重新排序