重难点梳理

使用到的新单词:

1.collection[kəˈlekʃn]

聚集

2.empty[ˈempti]

空的

3.clear[klɪə(r)]

清除

4.iterator

迭代器

学习目标:

1、能够了解Java集合的继承体系结构（Collection和Map接口的继承体系结构）

2、能够了解Collection集合特点以及使用

3、能够掌握List集合的特点以及使用

4、能够掌握ArrayList集合特点以及使用（特点，使用以及原理）

5、能够掌握常见数据结构的特点（栈，队列，数组，链表）

　　　　　　　　　　　　　　　　　　　　　　知识重点梳理

　　　　　　　　　　　　　　　　　　　　　　超详细讲义及源代码

==知识点==

1. 集合概述

2. Collection

3. List

4. 数据结构

5. ArrayList

6. LinkedList

1.Collection集合

1.1数组和集合的对比【记忆】(视频01)（6‘’）

• 相同点

  都是容器,可以存储多个数据

• 不同点

  • 数组的长度是不可变的,集合的长度是可变的

  • 数组可以存基本数据类型和引用数据类型

    集合只能存引用数据类型,如果要存基本数据类型,需要存对应的包装类

package com.itheima.mycollectiondemo1;
​
import java.util.ArrayList;
import java.util.Arrays;
​
public class MyCollectonDemo1 {
    public static void main(String[] args) {
        //数组可以存储基本数据类型也可以存储引用数据类型
        int [] arr1 = {1,2,3};
        String [] arr2 = {"a","b","c"};
        System.out.println(Arrays.toString(arr1));
        System.out.println(Arrays.toString(arr2));
​
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("a");
        list1.add("b");
        list1.add("c");
​
        System.out.println(list1);
​
        //如果集合要存储基本数据类型,那么实际存储的是他们的包装类
        //ArrayList<int> list2 = new ArrayList<int>();
        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(1);//
        list2.add(2);
        list2.add(3);
        System.out.println(list2);
    }
}

1.2集合类体系结构【熟悉】(视频02)(换双列) （3‘’）

1.3Collection 常用方法【重点】(视频03) （13‘’）

1.什么是Collection集合(*接口和特点单列)

Collection是单列集合的*接口，它没有直接的具体实现类，有两个子接口List和Set

2.如何创建Collection集合对象（Collection和ArrayList的关系）

• 多态的方式

• 具体的实现类ArrayList

3.Collection集合常用方法

方法名	说明
boolean add(E e)	添加元素
boolean remove(Object o)	从集合中移除指定的元素
boolean removeIf(Object o)	根据条件进行移除
void clear()	清空集合中的元素
boolean contains(Object o)	判断集合中是否存在指定的元素
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中元素的个数

package com.itheima.mycollectiondemo1;
​
import java.util.ArrayList;
import java.util.Collection;
​
public class MyCollectonDemo2 {
    public static void main(String[] args) {
        Collection<String> collection = new ArrayList<>();
//        boolean add(E e)      添加元素
        collection.add("aaa");
        collection.add("bbb");
        collection.add("ccc");
        collection.add("dddd");
        //System.out.println(collection);
        //method1(collection);
        //method2(collection);
        //method3(collection);
        //method4(collection);
        //method5(collection);
        //method6(collection);
​
​
    }
​
    private static void method6(Collection<String> collection) {
        //        int size()            集合的长度，也就是集合中元素的个数
        int size = collection.size();
        System.out.println(size);
    }
​
    private static void method5(Collection<String> collection) {
        //        boolean isEmpty()     判断集合是否为空
        collection.clear();
        boolean result = collection.isEmpty();
        System.out.println(result);
    }
​
    private static void method4(Collection<String> collection) {
        //        boolean contains(Object o)    判断集合中是否存在指定的元素
        boolean result = collection.contains("a");
        System.out.println(result);
​
​
        boolean result2 = collection.contains("aaa");
        System.out.println(result2);
    }
​
    private static void method3(Collection<String> collection) {
        //        void clear()          清空集合
        //就是将集合中所有的元素全部删除.
        collection.clear();
        System.out.println(collection);
    }
​
    private static void method2(Collection<String> collection) {
        //        boolean removeif(Object o)    根据条件进行删除
        //removeif底层会遍历集合,得到集合中的每一个元素
        //s依次表示集合中的每一个元素
        //就会把这每一个元素都到lambda表达式中去判断一下
        //如果返回的是true,则删除
        //如果返回的是false,则保留不删除.
​
​
        //boolean test(String t);
        collection.removeIf(
                (String s)->{
                    return s.length() == 3;
                }
​
        );
        System.out.println(collection);
    }
​
    private static void method1(Collection<String> collection) {
        //        boolean remove(Object o)      从集合中移除指定的元素
        //如果删除成功了,则返回true
        //如果删除失败了,则返回false
        boolean result1 = collection.remove("aaa");
        boolean result2 = collection.remove("ddd");
        System.out.println(result1);
        System.out.println(result2);
        System.out.println(collection);
    }
}

