JavaSEDemo23集合

秒速五厘米 2021-09-25 07:46 345阅读 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整理的笔记
  • 赘述可能有点多，还请各位朋友耐心阅读
  • 本人的内容和答案不一定是最好最正确的，欢迎各位朋友评论区指正改进

树

树删除元素

  1. //删除结点的方法
  2.     public void delete(int key) throws Exception{ 
  3.         //创建当前结点和它的父结点
  4.         Node parent = null;
  5.         Node current = root;
  6.         //如果要删除的结点是根结点
  7.         if(key == root.key){ 
  8.             parent = root;
  9.             root = root.left;
  10.             if(root.right !=null){ 
  11.                 Node temp = root.right;
  12.                 while(temp.right !=null){ 
  13.                     temp =temp.right;
  14.                 }
  15.                 temp.right = parent.right;
  16.             }
  17.         }else { 
  18.             while (key != current.key) { 
  19.                 parent = current;
  20.                 if (key < current.key) { 
  21.                     current = current.left;
  22.                 }
  23.                 if (key > current.key) { 
  24.                     current = current.right;
  25.                 }
  26.                 if (current == null) { 
  27.                     throw new IllegalStateException("没有找到与key值匹配的结点");
  28.                 }
  29.             }
  30.             //如果要删除的结点在父结点的左侧
  31.             if(parent.left == current){ 
  32.                 //删除结点:跳过父结点的原左结点
  33.                 if(current.left != null){ 
  34.                parent.left = current.left;
  36.                 //如果被删除的结点的右子树不为空
  37.                 if(current.right != null){ 
  38.                     //创建临时结点:赋的值是删除结点后,父结点的新的左结点
  39.                     Node temp = parent.left;
  40.                     //如果该结点的右子树不为空,则一直右移,直到为空
  41.                     while(temp.right != null){ 
  42.                         temp = temp.right;
  43.                     }
  44.                     temp.right = current.right;
  45.                 }
  46.                 }else { 
  47.                     parent.left = current.right;
  48.                 }
  49.             }//反之右侧
  50.             else { 
  51.                 if (current.right != null) { 
  52.                     //删除结点:跳过父结点的原右结点
  53.                     parent.right = current.right;
  54.                     //如果被删除的结点的左子树不为空
  55.                     if (current.left != null) { 
  56.                         //创建临时结点:赋的值是删除结点后,父结点的新的右结点
  57.                         Node temp = parent.right;
  58.                         //如果该结点的左子树不为空,则一直左移,直到为空
  59.                         while (temp.left != null) { 
  60.                             temp = temp.left;
  61.                         }
  62.                         temp.left = current.left;
  63.                     }
  64.                 }else { 
  65.                     parent.right = current.left;
  66.                 }
  67.             }
  68.         }
  70.     }

树的先序 中序 后续遍历

  1. /** *先序遍历二叉树 * @param node * @throws Exception */
  2.     public static void preOrder(Node node) throws Exception{ 
  3.         if(node!=null){ 
  4.             System.out.println(node.key);
  5.             preOrder(node.left);
  6.             preOrder(node.right);
  7.         }
  8.     }
  10.     /** *中序遍历二叉树 * @param node * @throws Exception */
  11.     public static void midOrder(Node node) throws  Exception{ 
  12.         if(node!=null){ 
  13.             midOrder(node.left);
  14.             System.out.println(node.key);
  15.             midOrder(node.right);
  16.         }
  17.     }
  19.     /** *后序遍历二叉树 * @param node * @throws Exception */
  20.     public static void laterOrder(Node node) throws  Exception{ 
  21.         if(node!=null){ 
  22.             laterOrder(node.left);
  23.             laterOrder(node.right);
  24.             System.out.println(node.key);
  25.         }
  26.     }

