带你走进java-第十三章. 集合-List接口

集合中的All方法

  Collection c1 = new ArrayList();
  Collection c2 = new Arraylist();
  c1.add("a");
  c1.add("b");
  c1.add("c");
  c1.add("d");
  c2.add("a");
  c2.add("b");
  c2.add("c");
  c2.add("d");
  System.out.println(c1);
  System.out.println(c2);

//  1. addAll  将 传入的集合中 的每一个元素 添加到调用集合中
     c1.addAll(c2);
     System.out.println(c1);
     结果:
       [a,b,c,d,a,b,c,d]
 //  add    将 传入的集合 当做一个整体 添加到调用集合中
     c1.add(c2);
     System.out.println(c1);
     输出结果:
       [a,b,c,d,[a,b,c,d]]

//  2. removeAll  删除的是 两个集合的交集
    c1.removeAll(c2);  // 两个完全相交,c1删除交集(本身这个集合)
    输出结果:
      []

//  3.retainAll  在调用集合中 求两个集合交集 ,若不同(变化)  返回true
//                           若调用集合和交集相同(未变化)  返回false
     c1.retainAll(c2); // 相同
     输出结果:
       false

     c1.remove("d");
     c1.retainAll(c2); // 不同
     输出结果:
       true

//  4.containsAll     调用集合  完全包含  被调用集合   返回true
    c1.containsAll(c2); // 完全包含
    输出结果:
    true

    c1.remove("d");
    c1.containsAll(c2); // 不完全包含
    输出结果:
    false

集合中(Collection接口)的遍历-利用迭代器

1.迭代器的使用方式

// 创建集合
   Collection collection = new ArrayList();
// 集合添加元素
   collection.add("a");
   collection.add("b");
   collection.add("c");
   collection.add("d");
// 1️⃣获取迭代器(通过集合调用方法)
   Iterator iterator = collection.iterator();
// 2️⃣判断集合 下一个是否有元素    iterator.hasNext()
   boolean b = iterator.hasNext();
// 3️⃣如果有元素,打印这个元素
  if (b) {
        Object object1 = iterator.next(); // 获取该元素
        System.out.println(object1);
  }

2.迭代器的原理

 //  迭代器中 相当于有一个指针
 //  默认指向 首元素的上面
 //  当调用hasNext()时,会判断下一个位置 有没有元素
 //  hasNext() 不会改变指针位置
 //  next()  会获取下一元素的值,并将指针向下 挪动一个位置
 //  注意: 迭代器遍历时  循环中只能调用一次next();
 //        [只要调用一次,指针就会移动一次,与new相似]
                         //   <--指针
     collection.add("a");//
     collection.add("b");//
     collection.add("c");//
     collection.add("d");//

3.迭代器的循环遍历

// 1.从集合中 获取迭代器(只获取一次)
    Iterator iterator = collection.iterator();
    // 2.判断下一个是否有元素(循环进行)
    while (iterator.hasNext()) {
            // 3.获取下一个元素
            Object object1 = iterator.next();
            System.out.println(object1);
    }

//  练习
/*
 * 创建一个集合 保存三个学生
 * 迭代器遍历 只打印学生的姓名
 */

 //  学生类
 class Student{
    private String name;
    private int age;
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "姓名: " + getName() + "  " + "年龄: " + getAge();
    }
    @Override
    public boolean equals(Object obj) {
        // 重新写判断 两个学生对象相等的规则
        // 人名 和 年龄相等
        // this 和 obj 比较
        // 转换类型
        Student stu = (Student) obj;
        return this.getName().equals(stu.getName())
                && this.getAge() == stu.getAge();
    }
}

// 集合遍历
        Collection collection = new ArrayList();
        collection.add(new Student("111",16));
        collection.add(new Student("222",16));
        collection.add(new Student("333",16));
        Iterator iterator = collection.iterator();
        while (iterator.hasNext()) {
            Student student = (Student) iterator.next();
            System.out.println(student.getName());
        }

List接口 (Collection的子接口):有序 有角标 可重复的

1. List接口的方法
   //  创建对象[多态创建]
   List list = new ArrayList();
   list.add("a");
   list.add("b");
   list.add("c");
   list.add("d");

//  1.插入   注意:插入索引 不能大于size(可以等于,相当于在最后一位添加)
    list.add(4,"x");
    输出结果:
    [a,b,c,d,x]

//  2.替换当前位置
    list.set(index,对象)

//  3.获取当前位置的值
    list.get(index);

//  4.删除当前位置的值
    list.remove(index);

2.集合中的自动装箱
  List list = new ArrayList();
  list.add(111);
  list.add(222);
  list.add(333);
  // 只有添加时 才会自动装箱(转换成Integer对象)
  // 移除时不会 自动装箱
  list.remove(111);
  System.out.println(list);
  输出结果:
        IndexOutOfBoundsException
        // 角标超出边界异常

//   3.利用List接口方法的集合遍历
    List list = new ArrayList();
    list.add("a");
    list.add("b");
    list.add("c");
    list.add("d");
    // 利用list中 特有的get()方法遍历元素
    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }

List子接口中的特有迭代器

//   1.错误的添加
     // 需求 遍历数组(使用迭代器)
     // 如果数组中 有"b"这个元素 就添加"Oh-Yes"这个元素
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        // 错误原因:
        // 从集合中获取迭代器时 就有一个长度(4)
        // 当前迭代器遍历集合时 系统就按长度4 进行遍历
        // 遍历过程中 修改集合长度
        // 这时发生  并发修改异常 ConcurrentModificationException
