JavaSE进阶06：Collection集合、迭代器、List、ArrayList、LinkedList

系列文章目录

JavaSE进阶01：继承、修饰符
JavaSE进阶02：多态、抽象类、接口
JavaSE进阶03：内部类、Lambda表达式
JavaSE进阶04：API中常用工具类
JavaSE进阶05：包装类、递归、数组的高级操作、异常
JavaSE进阶06：Collection集合、迭代器、List、ArrayList、LinkedList
JavaSE进阶07：泛型、Set集合、TreeSet、二叉树、红黑树
JavaSE进阶08：HashSet、Map集合、HashMap、TreeMap、可变参数、不可变集合
JavaSE进阶09：Stream流、File类
JavaSE进阶10：IO流、字节流、字节缓冲流
JavaSE进阶11：字符流、字符缓冲流、转换流、对象操作流、Properties集合
JavaSE进阶12：多线程、线程同步、线程池
JavaSE进阶13：网络编程入门、UDP通信程序、TCP通信程序、日志、枚举
JavaSE进阶14：类加载器、反射
JavaSE进阶15：XML、注解、单元测试
JavaSE进阶扩充：JDK8 HashMap底层分析（了解）
JavaSE进阶扩充：JDK8 ArrayList线程安全问题和源码分析、集合常见面试题
Java进阶作业

---

---

集合

集合类体系结构：

单列集合：首选ArrayList，重点学习
双列集合：首选HashMap，重点学习
数组和集合的区别：

• 相同点

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

• 不同点

  • 数组的长度是不可变的,集合的长度是可变的
  • 数组可以存基本数据类型和引用数据类型
  • 集合只能存引用数据类型,如果要存基本数据类型,需要存对应的包装类

1.Collection

1.1Collection 概述和使用【应用】

• Collection概述

  • 是单例集合的顶层接口,它表示一组对象,这些对象也称为Collection的元素
  • JDK 不提供此接口的任何直接实现.它提供更具体的子接口(如Set和List)实现

• 创建Collection的对象

  • 多态的方式
  • 具体的实现类ArrayList

• Collection常用方法

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

import java.text.ParseException;
import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo {
    public static void main(String[] args) throws ParseException {
        Collection<String> collection = new ArrayList<>();
        collection.add("A");
        collection.add("B");
        collection.add("C");
        collection.add("CC");
        System.out.println("集合："+collection);//集合：[A, B, C, CC]
        System.out.println("集合长度："+collection.size());//集合长度：4

        collection.removeIf((String s)->{
            return s.length()==2;
        });
        System.out.println("删除集合中长度2的元素后："+collection);//删除集合中长度2的元素后：[A, B, C]

        boolean result1=collection.contains("A");
        System.out.println("集合中是否有A："+result1);//集合中是否有A：true


        collection.clear();
        System.out.println("集合清空后："+collection);//集合清空后：[]

        boolean result2=collection.isEmpty();
        System.out.println("集合是否为空："+result2);//集合是否为空：true
        
    }
}

1.2迭代器 Iterator

迭代器介绍：迭代器,集合的专用遍历方式，迭代器一旦被取出，默认指向集合的0索引。

集合获取迭代器的方法：

方法名	说明
Iterator iterator()	返回此集合中元素的迭代器,通过集合对象的iterator()方法得到

Iterator中的常用方法：

方法名	说明
boolean hasNext()	判断当前位置是否有元素可以被取出
E next()	获取当前位置的元素,同时将迭代器对象移向下一个索引位置
void remove()	删除迭代器对象当前指向的元素

迭代器的注意事项：

• 一个迭代器只能使用一次，若还想再次迭代，只能再获取。
• 迭代的remove方法，指向谁删除谁。集合的remove方法，删除一次后，集合中被删除元素后面的元素全部前进1一格补位，即索引-1。
• 推荐删除用迭代器的remove方法删除。

迭代器的原理：
iterator()方法创建了一个迭代器对象，默认指向集合的0索引。

