Java学习Day22(第十一章)(迭代器，List,Set)

11.3 Iterator迭代器接口

package atguigu.java;

import org.junit.Test;

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

/**
 * 集合元素的遍历操作，使用迭代器Iterator接口
 * 1.内部的方法：hasNext()和next()
 * 2.集合对象每次调用iterator()方法都得到一个全新的迭代器对象
 * 默认游标都在集合第一个元素之前
 * 3.内部定义了remove(),可以在遍历的时候，删除集合中的元素。此方法不同于集合直接调用remove()
 * @author xq
 * @create 2020-12-27-10:46
 */

public class IteratorTest {
    @Test
    public void test1() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);

        Iterator iterator = coll.iterator();
        //方式一
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
        //方式二:不推荐
//        for (int i = 0; i < coll.size(); i++) {
//            System.out.println(iterator.next());
//        }
//        方式三：推荐
        //hasNext()判断是否还有下一个元素
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }


    }

    @Test
    public void test2(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);

        Iterator iterator = coll.iterator();
        //错误方式
//        while((iterator.next()) != null){
//            System.out.println(iterator.next());
//        }
    }
    @Test
    public void test3(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);

        Iterator iterator = coll.iterator();
        while(iterator.hasNext()){
            Object obj = iterator.next();
            if("Tom".equals(obj)){
                iterator.remove();
            }
        }

        Iterator iterator1 = coll.iterator();
        while (iterator1.hasNext()){
            System.out.println(iterator1.next());
        }
    }
}

11.4 Collection子接口之一：List接口

package atguigu.java;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * 1.List接口框架
 * ArrayList:作为List接口的主要实现类，线程不安全，效率高；底层使用object[] elementData存储
 * LinkedList:对于频繁的插入和删除操作，使用此类比ArrayList高；底层使用双向链表存储
 * Vector:作为List接口的古老实现类，线程安全的，效率低；底层使用object[] elementData存储
 *
 * 2.ArrayList的源码分析
 * 2.1 jdk7情况下
 * ArrayList的源码分析：jdk7情况下
 * ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组elementData
 * list.add(123);//elementData[0] = new Integer(123);
 * ....
 * list.add(11);//如果此次的添加导致底层elementData数组容量不够，则扩容。
 * 默认情况下，扩容为原来的容量的1.5倍，同时需要将原来数组中的数据复制到新的数组中。
 *
 * 结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int initialCapacity)
 *
 * 2.2 jdk8中ArrayList的变化：
 *      ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}，并没有创建长度为10的数组
 *
 *      list.add(123);第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData中
 *      ....
 *      后续的添加和扩容操作与jdk 7 无异。
 *
 * 2.3小结：jdk7中的ArrayList的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象的创建类似于单例的懒汉式，延迟
 * 了数组的创建，节省内存。
 *
 * 3.LinkedList的源码分析：
 *  LinkedList list = new LinkedList();内部声明了Node类型的first和last属性，默认值为null
 *  list.add(123);//将123封装到Node中，创建了Node对象
 *
 *
 *  4.List接口中的常用方法
 *
 *  其中，Node定义为：体现了LinkedList的双向链表的说法
 *  Private static class Node<E>{
 *      E item;
 *      Node<E> next;
 *      Node<E> prev;
 *
 *      Node(Node<E> prev,E element,Node<E> next){
 *          this.item = element;
 *          this.next = next;
 *          this.prev = prev;
 *      }
 *  }
 *
 *
 *
 * ArrayList,LinkedList,Vector三者的异同
 * 同：三个类都实现类list接口，存储数据的特点相同：存储有序的，可重复的数据
 *
 * 异：见上
 *
 * 总结：常用方法
 * 增：add
 * 删：remove
 * 改：set
 * 查：get
 * 插：add
 * 长度：size()
 * 遍历：Iterator迭代器
 *      增强for循环
 *      普通循环 
 * @author xq
 * @create 2020-12-27-11:32
 */
public class ListTest {
    @Test
    public void test1(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new Person("Tom",12));
        list.add(456);

        System.out.println(list);
        //加
        list.add(1,"BB");

