Java 重新排列arraylist中的对象 public void go（） { ArrayList=新的ArrayList（）； 水果。添加（“梨”）； 水果。加入（“菠萝”）； 水果。添加（“橙子”）； 水果。添加（“香蕉”）； 水果。添加（“苹果”）； 用于（字符串str:fruits） { 如果（str.contains（“苹果”）） {/*我想要任何包含“苹果”的东西 *即苹果和菠萝放在阵列顶部*/} } 用于（字符串str:fruits） { 系统输出打印项次（str）； } }

如您所见，上述代码如果按正常方式打印，将导致

梨，菠萝，橙子，香蕉，苹果

我如何对这个数组进行排序，就像苹果的任何东西都会先按字母顺序排序，而那些不按字母顺序排序的东西应该保持不变一样。i、 e，输出应如下所示：

苹果，菠萝，梨，橙子，香蕉

---

甚至有没有一种可能的方法可以绕过它呢？

我会将列表分成两部分：包含

apple

的项目和不包含

的项目。然后对包含apple的列表进行排序，然后附加非包含apple的列表

public void go()
{
    ArrayList<String> fruits = new ArrayList<>();

    fruits.add("pear");
    fruits.add("pineapple");
    fruits.add("oranges");
    fruits.add("banana");
    fruits.add("apple");

    for(String str: fruits)
    {
         if(str.contains("apple"))
         {   /* I would like anything containing 'apple' 
          * i.e. apple & pineapple to be placed on top of the array*/   }
    }
    for(String str: fruits)
    {
        System.out.println(str);
    }
}

List apples=new ArrayList（）；
列表非应用程序=新建ArrayList（）；
用于（串水果：水果）{
if（含有水果（“苹果”））{
苹果。加入（水果）；
}否则{
添加（水果）；
}
}
收集。分类（苹果）；
苹果。addAll（非苹果）；
//苹果现在含有你想要的东西。当然，现在它的名字错了：）

作为最后几行的备选方案，创建“仅苹果”列表的副本：

List<String> apples = new ArrayList<>();
List<String> nonApples = new ArrayList<>();
for (String fruit : fruits) {
  if (fruit.contains("apple")) {
    apples.add(fruit);
  } else {
    nonApples.add(fruit);
  }
}
Collections.sort(apples);
apples.addAll(nonApples);
// apples now contains what you want. Of course, it's now misnamed :)

列表结果=新的ArrayList（苹果）；
集合。排序（结果）；
结果：addAll（非应用程序）；

这几乎等同于JB Nizet的方法，只是它只检查每个项目的苹果容器一次，而不是检查原始列表两次。除非您的实际支票非常昂贵，否则这不太可能成为性能瓶颈，所以请使用您喜欢的方法

现在还不清楚您是否需要将结果放在原始列表中，或者是否可以将结果放在新列表中

如果需要将它们放在原始列表中，则始终可以使用：

List<String> result = new ArrayList<>(apples);
Collections.sort(result);
result.addAll(nonApples);

for（int i=0；i

使用
Collections.sort
的方法依赖于它的稳定性，这很有趣，但我个人觉得它们不如这种方法清晰。
比较法不是正确的答案。我会这样做：

for (int i = 0; i < result.size(); i++) {
  fruits.set(i, result.get(i));
}

List containingApple=new ArrayList（）；
用于（字符串s:列表）{
如果（s.包含（“苹果”））{
包含苹果。添加；
}
}
Collections.sort（包含apple）；
列表结果=新的ArrayList（List.size（））；
结果：addAll（包含apple）；
用于（字符串s:列表）{
如果（！s.包含（“苹果”））{
结果。添加（s）；
}
}
您还可以将
Collections.sort（）方法与自定义的一次性比较器一起使用，如下所示：

List<String> containingApple = new ArrayList<>();
for (String s : list) {
    if (s.contains("apple")) {
        containingApple.add(s);
    }
}
Collections.sort(containingApple);
List<String> result = new ArrayList<>(list.size());
result.addAll(containingApple);
for (String s : list) {
    if (!s.contains("apple")) {
        result.add(s);
    }
}

