精华内容
下载资源
问答
  • 主要介绍了java的arraylist排序示例,学习一下arraylist的用法,需要的朋友可以参考下
  • 由于其功能性和灵活性,ArrayList是 Java 集合框架中使用最为普遍的集合类之一。ArrayList 是一种 List 实现,它的内部用一个动态数组来存储元素,因此 ArrayList 能够在添加和移除元素的时候进行动态的扩展和缩减。...

    由于其功能性和灵活性,ArrayList是 Java 集合框架中使用最为普遍的集合类之一。ArrayList 是一种 List 实现,它的内部用一个动态数组来存储元素,因此 ArrayList 能够在添加和移除元素的时候进行动态的扩展和缩减。你可能已经使用过 ArrayList,因此我将略过基础部分。如果你对 ArrayList 还不熟悉,你可以参考它的 API 文档,可以很容易理解在 ArrayList 上执行基本的操作。In this post, I will discuss one of the most important operation on ArrayList that you will most likely require implementing during enterprise application development. It’s sorting the elements of an ArrayList.在这篇文章中,我将讨论 ArrayList 中一种极其重要的操作,你很有可能需要在企业应用开发中实现它。它就是 ArrayList 元素的排序。

    排序字符串对象的 ArrayList

    考虑一个 ArrayList 存储着以字符串形式存在的国名(country name),为了对这个 ArrayList 进行排序,你需要调用 Collections.sort()方法,传递由国名构成的 ArrayList 对象。这种方法将按照自然顺序(按字母升序)对元素(国名)进行排序。让我们为此来写一段代码。SortArrayListAscendingDescending.java

    在上面的类中,我们在构造器中初始化了一个 ArrayList 对象。在 sortAscending()方法中,我们调用了 Collections.sort()方法,并传递这个初始化的 ArrayList对象为参数,返回排序后的 ArrayList。在 sortDescending()方法中,我们调用重载的 Collections.sort()方法让其按照降序对元素排序,这个版本的 Collections.sort()接收ArrayList对象作为第一个参数,一个由 Collections.reverseOrder()方法返回的 Comparator 对象作为第二个参数。我们将会在稍后讲解 Comparator。为了测试排序功能,我们将写一段测试代码。SortArrayListAscendingDescendingTest.java

    在上面的测试代码中,我们创建一个 ArrayList 对象,并添加了 5 个字符串对象代表 5 个国家的名字。然后我们调用 getArrayList()、sortAscending()和 sortDescending()方法,并打印这些方法返回的 ArrayList 对象。输出如下:

    到目前为止,所要排序的 ArrayList 元素都是非常简单的,我们仅仅只是调用 Collections.sort()方法并传递了需要排序的 ArrayList 对象作为参数。但是更多的是你会遇到一些复杂的情景下对 ArrayList 进行排序。Collections.sort() 方法对 ArrayList 的元素或者任何其他 List 的实现提供的可比较的元素进行排序,这意味着这些元素的类需要实现 java.lang 包中的 Comparable 接口。正如 String 类实现了 Comparable 接口,我们就可以对由国名构成的 ArrayList 排序。有些其他的标准 Java 类实现了 Comparable 接口,包括原始的包装类,例如 Integer、Short、Double、Float、Boolean、BigInteger、BigDecimal、File 和 Date 类都实现了 Comparable 接口。

    使用Comparable排序ArrayList

    Comparable 是带有单一 compareTo()方法的接口。一个实现了 Comparable 接口的类对象可以与其它同类型的对象进行比较,实现 Comparable 接口的类需要重写 compareTo()方法,这个方法接收一个同类型的对象,并实现这个对象和传递给方法的另一个对象比较的逻辑。compareTo()方法返回Int类型的比较结果,分别代表下面的含义:正值表示当前对象比传递给 comPareTO()的对象大负值表示当前对象比传递给 comPareTO()的对象小零表示两个对象相等让我们来举一个例子,JobCandidate 类的对象保存在 ArrayList 中并准备对其进行排序。JobCandidate 类有三个成员变量:字符串类型的姓名和性别、整型的年龄。我们想要对保存在 ArrayList 中的 JobCandidate 对象按照年龄进行排序。因此我们要让 JobCandidate 类实现 Comparable 接口并重写 compareTo()方法。The code of the JobCandidate class is this.JobCandidate类的代码如下:JobCandidate.java

    在上面 JobCandidate 类被重写的 compareTo()方法中,我们实现了基于年龄的比较逻辑。我见过很多程序员将(this.getAge() – candidate.getAge())作为返回的比较结果。尽管使用这种 return 语句看上去似乎很吸引人,并且也不会对我们的例子造成影响,我的建议是远离这种语句。想象一下,比较整数值,其中有一个或者两个都是负数的结果。这会导致一些错误,让你的程序行为不定,而且更重要的是,这样的错误是很细微的,尤其是在大型的企业应用中很难检测出来。下面我们将写一个辅助类,为委托方对包含了 JobCandidate 元素的 ArrayList 对象进行排序。JobCandidateSorter.java

    在 JobCandidateSorter 类中,我们初始化了一个 ArrayList 对象,委托方将通过构造函数实例化 JobCandidateSorter 。然后我们编写了 getSortedJobCandidateByAge()方法,在这个方法中,我们调用 Collections.sort()并传递已经初始化了的 ArrayList 为参数,最后返回排序后的 ArrayList。接下来,我们写一个测试类来测试一下我们的代码。JobCandidateSorterTest.java

    在上面的测试类中,我们创建了四个 JobCandidate 对象并把它们添加到 ArrayList,然后传递这个 ArrayList 到构造函数来实例化 JobCandidateSorter 类。最后,我们调用 JobCandidateSorter 类的 getSortedJobCandidateByAge()方法,并打印这个方法返回的排序后的 ArrayList。测试的输出结果如下:

    使用 Comparable 对 ArrayList 排序是一种常用的方法。但是你必须知道有某些限制。你想要排序的对象的类必须实现 Comparable 并覆写 compareTo()方法。这基本上意味着你将只能基于一个成员变量来比较对象(我们例子中的年龄字段)。如果要求你按照姓名和年龄来对 JobCandidate 对象进行排序怎么办? Comparable 就不是解决的方法了。另外,比较逻辑是需要进行比较的对象的类的一部分,它消除了比较逻辑可复用性的可能。Java 通过使用在 java.util 包下提供的Comparator接口解决了上述的比较需求。

    使用 Comparator 排序 ArrayList

    Comparator 接口与Comparable 接口相似也提供了一个单一的比较方法叫作 compare()。然而,与 Comparable的 compareTo()方法不同的是,这个 compare()接受两个同类型的不同对象进行比较。我们将用 Comparator 对我们之前使用过的相同 JobCandidate 类对象进行排序。我们将通过实现 Comparatoras 匿名内部类,允许对 JobCandidate 对象按照年龄和姓名进行排序。下面是使用了 Comparator 的 JobCandidate 类代码JobCandidate.java

    在上面的类中,从 29 行到 35 行,我们写了一个匿名类并实现了 compare()方法,按照年龄的降序对 JobCandidate 对象进行排序。从37行到42行,我们又写了一个匿名类并实现了 compare() 方法,按照姓名的升序对 JobCandidate进行排序。现在我们写一个类,为委托方对 ArrayList 的元素进行排序。JobCandidateSorter.java

    在上面的类中,我们写了 getSortedJobCandidateByAge()方法,在这个方法内部我们调用了 Collections.sort()的重载版本,这个版本传递要被排序的 ArrayList 对象和比较年龄的 Comparator 对象。在 getSortedJobCandidateByName()方法内部,我们又调用了 Collections.sort()的另一个重载版本,这个版本传递要被排序的 ArrayList 对象和比较姓名的 Comparator 对象。Let’s write a test class to test our code.让我们写一个测试类来测试我们的代码。JobCandidateSorterTest.java

    在测试类中我们向 ArrayList 中添加若干 JobCandidate 对象,并使用 Before 注释在测试单元的 setup()方法中创建了一个 JobCandidateSorter 对象。如果你是一个 Junit 新手,可以参考我以前的文章包括 Junit 注释(Junit 单元测试系列)。在 testGetSortedJobCandidateByAge()测试方法中我们调用了 getSortedJobCandidateByAge()方法,并打印了该方法返回的排序后的 ArrayList。在 testGetSortedJobCandidateByName()测试方法中我们调用了getSortedJobCandidateByName()方法并同样打印该方法返回的 ArrayList。测试的输出如下:

    总结

    在本文中我们看到了 ArrayList 排序的不同方法。一种是使用 Comparable 另一种是使用 Comparator。方法的选择一直是造成程序员们困惑的原因之一。你最应该记住的就是一个 Comparable 对象可以说“我可以自己与另外一个对象比较”而一个 Comparator 对象可以说“我可以比较两个不同的对象”。你不能说一个接口比另一个要好。选择的接口取决于你需要实现的功能。

    展开全文
  • ArrayList类Java ArrayList排序的3种方法1. 使用Collections.sort()方法进行排序ArrayList 存储着以字符串形式存在的国名(country name),为了对这个 ArrayList 进行排序,你需要调用 Collections.sort()方法,传递...

    首页 > 基础教程 > 集合框架 > ArrayList类

    Java ArrayList排序的3种方法

    1. 使用Collections.sort()方法进行排序

    ArrayList 存储着以字符串形式存在的国名(country name),为了对这个 ArrayList 进行排序,你需要调用 Collections.sort()方法,传递由国名构成的 ArrayList 对象。这种方法将按照自然顺序(按字母升序)对元素(国名)进行排序。代码如下:

    public class SortArrayListAscendingDescending {

    private ArrayList arrayList;

    public SortArrayListAscendingDescending(ArrayList arrayList) {

    this.arrayList = arrayList;

    }

    public ArrayList getArrayList() {

    return this.arrayList;

    }

    public ArrayList sortAscending() {

    Collections.sort(this.arrayList);

    return this.arrayList;

    }

    public ArrayList sortDescending() {

    Collections.sort(this.arrayList, Collections.reverseOrder());

    return this.arrayList;

    }

    }

    在SortArrayListAscendingDescending类中,我们在构造器中初始化了一个 ArrayList 对象。在 sortAscending()方法中,我们调用了 Collections.sort()方法,并传递这个初始化的 ArrayList对象为参数,返回排序后的 ArrayList。在 sortDescending()方法中,我们调用重载的 Collections.sort()方法让其按照降序对元素排序,这个版本的 Collections.sort()接收ArrayList对象作为第一个参数,一个由 Collections.reverseOrder()方法返回的 Comparator 对象作为第二个参数。

    public class SortArrayListAscendingDescendingTest {

    public void testSortAscendingDescending() throws Exception {

    ArrayList countryList = new ArrayList();

    countryList.add("France");

    countryList.add("USA");

    countryList.add("India");

    countryList.add("Spain");

    countryList.add("England");

    SortArrayListAscendingDescending sortArrayList = new SortArrayListAscendingDescending(countryList);

    ArrayList unsortedArrayList = sortArrayList.getArrayList();

    System.out.println("Unsorted ArrayList: " + unsortedArrayList);

    ArrayList sortedArrayListAscending = sortArrayList.sortAscending();

    System.out.println("Sorted ArrayList in Ascending Order : " +

    sortedArrayListAscending);

    ArrayList sortedArrayListDescending = sortArrayList.sortDescending();

    System.out.println("Sorted ArrayList in Descending Order: " +

    sortedArrayListDescending);

    }

    }

    在SortArrayListAscendingDescendingTest测试代码中,我们创建一个 ArrayList 对象,并添加了 5 个字符串对象代表 5 个国家的名字。然后我们调用 getArrayList()、sortAscending()和 sortDescending()方法,并打印这些方法返回的 ArrayList 对象。

    显示结果:

    -------------------------------------------------------

    T E S T S

    -------------------------------------------------------

    Running guru.springframework.blog.sortarraylist.ascendingdescending.SortArrayListAscendingDescendingTest

    Unsorted ArrayList: [France, USA, India, Spain, England]

    Sorted ArrayList in Ascending Order : [England, France, India, Spain, USA]

    Sorted ArrayList in Descending Order: [USA, Spain, India, France, England]

    Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.001 sec - in guru.springframework.blog.sortarraylis

    2. 使用Comparable排序

    让我们来举一个例子,JobCandidate 类的对象保存在 ArrayList 中并准备对其进行排序。JobCandidate 类有三个成员变量:字符串类型的姓名和性别、整型的年龄。我们想要对保存在 ArrayList 中的 JobCandidate 对象按照年龄进行排序。因此我们要让 JobCandidate 类实现 Comparable 接口并重写 compareTo()方法。

    public class JobCandidate implements Comparable {

    private String name;

    private String gender;

    private int age;

    public JobCandidate(String name, String gender, int age) {

    this.name = name;

    this.gender = gender;

    this.age = age;

    }

    public String getName() {

    return name;

    }

    public String getGender() {

    return gender;

    }

    public int getAge() {

    return age;

    }

    @Override

    public int compareTo(JobCandidate candidate) {

    return ((this.getAge() < candidate.getAge()) ? (-1)

    : ((this.getAge() == candidate.getAge())

    ? 0 : 1));

    }

    @Override

    public String toString() {

    return " Name: " + this.name + ", Gender: " + this.gender + ", age:" +

    this.age;

    }

    }

    JobCandidate 类被重写的 compareTo()方法中,我们实现了基于年龄的比较逻辑。

    public class JobCandidateSorter {

    ArrayList jobCandidate = new ArrayList<>();

    public JobCandidateSorter(ArrayList jobCandidate) {

    this.jobCandidate = jobCandidate;

    }

    public ArrayList getSortedJobCandidateByAge() {

    Collections.sort(jobCandidate);

    return jobCandidate;

    }

    }

    在 JobCandidateSorter 类中,我们初始化了一个 ArrayList 对象,委托方将通过构造函数实例化 JobCandidateSorter 。然后我们编写了 getSortedJobCandidateByAge()方法,在这个方法中,我们调用 Collections.sort()并传递已经初始化了的 ArrayList 为参数,最后返回排序后的 ArrayList。

    public class JobCandidateSorterTest {

    public void testGetSortedJobCandidateByAge() throws Exception {

    JobCandidate jobCandidate1 = new JobCandidate("Mark Smith", "Male", 26);

    JobCandidate jobCandidate2 = new JobCandidate("Sandy Hunt", "Female", 23);

    JobCandidate jobCandidate3 = new JobCandidate("Betty Clark", "Female",

    20);

    JobCandidate jobCandidate4 = new JobCandidate("Andrew Styne", "Male", 24);

    ArrayList jobCandidateList = new ArrayList();

    jobCandidateList.add(jobCandidate1);

    jobCandidateList.add(jobCandidate2);

    jobCandidateList.add(jobCandidate3);

    jobCandidateList.add(jobCandidate4);

    JobCandidateSorter jobCandidateSorter = new JobCandidateSorter(jobCandidateList);

    ArrayList sortedJobCandidate = jobCandidateSorter.getSortedJobCandidateByAge();

    System.out.println("-----Sorted JobCandidate by age: Ascending-----");

    for (JobCandidate jobCandidate : sortedJobCandidate) {

    System.out.println(jobCandidate);

    }

    }

    }

    JobCandidateSorterTest类中,我们创建了四个 JobCandidate 对象并把它们添加到 ArrayList,然后传递这个 ArrayList 到构造函数来实例化 JobCandidateSorter 类。最后,我们调用 JobCandidateSorter 类的 getSortedJobCandidateByAge()方法,并打印这个方法返回的排序后的 ArrayList。测试的输出结果如下:

    -------------------------------------------------------

    T E S T S

    -------------------------------------------------------

    Running guru.springframework.blog.sortarraylist.comparable.JobCandidateSorterTest

    -----Sorted JobCandidate by age: Ascending-----

    Name: Betty Clark, Gender: Female, age:20

    Name: Sandy Hunt, Gender: Female, age:23

    Name: Andrew Styne, Gender: Male, age:24

    Name: Mark Smith, Gender: Male, age:26

    Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.003 sec

    - in guru.springframework.blog.sortarraylist.comparable.JobCandidateSorterTest

    3. 使用 Comparator 排序

    比如我有一个Person类,它的实例对象存储在ArrayList数组中,现在要把ArrayList数组中的Person对象按照年龄排序.代码如下:

    Person类

    public class Person {

    String name;

    int age;

    public Person(String name, int age) {

    this.name = name;

    this.age = age;

    }

    public int getAge() {

    return age;

    }

    public void setAge(int age) {

    this.age = age;

    }

    public String getName() {

    return name;

    }

    public void setName(String name) {

    this.name = name;

    }

    }

    Mycomparator类

    public class Mycomparator implements Comparator {

    public int compare(Object o1, Object o2) {

    Person p1 = (Person) o1;

    Person p2 = (Person) o2;

    if (p1.age < p2.age) return 1;

    else return 0;

    }

    }

    ListSort类

    public class ListSort {

    public static void main(String[] args) {

    ArrayList list = new ArrayList();

    list.add(new Person("lcl", 28));

    list.add(new Person("fx", 23));

    list.add(new Person("wqx", 29));

    Comparator comp = new Mycomparator();

    Collections.sort(list, comp);

    for (int i = 0; i < list.size(); i) {

    Person p = (Person) list.get(i);

    System.out.println(p.getName());

    }

    }

    }

    当然,如果你的List包装的是基本类型或者String,则只要 Collections.sort(list);即可

    版权声明:本文为JAVASCHOOL原创文章,未经本站允许不得转载。

    展开全文
  • Java 集合之给ArrayList排序

    千次阅读 2020-08-19 16:12:48
    Java 集合之给ArrayList排序 ArrayList的排序可以借助Collections工具类的sort(List list)以及重载的sort(List list, Comparator<? super T> c)方法;其中要想使用sort(List lis)方法进行排序集合元素必须实现...

    Java 集合之给ArrayList排序

    ArrayList的排序可以借助Collections工具类的sort(List list)以及重载的sort(List list, Comparator<? super T> c)方法;其中要想使用sort(List lis)方法进行排序集合元素必须实现comparable接口中的compareTo方法;使用重载的sort(List list, Comparator<? super T> c)方法则要传入一个自定义构造器,可以使用匿名内部类的方式传入构造器;

    • 1、如果是集合元素类型是8大基本类型的包装类(如Interge、Character等)或者是String类源码中这些类已经实现了Comparable接口,下面拿Integer类举例:
      List<Integer> list0 = new ArrayList<>();
        Random random = new Random();
        for(int i = 0; i<10;i++){
            list0.add(random.nextInt(100));
        }
    
        list0.forEach(System.out::println);  
    	//排序前  [27,71,6,65,53,84,75,0,66,70]
    
        //直接使用默认自然排序(即从小到大的顺序)
        Collections.sort(list0);
        System.out.println("自然排序后>>>>>>>>>");
        list0.forEach(System.out::println);
    	//自然排序后 [0,6,27,53,65,66,70,71,75,84]
    	
        //我们也可以使用同名重载方法传一个构造器进行临时改变排序规则(按从大到小排序)
    	Collections.sort(list0, new Comparator<Integer>() {
                @Override
                public int compare(Integer o1, Integer o2) {
                    return o2 < o1 ? -1 : ((02 == 01) ? 0 : 1);
                }
         });
        list0.forEach(System.out::println); 
    	// [84,75,71,70,66,65,53,27,6,0]
    
    
    • 对于对象的排序
             要想使用sort(List list)方法给集合排序集合元素必须实现comparable接口中的compareTo方法,所以要想实现对象自定义排序就要在compareTo方法里面做文章:
    int compareTo(T t);
       该方法用于使当前对象与给定对象进行比较。
       当返回值>0时:当前对象比参数对象大
       当返回值<0时:当前对象比参数对象小
       当返回值=0时:当前对象等于参数对象
    

    例子:
    Person类:

    @Data
    public class Person implements  Comparable<Person>{
    
        public Person(String name, Integer age) {
            this.name = name;
            this.age = age;
        }
    
        private String name;
    
        private Integer age;
    
    
    
        @Override
        public int compareTo(Person o) {
          // 按照年龄从小到大排序
            return this.getAge().compareTo(o.getAge());
        }
    }
    

    测试代码:

    Person p1 = new Person("小王",22);
            Person p2 = new Person("小m",20);
            Person p3 = new Person("小t",30);
            Person p4 = new Person("小q",19);
            Person p5 = new Person("小u",20);
            Person p6 = new Person("小L",36);
    
            List<Person> list = new ArrayList<>();
            list.add(p1);
            list.add(p2);
            list.add(p3);
            list.add(p4);
            list.add(p5);
            list.add(p6);
            System.out.println("未排序之前>>>:");
            list.forEach(System.out::println);
    
            Collections.sort(list);
            
             System.out.println("自定义排序之后>>>:");
            list.forEach(System.out::println);
    

    输出结果:

    未排序之前>>>:
    Person(name=小王, age=22)
    Person(name=小m, age=20)
    Person(name=小t, age=30)
    Person(name=小q, age=19)
    Person(name=小u, age=20)
    Person(name=小L, age=36)
    自定义排序之后>>>:
    Person(name=小q, age=19)
    Person(name=小m, age=20)
    Person(name=小u, age=20)
    Person(name=小王, age=22)
    Person(name=小t, age=30)
    Person(name=小L, age=36)
    

    我们会发现使用sort(List list)方法侵入性比较高,所以不建议使用这个方法,我们可以使用它的重载的sort(List list, Comparator<? super T> c)方法,以匿名内部类的方式传入构造器来完成排序,上面的例子使用此方法演示如下:
     
     Person类:

    @Data
    public class Person {
    
        public Person(String name, Integer age) {
            this.name = name;
            this.age = age;
        }
    
        private String name;
    
        private Integer age;
    
    
    }
    

    测试代码:

     Person p1 = new Person("小王",22);
            Person p2 = new Person("小m",20);
            Person p3 = new Person("小t",30);
            Person p4 = new Person("小q",19);
            Person p5 = new Person("小u",20);
            Person p6 = new Person("小L",36);
    
            List<Person> list = new ArrayList<>();
            list.add(p1);
            list.add(p2);
            list.add(p3);
            list.add(p4);
            list.add(p5);
            list.add(p6);
            System.out.println("未排序之前>>>:");
            list.forEach(System.out::println);
         //自定义排序,这里我按招年龄从小到大排序
            Collections.sort(list, new Comparator<Person>() {
                @Override
                public int compare(Person o1, Person o2) {
                    return o1.getAge().compareTo(o2.getAge());
                }
            });
            System.out.println("自定义排序之后>>>:");
            list.forEach(System.out::println);
    

    结果和上一种方法是一样的;

    仅供参考!!!感谢阅读!!!欢迎指正!!!!

    展开全文
  • 常常遇到数组排序的问题,下面提供二个java的arraylist排序示例,需要的朋友可以参考下
  • 主要介绍了对arraylist中元素进行排序实例代码,还是比较不错的,这里分享给大家,供需要的朋友参考。
  • java8新特性有很多,这里先对Lambda表达式进行简单的ArrayList排序体验,首先要使用java1.8,必须要先在myeclipse或者eclipse中装jdk1.8才行,需要注意的一点是,需要在eclipse开发工具中把编译级别也设置成jdk1.8,...

    java8新特性有很多,这里先对Lambda表达式进行简单的ArrayList排序体验,首先要使用java1.8,必须要先在myeclipse或者eclipse中装jdk1.8才行,需要注意的一点是,需要在eclipse开发工具中把编译级别也设置成jdk1.8,否则就不能使用Lambda表达式了。

    更改eclipse或myeclipse编译级别的方法:Window-->Java-->Compile-->Compile compliance level,选择1.8,这样就能使用jdk1.8的所有方法了。import java.util.ArrayList;

    import java.util.Collections;

    import java.util.Comparator;

    import java.util.List;

    public class Java8ListSort {

    public static void main(String[] args) {

    List numList = new ArrayList();

    numList.add("5");

    numList.add("7");

    numList.add("6");

    numList.add("4");

    numList.add("9");

    List numList2 = new ArrayList();

    numList2.add("15");

    numList2.add("13");

    numList2.add("20");

    numList2.add("30");

    numList2.add("11");

    sortListUserJava7(numList);

    System.out.println("java 7排序后:"+numList);

    sortListUserJava8(numList2);

    System.out.println("java 8排序后:"+numList2);

    }

    //使用java7对list进行排序

    public static void sortListUserJava7(List numList){

    Collections.sort(numList, new Comparator(){

    @Override

    public int compare(String num1, String num2) {

    return num1.compareTo(num2);

    }

    });

    }

    //使用java8对list进行排序

    public static void sortListUserJava8(List numList2){

    //Lambda表达式排序法

    //Collections.sort(numList2,(String num1,String num2) ->num1.compareTo(num2));

    Collections.sort(numList2,(num1,num2) ->num1.compareTo(num2));

    }

    }

    这里只是对java1.8新特性中的Lambda表达式进行简单的了解,下篇文章将系统的讲解java8的新特性。

    来源网站:太平洋学习网,转载请注明出处:http://www.tpyyes.com/a/java/134.html

    展开全文
  • Java 列表ArrayList排序

    万次阅读 多人点赞 2018-10-09 16:38:40
    对任意类型集合对象进行整体排序排序时将此接口的实现传递给Collections.sort方法或者Arrays.sort方法排序.  实现int compare(T o1, T o2);方法,返回正数,零,... stus = new ArrayList&lt;&gt;(); ...
  • 本文通过代码示例给大家介绍java对arraylist排序,代码简洁易懂,感兴趣的朋友一起学习吧
  • Java8 Lambda表达式 ArrayList排序

    千次阅读 2019-02-25 16:45:15
    Java7和 Java8对 List进行排序实例: package com.dc.utils; import java.util.*; /** * @author hdc * @date 2019/2/25 ... * Lambda表达式ArrayList排序 */ public class ListUtil { public static void ma...
  • ArrayList排序

    2019-01-08 04:09:34
    今天发现,ArrayList 排序不满足期望。 起先,List是这样Before sort: [1, @I, am, Love, java, very, Much] 使用Collections.sort()方法排后是这样 After sort: [1, @I, Love, Much, am, java, very] 顺序:...
  • public static void sort(ArrayList<Integer> list){} 编写测试程序,提示用户输入5个数字,将其存储在一个数组列表中,并且以升序进行显示。 代码实现 import java.util.ArrayList; import java.util...
  • ArrayList排序.txt

    2021-03-01 17:26:14
    通用ArrayList 排序
  • 如何实现ArrayList排序

    2018-04-28 10:57:00
    import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; /** * @description * * @author shilvfei * * @date 2018年4月28日 */ public class ...
  • android arrayList排序

    2018-03-23 11:04:00
    List list = new ArrayList<hashMap<String,Object>>(); HanhMap<String,Object> map; map = new HanhMap(); map.put("aa","11"); map.put("bb","1"); map.put("cc","1"); list.a...
  • 如何实现对ArrayList排序 sort()

    千次阅读 2018-09-25 11:27:10
    package com.collection;import java.util.ArrayList;import java.util.Collections;import java.util.Comp
  • ArrayList 排序

    2015-12-25 14:56:57
    1)排序字符串对象的ArrayList 一个 ArrayList 存储着以字符串形式存在的国名(country name),为了对这个 ArrayList 进行排序,你需要调用 Collections.sort() 方法,传递由国名构成的 ArrayList 对象。这种...
  • 按照hashmap中的key为name字段排序: private void descSort(final String order,String dir){ Collections.sort(arrayList, new Comparator>(){ @Override public int compa
  • java 使用comparator接口对ArrayList排序无效
  • java中对ArrayList进行排序的方法参考
  • Java对ArrayList进行排序

    2021-02-12 14:08:44
    数字使用直接比较大小来排序,String的话,使用compare()方法进行排序。测试代码:1.对字符串对象排序@Testpublic void test... stringList = new ArrayList<>();stringList.add("haha");stringList.add("123...
  • arraylist 对象中的某个值排序,并非单出的数组排序
  • c# ArrayList排序

    千次阅读 2014-10-22 20:06:50
    <pre name="code" class="csharp">ArrayList orders = new ArrayList(); OrdersData order = new OrdersData(); orders.Add(order); .... orders.Sort(new SortOnTypeid()); 注意SortOnTypeid 是class不是函数。 ...
  • Java 重写ArrayList排序

    千次阅读 2014-10-04 23:45:35
    //排序 Collections.sort(mapCountList,new Comparator() { @Override  public int compare(MapCount o1, MapCount o2) {  return new Integer(o2.getCount()).compareTo(new Integer(o1.getCount()));
  • Arraylist排序(sort)

    2016-06-28 10:31:29
    ArrayList list = new ArrayList(); list.add("92.8"); list.add("68.9"); list.add("168.61"); list.add("242"); list.add("317"); list.add("105"); 请对这个list里面的元素排序 如果你想按照数字排序,那就...
  • arrayList排序

    2009-04-14 13:58:57
    arrayList排序arrayList排序arrayList排序
  • 一、ArrayList排序使用 ArrayList中存在sort排序方法,只要你实现了Comparator的接口,按照你自己的排序业务进行实现,你只要告诉这个接口按照什么类型进行排序就OK了。这种方式类似于设计模式中的策略模式,把流程划分...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 207,315
精华内容 82,926
关键字:

arraylist排序

友情链接: chap24.rar