Java 将ArrayList排序为对象类型，然后按字母顺序排序

我已经定义了一个arrayList

每个对象都有自己的名称等。 我想把它们按类型分类，这样所有的西瓜都在一起，梨都在一起等等。然后在每个时间内按字母顺序对它们进行分类

使用

public int compare(String[] first, String[] second) {
    return first[1].compareTo(second[1]);
}

---

也可以只在已创建的类中执行此操作，以避免在新类中执行此操作。

关闭，但您将无法将

字符串

数组作为参数传递给比较方法。您需要创建一个

比较器

，参数将是

食品

参考

---

然后在

compare（Food f1，Food f2）

方法中，您需要比较类，如果它们相同，则比较名称。

关闭，但您将无法将

String

数组作为参数传递给compare方法。您需要创建一个

比较器

，参数将是

食品

参考

---

然后在

compare（Food f1，Food f2）

方法中，您需要比较类，如果它们相同，则比较名称。

您非常接近。您可以这样做（只需一次匿名实现

Comparator

接口，就不需要新类）：

Collections.sort（foodList，newcomparator（）{
@凌驾
公共整数比较（食品1、食品2）{
int结果=0；
if（food1.getType（）.equals（food2.getType（）））{
结果=food1.getName（）.compareTo（food2.getName（））；
}否则{
结果=food1.getType（）.compareTo（food2.getType（））；
}
返回结果；
}
});

另一种方法是让

Food

实现

compariable

，并对

comparieto（to）

实现使用相同的逻辑

---

比较首先检查食物类型是否相等（假设食物类型具有适用的

equals（）

方法）。如果它们相等，则需要根据它们的名称进行比较。否则，将根据食物类型进行比较。

您非常接近。您可以这样做（只需一次匿名实现

Comparator

接口，就不需要新类）：

Collections.sort（foodList，newcomparator（）{
@凌驾
公共整数比较（食品1、食品2）{
int结果=0；
if（food1.getType（）.equals（food2.getType（）））{
结果=food1.getName（）.compareTo（food2.getName（））；
}否则{
结果=food1.getType（）.compareTo（food2.getType（））；
}
返回结果；
}
});

另一种方法是让

Food

实现

compariable

，并对

comparieto（to）

实现使用相同的逻辑

---

比较首先检查食物类型是否相等（假设食物类型具有适用的

equals（）

方法）。如果它们相等，则需要根据它们的名称进行比较。否则，将根据食品类型进行比较。

您可以在

食品

实现或子类中实现

可比

接口。尽管编写一个适用于您的案例的实现很容易，但它并不像编写一个完全正确的

可比的
实现那样简单，特别是在继承方面。有关需求和常见缺陷的详细文档，请参见有效Java，第12项。
您可以在
食品
实现或子类中实现
可比
接口。尽管编写一个适用于您的案例的实现很容易，但它并不像编写一个完全正确的
可比的
实现那样简单，特别是在继承方面。有关需求和常见缺陷的详细文档，请参见有效Java，第12项。
您的比较方法名称错误。它将与可比接口进行比较：

public int compareTo(Fruit second) {
 return this.getWaterMelon().compareTo(second.getWaterMelon());
}

您的比较方法名称错误。它将与可比接口进行比较：

public int compareTo(Fruit second) {
 return this.getWaterMelon().compareTo(second.getWaterMelon());
}

我想说的是，您的
compare（）
方法需要为您的
类型
compareTo（）差异+
name
compareTo（）差异返回加权值。

差不多

public int compare(Food food1, Food food2) {
   int result = 0;
   result = food1.getType().compareTo(food2.getType()) * someMultiplier + food1.getName().compareTo(food2.getName());
   return result;
}

编辑：
这就是我建议的用法

public class ComparatorTest {

    static class ComaparableObject implements Comparable {
        private Object value1;
        private Object value2;

        public ComaparableObject(Object value1, Object value2) {
            this.value1 = value1;
            this.value2 = value2;
        }

        @Override
        public int compareTo(Object o) {
            int multiplier = 65535;
            ComaparableObject co = (ComaparableObject) o;
            int result = (value1.hashCode() * multiplier + value2.hashCode()) - (co.value1.hashCode() * multiplier + co.value2.hashCode()) ;
            return result;
        }

        public Object getValue1() {
            return value1;
        }

        public void setValue1(Object value1) {
            this.value1 = value1;
        }

        public Object getValue2() {
            return value2;
        }

        public void setValue2(Object value2) {
            this.value2 = value2;
        }

        public String toString() {
            String result = "value1=" + value1 + ", " + "value2=" + value2;
            return result;
        }

    }

    public static void main(String[] args) {
        ArrayList<ComaparableObject> al;


        al = new ArrayList<ComaparableObject>();
        ComaparableObject co;
        int value1 = 2;
        co = new ComaparableObject(value1, 3);
        al.add(co);
        co = new ComaparableObject(value1, 1);
        al.add(co);
        co = new ComaparableObject(value1, 2);
        al.add(co);
        value1 = 1;
        co = new ComaparableObject(value1, 3);
        al.add(co);
        co = new ComaparableObject(value1, 1);
        al.add(co);
        co = new ComaparableObject(value1, 2);
        al.add(co);

        System.out.println("Before sort: " + al);

        Collections.sort(al, new Comparator<ComaparableObject>() {
            @Override
            public int compare(ComaparableObject co1, ComaparableObject co2) {
                int result;
                result = co1.compareTo(co2);
                return result;
            }
        });

        System.out.println("After sort: " + al);

        }

}

公共类比较测试{
静态类ComaparableObject实现了可比较的{
私人物品价值1；
私人物品价值2；
public ComaparableObject（对象值1，对象值2）{
此值为1.value1=value1；
此参数为0.value2=value2；
}
@凌驾
公共整数比较对象（对象o）{
整数乘数=65535；
ComaparableObject co=（ComaparableObject）o；
int result=（value1.hashCode（）*乘数+value2.hashCode（））-（co.value1.hashCode（）*乘数+co.value2.hashCode（））；
返回结果；
}
公共对象getValue1（）{
返回值1；
}
public void setValue1（对象值1）{
此值为1.value1=value1；
}
公共对象getValue2（）{
返回值2；
}
public void setValue2（对象值2）{
此参数为0.value2=value2；
}
公共字符串toString（）{
字符串结果=“value1=“+value1+”，“+”value2=“+value2；
返回结果；
}
}
公共静态void main（字符串[]args）{
ArrayList al；
al=新的ArrayList（）；
科马帕拉布勒公司；
整数值1=2；
co=新的ComaparableObject（值1,3）；
al.add（co）；
co=新的ComaparableObject（值1,1）；
al.add（co）；
co=新的ComaparableObject（值1,2）；
al.add（co）；
值1=1；
co=新的ComaparableObject（值1，