1.4Collection-迭代器的基本使用【重点】（视频04 7‘’）

1. 迭代器 的作用

用于集合的遍历（迭代器就是一个对象）

2.如何创建迭代器

Iterator<E> iterator(): 返回此集合中元素的迭代器,该迭代器器对象默认指向当前集合0索引

3.Iterator中的常用方法

boolean hasNext(): 判断当前位置是否有元素可以被取出 ​ E next(): 获取当前位置的元素,同时将迭代器对象移向下一个索引位置

4.Collection集合的遍历

package com.itheima.mycollectiondemo1;
​
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
​
public class MyCollectonDemo3 {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
​
​
        //1,获得迭代器的对象
        //迭代器对象一旦被创建出来,默认指向集合的0索引处
        Iterator<String> it = list.iterator();
​
​
        //利用迭代器里面的方法进行遍历
        //当前位置是否有元素可以被取出
//        System.out.println(it.hasNext());
//        //取出当前位置的元素  + 将迭代器往后移动一个索引的位置
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());
​
​
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

1.5 迭代器的原理分析【重点、难点】（视频05）（5‘’）

迭代器原理(三个方法) ①. Iterator<E> iterator(): 获取迭代器对象,默认指向0索引 ②. boolean hasNext():判断当前位置是否有元素可以被取出 ③. E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置

​
        while(it.hasNext()){
            System.out.println(it.next());
        }

1.6 迭代器中删除的方法【重点】(视频06) （8‘’）

void remove(): 删除迭代器对象当前指向的元素

package com.itheima.mycollectiondemo1;
​
import java.util.ArrayList;
import java.util.Iterator;
​
public class MyCollectonDemo5 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("d");
​
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String s = it.next();
            if("b".equals(s)){
                //指向谁,那么此时就删除谁.
                it.remove();
            }
        }
        System.out.println(list);
    }
}

1.7 增强for循环-基本应用【重点】（视频07）（6‘’）

1.增强for的作用

简化数组和Collection集合的遍历,比迭代器简单也比for循环也简单

2.如何使用？

for(集合/数组中元素的数据类型 变量名 : 集合/数组名) {

// 已经将当前遍历到的元素封装到变量中了,直接使用变量即可

}

3.增强for的原理

它是JDK5之后出现的,其内部原理是一个Iterator迭代器(数组是for，集合为Iterator)

4.增强for的应用场景

实现Iterable接口的类才可以使用迭代器和增强for(数组)

代码

package com.itheima.mycollectiondemo1;
​
import java.util.ArrayList;
​
public class MyCollectonDemo6 {
    public static void main(String[] args) {
        ArrayList<String> list =  new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");
​
        //1,数据类型一定是集合或者数组中元素的类型
        //2,str仅仅是一个变量名而已,在循环的过程中,依次表示集合或者数组中的每一个元素
        //3,list就是要遍历的集合或者数组.
        for(String str : list){
            System.out.println(str);
        }
    }
}

1.8 增强for-注意事项和三种遍历的应用场景【记忆】(视频08)（4‘’）

1.注意事项

在增强for循环中无法改变数组或集合中的元素（iterator）

2.三种遍历方式使用场景 增强for: 对集合进行只要简单遍历时使用 普通for: 遍历过程中需要操作索引时使用 迭代器: 遍历过程中需要删除元素时使用

package com.itheima.mycollectiondemo1;
​
import java.util.ArrayList;
​
public class MyCollectonDemo7 {
    public static void main(String[] args) {
        ArrayList<String> list =  new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
​
//
//        for(String str : list){
//            str = "q";
//            System.out.println(str);
//        }
        for (String s : list) {
            System.out.println(s);
        }
​
        //System.out.println(list);
    }
}
​

1.9 Collection练习【重点】（视频9）(4'')

注意：增强for可以操作数组和集合，而迭代器只能操作集合

