Java SE 11 Sliver学习笔记(第九章)

2020-08-09

技术

字数统计: 1.6k | 阅读时长≈ 7 分钟

Java SE 11 sliver资格考试相关

第九章 API

間違えた：2，3，4，6，7，9，12，13，19

間違えし易い：

分からない： 2，15，17

回顾

Math.pow方法，没什么好说的。第一个参数是累乘对象，第二个是指数。

java.util.Comparator接口相关。例子：

public class comparator {
    public static void main(String[] args) {
        Sample[] samples = {
                new Sample(2, "B"),
                new Sample(3, "C"),
                new Sample(1, "A"),
        };
        List<Sample> list = new ArrayList<>(Arrays.asList(samples));
          //实现Comparator接口，自己在定义compare方法进行排序
        list.sort(new samplecomParator());
        for (Sample s: list ) {
              System.out.println(s.getName());
          }
          //因为Integer类已经实现了Comparable接口所以可以直接使用集合类的sort方法排序
        List<Integer> list2 = new ArrayList<>(); 
        list2.add(1);
        list2.add(2);
        list2.add(2);
        list2.add(3);
        Collections.sort(list2);
        for (Integer integer : list2) {
            System.out.println(integer);
        }
    }
    public static class samplecomParator implements Comparator<Sample> {
        @Override
        public int compare(Sample o1, Sample o2) {
            if (o1.getId() < o2.getId()) {
                return -1;
            }
            if (o1.getId() > o2.getId()) {
                return 1;
            }
            return 0;
        }
    }
    public static class Sample{
        private int id;
        private String name;

        public Sample(int id, String name) {
            super();
            this.id = id;
            this.name = name;
        }

        public int getId() {
            return id;
        }

        public String getName() {
            return name;
        }
    }

list.sort()中使用lamda表达式，传入比较方法，题目中想实现的是倒序，而Integer中实现的Comparable接口定义的compareTo是升序，所以要加负号。

package chapter09;

import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

public class compareLamda {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(new Integer[]{1, 2, 3});
//        Collections.sort(list);          //y也可以使用collections类的sort方法，只不过比较慢
//        Collections.reverse(list);
        
        list.sort((a, b) -> -a.compareTo(b));

        for (Integer num : list) {
            System.out.println(num);
        }
    }
}

三种方法参数都是char型因此不会报编译错误。

LocalDate类相关。parse方法传入的是字符串并且连接的必须是-，of方法中月份是从1开始。

1
2
3

LocalDate a = LocalDate.of(2015, 1, 1);
        LocalDate b = LocalDate.parse("2015-01-01");
        System.out.println(a.equals(b));

LocalDate类是immutable的所以调用with方法不会影响之前instance中的值，而是会生成一个新的instance。
ArrayList中是可以存null的，而且可以存重复元素，并且ArrayList是线程不安全的，vector是线程安全的。

不指定类型的ArrayList什么都可以存，除非这样指定的情况下，就是只能存String：

1 2	List<String> list = new Arraylist<String> (); //Java SE6开始 List<String> list = new Arraylist<> (); //Java SE7开始

关于ArrayList的初始化问题，初始化size的长度为0，容量为10？随着加入数据慢慢增加，size也慢慢增加。size指的是存的元素的个数。
ArrayList的set方法，将置换指定index的元素值。
ArrayList的remove方法，从list中删除元素。如果删除的对象有多个存在时，使用equals方法判断true的最初的对象删除。equal方法可以重写。
ArrayList的remove方法后后面的元素会向前移动，注意扩张for是将list中的元素一个一个取出，当删除完时之后的元素如果不再存在for循环将会终止。

ArrayList类的remove方法后不能在将List输出，原因参考这里，具体内容不需要理解，考试中注意当使用了remove方法后如果使用for循环读取list时会在运行时跳出java.util.ConcurrentModificationException异常。例子：

public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("A");
        list.add("B");
        list.add("C");
        list.add("D");
        list.add("E");
        //错误的
        for(String str : list){
            if ("C".equals(str)) {
                list.remove(str);
            }
        }
        //正确的
        for (int i = 0; i < list.size(); i++) {
            if ("C".equals(list.get(i))) {
                list.remove(list.get(i));
            }
        }
        //正确的
        for (Iterator<String> it = list.iterator(); it.hasNext(); ) {
            String str = it.next();
            if ("C".equals(str)) {
                list.remove(str);
                it.remove();
            }
        }
        for(String str : list){
            System.out.println(str);
        }
    }

List是不可以变更长度的。
Arrays类的mismatch方法的使用，返回的是两个输入数组最开始不相同元素的index，当两个数组完全相同时返回-1。
Arrays类的compare方法的返回值。因为是String类的compareTo方法，是按按字典顺序进行比较。参考参照最后一个链接。

关于List的removeIf方法，通过传入实现Predicate接口的lamda式（返回值必须为Boolean！！）判断删除的rule。需要注意第7行一开始生成的list不能直接删除，因为Arrays.asList生成的List是不能变更长度的！！

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class listRemoveIf {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList(new String[]{"A", "B", "C"}));
        //Arrays.asList生成的List是不能变更长度的，因此一定要在包装一下
        list.removeIf((String s) ->{
            return s.equals("B");
        });
        System.out.println(list);
    }
}

方法引用。forEach接受的是Consumer型的参数，也就是参数只有1个，没有返回值。此外，关于经常使用的方法，还可以使用方法引用。直接上例子：

import java.util.Arrays;

public class methodReferences {
        public static void main(String[] args) {
            String[] array = new String[] { "Apple", "Orange", "Banana", "Lemon" };
            Arrays.sort(array, methodReferences::cmp);//注意方法引用这里不需要加参数！！
            Arrays.sort(array, String::compareTo);
            //因为实例方法有一个隐含的this参数，String类的compareTo()方法在实际调用的时候，第一个隐含参数总是传入                                this，相当于静态方法
            System.out.println(String.join(", ", array));
        }
        static int cmp(String s1, String s2) {
            return s1.compareTo(s2);
        }
}

HashMap类是Map接口的实现类，key和value都可以使用null，并且使用put方法时如果key已经存在了将会覆盖之前的key对应的value而不是新插入元素。null不是存在第0位！！

public class hashMap {
    public static void main(String[] args) {
        HashMap<Integer, String> hashMap = new HashMap<>();

        hashMap.put(1, "A");
        hashMap.put(2, "B");
        hashMap.put(3, "C");
        hashMap.put(1, "D");
        hashMap.put(null, "null");
        hashMap.put(null, "new null ");
        hashMap.put(0, "??");
        System.out.println(hashMap.size());
    }
}

参考

版权声明： 本博客所有文章除特别声明外，著作权归作者所有。转载请注明出处！