//      int num = 0;
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            String string = (String) iterator.next();
            if (string.equals("b")) {
                // ConcurrentModificationException
                // 并发修改异常
//              num++;  
                list.add("Oh-Yes");// 增加集合长度
            }
        }
//      // 问题自我解决
//      for (int i = 0; i < num; i++) {
//          list.add("Oh-Yes");// 增加集合长度,但是在集合的最末尾
//      }
        System.out.println(list);

//  2.正确的迭代添加方式
List list = new ArrayList();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
// 遍历时使用 迭代器自己的添加方法
// 获取list特有的迭代器   ListIterator
ListIterator listIterator = list.listIterator();
while (listIterator.hasNext()) {
    String string = (String) listIterator.next();
    if (string.equals("b")) {
        listIterator.add("Oh-Yes");
    }
}
System.out.println(list);

//  3.反向遍历
List list = new ArrayList();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
// 正向遍历
ListIterator listIterator = list.listIterator();
while (listIterator.hasNext()) {
    String string1 = (String) listIterator.next();
    System.out.println(string1);
}
System.out.println("-------------------");
// 逆向遍历(只有先正向,再反向,才能生效.指针问题)
while (listIterator.hasPrevious()) {
    String string2 = (String) listIterator.previous();
    System.out.println(string2);
}

Vector

1.
  Vector     jdk1.0出现 (线程安全的 内部是数组实现的)
             被ArrayList替代

  Collection      jdk1.2出现

2.Vector特有的迭代器

        Vector vector = new Vector();
        vector.addElement("a");
        vector.addElement("b");
        vector.addElement("c");
        vector.addElement("d");
        // 迭代器遍历   Enumeration迭代器,通过elements()方法
        Enumeration elements = vector.elements();
        while (elements.hasMoreElements()) {
            String str = (String)elements.nextElement();
            System.out.println(str);
        }

LinkedList实现类

1.LinkedList 方法

// LinkedList linkedList = new LinkedList();
// 添加第一个元素
linkedList.addFirst("a");
linkedList.addFirst("b");
linkedList.addFirst("c");
// 从最后添加
linkedList.addLast("d");
linkedList.addLast("e");
linkedList.addLast("f");
// 删除最后一个元素,并打印那个删除元素
Object object = linkedList.removeLast();
System.out.println(linkedList);
System.out.println(object);

2.模拟栈结构
    /*
     * LinkedList  (内部是链表实现的)
     *             模拟一下栈结构
     *  栈结构: 先进后出
     *  队列:  先进先出
     *  
     *  入栈的方法   (下)  main   方法       (上)  addFirst()
     *  出栈的方法                               removeFirst()
     *  打印栈内容的方法
     */ 

class Statck{
    // 声明一个容器
    private LinkedList list = new LinkedList();
    // 入栈方法
    public void instatck(String str) {
        list.addFirst(str);
    }
    // 出栈方法
    public void outstatck() {
        // 判断集合不是空的,就循环删除
        while (!list.isEmpty()) {
            // 从栈顶删除
            Object object = list.removeFirst();
            System.out.println(object + "出栈了");
        }
    }
    // 遍历方法
    public void print() {
        for(Object str : list) {
            System.out.println(str + "----");
        }
    }

3.LinkedList实现类 与 ArrayList实现类 的区别

删除集合中重复的元素

//  1.重复的是 字符串
//  需求 在集合中存储 
//  "a""a""a" "b""b""b" "c""c""c"
//  要求 去除重复数据
LinkedList list = new LinkedList();
list.addLast("a");
list.addLast("a");
list.addLast("a");
list.addLast("b");
list.addLast("b");
list.addLast("b");
list.addLast("c");
list.addLast("c");
list.addLast("c");
System.out.println(list);

// 创建新的集合
LinkedList newList = new LinkedList();
// 遍历老集合
// 迭代器
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
    String str = (String) iterator.next();
    // 判断新集合是否包含这个元素
    if (!newList.contains(str)) {
        // 不包含就添加
        newList.add(str);
    }
}
System.out.println(newList);
}

//  2.集合中重复的是 对象 (办法:重写对象类中的equals方法)
        //  需求 在集合中存储 6个学生
        //  分别 两个 东东 18岁  两个生生 16岁 两个柳柳 20岁
        //  去除重复的
        Student student1 = new Student("东东", 18);
        Student student2 = new Student("东东", 18);;
        Student student3 = new Student("生生", 16);
        Student student4 = new Student("生生", 16);
        Student student5 = new Student("柳柳", 20);
        Student student6 = new Student("柳柳", 20);
        LinkedList list = new LinkedList();
        list.add(student1);
        list.add(student2);
        list.add(student3);
        list.add(student4);
        list.add(student5);
        list.add(student6);
        System.out.println(list);
        LinkedList newList = new LinkedList();
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Student s = (Student) iterator.next();
            /*
             * 判断
             * 
             * 本段代码 核心使用是contains方法
             * 点进contains方法  发现contains方法中
             * 依赖的是 equals方法判断
             * 
             * Object类中 equals方法
             * 判断的是两个对象的地址 是否相等
             * 
             * 人:   判断 名字和年龄相同 就是同一个人
             * 电脑:      地址相同才是一个人
             */
            if (!newList.contains(s)) {
                newList.add(s);
            }
        }
        System.out.println(newList);

        // 判断部分的重写
        @Override
        public boolean equals(Object obj) {
        // 重新写判断 两个学生对象相等的规则
        // 人名 和 年龄相等
        // this 和 obj 比较
        // 转换类型
        Student stu = (Student) obj;
        return this.getName().equals(stu.getName())
                && this.getAge() == stu.getAge();
        }