集合进阶（上）&&数据结构

集合进阶（上）&&数据结构

一：单列集合顶层接口Collection

（1）集合体系结构

List集合的特点：

有序（存和取的顺序一样，比如存的时候顺序是张三，李四，王五，那么取的时候还是张三，李四，王五）

可重复（集合中的元素可以重复）

有索引（我们可以通过索引去获取集合里面的每一个元素）

Set集合的特点：

无序（存和取的顺序不一定一样，存的顺序是张三，李四，王五，那么取的时候就不一样定是张三，李四，王五）

不重复（集合中的元素不可以重复）（可以利用这个特性进行数据的去重）

无索引（我们不可以通过索引去获取集合里面的每一个元素）

（2）Collection

Collection是单列集合的祖宗接口，它的功能是全部单列集合都可以继承使用的

方法名称	说明
public boolean add(E e)	把给定的对象添加到当前集合中
public void clear()	清空集合中所有元素
public boolean remove(E e)	把给定的对象在当前集合中删除
public boolean contains(Object obj)	判断当前集合中是否包含给定的对象
public boolean isEmpty()	判断当前集合是否为空
public int size()	返回集合中元素的个数/集合的长度

public class Test1 {
   
    public static void main(String[] args) {
   
        /*
        * Collection是一个接口，我们不能直接创建他的对象
        * 所以，现在我们学习他的方法的时候，只能创建他的实现类的对象
        * 实现类：ArrayList
        * */
        Collection<String> coll = new ArrayList<String>();

        /*
        * 1.添加元素：
        * 细节1：如果我们要往List系列集合里面添加元素，那么方法永远返回true，因为List系列的是允许元素重复的
        * 细节2：如果我们要往Set系列集合中添加元素，如果当前要添加元素不存在，方法返回true，表示添加成功
        *                                   如果当前要添加的元素已经存在，方法返回false，表示添加失败，因为Set不允许重复
        * */
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");

        // 2.清空
        // coll.clear();

        /*
        * 3.删除
        * 细节1：因为Collection里面定义的是共性的方法，所以此时不能通过索引进行删除，只能通过元素的的对象进行删除
        * 细节2：方法会有一个布尔类型的返回值，删除成功返回true，失败false
        * 如果要删除的元素不存在，就会删除失败
        * */
        // System.out.println(coll.remove("aaa"));
        // System.out.println(coll);

        /*
        * 4、判断元素是否包含
        * 细节1：底层是依赖equals方法进行判断是否存在的
        * 所以，如果集合中存储的是我们自定义的对象，也想通过contains方法来判断是否存在，那么在javabean中，一定要重写equals方法
        * 看下面的Test2
        * */
        boolean result = coll.contains("bbb");
        System.out.println(result); // true

        // isEmpty
        System.out.println(coll.isEmpty()); // false

        // size
        System.out.println(coll.size()); // 3
    }
}
class Test2 {
   
    public static void main(String[] args) {
   
        Collection<Student> coll = new ArrayList<>();
        Collections.addAll(coll,
                new Student("zhangsan", 23),
                new Student("lisi", 24),
                new Student("wangwu", 25));
        Student s4 = new Student("lisi", 24);
        // 为什么下面返回false？？
        // 因为contains方法在底层依赖equals方法判断是否一致
        // 如果存的是自定义对象，没有重写equals方法，那么默认使用的是Object类中的equals方法进行判断，
        // 而Object类中equals方法是以地址值进行判断的
        // 需求：如果同姓名和同年龄，就认为是同一个对象
        // 所以，需要在自定义的javabean类中，重写equals方法就可以了
        // 字符串怎么比的呢？也是这样比的，只不过字符串底层的equals方法已经重写好了，我们直接用就行
        boolean result = coll.contains(s4);
        System.out.println(result);
    }
}
class Student {
   
    private String name;
    private int age;

    public Student(String name, int age) {
   
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
   
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
   
        return Objects.hash(name, age);
    }
}

二：迭代器

（1）迭代器遍历

迭代器不依赖索引

迭代器在Java中的类是Iterator，迭代器是集合专用的遍历方式

（2）Collection集合获取迭代器

方法名称	说明
Iterator iterator	返回迭代器对象，默认指向当前集合的0索引

（3）Iterator中的常用方法

方法名称	说明
boolean hasNext()	判断当前位置是否有元素，有返回true，没有返回false
E next()	获取当前位置的元素，并将迭代器对象移向下一个位置

public class Test3 {
   
    public static void main(String[] args) {
   
        Collection<String> coll = new ArrayList<>();
        Collections.addAll(coll, "aaa", "bbb", "ccc");
        Iterator<String> iterator = coll.iterator();
        while (iterator.hasNext()) {
   
            System.out.println(iterator.next());
        }
    }
}

（4）细节注意点

1、报错NoSuchElementException

public class Test3 {
   
    public static void main(String[] args) {
   
        // 创建集合并添加蒜素
        Collection<String> coll = new ArrayList<>();
        Collections.addAll(coll, "aaa", "bbb", "ccc");
        // 获取迭代器对象
        Iterator<String> iterator = coll.iterator();
        // 利用循环获取每一个元素
        while (iterator.hasNext()) {
   
            System.out.println(iterator.next());
        }
        System.out.println(iterator.next()); //NoSuchElementException，为什么不是索引越界？因为迭代器遍历不依赖索引
    }
}

2、迭代器遍历完毕，指针不会复位

如果还想遍历一遍，只能再次获取一个迭代器对象

public class Test4 {
   
    public static void main(String[] args) {
   
        // 创建集合并添加蒜素
        Collection<String> coll = new ArrayList<>();
        Collections.addAll(coll, "aaa", "bbb", "ccc");
        // 获取迭代器对象
        Iterator<String> iterator = coll.iterator();
        // 利用循环获取每一个元素
        while (iterator.hasNext()) {
   
            System.out.println(iterator.next());
        }
        // 迭代器遍历完，指针不会复位
        // 因为遍历完了之后，已经指向了没有元素的位置，再次调用肯定为false
        System.out.println(iterator.hasNext()); // false
        System.out.println(iterator.hasNext()); // false
        System.out.println(iterator.hasNext()); // false
        System.out.println(iterator.hasNext()); // false

        // 如果还想遍历，要获取新的迭代器对象
        Iterator<String> iterator1 = coll.iterator();
        while (iterator1.hasNext()) {
   
            System.out.println(iterator1.next());
        }
    }
}

3、循环中只能使用一次next方法

public class Test5 {
   
    public static void main(String[] args) {
   
        // 创建集合并添加蒜素
        Collection<String> coll = new ArrayList<>();
        Collections.addAll(coll,