JAVA基础 －集合

/**
 * 列表 ArrayList,LinkedList
 * 1、值列表和对象列表 contains与indexOf测试
 * 2、基于LinkedList构建堆栈 push pop和队列 offer poll
 * <p>
 * Set HashSet,TreeSet   无序，不可重复
 * 1、HashSet比较hashcode()，再比较equals()
 * 2、TreeSet比较comparable和comparator
 * <p>
 * Map
 * 1、HashMap，2次添加相同key,之前value被覆盖； key为引用类型，则Hash也需实现hashCode和equals方法
 * 2、TreeMap  key为引用类型，同样是实现  comparable和comparator
 */
@Data
public class CollectionTest {

    @Test
    public void testList() {
        ArrayList<Integer> integers = new ArrayList<Integer>();
        integers.add(1);
        integers.add(2);
        integers.add(3);

        /**添加到指定位置*/
        integers.add(0, 0);
        /**修改指定位置值*/
        integers.set(0, -1);
        /**取索引位置值*/
        Integer integer = integers.get(0);
        /**列表索引从0开始*/
        int i0 = integers.indexOf(-1);
        int i3 = integers.indexOf(3);

        System.out.println("index:0:" + integer);
        System.out.println("index:-1:index:" + i0);
        System.out.println("elem:3:index:" + i3);

        integers.forEach(p -> {
            System.out.println(p);
        });
    }

    /**
     * 对象类型放入列表，当使用indexOf和Contains方法必须实现对应equals方法
     */
    @Test
    public void testObjList() {
        ArrayList<Demo> demos = new ArrayList<>();
        demos.add(new Demo(1, "binfire"));
        demos.add(new Demo(2, "shanshan"));

        Demo demo = new Demo(2, "yuxuan");
        int i = demos.indexOf(demo);
        boolean contains = demos.contains(demo);

        System.out.printf("index:%d,exists；%b", i, contains);
    }

    /**
     * %s:字符串 %c 字符 %b 布尔值 %x 16进制  %o 8进制 %d%% 百分笔  %n换行
     */
    @Test
    void testPrintf() {
        System.out.printf("%s;%c;%b;%d;%x;%o;%f;%d%%;%n", "china", 'i', true, 10, 100, 100, 99.9, 85);
        String a = "191328015";
        if (a == "191328015") {
            System.out.printf("ok");
        } else {
            System.out.printf("error");
        }

    }

    @Test
    void testLinkList() {
        LinkedList<Integer> integers = new LinkedList<>();
        integers.add(1);
        integers.add(2);
        integers.add(3);
        integers.addFirst(0);
        integers.addLast(4);

        System.out.printf("%d%n", integers.getFirst());
        System.out.printf("%d%n", integers.getLast());
        System.out.printf("%d%n", integers.get(1));

        integers.removeFirst();
        integers.removeLast();

        System.out.println(integers.toString());
    }

    /**
     * 模拟堆栈  linkedList.push  linkedList.pop
     */
    @Test
    void testStack() {
        LinkedList<Integer> integers = new LinkedList<>();
        integers.push(1);
        integers.push(2);
        integers.push(3);

        while (integers.size() > 0) {
            System.out.println(integers.pop());
        }
    }

    /**
     * 模拟队列 linkedList.offer linkedList.poll
     */
    @Test
    void testQueue() {
        LinkedList<Integer> integers2 = new LinkedList<>();
        integers2.offer(1);
        integers2.offer(2);
        integers2.offer(3);

        while (integers2.size() > 0) {
            System.out.println(integers2.poll());
        }
    }

    /**
     * 首先计算HashCode，再计算equals方法
     */
    @Test
    void testHashSet() {
        HashSet<Demo> demos = new HashSet<>();
        demos.add(new Demo(1, "binfire"));
        demos.add(new Demo(2, "yuxuan"));
        boolean shanshan = demos.add(new Demo(1, "shanshan"));
        System.out.printf("can add %b%n", shanshan);
        System.out.println(demos.toString());

        HashSet<String> strings = new HashSet<>();
        strings.add("binfire");
        strings.add("yuxuan");
        boolean binfire = strings.add("binfire");
        System.out.println("can add :" + binfire);
        System.out.println(strings.toString());
    }