package com.itheima.mycollectiondemo1;
​
public class Student {
    private String name;
    private int age;
​
    public Student() {
    }
​
    public Student(String name, int age) {
        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() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package com.itheima.mycollectiondemo1;
​
import java.util.ArrayList;
import java.util.Iterator;
​
public class MyCollectonDemo8 {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();
​
        Student s1 = new Student("小皮同学",23);
        Student s2 = new Student("小路同学",31);
        Student s3 = new Student("小贾同学",33);
​
        list.add(s1);
        list.add(s2);
        list.add(s3);
​
​
        //迭代器的方式进行遍历
        Iterator<Student> it = list.iterator();
        while(it.hasNext()){
            Student s = it.next();
            System.out.println(s);
        }
​
        System.out.println("-------------------------");
        //增强for
        for (Student student : list) {
            System.out.println(student);
        }
    }
}

2.List集合

2.1List集合的概述和特点【记忆】(视频10) （4‘’）

• List集合的特点

  • 存取有序

  • 可以重复

  • 有索引

package com.itheima.mylistdemo1;
​
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
​
public class MyListDemo1 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
​
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
​
​
​
​
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
​
        System.out.println("---------------------");
        for (String s : list) {
            System.out.println(s);
        }
    }
}

2.2List集合的特有方法【重点】(视频11) （7‘’）

• 方法介绍

  方法名	描述
  void add(int index,E element)	在此集合中的指定位置插入指定的元素
  E remove(int index)	删除指定索引处的元素，返回被删除的元素
  E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
  E get(int index)	返回指定索引处的元素

• 示例代码

  package com.itheima.mylistdemo1;
  ​
  import java.util.ArrayList;
  import java.util.List;
  ​
  public class MyListDemo2 {
      public static void main(String[] args) {
          List<String> list = new ArrayList<>();
          list.add("aaa");
          list.add("bbb");
          list.add("ccc");
        //method1(list);
          //method2(list);
          //method3(list);
          //method4(list);
      }
  ​
    private static void method4(List<String> list) {
          //        E get(int index)      返回指定索引处的元素
          String s = list.get(0);
          System.out.println(s);
      }
  ​
      private static void method3(List<String> list) {
          //        E set(int index,E element)    修改指定索引处的元素，返回被修改的元素
        //被替换的那个元素,在集合中就不存在了.
          String result = list.set(0, "qqq");
          System.out.println(result);
          System.out.println(list);
      }
  ​
      private static void method2(List<String> list) {
          //        E remove(int index)       删除指定索引处的元素，返回被删除的元素
          //在List集合中有两个删除的方法
          //第一个 删除指定的元素,返回值表示当前元素是否删除成功
        //第二个 删除指定索引的元素,返回值表示实际删除的元素
          String s = list.remove(0);
          System.out.println(s);
          System.out.println(list);
      }
  ​
      private static void method1(List<String> list) {
          //        void add(int index,E element) 在此集合中的指定位置插入指定的元素
          //原来位置上的元素往后挪一个索引.
          list.add(0,"qqq");
          System.out.println(list);
      }
  }

3.数据结构

3.1数据结构之栈和队列【记忆】（视频12）（6‘’）

• 栈结构

  先进后出

　　　　

• 队列结构

  先进先出

　　

3.2数据结构之数组和链表【记忆】(视频13) （11‘’）

• 数组结构（内存，下标）

  数组的特点

  查询快、增删慢

  

• 链表结构（内存,下标）

  1. 什么是链表

  

  

  1. 链表的特点

     查询慢、增删快

4.ArrayList源码解析【难点】（视频14）（16‘’）

1.ArrayList底层是一个数组

2.当初始化ArrayList，数组的长度为0

3.当第一次添加的时候，数组的长度为10

4.以后添加时，如果数组的长度不满足时，进行扩容 ，按1.5来进行扩容

5.扩容之后，将原数组中的元素拷贝到新的数组中

5.List集合的实现类

5.1LinkedList-基本应用【记忆】(视频15) （3‘’）

• ArrayList集合的特点(加塞儿代码验证1万次)

  底层是数组结构实现，查询快、增删慢

• LinkedList集合特点

  底层是链表结构实现，查询慢、增删快

比较添加

    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        ArrayList<Integer> array=new ArrayList<>();
        LocalDateTime arrayStartTime = LocalDateTime.now();
        for (int i=0;i<100000;i++){
            array.add(0,i);
        }
        LocalDateTime arrayEndTime = LocalDateTime.now();
        Duration duration = Duration.between(arrayStartTime, arrayEndTime);
        System.out.println(duration.toNanos());
        LocalDateTime linkStartTime = LocalDateTime.now();
        for (int i=0;i<100000;i++){
            list.add(0,i);
        }
        LocalDateTime linkEndTime = LocalDateTime.now();
        Duration duration1 = Duration.between(linkStartTime, linkEndTime);
        System.out.println(duration1.toNanos());
    }