集合

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方法

  1. @Test
  2.     public void test() { 
  3.         //创建对象
  4.         ArrayList<Integer> arrayList1 = new ArrayList<>();
  5.         arrayList1.add(10);
  6.         arrayList1.add(30);
  7.         arrayList1.add(20);
  8.         arrayList1.add(50);
  9.         arrayList1.add(40);
  10.         arrayList1.add(70);
  12.         arrayList1.add(1, 100);
  13.         //打印集合
  14.         System.out.println(arrayList1);
  16.         ArrayList<Integer> arrayList2 = new ArrayList<>();
  17.         arrayList2.add(1);
  18.         arrayList2.add(2);
  19.         arrayList2.add(3);
  20.         arrayList2.add(4);
  21.         arrayList2.add(5);
  22.         boolean b = arrayList2.addAll(1, arrayList1);
  23.         System.out.println("b = " + b);
  24.         System.out.println(arrayList2);
  26.         arrayList2.clear();
  27.         System.out.println("arrayList2 = " + arrayList2);
  28.     }

remove(int index)方法

  1. @Test
  2.     public void testRemove() { 
  3.         ArrayList<Integer> list = new ArrayList<>();
  4.         list.add(10);
  5.         list.add(20);
  6.         list.add(30);
  7.         list.add(40);
  8.         list.add(50);
  9.         System.out.println(list);
  10.         Integer remove = list.remove(1);
  11.         System.out.println("remove = " + remove);
  12.         System.out.println(list);
  13.     }

remove(Object obj)方法

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

    @Test

    1. public void testRemove2() { 
    2.     ArrayList<Integer> list = new ArrayList<>();
    3.     list.add(10);
    4.     list.add(20);
    5.     list.add(30);
    7.     boolean b = list.remove(new Integer("20"));
    8.     System.out.println("b = " + b);
    9.     System.out.println("list = " + list);
    10. }

removeAll方法

  1. @Test
  2.     public void testRemoveAll() { 
  3.         ArrayList<Integer> list1 = new ArrayList<>();
  4.         ArrayList<Integer> list2 = new ArrayList<>();
  5.         list1.add(10);
  6.         list1.add(20);
  7.         list1.add(30);
  8.         list1.add(40);
  9.         list1.add(50);
  10.         list1.add(60);
  11.         list1.add(70);
  12.         list1.add(80);
  15.         list2.add(20);
  16.         list2.add(30);
  18.         System.out.println(list1);
  19.         list1.removeAll(list2);
  20.         System.out.println(list1);
  21.     }

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

  1. @Test
  2.     //替换指定索引处的元素
  3.     public void testSet() { 
  4.         ArrayList<Integer> list = new ArrayList<>();
  5.         list.add(10);
  6.         list.add(20);
  7.         list.add(30);
  8.         list.set(1, 50);
  10.         System.out.println(list);
  11.         System.out.println(list.size());
  12.         System.out.println(list.isEmpty());
  13.     }

contains方法

  1. @Test
  2.     public void testContains(){ 
  3.         ArrayList<Integer> list = new ArrayList<>();
  4.         list.add(10);
  5.         list.add(20);
  6.         list.add(30);
  7.         list.add(40);
  8.         list.add(50);
  9.         list.add(60);
  11.         System.out.println(list.contains(30));
  12.     }

containsAll方法

  1. @Test
  2.     public void testContainsAll(){ 
  3.         ArrayList<Integer> list1 = new ArrayList<>();
  4.         ArrayList<Integer> list2 = new ArrayList<>();
  5.         list1.add(10);
  6.         list1.add(20);
  7.         list1.add(30);
  8.         list1.add(40);
  9.         list1.add(50);
  10.         list1.add(60);
  11.         list1.add(70);
  13.         list2.add(10);
  14.         list2.add(20);
  16.         System.out.println("list1.containsAll(list2) = " + list1.containsAll(list2));
  17.     }

indexOf方法

  1. @Test
  2.     public void testIndexOf(){ 
  3.         ArrayList<Integer> list = new ArrayList<>();
  4.         list.add(10);
  5.         list.add(20);
  6.         list.add(30);
  7.         list.add(40);
  8.         list.add(50);
  9.         list.add(20);
  10.         list.add(20);
  11.         list.add(20);
  12.         list.add(20);
  13.         list.add(20);
  15.         System.out.println("list.indexOf(20) = " + list.indexOf(20));
  16.         System.out.println("list.indexOf(200) = " + list.indexOf(200));
  18.         System.out.println("list.lastIndexOf(20) = " + list.lastIndexOf(20));
  19.     }