    /**
     * 比较实现Comparable<T>接口, 重复则不添加
     */
    @Test
    void testTreeSet() {
        TreeSet<Integer> set = new TreeSet<>();
        set.add(1);
        set.add(9);
        set.add(8);
        set.add(7);
        set.add(6);
        set.add(5);
        set.add(1);
        System.out.println(set.toString());

        /**Demo继承Comparator*/
        TreeSet<Demo> demos = new TreeSet<>();
        demos.add(new Demo(1, "binfire"));
        demos.add(new Demo(2, "shanshan"));
        demos.add(new Demo(3, "yuxuan"));
        demos.add(new Demo(1, "xiaohong"));

        System.out.println(demos.toString());

        /**自定义比较器*/
        TreeSet<Demo> demos1 = new TreeSet<>(new Comparator<Demo>() {
            @Override
            public int compare(Demo o1, Demo o2) {
                return o1.id - o2.id;
            }
        });
        demos1.add(new Demo(1, "binfire"));
        demos1.add(new Demo(2, "shanshan"));
        demos1.add(new Demo(3, "yuxuan"));
        demos1.add(new Demo(1, "xiaohong"));
        System.out.println(demos1.toString());

    }

    @Test
    void testHashMap() {
        Map<Integer, String> integerStringHashMap = new HashMap<Integer, String>();
        integerStringHashMap.put(1, "binfire");
        integerStringHashMap.put(2, "shanshan");
        String yuxuan = integerStringHashMap.put(1, "yuxuan");  /*相同key则覆盖*/
        System.out.println(yuxuan);
        System.out.println(integerStringHashMap.toString());
        String binfire = integerStringHashMap.put(3, "binfire");
        System.out.println(binfire + "空");

        //integerStringHashMap.entrySet().for
        for (Map.Entry<Integer, String> integerStringEntry : integerStringHashMap.entrySet()) {
            System.out.println(integerStringEntry.getKey() + ":" + integerStringEntry.getValue());
        }

        HashMap<Demo, String> demoStringHashMap = new HashMap<>();
        demoStringHashMap.put(new Demo(1, "binfier001"), "001");
        demoStringHashMap.put(new Demo(2, "binfier002"), "002");
        demoStringHashMap.put(new Demo(1, "binfier003"), "003");

        for (Map.Entry<Demo, String> demoStringEntry : demoStringHashMap.entrySet()) {
            System.out.println(demoStringEntry.getKey() + ":" + demoStringEntry.getValue());
        }
    }

    @Test
    void testTreeMap() {
        TreeMap<Demo, String> demoStringTreeMap = new TreeMap<>(new Comparator<Demo>() {
            @Override
            public int compare(Demo o1, Demo o2) {
                return o1.id-o2.id;
            }
        });
        demoStringTreeMap.put(new Demo(1,"binfire001"),"001");
        demoStringTreeMap.put(new Demo(2,"binfire002"),"002");
        demoStringTreeMap.put(new Demo(1,"binfire001"),"003");

        for (Map.Entry<Demo, String> demoStringEntry : demoStringTreeMap.entrySet()) {
            System.out.println("key="+demoStringEntry.getKey().toString()+";value="+demoStringEntry.getValue());
        }
    }


    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @Accessors(chain = true)
    class Demo implements Comparable<Demo> {
        private int id;
        private String name;

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof Demo)) return false;
            Demo demo = (Demo) o;
            return id == demo.id;
        }

        @Override
        public int hashCode() {
            return Objects.hash(id);
        }

        @Override
        public int compareTo(Demo o) {
            return this.id - o.id;
        }

        @Override
        public String toString() {
            return "Demo{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    '}';
        }
    }

}