hasNext()方法判断当前指向的索引有没有元素。0~9都会返回true

next()方法：1.取出当前迭代器指向的元素。2.移动迭代器的位置

hasNext()方法返回false循环结束。

1.3Collection集合的遍历

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

public class IteratorDemo1 {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> collection = new ArrayList<>();

        //添加元素
        collection.add("aaa");
        collection.add("bbb");
        collection.add("ccc");

        //Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
        Iterator<String> it = collection.iterator();
        //用while循环改进元素的判断和获取
        while (it.hasNext()) {
            System.out.println(it.next());//aaa  bbb  ccc
        }
        System.out.println(it.hasNext());//false
        //System.out.println(it1.next());//报错：此时it已经迭代完了，一个迭代器只能使用一次。
        //若还想再次迭代，只能再获取
        it=collection.iterator();
        //用while循环改进元素的判断和获取
        while (it.hasNext()) {
            if (it.next().equals("bbb")){
                it.remove();
            }
        }
        System.out.println(collection);//[aaa, ccc]
    }
}

1.4增强for循环【应用】

• 介绍

  • 它是JDK5之后出现的,其内部原理是一个Iterator迭代器
  • 实现Iterable接口的类才可以使用迭代器和增强for
  • 简化数组和Collection集合的遍历

• 格式

  ​	for(集合/数组中元素的数据类型 变量名 :  集合/数组名) {
  ​		// 已经将当前遍历到的元素封装到变量中了,直接使用变量即可
  }

注意：
增强for中的形参并不会改变数据源中的数据。

• 例子

import java.util.ArrayList;
public class MyCollectonDemo1 {
    public static void main(String[] args) {
        ArrayList<String> list =  new ArrayList<>();
        int[] nums={111,222,333};
        list.add("a");
        list.add("b");
        list.add("c");
        //1,数据类型一定是集合或者数组中元素的类型
        //2,str仅仅是一个变量名而已,在循环的过程中,依次表示集合或者数组中的每一个元素
        //3,list就是要遍历的集合或者数组
        for (int num : nums) {
            num=0;//并不会改变nums中的元素
        }
        for(String s : list){
            s="";//并不会改变list中的元素
        }
        for(String s : list){
            System.out.print(s);
        }
        for(int i: nums){
            System.out.print(i);
        }
    }
}
/*
结果：abc111222333
 */

1.5三种遍历的使用场景

增强for:
    对集合进行遍历时使用,遍历过程中若要增删元素则不能使用	
普通for:
    遍历过程中需要增删元素或操作索引时使用
迭代器:
    遍历过程中需要删除元素时使用

2.List集合

2.1List集合的概述和特点【记忆】

• List集合的概述：
  • 有序集合,这里的有序指的是存取顺序
  • 用户可以精确控制列表中每个元素的插入位置,用户可以通过整数索引访问元素,并搜索列表中的元素
  • 与Set集合不同,列表通常允许重复的元素
• List集合的特点：
  • 存取有序
  • 可以重复
  • 有索引

2.2List集合的特有方法【应用】

• 方法介绍

  方法名	描述
  void add(int index,E element)	在此集合中的指定位置插入指定的元素
  boolean remove(Object o)	从列表中删除第一次出现的该元素
  E remove(int index)	删除指定索引处的元素，返回被删除的元素
  E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
  E get(int index)	返回指定索引处的元素

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

