【JavaOOP应用】1、集合类

1. 集合类

1.1 Java结合接口分层图

1.2 List集合

1.2.1 ArrayList 类与 Vector 类

ArrayList 特点：
1、有序，集合的顺序与存放的顺序一样
2、可以通过下标访问、可以放重复元素

1.2.1.1 ArrayList的基本用法

/**
 * 1、ArrayList的基本用法
 * 注意：
 *   ① 默认集合的长度为10个元素。
 *   ② 当容量不够时，会自动增长原来的一半，如：第一次增长就为15个长度，这样就实现了自动扩容。
 *   private void grow(int minCapacity) {
 *         // overflow-conscious code
 *         int oldCapacity = elementData.length;
 *         int newCapacity = oldCapacity + (oldCapacity >> 1);
 *         if (newCapacity - minCapacity < 0)
 *             newCapacity = minCapacity;
 *         if (newCapacity - MAX_ARRAY_SIZE > 0)
 *             newCapacity = hugeCapacity(minCapacity);
 *         // minCapacity is usually close to size, so this is a win:
 *         elementData = Arrays.copyOf(elementData, newCapacity);
 *     }
 */
@Test
public void test01(){
    // 1. 定义ArrayList对象
    List list = new ArrayList<>();

    // 2. 向list中添加数据
    list.add("abc");
    list.add("def");
    list.add(3.45);
    list.add(new Integer(123));
    List small = new ArrayList();
    small.add(true);
    small.add(true);
    small.add(true);
    small.add(true);
    small.add(true);
    small.add(true);
    small.add(true);
    list.addAll(small);         // 在大集合中放小集合

    //3. 实际查看长度
    int size = list.size();
    System.out.println("size = " + size);

    // 4. 删除指定元素
    // 4.1 根据内容删除单个元素
    list.remove(new Integer(123));
    // 4.2 根据下标删除元素
    list.remove(1);
    // 4.3 从大集合中删除小集合
    list.removeAll(small);
    System.out.println("list = " + list);

    // 5. 修改元素
    list.set(1,"welcome");          // 参数1：修改元素的下标  参数2：要修改的值
    System.out.println("list = " + list);

    // 6. 通过下标获取元素
    Object o = list.get(0);
    System.out.println("o = " + o);

    // 7. 遍历集合
    // 7.1 方法一：基本for循环
    for (int i = 0; i < list.size(); i++) {
        Object obj = list.get(i);
        System.out.println(obj);
    }
    System.out.println("---------------------------");
    // 7.2 方法二：增强for循环
    for (Object o1 : list) {
        System.out.println(o1);
    }
    System.out.println("---------------------------");
    // 7.3 方法三：迭代器完成
    Iterator iterator = list.iterator();
    while(iterator.hasNext()){
        Object next = iterator.next();
        System.out.println( next);
    }
    System.out.println("---------------------------");
    // 7.4 方法四：使用forEach函数
    list.forEach(new Consumer() {
        @Override
        public void accept(Object o) {
            System.out.println(o);
        }
    });
    System.out.println("---------------------------");
    list.forEach(a -> System.out.print(a + "\t"));
    System.out.println("\n---------------------------");
    list.forEach(System.out::println);
}

1.2.1.2 ArrayList的泛型用法

/**
     * ArrayList的泛型用法
     */
@Test
public void test02(){
    // 1. 定义ArrayList集合
    List<Student> list = new ArrayList<>();
    // 2. 定义一组学生对象
    Student st1 = new Student(1001,"张三","男",20,"上海");
    Student st2 = new Student(1002,"李四","男",22,"西安");
    Student st3 = new Student(1003,"王五","女",21,"杭州");
    Student st4 = new Student(1004,"赵六","女",23,"广州");
    // 3. 添加到集合中
    list.add(st1);
    list.add(st2);
    list.add(st3);
    // 4. 打印学生
    list.forEach(System.out::println);
    System.out.println("-------------------------------");
    for (Student student : list) {
        System.out.println(student);
    }
    System.out.println("-------------------------------");
    // 5. 查看某个学生
    Student stud = list.get(1);
    System.out.println("stud = " + stud);
    // 6. 修改学生
    list.set(2,st4);
    System.out.println("-------------------------------");
    System.out.println("修改后 ： " + list);
    // 7. 删除学生
    list.remove(st4);
    System.out.println("-------------------------------");
    System.out.println("删除后 ： " + list);
}

