精华内容
下载资源
问答
  • 主要介绍了深入理解java中Arrays.sort()的用法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 主要介绍了JAVA基于Arrays.sort()实现数组升序和降序,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了Java中的Arrays.sort()代码详解,涉及Arrays.sort()简单示例,策略模式,”super”的使用等相关内容,具有一定借鉴价值,需要的朋友可以参考下。
  • 主要介绍了Java Arrays.sort和Collections.sort排序实现原理解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • Arrays.sort(intArray); System.out.println(Arrays.toString(intArray)); 字符串排序(先大写后小写): String[] strArray = new String[]{"Z", "a", "D"}; Arrays.sort(strArray); System.out.println(Arrays....

    1、对基本数据类型数组的排序:

    数字排序:

    int[] intArray = new int[]{1,34,5,-9};
    Arrays.sort(intArray);
    System.out.println(Arrays.toString(intArray));
    

    字符串排序(先大写后小写):

    String[] strArray = new String[]{"Z", "a", "D"}; 
    Arrays.sort(strArray); 
    System.out.println(Arrays.toString(strArray));
    

    字符串排序(忽略大小写):

    Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);
    

    反向排序:

    Arrays.sort(strArray, Collections.reverseOrder());
    

    注意:Arrays.sort()使用的是双轴快排:
    1.对于很小的数组(长度小于27),会使用插入排序。
    2.选择两个点P1,P2作为轴心,比如我们可以使用第一个元素和最后一个元素。
    3.P1必须比P2要小,否则将这两个元素交换,现在将整个数组分为四部分:
    (1)第一部分:比P1小的元素。
    (2)第二部分:比P1大但是比P2小的元素。
    (3)第三部分:比P2大的元素。
    (4)第四部分:尚未比较的部分。
    在开始比较前,除了轴点,其余元素几乎都在第四部分,直到比较完之后第四部分没有元素。
    4.从第四部分选出一个元素a[K],与两个轴心比较,然后放到第一二三部分中的一个。
    5.移动L,K,G指向。
    6.重复 4 5 步,直到第四部分没有元素。
    7.将P1与第一部分的最后一个元素交换。将P2与第三部分的第一个元素交换。
    8.递归的将第一二三部分排序。
    对于基本类型的数组如int[], double[], char[] ,Arrays类只提供了默认的升序排列,没有降序,需要传入自定义比较器,使用Arrays.sort(num,c),传入一个实现了Comparator接口的类的对象c
    逆序排列:

    Arrays.sort(num,new Comparator<Integer>(){
    		public int compare(Integer a, Integer b){
    				return b-a;
    		}
    });
    

    2、给对象数组排序:要先Comparable接口或Comparator接口。

    两种比较器的对比:

    内部比较器:

    需要比较的对象必须实现Comparable接口,并重写compareTo(T o)方法,表明该对象可以用来排序,否则不能直接使用Arrays.sort()方法。

    public class Employee implements Comparable<Employee> {  
          
        private int id;// 员工编号  
        private double salary;// 员工薪资  
          
        public int getId() {  
            return id;  
        }  
      
        public void setId(int id) {  
            this.id = id;  
        }  
      
        public double getSalary() {  
            return salary;  
        }  
      
        public void setSalary(double salary) {  
            this.salary = salary;  
        }  
          
        public Employee(int id, double salary) {  
            super();  
            this.id = id;  
            this.salary = salary;  
        }  
          
        // 为了输出方便,重写toString方法  
        @Override  
        public String toString() {  
            // 简单输出信息  
            return "id:"+ id + ",salary=" + salary;  
        }  
      
        // 比较此对象与指定对象的顺序  
        @Override  
        public int compareTo(Employee o) {  
            // 比较员工编号,如果此对象的编号大于、等于、小于指定对象,则返回1、0、-1  
            int result = this.id > o.id ? 1 : (this.id == o.id ? 0 : -1);  
            // 如果编号相等,则比较薪资  
            if (result == 0) {  
                // 比较员工薪资,如果此对象的薪资大于、等于、小于指定对象,则返回1、0、-1  
                result = this.salary > o.salary ? 1 : (this.salary == o.salary ? 0 : -1);  
            }  
            return result;  
        }  
      
    }  
    
    外部比较器:

    需要自己写一个比较器实现Comparator接口,并实现compare(T o1, T o2)方法,根据自己的需求定义比较规则。使用外部比较器这种方式比较灵活,例如现在需求是按照员工编号和薪资进行排序,以后可能按照姓名进行排序,这时只要再写一个按照姓名规则比较的比较器就可以了。

    /** 
     * 测试两种比较器 
     * @author Sam 
     * 
     */  
    public class TestEmployeeCompare {  
      
        /** 
         * @param args 
         */  
        public static void main(String[] args) {  
              
            List<Employee> employees = new ArrayList<Employee>();  
            employees.add(new Employee(2, 5000));  
            employees.add(new Employee(1, 4500));  
            employees.add(new Employee(4, 3500));  
            employees.add(new Employee(5, 3000));  
            employees.add(new Employee(4, 4000));  
            // 内部比较器:要排序的对象要求实现了Comparable接口 ,直接传入该对象即可
            Arrays.sort(employees);  
            System.out.println("通过内部比较器实现:");  
            System.out.println(employees);  
              
            List<Employee> employees2 = new ArrayList<Employee>();  
            employees2.add(new Employee(2, 5000));  
            employees2.add(new Employee(1, 4500));  
            employees2.add(new Employee(4, 3500));  
            employees2.add(new Employee(5, 3000));  
            employees2.add(new Employee(4, 4000));  
            // 外部比较器:自定义类实现Comparator接口  ,需要传入自定义比较器类
            Arrays.sort(employees2, new EmployeeComparable());  
            System.out.println("通过外部比较器实现:");  
            System.out.println(employees2);  
        }  
      
    }  
      
    /** 
     * 自定义员工比较器 
     * 
     */  
    class EmployeeComparable implements Comparator<Employee> {  
      
        @Override  
        public int compare(Employee o1, Employee o2) {  
            // 比较员工编号,如果此对象的编号大于、等于、小于指定对象,则返回1、0、-1  
            int result = o1.getId() > o2.getId() ? 1 : (o1.getId() == o2.getId() ? 0 : -1);  
            // 如果编号相等,则比较薪资  
            if (result == 0) {  
                // 比较员工薪资,如果此对象的薪资大于、等于、小于指定对象,则返回1、0、-1  
                result = o1.getSalary() > o2.getSalary() ? 1 : (o1.getSalary() == o2.getSalary() ? 0 : -1);  
            }  
            return result;  
        }  
          
    } 
    

    最后巧用lambda表达式:(参数) -> 一个表达式或一段代码
    如:

    实现逆序:

    Arrays.sort(nums, ( Integer a, Integer b) -> { return b-a;});
    

    字符串数组,按长度排序:

    Arrays.sort(strs, (String first, String second) ->
    {
        if(first.length() < second.length()) return -1;
        else if(first.length() > second.length()) return 1;
        else return 0;
    });
    

    总结:

    Array.sort()中如果使用自定义比较器Comparator规则是对于参与比较的两个元素(a,b)而言,若返回值为正数则说明发生交换,如果当前比较器规则为(b+a).compareTo(a+b),如果大于0,Comparator接收返回值为正数,就会交换a和b

            Arrays.sort(numsToWord,(a,b)->{
                return (b+a).compareTo(a+b);
            });
    

    转载:https://blog.csdn.net/qq_41030039/article/details/100176410

    展开全文
  • Arrays.sortArrays.parallelSort区别

    千次阅读 2020-06-07 15:40:17
    我们都使用过 Arrays.sort() 对对象或原始数据类型数组(byte,short,int,long,char,float,double和boolean)进行排序。在 JDK 8 中,创造者增强了 API 以提供一种新方法:Arrays.parallelSort()。 在文章中,...

     

    概述


    我们都使用过 Arrays.sort() 对对象或原始数据类型数组(byte,short,int,long,char,float,double和boolean)进行排序。在 JDK 8 中,创造者增强了 API 以提供一种新方法:Arrays.parallelSort()。

    在文章中,我们将对 sort() 和 parallelSort() 方法进行比较。

     

    Arrays.sort()


    Arrays.sort() 方法对对象或原始数据类型的数组进行排序。此方法中使用的排序算法是 Dual-Pivot Quicksort。 换句话说,它是快速排序算法的自定义实现,以实现更好的性能。

    此方法是单线程的 ,有两种变体:

    • sort(array)–将整个数组按升序排序

    • sort(array, fromIndex, toIndex)–仅将从 fromIndex 到 toIndex 的元素排序

     

    优点

    缺点

    快速处理较小的数据集

    大型数据集的性能下降

     

    没有利用系统的多个核心

     

    Arrays.parallelSort()


    此方法对对象或原始数据类型的数组进行排序。与 sort() 类似,它也有两个变体来对完整数组和部分数组进行排序

    parallelSort() 在功能上有所不同。与 sort() 使用单个线程对数据进行顺序排序不同,它使用并行排序-合并排序算法。它将数组分成子数组,这些子数组本身先进行排序然后合并。

    为了执行并行任务,它使用 ForkJoin 池。

    但是我们需要知道,只有在满足某些条件时,它才会使用并行性。如果数组大小小于或等于 8192,或者处理器只有一个核心,则它将使用顺序的 Dual-Pivot Quicksort 算法。否则,它使用并行排序。

    让我们总结一下使用它的优缺点:

    优点

    缺点

    为大型数据集提供更好的性能

    对于大小较小的数组,处理速度较慢

    利用系统的多个核心

     

     

    比较


    现在,让我们看看在不同大小的数据集上两种方法怎样执行。以下数字是使用JMH 基准测试得出的。测试环境使用 AMD A10 PRO 2.1Ghz 四核处理器和 JDK 1.8.0_221:

    数组大小

    Arrays.sort()

    Arrays.parallelSort()

    1000

    0.048

    0.054

    10000

    0.847

    0.425

    100000

    7.570

    4.395

    1000000

    65.301

    37.998

     

    结论


    在这篇快速文章中,我们看到了 sort() 和 parallelSort() 的不同之处。

    根据性能结果,我们可以得出结论,当我们要排序的数据集很大时,parallelSort() 可能是更好的选择。但是,在数组较小的情况下,最好使用 sort(),因为它可以提供更好的性能。

     

    展开全文
  • Arrays.sort()的用法

    千次阅读 多人点赞 2020-12-29 12:36:18
    一、介绍1、sort(T[] a) 的使用2、sort(T[] a,int formIndex, int toIndex) 的使用3、sort(T[] a, Comparator<? supre T> c)的使用补充:sort(T[] a, Comparator&...Arrays.sort()的作用是对括号中的数组进行排序


    Arrays.sort()的作用是对括号中的数组进行排序,时间复杂度O(n*logn),方法返回值为void。 是在原来数组的空间基础上进行升序排序,因此不需要定义一个数组接收它,即不需要返回值。
    Arrays.sort()重载了四类方法:
    sort(T[] a):对指定T型数组按数字升序排序。
    sort(T[] a,int formIndex, int toIndex):对指定T型数组的指定范围按数字升序排序。
    sort(T[] a, Comparator<? supre T> c): 根据指定比较器产生的顺序对T型数组进行排序。
    sort(T[] a, int formIndex, int toIndex, Comparator<? supre T> c): 根据指定比较器产生的顺序对T型数组的指定范围进行排序。

    1、sort(T[] a) 的使用

    import java.util.Arrays;
    import java.util.Comparator;
    
    public class ArraysSort {
        public static void main(String[] args) {
            int[] a={2,5,4,3,1,8};
            Arrays.sort(a);
            System.out.println(Arrays.toString(a));
        }
    }// 结果// [1, 2, 3, 4, 5, 8]
    

    2、sort(T[] a,int formIndex, int toIndex) 的使用

    import java.util.Arrays;
    import java.util.Comparator;
    
    public class ArraysSort {
        public static void main(String[] args) {
            int[] a={2,5,4,3,1,8};
            Arrays.sort(a,2,5);
            System.out.println(Arrays.toString(a));
        }
    }
    
    // 结果
    // [2, 5, 1, 3, 4, 8]
    

    3、sort(T[] a, Comparator<? supre T> c)的使用

    // 按第一维元素比较二维数组
    import java.util.Arrays;
    import java.util.Comparator;
    
    public class ArraysSort {
        public static void main(String[] args) {
            int[][] nums=new int[][]{{1,3},{1,2},{4,5},{3,7}};
            //方法一
            Arrays.sort(nums,new Comparator<int[]>(){
                @Override
                public int compare(int[] a,int[] b){
                    if(a[0]==b[0]){ // 不明白为什么要这样写  ,自己的基础有问题,不解
                        return a[1]-b[1];
                    }else{
                        return a[0]-b[0];
                    }
                }
            });
            for (int[] num : nums) {
                System.out.println(Arrays.toString(num));
            }
        }
    }
    
    // 结果
    /*
    [1, 2]
    [1, 3]
    [3, 7]
    [4, 5]
    */
    
    
    // 按照第二维元素比较二维数组
    
    import java.util.Arrays;
    import java.util.Comparator;
    
    public class ArraysSort {
        public static void main(String[] args) {
            int[][] nums=new int[][]{{1,3},{1,2},{4,5},{3,7}};
            //方法一
            Arrays.sort(nums,new Comparator<int[]>(){
                @Override
                public int compare(int[] a,int[] b){
                    if(a[1]==b[1]){  //同样不解
                        return a[0]-b[0];
                    }else{
                        return a[1]-b[1];
                    }
                }
            });
    
            //方法二
            /*Arrays.sort(nums,(a,b)->a[1]-b[1]);*/
            for (int[] num : nums) {
                System.out.println(Arrays.toString(num));
            }
    
        }
    }
    // 结果
    /*
    [1, 2]
    [1, 3]
    [4, 5]
    [3, 7]
    */
    

    补充:sort(T[] a, Comparator<? supre T> c)类对象比较的使用

    import java.util.Arrays;
    import java.util.Comparator;
    
    class Dog{
        int size;
        int weight;
    
        public Dog(int s, int w){
            size = s;
            weight = w;
        }
    }
    
    class DogSizeComparator implements Comparator<Dog>{
    
        @Override
        public int compare(Dog o1, Dog o2) {
            return o1.size - o2.size;
        }
    }
    
    class DogWeightComparator implements Comparator<Dog>{  // **在这里尖括号传入的是对象**
    
        @Override
        public int compare(Dog o1, Dog o2) {
            return o1.weight - o2.weight;
        }
    }
    
    public class ArraysSort {
        public static void main(String[] args) {
            Dog d1 = new Dog(2, 50);
            Dog d2 = new Dog(1, 30);
            Dog d3 = new Dog(3, 40);
    
            Dog[] dogArray = {d1, d2, d3};
            printDogs(dogArray);
    
            Arrays.sort(dogArray, new DogSizeComparator());
            printDogs(dogArray);
    
            Arrays.sort(dogArray, new DogWeightComparator());
            printDogs(dogArray);
        }
    
        public static void printDogs(Dog[] dogs){
            for(Dog d: dogs)
                System.out.print("size="+d.size + " weight=" + d.weight + " ");
    
            System.out.println();
        }
    }
    
    // 结果
    /*
    size=2 weight=50 size=1 weight=30 size=3 weight=40 
    size=1 weight=30 size=2 weight=50 size=3 weight=40 
    size=1 weight=30 size=3 weight=40 size=2 weight=50 
    */
    

    补充:那么在参数中会出现super呢?这意味着这类型可以是T或者它的父类型。这就是的该方法可以允许所有子类使用相同的比较器。

    import java.util.Arrays;
    import java.util.Comparator;
    
    class Animal{
        int size;
    }
    
    class Dog extends Animal{
        public Dog(int s){
            size = s;
        }
    }
    
    class Cat extends Animal{
        public Cat(int s){
            size  = s;
        }
    }
    
    class AnimalSizeComparator implements Comparator<Animal>{
        @Override
        public int compare(Animal o1, Animal o2) {
            return o1.size - o2.size;
        }
    }
    
    public class ArraysSort {
        public static void main(String[] args) {
            Dog d1 = new Dog(2);
            Dog d2 = new Dog(1);
            Dog d3 = new Dog(3);
    
            Dog[] dogArray = {d1, d2, d3};
            printDogs(dogArray);
    
            Arrays.sort(dogArray, new AnimalSizeComparator());
            printDogs(dogArray);
    
            System.out.println();
            
            Cat c1 = new Cat(2);
            Cat c2 = new Cat(1);
            Cat c3 = new Cat(3);
    
            Cat[] catArray = {c1, c2, c3};
            printDogs(catArray);
    
            Arrays.sort(catArray, new AnimalSizeComparator());
            printDogs(catArray);
        }
    
        public static void printDogs(Animal[] animals){
            for(Animal a: animals)
                System.out.print("size="+a.size + " ");
            System.out.println();
        }
    }
    
    // 结果
    /*
    size=2 size=1 size=3 
    size=1 size=2 size=3 
    
    size=2 size=1 size=3 
    size=1 size=2 size=3 
    */
    

    巨人的肩膀:https://www.cnblogs.com/SupremeBoy/p/12717532.html

    展开全文
  • 如果我们需要对一个对象数组进行排序,我们可以使用Arrays.sort()方法。 如果我们需要排序一个对象列表,我们可以使用Collections.sort()方法。 Collections.sort内部实现也是Arrays.sort() Arrays.sort() Arrays....

    区别
    如果我们需要对一个对象数组进行排序,我们可以使用Arrays.sort()方法。
    如果我们需要排序一个对象列表,我们可以使用Collections.sort()方法。
    Collections.sort内部实现也是Arrays.sort()

    Arrays.sort()
    Arrays.sort() 采用了2种排序算法 – 基本类型数据使用快速排序法,对象数组使用归并排序。

    展开全文
  • 浅谈Arrays.sort()原理

    万次阅读 多人点赞 2019-04-10 00:29:57
    首先先来看一下Arrays.sort()使用的例子。 //注意一定要用Integer对象类 Integer[] a1 = {34, 57, 46, 89, 98, 12, 55, 84, 29}; Integer[] a2 = {34, 57, 46, 89, 98, 12, 55, 84, 29}; //增序,Arrays....
  • 1、Arrays.sort() 源码: public static <T> void sort(T[] a, Comparator<? super T> c) { if (c == null) { sort(a); } else { if (LegacyMergeSort.userRequested) legacyMergeSort(a, c);
  • Collections.sortArrays.sort比较

    千次阅读 2019-01-02 20:03:28
    Collections.sort @SuppressWarnings("unchecked") public static &lt;T extends Comparable&lt;? super T&gt;&gt; void sort(List&lt;T&gt; list) { list.sort(null); } @...
  • Arrays.sort和Collections.sort实现原理解析 1、使用 排序 2、原理 事实上Collections.sort方法底层就是调用的array.sort方法,而且不论是Collections.sort或者是Arrays.sort方法, 跟踪下源代码吧,首先我们写个...
  • Arrays.sort详解

    2020-12-31 16:17:21
    今天做一道题,使用了Arrays.sort并重写Comparator比较器。 之前也做过,知道怎么写,但是具体怎么实现的有点迷糊。 1、Arrays.sort(int[] a) 这个是最基础的,我们都知道可以将数组按从小到大的顺序进行排序。 ...
  • Java的Arrays类中有一个sort()方法,该方法是Arrays类的静态方法,在需要对数组进行排序时,非常的好用。 但是sort()的参数有好几种,下面我就为大家一一介绍,这几种形式的用法。 ==============================...
  • Arrays.sort Arrays.sort 针对任意对象,排序的类型就为传入的对象类 如:Arrays.sort(a)//这里a为数组,可以是 int/String /类 数组,排序类型依次为int ,String ,类 Collections.sort Collections.sort 针对集合...
  • 在Java 6中Arrays.sort()和Collections.sort()使用的是MergeSort,而在Java 7中,内部实现换成了TimSort(做了大量优化的归并排序),其对对象间比较的实现要求更加严格: Comparator的实现必须保证以下几点: ...
  • 前段时间看到一篇关于Arrays.sort()基本原理和使用的解读,正好之前自己也想总结一下关于Java中和排序相关的一些内容,不限于Arrays.sort()、ArrayList.sort()以及Comparator和Comparable接口。在本文中将介绍Arrays...
  • 区别 如果我们需要对一个对象数组进行排序,我们可以使用Arrays.sort()方法。 如果我们需要排序一个对象列表,我们可以使用Collections.sort()方法。...在Java 6中Arrays.sort()和Collections.sort()使用的是Me...
  • 今天在写LeetCode题目时,本来想使用Arrays.sort()方法,可以对于其中传入比较器的使用带有疑惑,所以来整理一篇Arrays.sort()的用法。对于需要我们自己去实现排序的题的话,就不要投机取巧使用Arrays.sort()了,...
  • 通过Arrays类事物静态sort()方法可以实现对数组的排序。sort方法提供了多种重载方式,可以对任意类型的数组进行升序排序。
  • Arrays.sort实现降序排序

    千次阅读 2020-06-26 11:25:05
    在调用Arrays.sort()对数组进行排序时,默认是升序排序的,如果想让数组降序排序,有下面两种方法: 1.Collections的reverseOrder import java.util.*; public class Main { public static void main(String[] ...
  • Arrays.sort()有以下重载(此处只展示两种): Arrays.sort(Object[] a); Arrays.sort(T[] a, Comparator<? super T> c); Arrays.sort(Object[] a) 此方法看似没有要求我们实现比较器,对于基本数据类型,...
  • 首先注意默认排规则,当使用sort(Objetc[] a)来进行对象的自然排序,该对象必需实现Compareable接口,重写compareableTo方法,并一般在此方法中定义这3种返回值(1,0,-1)来进行排序标准的...Arrays.sort(numsArr,...
  • Arrays.sort()源码分析与典型实现例子

    千次阅读 2020-07-06 18:14:54
    文章目录自定义排序用匿名内部类实现一维数组升序Lamda表达式对二维数组进行第一维度排序对二维数组进行双维度排序源码Comparator的compare的源码Arrays.sort() 自定义排序 在做一些算法题时常常会需要对数组、...
  • 文章目录ArrayList/List 的排序:Collections.sort()/List.sort()Array 的排序:Arrays.sort() 此文首发于我的Jekyll博客:zhang0peter的个人博客 之前写了一篇博客:Java:获取数组中的子数组的多种方法 现在在做...
  • index=Arrays.binarySearch(int[] array,staIndex,length,int key) 1.有多个同名的默认返回第一个,并不保证顺序 2.当存在时返回的是找到的该数组中的下标值,即序数-1,不存在时返回负数。使用-index-2为第一个...
  • 最近在刷算法题的过程中,频频用到Arrays.sort()这个排序API,所以我就想看一看这个方法的底层到底是采用什么排序策略。和我一起来看看吧! // Use Quicksort on small arrays if (right - left < QUICKSORT_...
  • 320) at java.util.ComparableTimSort.sort(ComparableTimSort.java:188) at java.util.Arrays.sort(Arrays.java:1246) at ComparableInterface.Test.main(Test.java:54) 提示你:cannot be cast to java.lang....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 171,675
精华内容 68,670
关键字:

arrays.sort