JavaSEDemo23集合-优快云博客

本文链接：https://blog.youkuaiyun.com/hypertext123/article/details/115999150

简介

本文是2021/04/22整理的笔记
赘述可能有点多，还请各位朋友耐心阅读
本人的内容和答案不一定是最好最正确的，欢迎各位朋友评论区指正改进

树

树删除元素

//删除结点的方法
    public void delete(int key) throws Exception{
        //创建当前结点和它的父结点
        Node parent = null;
        Node current = root;
        //如果要删除的结点是根结点
        if(key == root.key){
            parent = root;
            root = root.left;
            if(root.right !=null){
                Node temp = root.right;
                while(temp.right !=null){
                    temp =temp.right;
                }
                temp.right = parent.right;
            }
        }else {
            while (key != current.key) {
                parent = current;
                if (key < current.key) {
                    current = current.left;
                }
                if (key > current.key) {
                    current = current.right;
                }
                if (current == null) {
                    throw new IllegalStateException("没有找到与key值匹配的结点");
                }
            }
            //如果要删除的结点在父结点的左侧
            if(parent.left == current){
                //删除结点:跳过父结点的原左结点
                if(current.left != null){
               parent.left = current.left;

                //如果被删除的结点的右子树不为空
                if(current.right != null){
                    //创建临时结点:赋的值是删除结点后,父结点的新的左结点
                    Node temp = parent.left;
                    //如果该结点的右子树不为空,则一直右移,直到为空
                    while(temp.right != null){
                        temp = temp.right;
                    }
                    temp.right = current.right;
                }
                }else {
                    parent.left = current.right;
                }
            }//反之右侧
            else {
                if (current.right != null) {
                    //删除结点:跳过父结点的原右结点
                    parent.right = current.right;
                    //如果被删除的结点的左子树不为空
                    if (current.left != null) {
                        //创建临时结点:赋的值是删除结点后,父结点的新的右结点
                        Node temp = parent.right;
                        //如果该结点的左子树不为空,则一直左移,直到为空
                        while (temp.left != null) {
                            temp = temp.left;
                        }
                        temp.left = current.left;
                    }
                }else {
                    parent.right = current.left;
                }
            }
        }

    }

树的先序中序后续遍历

    /**
     *先序遍历二叉树
     * @param node
     * @throws Exception
     */
    public static void preOrder(Node node) throws Exception{
        if(node!=null){
            System.out.println(node.key);
            preOrder(node.left);
            preOrder(node.right);
        }
    }

    /**
     *中序遍历二叉树
     * @param node
     * @throws Exception
     */
    public static void midOrder(Node node) throws  Exception{
        if(node!=null){
            midOrder(node.left);
            System.out.println(node.key);
            midOrder(node.right);
        }
    }

    /**
     *后序遍历二叉树
     * @param node
     * @throws Exception
     */
    public static void laterOrder(Node node) throws  Exception{
        if(node!=null){
            laterOrder(node.left);
            laterOrder(node.right);
            System.out.println(node.key);
        }
    }

集合

Collection接口

List接口

特点

有序
重复

常用方法

add(E e) 向列表的尾部添加指定的元素
add(int index,E element) 在列表的指定位置添加指定的元素
addAll(Collection<? extends E> c) 添加指定collection中的所有元素到此列表的结尾。
addAll(int index,Collection<? extends E> c) 将指定 collection 中的所有元素都插入
到列表中的指定位置
clear() 从列表中移除所有元素
contains(Object o) 如果列表包含指定的元素，则返回 true
containsAll(Collection<?> c) 如果列表包含指定 collection 的所有元素，则返回 true
equals(Object o) 比较指定的对象与列表是否相等
get(int index) 返回值列表中指定位置的元素
indexOf(Object o) 返回此列表中第一次出现的指定元素的索引；如果不包含此元素，返回-1
isEmpty() 如果列表为空，返回true
iterator() 返回按适当顺序在列表的元素上进行迭代的迭代器。
listIterator( ) 返回此列表元素的列表迭代器
remove(int index) 移除列表中指定位置的元素
remove(Object o) 移除列表中第一次出现的指定元素
set(int index,E element) 用指定元素替换列表中指定位置的元素
size() 返回列表中的元素数

通过实现类ArrayList实现对上述方法的使用