1.2.2 ArrayList 类与 Vector 类的区别

1、ArrayList 类是 JDK1.2 之后才出现的新类，而 Vector 则是 JDK1.0 之后就出现的老的集合类。
2、当容量不够时，Vector 容量会增加为原来的一倍，而 ArrayList 则会增加为原来的1/2。
3、Vector 是现成安全的，是同步的（synchronized），所以性能较低，而 ArrayList 则是异步的，所以性能较高。

1.2.3 LinkedList 类

/**
 * LinkedList集合
 */
@Test
public void test01(){
    LinkedList list = new LinkedList();
    list.add("abc");                // 向集合后面存放
    list.push(true);             // 将元素入栈（栈操作）
    list.addFirst("hello");      // 将元素放到集合的头部
    list.addLast("world");       // 添加元素到集合的尾部

    //Object pop = list.pop();        // 出栈（弹出栈顶元素）
    Object peek = list.peek();        // 查看栈顶元素

    System.out.println("peek = " + peek);
    // System.out.println("pop = " + pop);
    System.out.println("list = " + list);

    // 循环查看元素，查看一个就弹出一个
    while(!list.isEmpty()){
        Object pop = list.pop();        // 每次循环弹出一个元素
        System.out.println(pop);
    }
    int size = list.size();            // 最后查看元素个数为0
    System.out.println("size = " + size);
}

1.2.4 ArrayList 与 LinkedList 集合的区别

1、ArrayList 集合底层使用的是数组实现的，而 LinkedList 底层使用的是链表实现的。
2、ArrayList 集合在对集合遍历和查找时，效率较高，而 LinkedList 在对集合进行添加或删除元素时，效率较高。

1.3 Set集合

TreeSet与HashSet集合：
1、前者是一个经过排了序的set
2、后者是一个未经过排序的set
3、两种集合都会自动去重，二者都是由JDK1.2才出现的集合类，都是线程异步的。

1.3.1 HashSet 集合

/**
 * 1. HashSet：数据无序
 */
@Test
public void test01(){
    // 1. 定义一个set集合
    Set<String> set = new HashSet<>();
    set.add("星期1");
    set.add("星期4");
    set.add("星期5");
    set.add("星期2");
    set.add("星期6");
    set.add("星期6");
    set.add("星期3");
    set.add("星期3");
    // 2. 遍历集合
    // 方法一：增强for循环
    for (String s : set) {
        System.out.println(s);
    }
    System.out.println("------------------------------");
    // 方法二：使用迭代器
    Iterator<String> iterator = set.iterator();
    while(iterator.hasNext()){
        String next = iterator.next();
        System.out.println(next);
    }
    System.out.println("------------------------------");
    // 方法三：使用foreach函数
    set.forEach(System.out::println);
    // 3. 删除元素
    set.remove("星期3");
    System.out.println("------------------------------");
    set.forEach(System.out::println);
    System.out.println("set = " + set);
}

1.3.2 TreeSet 集合

/**
     * 2、TreeSet集合用法
     * 特点：
     *   去重、经过排了序的set集合
     */
@Test
public void test02(){
    // 2.1 定义一个set集合
    Set<String> set = new TreeSet<>();
    // 2.2 将元素放到集合中
    set.add("星期1");
    set.add("星期4");
    set.add("星期5");
    set.add("星期2");
    set.add("星期6");
    set.add("星期6");
    set.add("星期3");
    set.add("星期3");
    // System.out.println("set = " + set);
    // 2.3 删除元素
    set.remove("星期3");
    System.out.println("删除元素后：");
    // 2.4 打印元素
    for (String s : set) {
        System.out.println(s);
    }
}

1.4 Map 集合

HashMap与Hashtable的区别：
1、二者都是key、value集合
2、前者是JDK1.2出现的，后者是JDK1.0出现的
3、前者是线程异步的，后者是线程同步的，安全的，性能较低。
4、前者是可以放null键与null值，后者不能放null键与null值。

1.4.1 HashMap 集合

/**
 * 1. HashMap用法
 */