public class MyListDemo {
    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 method1(List<String> list) {
        //        void add(int index,E element)	在此集合中的指定位置插入指定的元素
        //原来位置上的元素往后挪一个索引.
        list.add(0,"qqq");
        list.add(2,"ppp");
        list.add(list.size(),"ppp");
        System.out.println(list);//结果：[qqq, aaa, ppp, bbb, ppp, ccc]
    }
    private static void method2(List<String> list) {
        //       boolean   remove(String item)     从列表中删除第一次出现的该元素。
        //        E     remove(int index)		删除指定索引处的元素，返回被删除的元素
        //在List集合中有两个删除的方法
        //第一个 删除指定的元素,返回值表示当前元素是否删除成功
        //第二个 删除指定索引的元素,返回值表示实际删除的元素
        System.out.println(list.remove("ppp"));//结果：true
        System.out.println(list.remove(0));//结果：qqq
        System.out.println(list);//结果：[aaa, bbb, ppp, ccc]
    }
    private static void method3(List<String> list) {
        //        E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
        //被替换的那个元素,在集合中就不存在了.
        System.out.println(list.set(0, "qqq"));//结果：aaa
        System.out.println(list);//结果：[qqq, bbb, ppp, ccc]
    }
    private static void method4(List<String> list) {
        //        E get(int index)		返回指定索引处的元素
        String s = list.get(0);
        System.out.println(s);//结果：qqq
    }
}

3.数据结构

数据结构是计算机存储、组织数据的方式。是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。

3.1数据结构之栈和队列【记忆】

• 栈结构

  ​ 先进后出

• 队列结构

  ​ 先进先出

3.1.1栈（先进后出）

数据进入栈模型的过程称为：压/进栈
数据离开栈模型的过程称为：弹/出栈
常见的栈结构：弹夹

3.1.2队列（先进先出）

数据从后端进入队列模型的过程称为：入队列
数据从前端离开队列模型的过程称为：出队列

3.2数据结构之数组和链表【记忆】

• 数组结构：连续的内存空间

  ​ 查询快、增删慢

• 链表结构：各个节点组成

  ​ 查询慢、增删快

3.2.1 数组

查询数据通过地址值和索引定位，查询任意数据耗时相同，查询速度快
删除数据时，要将原始数据删除，同时后面每个数据前移，删除效率低
添加数据时，添加位置后的每个数据后移，再添加元素，添加效率极低

3.2.2 链表

链表由结点组成，每个结点是独立的。第一个被创建结点被称为头结点，尾结点的数据地址是Null。

添加数据：尾结点的数据地址指向新增结点的内存地址

插入数据：插入位置前的结点指向新插入结点，新插入结点指向位置后的结点。

删除数据：删除位置前的结点直接指向删除位置后的结点。

查询数据：从头结点（head）依次开始查询，直至目标结点or尾结点。

---

双向链表查询时，会先判断是距离头还是尾距离更近，哪边近就从哪边开始依次查询。

4.List集合的实现类

4.1List集合子类的特点【记忆】

• ArrayList集合

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

• LinkedList集合

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

4.2ArrayList

Java基础09：ArrayList集合
List有的功能，ArrayList都有。

---

底层分析：
配合源码分析ArrayList集合通过空参构造方法创建对象,并第一次添加元素的过程.

List list =new ArrayList();
空参构造会在底层创建一个长度为0的数组。

list.add(“a”);
当用add()方法添加数据的时候，集合会创建一个新的长度10的数组elementData，默认初始值全部为Null。还有一个变量size，默认指向0索引，即表示下一个要操作的位置，也表示列表大小和elementData中存储的元素个数。

当10的容量不够时，即size指向11并添加数据时，集合自动扩容，再创建一个长度1.5倍的数组，将上个数组的内容存进去再在新数组里添加数据。

集合查询时，只需要数组的地址值和索引，不过查询时先会判断查询位置若>=size，就报错。

4.3LinkedList集合的特有功能【应用】

List有的功能，LinkedList都有。

• 特有方法

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

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");
        System.out.println(list);
        //        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 method1(LinkedList<String> list) {
        list.addFirst("qqq");
        System.out.println(list);
    }

    private static void method2(LinkedList<String> list) {
        list.addLast("www");
        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 method4(LinkedList<String> list) {
        String first = list.removeFirst();
        System.out.println(first);

        String last = list.removeLast();
        System.out.println(last);

        System.out.println(list);
    }
}
/*
[aaa, bbb, ccc]
[qqq, aaa, bbb, ccc]
[qqq, aaa, bbb, ccc, www]
qqq
www
qqq
www
[aaa, bbb, ccc]
*/