java基础总结(107)--排序

- 日理万妓 2022-10-22 07:41 154阅读 0赞

**目录**

0公共的知识

list与数组相互转化

map转list

list转map

2对数组进行排序

3list排序

3.1基础类型List排序

3.2对象List单属性排序

3.3对象List多属性排序

4map排序

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

# 0公共的知识 #

## list与数组相互转化 ##

1 数组转换为List  
1.1 使用java.util.Arrays工具类中的asList()方法

String[] arrays = {"a", "b", "c"};
    List<String> list = Arrays.asList(arrays);

注意 : 将数组转换List后,不能对List增删,只能查改,否则抛出 UnsupportedOperationException异常

对转换后的List插入一条数据

list.add("d");

执行后抛出 :

java.lang.UnsupportedOperationException
        at java.util.AbstractList.add(AbstractList.java:148)
        at java.util.AbstractList.add(AbstractList.java:108)

原因解析：

> Arrays.asList(strArray)返回值是java.util.Arrays类中一个私有静态内部类java.util.Arrays.ArrayList，它并非java.util.ArrayList类。java.util.Arrays.ArrayList类具有 set()，get()，contains()等方法，但是不具有添加add()或删除remove()方法,所以调用add()方法会报错。

使用场景：Arrays.asList(strArray)方式仅能用在将数组转换为List后，不需要增删其中的值，仅作为数据源读取使用。

1.2 使用Stream中的Collector收集器

String[] arrays = {"a", "b", "c"};
    List<String> listStrings = Stream.of(arrays).collect(Collectors.toList());

转换后的List 属于 java.util.ArrayList 能进行正常的增删查操作  
2. List转换为数组  
2.1 使用Stream

List<String> list = new ArrayList<>();
            list.add("a");
            list.add("b");
            list.add("c");
            String[] strings = list.stream().toArray(String[]::new);

2.2 使用List中的toArray()方法

List<String> list = new ArrayList<>();
            list.add("a");
            list.add("b");
            list.add("c");
    String[] strings = list.toArray(new String[list.size()]);

————————————————  
版权声明：本文为CSDN博主「makesailing」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。  
原文链接：https://blog.csdn.net/qq\_37653556/article/details/83271784

## map转list ##

Map<String, String> map = new HashMap<String, String>();  
            map.put("1", "AA");  
            map.put("2", "BB");  
            map.put("3", "CC");  
            map.put("4", "DD");  
           
            Collection<String> valueCollection = map.values();  //获取map所有的value  
            final int size = valueCollection.size();  
          
            List<String> valueList = new ArrayList<String>(valueCollection);  //转换成list  
————————————————  
版权声明：本文为CSDN博主「狂奔的黑驴」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。  
原文链接：https://blog.csdn.net/yuzhoaheyou/article/details/88952249

## list转map ##

List集合转Map，用到的是Stream中Collectors的toMap方法：Collectors.toMap  
具体用法实例如下：

//声明一个List集合
    List<Person> list = new ArrayList();  
            list.add(new Person("1001", "小A"));  
            list.add(new Person("1002", "小B"));  
            list.add(new Person("1003", "小C"));
            System.out.println(list);
    //将list转换map
    Map<String, String> map = list.stream().collect(Collectors.toMap(Person::getId, Person::getName));
            System.out.println(map);

输出结果为：

![20210405105825931.png][]

注意：用Collectors的toMap方法转换List，一般会遇到两个问题。一个是转换map，key重复问题；另一个是空指针异常，即转为map的value是null。  
问题解决！！！  
一、第一种问题报的错误如下：Duplicate key

![20210405105929821.png][]

原因是声明List集合时，有的值重复，如图：

![20210405105937996.png][]

解决方法：(分三种，具体哪种看业务需求)  
1.重复时用后面的value 覆盖前面的value

Map<String, String> map = list.stream().collect(Collectors.toMap(Person::getId, Person::getName,(key1 , key2)-> key2 ));
            System.out.println(map);

输出结果：

![20210405110100985.png][]

2.重复时将前面的value 和后面的value拼接起来；

Map<String, String> map = list.stream().collect(Collectors.toMap(Person::getId, Person::getName,(key1 , key2)-> key1+","+key2 ));
            System.out.println(map);

输出结果：

![20210405110140873.png][]

3.重复时将重复key的数据组成集合