@Test
public void test01(){
    // 1.1 定义一个HashMap集合
    Map<Integer, Student> studentMap = new HashMap<>();
    // 1.2 定义几个学生对象
    Student st1 = new Student(1001,"张三","男",20,"上海");
    Student st2 = new Student(1002,"李四","男",22,"西安");
    Student st3 = new Student(1003,"王五","女",21,"杭州");
    Student st4 = new Student(1004,"赵六","女",23,"广州");
    // 1.3 将学生放到map集合
    studentMap.put(st1.getSid(),st1);
    studentMap.put(st2.getSid(),st2);
    studentMap.put(st3.getSid(),st3);
    studentMap.put(null,null);              // 可以放null键和null值
    // 1.4 遍历数据：
    // 方法一：遍历key，通过key得到值
    Set<Integer> keySet = studentMap.keySet();
    for (Integer key : keySet) {
        Student student = studentMap.get(key);      // 通过key取值
        System.out.println(student);
    }
    System.out.println("-----------------------------------------");
    // 方法二：遍历值的集合
    Collection<Student> values = studentMap.values();
    for (Student value : values) {
        System.out.println(value);
    }
    System.out.println("-----------------------------------------");
    // 方法三：将key与value当作一个整体进行遍历
    Set<Map.Entry<Integer, Student>> entries = studentMap.entrySet();
    for (Map.Entry<Integer, Student> entry : entries) {
        Integer key = entry.getKey();
        Student value = entry.getValue();
        System.out.println(value);
    }
    System.out.println("-----------------------------------------");
    // 方法四：使用forEach函数遍历
    studentMap.forEach((k,v) -> {
        System.out.println(k + "====》" + v);
    });
    // 1.5 修改元素(相同的key，新值覆盖旧值)
    studentMap.put(st2.getSid(),st4);
    System.out.println("-----------------------------------------");
    System.out.println("修改后：");
    studentMap.forEach((k,v) -> System.out.println(k + "====》" + v));
    //1.6 删除元素
    studentMap.remove(1002);
    System.out.println("-----------------------------------------");
    System.out.println("删除后：");
    studentMap.forEach((k,v) -> System.out.println(k + "====》" + v));

    // 1.7 替换元素
    studentMap.replace(st2.getSid(),st4);
    System.out.println("-----------------------------------------");
    System.out.println("替换后：");
    studentMap.forEach((k,v) -> System.out.println(k + "====》" + v));
}

1.4.2 Hashtable 集合

/**
 * Hashtable的用法
 */
@Test
public void test03(){
    // 1.1 定义一个HashMap集合
    Hashtable<Integer, Student> studentMap = new Hashtable<>();
    // 1.2 定义几个学生对象
    Student st1 = new Student(1001,"张三","男",20,"上海");
    Student st2 = new Student(1002,"李四","男",22,"西安");
    Student st3 = new Student(1003,"王五","女",21,"杭州");
    Student st4 = new Student(1004,"赵六","女",23,"广州");
    // 1.3 将学生放到map集合
    studentMap.put(st1.getSid(),st1);
    studentMap.put(st2.getSid(),st2);
    studentMap.put(st3.getSid(),st3);
    studentMap.put(null,null);              // 不能放null键和null值
    // 1.4 遍历数据：
    // 方法一：遍历key，通过key得到值
    Set<Integer> keySet = studentMap.keySet();
    for (Integer key : keySet) {
        Student student = studentMap.get(key);      // 通过key取值
        System.out.println(student);
    }
    System.out.println("-----------------------------------------");
    // 方法二：遍历值的集合
    Collection<Student> values = studentMap.values();
    for (Student value : values) {
        System.out.println(value);
    }
    System.out.println("-----------------------------------------");
    // 方法三：将key与value当作一个整体进行遍历
    Set<Map.Entry<Integer, Student>> entries = studentMap.entrySet();
    for (Map.Entry<Integer, Student> entry : entries) {
        Integer key = entry.getKey();
        Student value = entry.getValue();
        System.out.println(value);
    }
    System.out.println("-----------------------------------------");
    // 方法四：使用forEach函数遍历
    studentMap.forEach((k,v) -> {
        System.out.println(k + "====》" + v);
    });
    // 方法四：使用枚举器遍历
    System.out.println("-----------------------------------------");
    Enumeration<Student> elements = studentMap.elements();
    while (elements.hasMoreElements()) {
        Student student = elements.nextElement();
        System.out.println(student);
    }
}