package com.itheima.mylistdemo1;
​
import java.util.Iterator;
import java.util.LinkedList;
​
public class MyLinkedListDemo3 {
    public static void main(String[] args) {
        LinkedList<String>  list = new LinkedList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
​
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
​
        System.out.println("-------------------------");
​
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
​
        System.out.println("--------------------------");
​
        for (String s : list) {
            System.out.println(s);
        }
    }
}

5.2LinkedList集合的特有功能【重点】(视频16) （5‘’）

• 特有方法

  方法名	说明
  public void addFirst(E e)	在该列表开头插入指定的元素
  public void addLast(E e)	将指定的元素追加到此列表的末尾
  public E getFirst()	返回此列表中的第一个元素
  public E getLast()	返回此列表中的最后一个元素
  public E removeFirst()	从此列表中删除并返回第一个元素
  public E removeLast()	从此列表中删除并返回最后一个元素

• 示例代码

  package com.itheima.mylistdemo1;
  ​
  import java.util.LinkedList;
  ​
  public class MyLinkedListDemo4 {
      public static void main(String[] args) {
          LinkedList<String> list = new LinkedList<>();
          list.add("aaa");
        list.add("bbb");
          list.add("ccc");
  //        public void addFirst•(E e)    在该列表开头插入指定的元素
        //method1(list);
  ​
  //        public void addLast•(E e) 将指定的元素追加到此列表的末尾
          //method2(list);
  ​
  ​
  //        public E getFirst•()      返回此列表中的第一个元素
  //        public E getLast•()       返回此列表中的最后一个元素
          //method3(list);
  ​
  ​
  //        public E removeFirst•()       从此列表中删除并返回第一个元素
  //        public E removeLast•()        从此列表中删除并返回最后一个元素
          //method4(list);
  ​
  ​
      }
  ​
      private static void method4(LinkedList<String> list) {
          String first = list.removeFirst();
        System.out.println(first);
  ​
          String last = list.removeLast();
          System.out.println(last);
  ​
          System.out.println(list);
      }
  ​
      private static void method3(LinkedList<String> list) {
          String first = list.getFirst();
          String last = list.getLast();
          System.out.println(first);
        System.out.println(last);
      }
  ​
      private static void method2(LinkedList<String> list) {
          list.addLast("www");
          System.out.println(list);
      }
  ​
      private static void method1(LinkedList<String> list) {
          list.addFirst("qqq");
          System.out.println(list);
      }
  }

5.3 LinkedList-源码解析【难点】 (视频17) （13‘’）

1.add方法解析：

1.new LinkedList

2.list.add("aaa")

3.list.add("bbb")

4.list.add("ccc")

2.get方法解析：

get(Index) 首先判断索引离头近还是离尾近，如果离头从头查，如果离尾近从尾查

　　　　　　　　　　　　　　　　　　　　扩展练习

问答题【Collection接口】

1.1 请问Collection接口下有哪些类型的集合？它们分别是什么？

List 有序,有索引,元素可重复
Set  元素不可重复;

1.2 请问Collection接口中定义的方法，它的所有子类是否都有，而且都会实现这些方法？

是

1.3 请问向Collection集合添加一个元素用什么方法？

类名.add(元素)

1.4 请问从Collection集合中删除一个元素用什么方法？这个方法有返回值吗？

类名.remove(元素)返回true/fasle

1.5 请问判断Collection集合中是否包含一个元素用什么方法？

contains(),判断集合是否存在元素

1.6 请问用什么方法可以获取Collection集合中元素的数量？

类名.size

问答题【数据结构】

1 请写出数组结构的特点；

查看快,增加删除慢

2 请写出链表结构的特点

查看慢,增加删除快

3 请写出栈结构的特点；

先进后出

4 请写出队列结构的特点；

先进先出

编程题【Collection集合、迭代器】

题目1

请定义一个Collection类型的集合，存储以下字符串： “JavaEE企业级开发指南”，”Oracle高级编程”，”MySQL从入门到精通”，”Java架构师之路” 要求: 请编程实现以下功能： 使用迭代器遍历所有元素，并打印 使用迭代器遍历所有元素，筛选书名小于10个字符的，并打印； 使用迭代器遍历所有元素，筛选书名中包含“Java”的，并打印 如果书名中包含“Oracle”，则删掉此书。删掉后，遍历集合，打印所有书名。 (注意：以上每个功能都单独写个方法，在main方法中逐个调用测试即可)

