javase-day04

luoyiang

于 2024-08-07 19:08:04 发布

阅读量55

点赞数 1

文章标签： java 算法开发语言

本文链接：https://blog.csdn.net/m0_64370841/article/details/140999232

版权

CollectionDemo01

package com.se.aCollection;

import java.util.ArrayList;
import java.util.Collection;

/**
 * Collection接口的常用方法练习：
 * <p>
 * Collection接口是子接口List/Set/Queue的父接口，里面提供了子类常用的方法
 */

public class CollectionDemo01 {
    public static void main(String[] args) {
        //使用多态的向上造型创建一个子类型对象
        Collection<String> c1 = new ArrayList<>();

        //1. E add(E e)  向集合中添加元素\
        c1.add("A");
        c1.add("B");
        c1.add("C");

        //2. Boolean isEmpty()  判断集合是否为空
        boolean empty = c1.isEmpty();
        System.out.println(empty);

        //3. int size()  返回集合中元素的个数
        System.out.println(c1.size());

        //4.String toString()  返回集合的字符串形式
        System.out.println(c1.toString());

        Collection<String> c2 = new ArrayList<>();
        c2.add("B");
        c2.add("C");
        c2.add("D");

        //5. addAll(Collection c)  向集合中添加元素
        c1.addAll(c2);
        System.out.println(c1.toString());

        //6. boolean contains(Object o)  判断集合中是否包含某个元素
        //查看是否包含元素B
        boolean contains = c1.contains("B");
        System.out.println(contains);

        //7. boolean containsAll(Collection c)  判断集合中是否包含另一个集合
        //查看c1是否包含集合c2
        boolean containsAll = c1.containsAll(c2);
        System.out.println(containsAll);

        //8. boolean equals(Object o)  判断两个集合是否相等
        //测试：创建一个新的集合c3 添加元素A B C B D D
        //判断两个集合是否相同
        Collection<String> c3 = new ArrayList<>();
        c3.add("A");
        c3.add("B");
        c3.add("C");
        c3.add("B");
        c3.add("D");
        c3.add("D");
        System.out.println("是否相同" + c1.equals(c3));

        //9. boolean remove(Object o)  从集合中删除元素
        boolean remove = c1.remove("B");
        System.out.println(remove);

        //10. boolean removeAll(Collection<?> c)  从集合中删除另一个集合
        //新建一个集合c4 添加元素 B C
        //测试c1移除子集c4
        Collection<String> c4 = new ArrayList<>();
        c4.add("B");
        c4.add("C");
        boolean removeAll = c1.removeAll(c2);
        System.out.println(removeAll);

        //11. boolean retainAll(Collection<?> c)  从集合中删除另一个集合中不存在的元素
        //测试： 向c1添加E F G 然后保留子集c5  c5中有A E
        c1.add("E");
        c1.add("F");
        c1.add("G");
        System.out.println(c1.toString());
        Collection<String> c5 = new ArrayList<>();
        c5.add("A");
        c5.add("E");
        boolean retainAll = c1.retainAll(c5);
        System.out.println(retainAll);
        System.out.println(c1.toString());

        //12. void clear();  测试: 清空c1
        c1.clear();
        System.out.println(c1.toString());
        System.out.println(c1.size());
    }
}

CollectionDemo02

package com.se.aCollection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
 *  集合的迭代：
 *    1. 集合的迭代，就是指集合的遍历操作
 *    2. 几乎所有的集合子类型都实现了迭代接口Iterable
 *    3. 迭代接口提供了多个方法，用于迭代
 *       - boolean hasNext()： 用于判断集合中是否有下一个元素
 *                 可以形象的认为有指针，指针的最初位置在集合的第一个元素前面
 *       - E next()： 用于获取指针指向的元素，并将指针移动到下一个元素
 *       - void remove()： 用于删除指针指向的元素，并将指针移动到下一个元素
 *
 *     tips：在使用迭代器的时候，不可使用集合的remove方法，否则会抛出异常
 */

public class CollectionDemo02 {
    public static void main(String[] args) {
        Collection<Integer> c1 = new ArrayList<>();
        c1.add(1);
        c1.add(2);
        c1.add(3);
        c1.add(4);
        c1.add(5);
        //使用增强for循环遍历，底层原理就是迭代器
        for (Integer i : c1) {
            System.out.print(i+"");
        }

        //使用迭代器iterator()方法进行遍历
        //第一步: 获取要遍历的集合对象的迭代器对象
        Iterator<Integer> it = c1.iterator();
        //第二步：问是否有下一个元素
        while (it.hasNext()) {
            //第三步：获取元素
            Integer a = it.next();
            System.out.print(a+"");
        }




    }
}

CollectionDemo03