add方法、addAll方法和clear方法

 @Test
    public void test() {
        //创建对象
        ArrayList<Integer> arrayList1 = new ArrayList<>();
        arrayList1.add(10);
        arrayList1.add(30);
        arrayList1.add(20);
        arrayList1.add(50);
        arrayList1.add(40);
        arrayList1.add(70);
        
        arrayList1.add(1, 100);
        //打印集合
        System.out.println(arrayList1);
        
        ArrayList<Integer> arrayList2 = new ArrayList<>();
        arrayList2.add(1);
        arrayList2.add(2);
        arrayList2.add(3);
        arrayList2.add(4);
        arrayList2.add(5);
        boolean b = arrayList2.addAll(1, arrayList1);
        System.out.println("b = " + b);
        System.out.println(arrayList2);

        arrayList2.clear();
        System.out.println("arrayList2 = " + arrayList2);
    }

remove(int index)方法

@Test
    public void testRemove() {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
        System.out.println(list);
        Integer remove = list.remove(1);
        System.out.println("remove = " + remove);
        System.out.println(list);
    }

remove(Object obj)方法

因为remove方法有两种重载形式，所以List的remove(Object obj) 需要包装一下
例如:list.remove(new Integer(“20”));

@Test
    public void testRemove2() {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(20);
        list.add(30);

        boolean b = list.remove(new Integer("20"));
        System.out.println("b = " + b);
        System.out.println("list = " + list);
    }

removeAll方法

    @Test
    public void testRemoveAll() {
        ArrayList<Integer> list1 = new ArrayList<>();
        ArrayList<Integer> list2 = new ArrayList<>();
        list1.add(10);
        list1.add(20);
        list1.add(30);
        list1.add(40);
        list1.add(50);
        list1.add(60);
        list1.add(70);
        list1.add(80);


        list2.add(20);
        list2.add(30);

        System.out.println(list1);
        list1.removeAll(list2);
        System.out.println(list1);
    }

set方法、size方法和isEmpty()方法

 @Test
    //替换指定索引处的元素
    public void testSet() {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(20);
        list.add(30);
        list.set(1, 50);

        System.out.println(list);
        System.out.println(list.size());
        System.out.println(list.isEmpty());
    }

contains方法

    @Test
    public void testContains(){
        ArrayList<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
        list.add(60);

        System.out.println(list.contains(30));
    }

containsAll方法

    @Test
    public void testContainsAll(){
        ArrayList<Integer> list1 = new ArrayList<>();
        ArrayList<Integer> list2 = new ArrayList<>();
        list1.add(10);
        list1.add(20);
        list1.add(30);
        list1.add(40);
        list1.add(50);
        list1.add(60);
        list1.add(70);

        list2.add(10);
        list2.add(20);

        System.out.println("list1.containsAll(list2) = " + list1.containsAll(list2));
    }

indexOf方法

    @Test
    public void testIndexOf(){
        ArrayList<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
        list.add(20);
        list.add(20);
        list.add(20);
        list.add(20);
        list.add(20);

        System.out.println("list.indexOf(20) = " + list.indexOf(20));
        System.out.println("list.indexOf(200) = " + list.indexOf(200));

        System.out.println("list.lastIndexOf(20) = " + list.lastIndexOf(20));
    }

toArray方法

@Test
    public void testToArray(){
        ArrayList<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
        list.add(60);
        list.add(70);
        list.add(80);

        Object[] array = list.toArray();
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }

get方法

@Test
    public void testGet(){
        ArrayList<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(20);
        list.add(30);

        System.out.println("list.get(1) = " + list.get(1));
    }

普通for循环

@Test
    public void testFor(){
        ArrayList<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);

        for (int i = 0; i < list.size(); i++) {
            Integer integer = list.get(i);
            System.out.println("integer = " + integer);
        }
    }

增强for循环

 @Test
    public void testEach(){
        ArrayList<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);

        for (Integer integer : list) {
            System.out.println("integer = " + integer);
        }

    }

iterator

@Test
    public void testIterator(){
        ArrayList<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);

        Iterator<Integer> iterator = list.iterator();
        //hasNext表示是否有下一个元素
        while(iterator.hasNext()){
            //next表示下一个元素
            Integer next = iterator.next();
            System.out.println("next = " + next);
        }

    }

listIterator

先正序才能逆序

@Test
    public void testListIterator(){
        ArrayList<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);

        ListIterator<Integer> iterator = list.listIterator();
        //hasNext表示是否有下一个元素
        while(iterator.hasNext()){
            //next表示下一个元素
            Integer next = iterator.next();
            System.out.println("next = " + next);
        }

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

        while(iterator.hasPrevious()){
            Integer previous = iterator.previous();
            System.out.println("previous = " + previous);
        }

    }

普通for循环删除

  @Test
    public void testForDel(){
        ArrayList<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(20);
        list.add(30);
        for (int i = 0; i < list.size(); i++) {
            System.out.println("list.get(i) = " + list.get(i));
            list.remove(0);
        }
        System.out.println(list);
    }