        //加
        List<Integer> list1 = Arrays.asList(1, 2, 3);
        list.addAll(list1);
        System.out.println(list.size());
        //找
        System.out.println(list.get(1));
        //找
        int index = list.indexOf(456);
        System.out.println(index);
        //

        System.out.println(list.lastIndexOf(456));
        //
        Object obj = list.remove(1);
        System.out.println(obj);
        System.out.println(list);
        //
        list.set(1, "CC");
        System.out.println(list);

        System.out.println(list.subList(3, 5));
        System.out.println(list);
    }

}

11.5 Collection子接口之二：Set接口

HashSet,LinkedHashSet

package atguigu.java1;

import atguigu.java.Person;
import org.junit.Test;

import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;

/**
 * 1.Set接口的框架：
 *
 * HashSet:作为Set接口的主要实现类；线程不安全的；可以存储null值
 *      LinkedHashSet:作为HashSet的子类，遍历其内部数据时，可以按照添加的顺序遍历
 * TreeSet:可以按照添加对象的指定属性，进行排序。
 *
 *
 * 1.Set接口中没有额外定义新的方法，使用的都是Collection中声明过的方法
 *
 * 2.要求:向Set中添加的数据，其所在的类一定要重写hashCode()和equals()
 *  要求:重写hashCode()和Equals()尽可能保持一致性：相等的对象必须具有相等的散列码
 *
 * @author xq
 * @create 2020-12-27-15:52
 */
public class SetTest {
    /*
    Set:存储无序的、不可重复的数据
    以HashSet为例说明
    1.无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加。而是根据数据的哈希值决定的

    2.不可重复性：保证添加的元素按照equals()判断时，不能返回true。即：相同的元素只能添加一个

    二、添加元素的过程：以HashSet为例：
        我们向HashSet中添加元素a，首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，
        此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置），判断
        数组此位置上是否已经有元素：
        如果此位置上没有其他元素，则元素a添加成功。 ----->情况一
        如果此位置上有其他元素b(或以链表形式存在的多个元素)，则比较元素a与元素b的hash值：
            如果hash值不相同，则元素a添加成功。----->情况二
            如果hash值相同，进而需要调用元素a所在类的equlas()方法
                equals()返回true,元素a添加失败
                equals()返回false,则元素a添加成功----->情况三
        对于添加成功的情况二和情况三而言，元素a与已经存在指定索引位置上数据以链表的方式存储。
        jdk 7:元素a放到数组中，指向原来的元素
        jdk 8:原来的元素在数组中，指向元素a
        七上八下

        HashSet底层：数组+链表的结构




     */
    @Test
    public void test1(){
        Set set = new HashSet();
        set.add(456);
        set.add(123);
        set.add("AA");
        set.add("CC");
        set.add(new Person("Tom",12));
        set.add(129);

        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }





    }
    //LinkedHashSet的使用
    //LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据
    //前一个数据和后一个数据
    //优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet
    @Test
    public void test2(){
        Set set = new LinkedHashSet();
        set.add(456);
        set.add(123);
        set.add("AA");
        set.add("CC");
        set.add(new Person("Tom",12));
        set.add(129);

        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }


    }
}

TreeSet

package atguigu.java1;

import atguigu.java.Person;
import org.junit.Test;

import java.util.Iterator;
import java.util.TreeSet;

/**
 * @author xq
 * @create 2020-12-27-17:00
 */
public class TreeSetTest {
    /*
    1.向TreeSet中添加的数据，要求是相同类的对象。
    2.两种排序方式：自然排序和定制排序

    3.自然排序中，比较两个对象是否相同的标准为：compareTo()返回0，不再是equals()
    4.定制排序中，比较两个对象中否相同的标准为：compare()返回0，不再是equals()
     */
    @Test
    public void test1(){
        TreeSet set = new TreeSet();
        //不能添加不同类的对象
//         set.add(123);
//         set.add(456);
//         set.add(new Person("Tom",12));
//         set.add("AA");
        set.add(123);
        set.add(4444);
        set.add(9999);
        set.add(789);
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }


    }
}