List应用2

于 2023-04-22 08:00:00 发布
阅读量54 收藏
点赞数
文章标签： list java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_58093198/article/details/130213358
版权
文章介绍了如何使用Collections.sort()方法对Integer和String类型的集合进行排序，强调了Comparator在自定义排序规则中的重要性。同时，展示了Lambda表达式在简化排序代码方面的优势。此外，文章还讨论了Set接口在实现不可重复集合和去重操作中的作用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

  1. 集合排序：

    • Collections为集合的工具类，里面定义了很多静态方法用于操作集合

    • Collections.sort(List list)方法：可以对list集合进行自然排序(从小到大)，但是其要求List集合中的元素必须是可比较的，判断是否可以比较的标准是元素是否实现了Comparable接口，若没有实现该接口则直接发生编译错误，但是在实际开发中，我们一般是不会不让我们自己写的类去实现Comparable接口的，因为这对我们的程序有侵入性。

    • 侵入性：当我们调用某个API功能时，其要求我们为其修改其它额外的代码，这个现象叫做侵入性。侵入性越强越不利于程序的后期维护，应尽量避免。

    • 建议使用重载的Collections.sort(List list, Comparator o);可以通过Comparator来自定义比较规则

      package collection;
import java.util.Random;
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
/**
 * 对Integer元素数据排序
 */
public class SortInteger {
    public static void main(String[] args) {
        Random rand = new Random();
        List<Integer> list = new ArrayList<>();
        for(int i=0;i<10;i++){
            list.add(rand.nextInt(100));
        }
        System.out.println("list原始数据:"+list);

        Collections.sort(list); //自然排序(从小到大)
        System.out.println("list排序后数据:"+list);

        Collections.reverse(list); //反转list集合(数据已经变了--大到小)
        System.out.println("list反转后数据:"+list);
        System.out.println("第1个元素为:"+list.get(0)); //大
    }
}

package collection;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * 对String元素排序
 */
public class SortString {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("王克晶");
        list.add("传奇sdfsdf");
        list.add("国斌老师");
        System.out.println("list原始数据: "+list); //[王克晶, 传奇djflkjflw, 国斌老师]

        //自定义排序规则:
        Collections.sort(list, new Comparator<String>() {
            /*
              compare()方法用于定义o1和o2比较大小的规则，它的返回值表达大小关系
              结论:
                1)前面的-后面的------------升序
                2)后面的-前面的------------降序
             */
            public int compare(String o1, String o2) {
                //return o1.length()-o2.length(); //升序
                return o2.length()-o1.length(); //降序
            }
        });

        //Lambda简化版
        Collections.sort(list, (o1,o2)->o1.length()-o2.length());

        System.out.println("list排序后数据:"+list);

        /*
        List<String> list = new ArrayList<>();
        list.add("jack");
        list.add("rose");
        list.add("tom");
        list.add("jerry");
        list.add("black");
        list.add("Kobe");
        System.out.println("list原始数据:  "+list); //[jack, rose, tom, jerry, black, Kobe]

        //对英文字符串排序时，会按首字母的ASCII码来排
        //若首字母相同，则比较第2个字母的ASCII码，以此类推
        Collections.sort(list);
        System.out.println("list排序后数据:"+list);
         */

    }
}

public class SortPoint {
    public static void main(String[] args) {
        List<Point> list = new ArrayList<>();
        list.add(new Point(5,8));
        list.add(new Point(15,60));
        list.add(new Point(57,89));
        list.add(new Point(1,4));
        list.add(new Point(10,8));
        list.add(new Point(22,35));
        System.out.println("list原始数据:"+list);

        //jdk1.8时，List集合自身提供了sort方法进行排序，方法中需要传入比较器
        list.sort(new Comparator<Point>() {
            public int compare(Point o1, Point o2) {
                return o1.getX()-o2.getX();
            }
        });
        System.out.println("list排序后数据:"+list);

        list.sort((o1,o2)->{
            int len1 = o1.getX()*o1.getX()+o1.getY()*o1.getY();
            int len2 = o2.getX()*o2.getX()+o2.getY()*o2.getY();
            return len1-len2; //升序
        });

        /*
        //自定义排序规则:
        Collections.sort(list, new Comparator<Point>() {
            public int compare(Point o1, Point o2) {
                int len1 = o1.getX()*o1.getX()+o1.getY()*o1.getY();
                int len2 = o2.getX()*o2.getX()+o2.getY()*o2.getY();
                //return len1-len2; //升序
                return len2-len1; //降序
                //return o1.getX()-o2.getX(); //按x坐标升序
                //return o2.getY()-o1.getY(); //按y坐标降序
            }
        });
         */
        Collections.sort(list,(o1,o2)->{
            int len1 = o1.getX()*o1.getX()+o1.getY()*o1.getY();
            int len2 = o2.getX()*o2.getX()+o2.getY()*o2.getY();
            return len1-len2; //升序
        });

        System.out.println("list排序后数据:"+list);

    }
}

  2. Lambda表达式：

    • JDK1.8之后推出了一个新特性：Lambda表达式

    • 规则：

      • 不是任何匿名内部类都可以转换为Lambda表达式
      • Lambda表达式对接口的要求：只能是函数式接口
      • 函数式接口:接口中要求实现类必须重写的方法只有一个

    • 语法：

      (参数列表)->{
   方法体
}

      public class LambdaDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        //匿名内部类写法
        Collections.sort(list, new Comparator<String>() {
            public int compare(String o1, String o2) {
                return o1.length()-o2.length();
            }
        });

        //Lambda表达式写法
        Collections.sort(list, (String o1, String o2) -> {
                return o1.length()-o2.length();
        });

        //Lambda表达式中的参数类型可以不写
        Collections.sort(list, (o1, o2) -> {
            return o1.length()-o2.length();
        });

        //Lambda表达式方法体中只有一句代码，方法体的{}可以不写，如果这句话中有return，也一并不写
        Collections.sort(list, (o1, o2) -> o1.length()-o2.length());

        //Lambda表达式的方法参数只有1个,那么()可以忽略不写---本案例不适用

    }
}

  3. Set接口：

    • 不可重复集合，并且大部分实现类都是无序的

      package collection;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * Set集合的演示
 */
public class SetDemo {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("one");
        set.add("two");
        set.add("three");
        set.add("four");
        set.add("five");
        set.add("two"); //无法被正确添加进去，因为Set集是不可重复集合
        System.out.println(set); //并且大部分实现类都是无序的
    }
}

    • 小面试题：如何去重？

      package collection;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * Set集合的演示
 */
public class SetDemo {
    public static void main(String[] args) {
        //小面试题:如何去重?
        List<String> list = new ArrayList<>();
        list.add("one");
        list.add("two");
        list.add("three");
        list.add("four");
        list.add("five");
        list.add("two");
        System.out.println("list:"+list); //[one, two, three, four, five, two]

        Set<String> set = new HashSet<>();
        set.addAll(list); //将list集合元素添加到set集合中，重复的添加不进去
        System.out.println("set:"+set); //[one, two, three, four, five]
    }
}
洛于尘
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值