java中bean对象的列表按字母顺序升序排序

下面是bean类：

public class bean  {
    private String Name;

    public String getName() {
        return Name;
    }

    public void setName(String name) {
        Name = name;
    }



    @Override
    public String toString() {
        return "bean [Name=" + Name + "]";
    }
}

下面是我的java类，我试图按升序（我指的是字母顺序）对bean列表进行排序：

公共类测试{
公共静态void main（字符串[]args）{
bean b1=新bean（）；
bean b2=新bean（）；
bean b3=新bean（）；
List beanList=new ArrayList（）；
b1.设定名称（“b”）；
b2.设定名称（“a”）；
b3.设定名称（“Z”）；
添加（b1）；
添加（b2）；
添加（b3）；
}
}

---

我无法实现按字母顺序（如a、b、z）对bean值进行排序。任何人都可以建议使用comparator的内联定义的sort的第一个实现是正确的

您会发现，在这个示例中，排序的bean按“Z”、“a”和“b”的顺序出现

大写Z与小写字母a和b进行比较。因此，排序后的列表按上述顺序排列

如果希望比较不区分大小写，可以在比较之前对两个字符串使用

tolowercase

参考下文。代码段：

Collections.sort(beanList, new Comparator<bean>() {
                public int compare(final bean object1, final bean object2) {
                    return object1.getName().toLowerCase().compareTo(object2.getName().toLowerCase());
                }
            });

或者，您可以使用第二个方法（Collections.sort（）），在对集合调用sort时，不显式地提到comparator。这是可能的，因为bean类实现了

comparable

接口

为了实现

compariable

接口，comparieto方法必须实现如下：

Collections.sort(beanList, new Comparator<bean>() {
                public int compare(final bean object1, final bean object2) {
                    return object1.getName().compareToIgnoreCase(object2.getName());
                }
            });

@Override
public int compareTo(bean o) {
    return this.Name.compareToIgnoreCase(o.Name);
}

---

使用比较器内联定义的sort的第一个实现是正确的

您会发现，在这个示例中，排序的bean按“Z”、“a”和“b”的顺序出现

大写Z与小写字母a和b进行比较。因此，排序后的列表按上述顺序排列

如果希望比较不区分大小写，可以在比较之前对两个字符串使用

tolowercase

参考下文。代码段：

Collections.sort(beanList, new Comparator<bean>() {
                public int compare(final bean object1, final bean object2) {
                    return object1.getName().toLowerCase().compareTo(object2.getName().toLowerCase());
                }
            });

或者，您可以使用第二个方法（Collections.sort（）），在对集合调用sort时，不显式地提到comparator。这是可能的，因为bean类实现了

comparable

接口

为了实现

compariable

接口，comparieto方法必须实现如下：

Collections.sort(beanList, new Comparator<bean>() {
                public int compare(final bean object1, final bean object2) {
                    return object1.getName().compareToIgnoreCase(object2.getName());
                }
            });

@Override
public int compareTo(bean o) {
    return this.Name.compareToIgnoreCase(o.Name);
}

---

您正在排序2次，这超出了您的需要

第一个测试不需要实现可比较的

public class Test  {
    public static void main(String[] args) { 
        Bean b1 = new Bean();
        Bean b2 = new Bean();
        Bean b3 = new Bean();
        List<Bean> beanList = new ArrayList<Bean>();
        b1.setName("b");
        b2.setName("a");
        b3.setName("Z");
        beanList.add(b1);
        beanList.add(b2);
        beanList.add(b3);
        
        Collections.sort(beanList);
        System.out.println("finally " + beanList);
    }
}

公共类测试{
公共静态void main（字符串[]args）{
Bean b1=新Bean（）；
Bean b2=新Bean（）；
Bean b3=新Bean（）；
List beanList=new ArrayList（）；
b1.设定名称（“b”）；
b2.设定名称（“a”）；
b3.设定名称（“Z”）；
添加（b1）；
添加（b2）；
添加（b3）；
Collections.sort（beanList）；
System.out.println（“finally”+beanList）；
}
}