toArray方法

  1. @Test
  2.     public void testToArray(){ 
  3.         ArrayList<Integer> list = new ArrayList<>();
  4.         list.add(10);
  5.         list.add(20);
  6.         list.add(30);
  7.         list.add(40);
  8.         list.add(50);
  9.         list.add(60);
  10.         list.add(70);
  11.         list.add(80);
  13.         Object[] array = list.toArray();
  14.         for (int i = 0; i < array.length; i++) { 
  15.             System.out.print(array[i] + " ");
  16.         }
  17.     }

get方法

  1. @Test
  2.     public void testGet(){ 
  3.         ArrayList<Integer> list = new ArrayList<>();
  4.         list.add(10);
  5.         list.add(20);
  6.         list.add(30);
  8.         System.out.println("list.get(1) = " + list.get(1));
  9.     }

普通for循环

  1. @Test
  2.     public void testFor(){ 
  3.         ArrayList<Integer> list = new ArrayList<>();
  4.         list.add(10);
  5.         list.add(20);
  6.         list.add(30);
  7.         list.add(40);
  8.         list.add(50);
  10.         for (int i = 0; i < list.size(); i++) { 
  11.             Integer integer = list.get(i);
  12.             System.out.println("integer = " + integer);
  13.         }
  14.     }

增强for循环

  1. @Test
  2.     public void testEach(){ 
  3.         ArrayList<Integer> list = new ArrayList<>();
  4.         list.add(10);
  5.         list.add(20);
  6.         list.add(30);
  7.         list.add(40);
  8.         list.add(50);
  10.         for (Integer integer : list) { 
  11.             System.out.println("integer = " + integer);
  12.         }
  14.     }

iterator

  1. @Test
  2.     public void testIterator(){ 
  3.         ArrayList<Integer> list = new ArrayList<>();
  4.         list.add(10);
  5.         list.add(20);
  6.         list.add(30);
  7.         list.add(40);
  8.         list.add(50);
  10.         Iterator<Integer> iterator = list.iterator();
  11.         //hasNext表示是否有下一个元素
  12.         while(iterator.hasNext()){ 
  13.             //next表示下一个元素
  14.             Integer next = iterator.next();
  15.             System.out.println("next = " + next);
  16.         }
  18.     }

listIterator

  • 先正序 才能逆序

    @Test

    1. public void testListIterator(){ 
    2.     ArrayList<Integer> list = new ArrayList<>();
    3.     list.add(10);
    4.     list.add(20);
    5.     list.add(30);
    6.     list.add(40);
    7.     list.add(50);
    9.     ListIterator<Integer> iterator = list.listIterator();
    10.     //hasNext表示是否有下一个元素
    11.     while(iterator.hasNext()){ 
    12.         //next表示下一个元素
    13.         Integer next = iterator.next();
    14.         System.out.println("next = " + next);
    15.     }
    17.     System.out.println("===========================");
    19.     while(iterator.hasPrevious()){ 
    20.         Integer previous = iterator.previous();
    21.         System.out.println("previous = " + previous);
    22.     }
    24. }

普通for循环删除

  1. @Test
  2.     public void testForDel(){ 
  3.         ArrayList<Integer> list = new ArrayList<>();
  4.         list.add(10);
  5.         list.add(20);
  6.         list.add(30);
  7.         for (int i = 0; i < list.size(); i++) { 
  8.             System.out.println("list.get(i) = " + list.get(i));
  9.             list.remove(0);
  10.         }
  11.         System.out.println(list);
  12.     }

发表评论

表情：
评论列表 （有 0 条评论，345人围观）

还没有评论，来说两句吧...

相关阅读

    相关 JavaSEDemo06

    文章目录 简介 显示继承与隐式继承 继承的重点 继承与构造方法 继承的优点和缺点 final关键字 多重继承时构造方法的执行情况

    清疚清疚/ 0 赞/ 375 阅读

    相关 JavaSEDemo05

    文章目录 简介 void方法中return语句的使用规范 可变API与不可变API 数据交换与方法传参 为什么不能用返回值类型来判断方法是否

    比眉伴天荒比眉伴天荒/ 0 赞/ 392 阅读