Map<String, List<String>> map = list.stream().collect(Collectors.toMap(Person::getId,
                    p ->  {
                         List<String> getNameList = new ArrayList<>();
                             getNameList.add(p.getName());
                             return getNameList;
                         },
                         (List<String> value1, List<String> value2) -> {
                             value1.addAll(value2);
                             return value1;
                         }
                     ));
           
             System.out.println(map);

输出结果：

![20210405110203302.png][]

二、第二种问题报的错误如下：NullPointerException

![20210405110215361.png][]

原因是声明List集合时有的值为空(如图)，但是HashMap中k,v是可以存null值的。

![20210405110225493.png][]

解决方法：在转换流中加上判空，即便value为空,依旧输出。(与上面方法三相同)

输出结果为：

![20210405110258787.png][]

————————————————  
版权声明：本文为CSDN博主「菜鸟驿站ㅤ」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。  
原文链接：https://blog.csdn.net/qq\_39629277/article/details/83012548

# 2对数组进行排序 #

来自：[https://blog.csdn.net/weixin\_41987908/article/details/90445062][https_blog.csdn.net_weixin_41987908_article_details_90445062]

其实Arrays.Sort(str) 是不稳定的，稳定排序可以用Arrays.parallelSort(str)

若是升序直接Arrays.Sort(str)  就可以，若不是则得改造一下
            Integer[]str={1,3,4,5,7,2};
            Arrays.sort(str,new Comparator<Integer>() {
                @Override
                public int compare(Integer o1, Integer o2) {
                    //反序有 -   若是正序则去掉 -
                    return -o1.compareTo(o2);
                }
            });
            System.out.println(Arrays.toString(str));

java8 数组排序：

目前我只会先变为list 在转数组不会一次性转数组（还得继续学习）
        反序：
            Integer[]str={1,3,4,5,7,2};
            List<Integer> collect = Arrays.stream(str).sorted(Comparator.reverseOrder()).collect(Collectors.toList());
            Integer[] integers = collect.toArray(new Integer[6]);
            String s = Arrays.toString(integers);
            System.out.println(s);
            输出：[7, 5, 4, 3, 2, 1]  
        正序：
       Comparator.reverseOrder()   改为 Comparator.naturalOrder()    就行

如果是一个对象的一个属性排序则：

List<FollowIMSI> collect = listResult.stream()
                .sorted(Comparator.comparing(FollowIMSI::getFollowDegree).reversed())
                .collect(Collectors.toList());

如果两个对象的一个属性排序:

List<Human> humans = new ArrayList<>();
    humans.add(new Human("Sarah", 10));
    humans.add(new Human("Jack", 12));
    正序是:
    Collections.sort(humans, Comparator.comparing(Human::getName));
    反序是：
    Collections.sort(humans, Comparator.comparing(Human::getName).reversed());

多条件排序：

//先按年龄从小到大排序，年龄相同再按id从小到大排序
    personList.stream().sorted(Comparator.comparing((Person::getAge).thenComparing(Person::getId())).collect(Collectors.toList())

# 3list排序 #

##   3.1基础类型List排序 ##

来自[https://my.oschina.net/sdlvzg/blog/2243766][https_my.oschina.net_sdlvzg_blog_2243766]

//对数字进行排序
    List<Integer> nums = Arrays.asList(3,1,5,2,9,8,4,10,6,7);
    nums.sort(Comparator.reverseOrder()); //reverseOrder倒序
    System.err.println("倒序:"+nums);
    
    nums.sort(Comparator.naturalOrder()); //naturalOrder自然排序即：正序
    System.err.println("正序:"+nums);

![20210405112351262.png][]

##   3.2对象List单属性排序 ##

List<Developer> listDevs = ComparatorTest.getDevelopers();
    
    System.out.println("排序前:");
    //JAVA8的写法，循环
    listDevs.forEach((developer)->System.out.println(developer));
    
    //第一个写法
    Collections.sort(listDevs, new Comparator<Developer>() {
        @Override
        public int compare(Developer o1, Developer o2) {
            return o1.getAge().compareTo(o2.getAge());
        }
    });
    //第二个写法,JAVA8的写法，List 接口支持直接使用 sort 该方法，不再需要使用 Collections.sort 了
    //listDevs.sort(listDevs, new Comparator<Developer>() {
    //   @Override
    //   public int compare(Developer o1, Developer o2) {
    //       return o1.getAge().compareTo(o2.getAge();
    //   }
    //});
    
    //第三个写法,Lambda写法，JAVA8的写法
    //listDevs.sort((Developer o1, Developer o2)->o1.getAge().compareTo(o2.getAge()));
    
    //第四个写法,Lambda写法，JAVA8的写法
    //listDevs.sort((o1, o2)->o1.getAge().compareTo(o2.getAge()));
    
    //第五写法,个Lambda写法，JAVA8的写法
    //listDevs.sort(Comparator.comparing(Developer::getAge));
    
    //第六写法,个Lambda写法，JAVA8的写法
    Comparator<Developer> ageComparator = (o1, o2)->o1.getAge().compareTo(o2.getAge());
    listDevs.sort(ageComparator);       //按上面配置的顺序取值
    listDevs.sort(ageComparator.reversed());    //按上面配置的顺序反向取值
    
    System.out.println("排序后:");
    //JAVA8的写法，循环
    listDevs.forEach((developer)->System.out.println(developer));

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xzeDIwMTc_size_16_color_FFFFFF_t_70][]

##   3.3对象List多属性排序 ##

//        多条件排序第一个写法，先按Age排序，再根据Salary排序
    //        Comparator<Developer> comparator = (o1, o2) -> {
    //            if (o1.getName().equals(o2.getName())) {
    //                return o1.getSalary().compareTo(o2.getSalary());
    //            }
    //            return o2.getAge().compareTo(o1.getAge());
    //        };
    //        listDevs.sort(comparator.reversed());
    
    //        多条件排序，先按Age排序，再根据Salary排序
    //        Comparator<Developer> ageComparator = (o1, o2)->o1.getAge().compareTo(o2.getAge());
    //        Comparator<Developer> salaryComparator = (o1, o2)->o1.getSalary().compareTo(o2.getSalary());
    //        listDevs.sort(ageComparator.thenComparing(salaryComparator));
    
    //        多条件排序第二个写法，先按Age排序，再根据Salary排序
    listDevs.sort(Comparator.comparing(Developer::getAge).thenComparing(Developer::getSalary));

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xzeDIwMTc_size_16_color_FFFFFF_t_70 1][]

来自[https://blog.csdn.net/qq\_23179075/article/details/78753136][https_blog.csdn.net_qq_23179075_article_details_78753136]

在日常开发中，很多时候都需要对一些数据进行排序的操作。然而那些数据一般都是放在一个集合中如：Map ，Set ，List 等集合中。他们都提共了一个排序方法 sort()，要对数据排序直接使用这个方法就行，但是要保证集合中的对象是 可比较的。

怎么让一个对象是 可比较的，那就需要该对象实现 Comparable<T> 接口啦。然后重写里面的  
compareTo()方法。我们可以看到Java中很多类都是实现类这个接口的 如：Integer，Long 等等。。。

假设我们有一个学生类，默认需要按学生的年龄字段 age 进行排序 代码如下：

public class Student implements Comparable<Student> {
        private int id;
        private int age;
        private String name;
    
        public Student(int id, int age, String name) {
            this.id = id;
            this.age = age;
            this.name = name;
        }
        @Override
        public int compareTo(Student o) {
            //降序
            //return o.age - this.age;
            //升序
            return this.age - o.age;        
        }
        @Override
        public String toString() {
            return "Student{" +
                    "id=" + id +
                    ", age=" + age +
                    ", name='" + name + '\'' +
                    '}';
        }
    }

这里说一下重写的 public int compareTo(Student o)\{\} 这个方法，它返回三种 int 类型的值： 负整数，零 ，正整数。

<table> 
 <thead> 
  <tr> 
   <th>返回值</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>负整数</td> 
   <td>当前对象的值&nbsp;<strong>&lt;</strong>&nbsp;比较对象的值 ， 位置排在前</td> 
  </tr> 
  <tr> 
   <td>零</td> 
   <td>当前对象的值&nbsp;<strong>=</strong>&nbsp;比较对象的值 ， 位置不变</td> 
  </tr> 
  <tr> 
   <td>正整数</td> 
   <td>当前对象的值&nbsp;<strong>&gt;</strong>&nbsp;比较对象的值 ， 位置排在后</td> 
  </tr> 
 </tbody> 
</table>

测试代码

public static void main(String args[]){
            List<Student> list = new ArrayList<>();
            list.add(new Student(1,25,"关羽"));
            list.add(new Student(2,21,"张飞"));
            list.add(new Student(3,18,"刘备"));
            list.add(new Student(4,32,"袁绍"));
            list.add(new Student(5,36,"赵云"));
            list.add(new Student(6,16,"曹操"));
            System.out.println("排序前:");
            for (Student student : list) {
                System.out.println(student.toString());
            }
            //使用默认排序
            Collections.sort(list);
            System.out.println("默认排序后:");
            for (Student student : list) {
                System.out.println(student.toString());
            }
    }

输出日志：

排序前:
    Student{id=1, age=25, name='关羽'}
    Student{id=2, age=21, name='张飞'}
    Student{id=3, age=18, name='刘备'}
    Student{id=4, age=32, name='袁绍'}
    Student{id=5, age=36, name='赵云'}
    Student{id=6, age=16, name='曹操'}
    默认排序后:
    Student{id=6, age=16, name='曹操'}
    Student{id=3, age=18, name='刘备'}
    Student{id=2, age=21, name='张飞'}
    Student{id=1, age=25, name='关羽'}
    Student{id=4, age=32, name='袁绍'}
    Student{id=5, age=36, name='赵云'}

比较器的使用  
这个时候需求又来了，默认是用 age 排序，但是有的时候需要用 id 来排序怎么办？ 这个时候比较器 ：Comparator 就排上用场了。

Comparator 的使用有两种方式：

Collections.sort(list,Comparator<T>）;  
list.sort(Comparator<T>);  
其实主要是看 Comparator 接口的实现，重写里面的 compare 方法。代码如下：

//自定义排序1
    Collections.sort(list, new Comparator<Student>() {
        @Override
        public int compare(Student o1, Student o2) {
            return o1.getId() - o2.getId();
        }
    });

`compare(Student o1, Student o2)` 方法的返回值跟 `Comparable<>` 接口中的 `compareTo(Student o)` 方法 返回值意思相同。另一种写法如下：

//自定义排序2
    list.sort(new Comparator<Student>() {
        @Override
        public int compare(Student o1, Student o2) {
            return o1.getId() - o2.getId();
        }
    });

输出日志：

排序前:
    Student{id=1, age=25, name='关羽'}
    Student{id=2, age=21, name='张飞'}
    Student{id=3, age=18, name='刘备'}
    Student{id=4, age=32, name='袁绍'}
    Student{id=5, age=36, name='赵云'}
    Student{id=6, age=16, name='曹操'}
    自定义排序后:
    Student{id=1, age=25, name='关羽'}
    Student{id=2, age=21, name='张飞'}
    Student{id=3, age=18, name='刘备'}
    Student{id=4, age=32, name='袁绍'}
    Student{id=5, age=36, name='赵云'}
    Student{id=6, age=16, name='曹操'}

## 4map排序 ##

如果是treemap对象，本来就具备排序功能。所以不需要单独的排序

TreeMap<String, Integer> treeMap = new TreeMap<>();
            treeMap.put("k", 1);
            treeMap.put("w", 3);
            treeMap.put("z", 2);
            System.out.println(treeMap);

执行输出：

\{k=1, w=3, z=2\}

TreeMap默认是按照key的自然顺序升序排列的，比如上面k, w, z，按照它们的ASCII码值排序就是kwz。下面博客介绍了如何修改treemap的排序规则。

来自[https://www.cnblogs.com/huiyi0521/p/10990543.html][https_www.cnblogs.com_huiyi0521_p_10990543.html]

TreeMap默认是升序的，如果我们需要改变排序方式，则需要使用比较器：Comparator。

Comparator可以对集合对象或者数组进行排序的比较器接口，实现该接口的public compare(T o1,To2)方法即可实现排序，该方法主要是根据第一个参数o1,小于、等于或者大于o2分别返回负整数、0或者正整数。代码如下:

public class TreeMapTest {
        public static void main(String[] args) {
            Map<String, String> map = new TreeMap<String, String>(
                    new Comparator<String>() {
                        public int compare(String obj1, String obj2) {
                            // 降序排序
                            return obj2.compareTo(obj1);
                        }
                    });
            map.put("c", "ccccc");
            map.put("a", "aaaaa");
            map.put("b", "bbbbb");
            map.put("d", "ddddd");
    
            Set<String> keySet = map.keySet();
            Iterator<String> iter = keySet.iterator();
            while (iter.hasNext()) {
                String key = iter.next();
                System.out.println(key + ":" + map.get(key));
            }
        }
    }

运行结果如下：
    d:ddddd
    c:ccccc
    b:bbbbb
    a:aaaaa

上面例子是对根据TreeMap的key值来进行排序的，但是有时我们需要根据TreeMap的value来进行排序。对value排序我们就需要 借助于Collections的sort(List<T> list, Comparator<? super T> c)方法，该方法根据指定比较器产生的顺序对指定列表进行排序。但是有一个前提条件，那就是所有的元素都必须能够根据所提供的比较器来进行比较。如下：

public class TreeMapTest {
        public static void main(String[] args) {
            Map<String, String> map = new TreeMap<String, String>();
            map.put("d", "ddddd");
            map.put("b", "bbbbb");
            map.put("a", "aaaaa");
            map.put("c", "ccccc");
    
            //这里将map.entrySet()转换成list
            List<Map.Entry<String,String>> list = new ArrayList<Map.Entry<String,String>>(map.entrySet());
            //然后通过比较器来实现排序
            Collections.sort(list,new Comparator<Map.Entry<String,String>>() {
                //升序排序
                public int compare(Entry<String, String> o1,
                        Entry<String, String> o2) {
                    return o1.getValue().compareTo(o2.getValue());
                }
            });
            for(Map.Entry<String,String> mapping:list){                System.out.println(mapping.getKey()+":"+mapping.getValue()); 
              } 
        }
    }

运行结果如下：
    d:ddddd
    c:ccccc
    b:bbbbb
    a:aaaaa

我们都是HashMap的值是没有顺序的，他是按照key的HashCode来实现的。对于这个无序的HashMap我们要怎么来实现排序呢？参照TreeMap的value排序，我们一样的也可以实现HashMap的排序。

public class HashMapTest {
        public static void main(String[] args) {
            Map<String, String> map = new HashMap<String, String>();
            map.put("c", "ccccc");
            map.put("a", "aaaaa");
            map.put("b", "bbbbb");
            map.put("d", "ddddd");
    
            List<Map.Entry<String,String>> list = new ArrayList<Map.Entry<String,String>>(map.entrySet());
            Collections.sort(list,new Comparator<Map.Entry<String,String>>() {
                //升序排序
                public int compare(Entry<String, String> o1,
                        Entry<String, String> o2) {
                    return o1.getValue().compareTo(o2.getValue());
                }
    
            });
    
            for(Map.Entry<String,String> mapping:list){ 
                   System.out.println(mapping.getKey()+":"+mapping.getValue()); 
              } 
         }
    }

运行结果如下：  
d:ddddd  
c:ccccc  
b:bbbbb  
a:aaaaa

[20210405105825931.png]: /images/20221022/2059b92261c94e61a8332fd79107655c.png
[20210405105929821.png]: /images/20221022/d3a7452beeb14c028f0a2b191abf2715.png
[20210405105937996.png]: /images/20221022/8bd50635b11a419d83c0cd1d20bb45f7.png
[20210405110100985.png]: /images/20221022/5b6e149bd1214449801d5fdc3819ae8c.png
[20210405110140873.png]: /images/20221022/e55b44a0719249589815fbce4d9cb953.png
[20210405110203302.png]: /images/20221022/781c8e6aaf284998b36f01d465b55a85.png
[20210405110215361.png]: /images/20221022/f739f30a9a334a3399f4905f57a0e1a4.png
[20210405110225493.png]: /images/20221022/50226af5b2f146029658765a195a50dd.png
[20210405110258787.png]: /images/20221022/78858ff0544a47b6909a566d36885ac6.png
[https_blog.csdn.net_weixin_41987908_article_details_90445062]: https://blog.csdn.net/weixin_41987908/article/details/90445062
[https_my.oschina.net_sdlvzg_blog_2243766]: https://my.oschina.net/sdlvzg/blog/2243766
[20210405112351262.png]: /images/20221022/32a79e19a1014eed9672ce99dd13c5ef.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xzeDIwMTc_size_16_color_FFFFFF_t_70]: /images/20221022/741098fc97bb49d3b84115f18b85dcd7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xzeDIwMTc_size_16_color_FFFFFF_t_70 1]: /images/20221022/bf412dd28b0741f59b66e4bf219fa4f5.png
[https_blog.csdn.net_qq_23179075_article_details_78753136]: https://blog.csdn.net/qq_23179075/article/details/78753136
[https_www.cnblogs.com_huiyi0521_p_10990543.html]: https://www.cnblogs.com/huiyi0521/p/10990543.html