JavaSEDemo23集合

秒速五厘米 2021-09-25 07:46 217阅读 0赞

### 文章目录 ###

*  简介
 *  树
 *   *  树删除元素
     *  树的先序 中序 后续遍历
 *  集合
 *  Collection接口
 *   *  List接口
     *   *  特点
         *  常用方法
     *  通过实现类ArrayList实现对上述方法的使用
     *  add方法、addAll方法和clear方法
     *  remove(int index)方法
     *  remove(Object obj)方法
     *  removeAll方法
     *  set方法、size方法和isEmpty()方法
     *  contains方法
     *  containsAll方法
     *  indexOf方法
     *  toArray方法
     *  get方法
     *  普通for循环
     *  增强for循环
     *  iterator
     *  listIterator
     *  普通for循环删除

# 简介 #

*  本文是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);
        }