你真的了解java吗？java总结九

对象数组排序

注意，对象数组排序我们需要自己去实现接口，如果直接排序则会报错。

对于浮点数，我们必须使用Double.compare方法进行判断，否则会出现精度误差

        Student[] students = new Student[3];
        students[0] = new Student("张三",15,158);
        students[1] = new Student("李四",12,185);
        students[2] = new Student("王五",13,188);

        //根据年龄排序
        Arrays.sort(students, new Comparator() {
            @Override
            public int compare(Student o1, Student o2) {
                //通过年龄排序
//                return o1.getAge()-o2.getAge();
                //通过身高排序（浮点型需要通过Double.compare方法判断）
//                return Double.compare(o1.getHeight(),o2.getHeight());   //升序
                return Double.compare(o2.getHeight(),o1.getHeight());   //降序
            }
        });
        System.out.println(Arrays.toString(students));

lambda表达式是JDK8的新语法

作用：简化匿名内部类的代码写法

注意：Lambda表达式只能简化函数式接口的匿名内部类的写法形式

• 必须是接口，有且仅有一个抽象方法
• 通常我们会在接口上方加一个@FunctionalInterface注解，标记改接口必须是满足函数式接口

public class LambdaDemo2 {
    public static void main(String[] args) {

        //第一种
        Sp sp1 = new Sp() {
            @Override
            public void to() {
                System.out.println("sp1~~~~~~");
            }
        };
        s1(sp1);

        //第二种
        Sp sp2 = ()->{
            System.out.println("sp2~~~~~~");
        };
        s1(sp2);

        //第三种
        s1(()->{
            System.out.println("sp3~~~~~~");
        });

    }
    public static void s1(Sp sp){
        sp.to();
    }
}

//一但加上这个接口，必须是函数式接口，只能有一个抽象方法
@FunctionalInterface
interface Sp{
    void to();
}

以下两段代码的功能相同，使用lambda表达式可以进行简化

        Arrays.sort(arr1, new Comparator() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return -(o1-o2);    //降序
            }
        });

        Arrays.sort(arr1, (Integer o1,Integer o2) -> {
            return -(o1-o2);    //降序
        });

• 参数类型可以不写
• 如果只有一个参数，参数类型与（）都可以省略
• Lambda表达式方法体代码如果只有一行，那么可以省略大括号不写，同时省略分号
• Lambda表达式方法体代码如果只有一行，大括号可以不写，如果这行代码是return，则必须省略return不写，同时省略“；”不写

所以，上述代码可以简化成

        Arrays.sort(arr1,(o1, o2) -> o1-o2);

集合和数组都是容器

• 定义完成并启动后，类型确定，长度固定。
• 进行增删改查 *** 作的时候，数组不是很方便，增删数据都需要放弃原有数组或移位

• 当业务数据的个数固定，且都是同一批数据类型，可以采用数组存储

• 集合大小不固定，启动后可动态变化，类型可以选择，不固定。
• 集合非常适合和做元素增删 *** 作
• 注意：集合中只能存储引用数据类型，如果要存储基本数据类型可以使用包装类

• 数据的个数不确定，需要进行增删元素的时候

• 单列（Collection）
• 双列（Map）

Collection单列集合，每个元素只包含一个值

Map双列集合，每个元素包括两个值（键值对）

• List
  • ArrayList
  • LinkedList
• Set
  • HashSet
    • LinkedHashSet
  • TreeSet

• list集合：添加的元素是有序、可重复、有索引
  • ArrayList、LinekdList:有序、可重复、有索引
• Set集合：添加元素是无序、不重复、无索引
  • HashSet:无序、不重复、无索引
    • LinkedSet:有序、不重复、无索引
  • TreeSet：按照大小默认升序排序、不重复、无索引

• 集合都是支持泛型的，可以在编译阶段约束集合只能 *** 作某种数据类型

        Collection collection2 = new ArrayList();
        //JDK7后，后面的泛型声明可以不写
        Collection collection3 = new ArrayList<>();

注意：集合和泛型只支持引用数据类型，都认为是对象，不支持基本数据类型

        Collection list = new ArrayList<>();
        //添加元素
        list.add("JAVA");
        list.add("JAVA");
        list.add("ssm");
        list.add("springboot");
        System.out.println(list);

        //清空集合
//        list.clear();
        System.out.println(list);

        //集合判空
        System.out.println(list.isEmpty());

        //获取集合大小
        System.out.println(list.size());

        //判断是否包含某个元素
        System.out.println(list.contains("JAVA"));

        //删除某个元素,如果有多个重复元素，则删除第一个
        System.out.println(list.remove("JAVA"));
        System.out.println(list);

        //集合转换成数组
        Object[] objects = list.toArray();
        System.out.println("数组："+Arrays.toString(objects));

        Collection list1 = new ArrayList<>();
        list1.add("redis");

        //将list元素添加到list1中
        list1.addAll(list);
        System.out.println(list1);

    public static void main(String[] args) {
        Collection list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("赵六");
        System.out.println(list);

        //1.获得当前集合的迭代器对象
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

        System.out.println("-------------------------------");

        //2.foreach循环
        for (String s : list) {
            System.out.println(s);
        }

        System.out.println("-------------------------------");

        //3.调用接口遍历
        list.forEach(new Consumer() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

        System.out.println("--------------------------------");

        //4.lambda表达式形式
        list.forEach(s-> System.out.println(s));

        System.out.println("--------------------------------");

        //5.方法引用
        list.forEach(s-> System.out.println(s));

    }