Collections.sort（水果，新比较器（）{
@凌驾
公共整数比较（字符串arg0、字符串arg1）{
如果（arg0.contains（“苹果”）和&arg1.contains（“苹果”））{
返回arg0.compareTo（arg1）；
}
else if（arg0.contains（“苹果”）和&！arg1.contains（“苹果”））{
返回-1；
}
如果（！arg0.contains（“苹果”）和&arg1.contains（“苹果”），则为else{
返回1；
}否则返回0；
} });

请注意，
else return 0的最终语句对于确保不包含“apple”的其他值不会被排序至关重要。
这是一段相当难看的代码，但它确实起到了作用。

其思想是实现一个
比较器
，如果两个字符串都包含
apple
，则按字典顺序对它们进行比较，如果其中只有一个包含，则将其视为“较小”，如果两者都不包含，则将其视为“相等”（即，我们返回0，并且不改变顺序）

公共类AppleStringComparator实现Comparator{
@凌驾
公共整数比较（字符串o1、字符串o2）{
如果（o1.包含（“苹果”））{
如果（含氧气（“苹果”））{
返回o1。与（o2）相比；
}否则{
返回-1；
}
}否则{
如果（含氧气（“苹果”））{
返回1；
}否则{
返回0；
}
}
}
}
公共类主类{
公开作废go（）{
//来自OP的示例代码
ArrayList=新的ArrayList（）；
水果。添加（“梨”）；
水果。加入（“菠萝”）；
水果。添加（“橙子”）；
水果。添加（“香蕉”）；
水果。添加（“苹果”）；
Collections.sort（水果，新AppleStringComparator（））；
//为了完整起见，打印出结果：
系统输出打印LN（水果）；
}
我在想，搜索整个数组，找到包含苹果的字符串，然后将它们挑选出来，放入新的数组列表中。接下来，我将对新数组进行排序，然后首先放入第三个数组中。接下来，第一个数组中剩余的内容将添加到第三个数组中。我明白了吗？@RohitJain，b因为菠萝确实包含“苹果”。这就是为什么它是按字母顺序排列的。当然，这只是我的代码片段，因为我的原始代码和数组要大得多。但这当然是我的想法。现在我重新阅读了你的问题，这正是我要做的-但是使用列表，而不是数组。谢谢大家的使用我想，既然我对Comparator类不太熟悉，而且将我的列表分成两个列表会更容易实现和理解，我决定采用这种方法。当然，我学到了我所期望的更多概念。我感谢这里的所有帮助。：）仅供参考：我选择不为非应用程序beca提供列表使用我的猜测是，它将包含几乎所有的e
Collections.sort(fruits, new Comparator<String>(){

        @Override
        public int compare(String arg0, String arg1) {
            if (arg0.contains("apple") && arg1.contains("apple")) {
                return arg0.compareTo(arg1);
            }
            else if (arg0.contains("apple") && !arg1.contains("apple")){
                return -1;
            }
            else if (!arg0.contains("apple") && arg1.contains("apple")){
                return 1;
            } else return 0;
        } });

public class AppleStringComparator implements Comparator<String> {

    @Override
    public int compare(String o1, String o2) {
        if (o1.contains("apple")) {
            if (o2.contains("apple")) {
                return o1.compareTo(o2);
            } else {
                return -1;
            }
        } else {
            if (o2.contains("apple")) {
                return 1;
            } else {
                return 0;
            }
        }
    }
}

public class MainClass {
    public void go() {
        // The example code from the OP
        ArrayList<String> fruits = new ArrayList<>();

        fruits.add("pear");
        fruits.add("pineapple");
        fruits.add("oranges");
        fruits.add("banana");
        fruits.add("apple");

        Collections.sort(fruits, new AppleStringComparator());

        // Print out the result, for completeness' sake:
        System.out.println(fruits);
}