bean类应该比较字符串，因为这是排序标准

public class Bean implements Comparable<Bean> {
    private String Name;

    public String getName() {
        return Name;
    }

    public void setName(String name) {
        Name = name;
    }

    @Override
    public String toString() {
        return "bean [Name=" + Name + "]";
    }

    @Override
    public int compareTo(Bean o) {
        return o.getName().compareTo(this.getName());
    }
}

公共类Bean实现了可比较的{
私有字符串名称；
公共字符串getName（）{
返回名称；
}
公共void集合名（字符串名）{
名称=名称；
}
@凌驾
公共字符串toString（）{
返回“bean[Name=“+Name+”]”；
}
@凌驾
公共整数比较（Bean o）{
返回o.getName（）.compareTo（this.getName（））；
}
}

---

编辑： 您可以肯定地向bean类添加多个字段，例如：lastname，或者您可以使用匿名比较器并使用yoor或自己的条件进行排序

姓氏示例：

公共类Bean实现了可比较的{
私有字符串名称；
私有字符串lastName；
公共字符串getLastName（）{
返回姓氏；
}
public void setLastName（字符串lastName）{
this.lastName=lastName；
}
公共字符串getName（）{
返回名称；
}
公共void集合名（字符串名）{
this.name=名称；
}
@凌驾
公共字符串toString（）{
返回“Bean[name=“+name+”，lastName=“+lastName+”]”；
}
@凌驾
公共整数比较（Bean o）{
返回这个.getName（）.compareTo（o.getName（））；
}
}

您正在排序2次，这超出了您的需要

第一个测试不需要实现可比较的

public class Test  {
    public static void main(String[] args) { 
        Bean b1 = new Bean();
        Bean b2 = new Bean();
        Bean b3 = new Bean();
        List<Bean> beanList = new ArrayList<Bean>();
        b1.setName("b");
        b2.setName("a");
        b3.setName("Z");
        beanList.add(b1);
        beanList.add(b2);
        beanList.add(b3);
        
        Collections.sort(beanList);
        System.out.println("finally " + beanList);
    }
}

公共类测试{
公共静态void main（字符串[]args）{
Bean b1=新Bean（）；
Bean b2=新Bean（）；
Bean b3=新Bean（）；
List beanList=new ArrayList（）；
b1.设定名称（“b”）；
b2.设定名称（“a”）；
b3.设定名称（“Z”）；
添加（b1）；
添加（b2）；
添加（b3）；
Collections.sort（beanList）；
System.out.println（“finally”+beanList）；
}
}

bean类应该比较字符串，因为这是排序标准

public class Bean implements Comparable<Bean> {
    private String Name;

    public String getName() {
        return Name;
    }

    public void setName(String name) {
        Name = name;
    }

    @Override
    public String toString() {
        return "bean [Name=" + Name + "]";
    }

    @Override
    public int compareTo(Bean o) {
        return o.getName().compareTo(this.getName());
    }
}

公共类Bean实现了可比较的{
私有字符串名称；
公共字符串getName（）{
返回名称；
}
公共void集合名（字符串名）{
名称=名称；
}
@凌驾
公共字符串toString（）{
返回“bean[Name=“+Name+”]”；
}
@凌驾
公共整数比较（Bean o）{
返回o.getName（）.compareTo（this.getName（））；
}
}

---

编辑： 您可以肯定地向bean类添加多个字段，例如：lastname，或者您可以使用匿名比较器并使用yoor或自己的条件进行排序

姓氏示例：

公共类Bean实现了可比较的{
私有字符串名称；
私有字符串lastName；
公共字符串getLastName（）{
返回姓氏；
}
public void setLastName（字符串lastName）{
this.lastName=lastName；
}
公共字符串getName（）{
返回名称；
}
公共void集合名（字符串名）{
this.name=名称；
}
@凌驾
公共字符串toString（）{