package com.se.aCollection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
 * IDE(idea，eclipse)这样的开发工具应该都有debug功能，该功能是用来调试代码，
 *   捋请运行逻辑，找到发生异常的地方。
 *
 *   如果想要使用debug功能，需要在可能出现异常或者你想要看的地方发一个断点。
 *   断电的作用： 就是在debug运行到这一地方时，进行程序的阻塞
 *   然后可以使用相应的快捷键或者按钮，
 *
 *   迭代器的源码解析：
 *      三个成员变量：
 *      cursor： 记录下一次要返回的元素的下标
 *      lastRet： 记录上一次返回的元素的下标
 *      expectedModCount： 预计集合的修改次数  默认为集合长度 与modCount的值一致
 *                         tips： 集合在调用add(E e)方法添加元素时，modCount++
 *
 *      hasNext()： return   cursor！= size    当光标的值为集合长度时，没有下一个元素
 *      next()：
 *         1. 检查 expectedModCount与modCount的值是否一致，不一致则抛出异常
 *         2. 光标额值先赋值给lastRet，指针后移。光标的值+1，为下一次的hasNext()方法做准备工作
 *             新的lastRet的值就是指针指向的元素，也就是新取出的元素
 *      remove()：
 *         1. 检查 expectedModCount与modCount的值是否一致，不一致则抛出异常
 *         2. 调用ArrayList的E remove(int index)方法做真正的删除元素
 *             而E remove(int index)方法会调用System.arraycopy()方法，
 *             从指定的index+1，向前移动一位，以此形式做删除操作
 *
 *             index的值是lastRet的值
 *
 *             因为后续元素的下标前移了一位，所以光标(cursor)的值需要前移一次
 *
 *             最重要的是： remove(int index)里面进行了modCount++，
 *             但是迭代器的remove里，进行了重新赋值expectedModCount = modCount;
 *
 *
 *
 */

public class CollectionDemo03 {
    public static void main(String[] args) {
        Collection<String> c1 = new ArrayList<>();
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("c");
        c1.add("d");
        c1.add("d");

        //使用迭代器时，如果发现c元素，就将其删除
        Iterator<String> it = c1.iterator();
        while (it.hasNext()) {
            String element = it.next();
            if (element.equals("c")) {
                //使用集合自己的删除方法，会报错ConcurrentModificationException  表示不应该修改元素
//                c1.remove(element); 可以使用迭代器的删除方法
                it.remove();
            }
        }
        System.out.println(c1);
    }
}

ListDemo01

package com.se.bList;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 * List接口的特点：
 *   1. 元素有序，可以重复
 *   2. 两个实现类：ArrayList和LinkedList
 *        -ArrayList：动态数组+各种方法
 *        -LinkedList：双向链表+各种方法
 *   3. 两个实现类的效率： (元素量很多的情况)
 *      -对于随机访问来说：ArrayList > LinkedList
 *      -对于频繁地插入和删除来说：LinkedList > ArrayList
 *   4. 基于List接口，两个实现类的方法基本一致
 */

public class ListDemo01 {
    public static void main(String[] args) {
        //创建一个ArrayList集合对象
        List<String> names = new ArrayList<>();
        //创建一个LinkedList集合对象
        List<String> adds = new LinkedList<>();

        /*
          添加元素
          boolean add(E e)   添加元素，默认添加到集合末尾
          void add(int index, E element)   插入元素，下标范围[0,size()]
          boolean addAll(Collection c)
          boolean addAll(Collection<? extends E> c)
         */
        names.add("micheal");
        names.add(1, "jack");
        System.out.println(names);

        //地址集合添加两个元素
        adds.add("beijing");
        adds.add("shanghai");

        //将地址集合添加到names集合中
        names.addAll(adds);
        System.out.println(names);

        //将地址集合添加到names集合中两个元素之间
//        names.addAll(1, adds);
//        System.out.println(names);

        // E get(int index)   获取指定位置的元素
        System.out.println(names.get(0));

        //int indexOf(Object o)   查找指定元素的下标
        int index = names.indexOf("jack");
        System.out.println(index);

        //int lastIndexOf(Object o)   获取指定元素的最后一个下标
        int lastIndex = names.lastIndexOf("jack");
        System.out.println(lastIndex);

        //E remove(int index)   删除指定位置的元素
        names.remove(1);
        System.out.println(names);

        //E set(int index, E element)   修改指定位置的元素
        names.set(1, "tom");
        System.out.println(names);

        //List subList(int fromIndex, int toIndex)   截取集合
        List<Integer> nums = new ArrayList<>();
        for (int i = 1; i < 11; i++) {
            nums.add(i);
        }
        System.out.println(nums);
        List<Integer> subNums = nums.subList(3, 7);
        System.out.println(subNums);

        //对子集里的每一个元素扩大十倍。
        for (int i = 0; i < subNums.size(); i++) {
            subNums.set(i, subNums.get(i) * 10);
        }
        System.out.println(subNums);
        System.out.println(nums);
    }
}