效果:

参考代码:

package day7.No_1;
​
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
​
public class Demo {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        list.add("JavaEE企业级开发指南");
        list.add("Oracle高级编程");
        list.add("MySQL从入门到精通");
        list.add("Java架构师之路");
        System.out.println("遍历");
        Iterator<String> it = list.iterator();
        System.out.println("遍历为:");
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("-----------");
        Iterator<String> it2 = list.iterator();
        System.out.println("长度小于10的为:");
        while (it2.hasNext()) {
            String s = it2.next();
            if (s.length() < 10) {
                System.out.println( s);
            }
        }
        System.out.println("-----------");
        Iterator<String> it1 = list.iterator();
        System.out.println("包含Java为:");
        while (it1.hasNext()){
            String s = it1.next();
            if (s.contains("Java")){
                System.out.println(s);
            }
        }
        System.out.println("-----------");
        Iterator<String> it3 = list.iterator();
        while (it3.hasNext()){
            String s = it3.next();
            if (s.contains("Oracle")){
                it3.remove();
                System.out.println("Oracle已成功删除!");
            }
        }
        System.out.println("-----------");
        System.out.println("删除后为:"+list);
​
​
    }
}
​
运行效果:

题目2

请定义一个Collection类型的集合，存储以下分数信息： 88.5,39.2,77.1,56.8,89.0,99.0,59.5

要求:

请编程实现以下功能： 使用增强for遍历所有元素，并打印 使用增强for遍历所有元素，打印不及格的分数； 使用增强for遍历所有元素，计算不及格的分数的数量，和平均分，并打印计算结果。 使用增强for遍历所有元素，求出最高分，并打印；

效果:

参考代码:

package day7.No_2;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

public class Demo {

    public static void main(String[] args) {

        Collection <Double>list=new ArrayList<>();

        list.add(88.5);

        list.add(39.2);

        list.add(77.1);

        list.add(56.8);

        list.add(89.0);

        list.add(99.0);

        list.add(59.5);

        System.out.println("增强for遍历所有为:");

        for (Double d : list) {

            System.out.println(d);

        }

        System.out.println("不及格的为:");

        for (Double d : list) {

            if (d<60){

                System.out.println(d);

            }

        }

        int sum=0;

        int Num=0;

        for (Double d : list) {

            if (d<60){

                Num++;

                sum+=d;

            }

        }

        System.out.println("不及格人数为"+Num);

        System.out.println("不及格平均分为"+(sum/Num));

        System.out.println("-----------");

        double max = Double.MIN_VALUE;

        for (Double d : list) {

            if (d>max){

                max=d;

            }

        }

        System.out.println("最高分为:"+max);

    }

}

运行效果:

题目3

请定义方法找出集合中所有姓张的人并且年龄大于18岁的并全部返回,然后在main方法中输出返回的人; 集合原始数据有: 张三,22 李四,26 张翠山,38 赵六,19 张三丰,103 张无忌,17 赵敏,16

要求:

集合中的人需要以对象的形式存在,人只要有姓名和年龄两个成员变量即可;

注意:仔细思考一下自定义的方法要不要设计参数和返回值;

效果:

参考代码:

package day7.No_3;

import java.util.ArrayList;

public class Demo {

    public static void main(String[] args) {

        ArrayList<Ren> list = new ArrayList<>();

        Ren r1 = new Ren("张三", 22);

        Ren r2 = new Ren("李四", 26);

        Ren r3 = new Ren("张翠山", 38);

        Ren r4 = new Ren("赵六", 19);

        Ren r5 = new Ren("张三丰", 103);

        Ren r6 = new Ren("张无忌", 17);

        Ren r7 = new Ren("赵敏", 16);

        list.add(r1);

        list.add(r2);

        list.add(r3);

        list.add(r4);

        list.add(r5);

        list.add(r6);

        list.add(r7);

        get(list);

    }

    private static void get(ArrayList<Ren> list) {

        System.out.println("大于18的人为:");

        for (Ren ren : list) {

            if (ren.getAge() > 18) {

                System.out.println(ren);

            }

        }

    }

}

class Ren {

    private String name;

    private int age;

    @Override

    public String toString() {

        return "Ren{" +

                "name='" + name + '\'' +

                ", 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;

    }

    public Ren(String name, int age) {

        this.name = name;

        this.age = age;

    }

    public Ren() {

    }

}