Java(七)——集合框架---Collection (集合) 、Iterator接口、List接口

原创已于 2022-11-23 08:36:56 修改 · 386 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

Java

于 2022-10-26 12:10:04 首次发布

本文介绍了Java集合框架的起源、结构，重点讲解了Collection接口、Iterator接口以及List接口的特性与方法。集合框架解决了数组长度固定的弊端，提供了灵活的数据存储方式。在迭代器的使用中，介绍了并发修改异常的产生原因及避免方法，并探讨了List接口的实现类如ArrayList和LinkedList的数据结构及其优缺点。

集合框架由来

Java 集合框架主要包括两种类型的容器，一种是集合（Collection），存储一个元素集合，另一种是图（Map），存储键/值对映射。Collection 接口又有 3 种子类型，List、Set 和 Queue，再下面是一些抽象类，最后是具体实现类，常用的有 ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap 等等。

集合框架是一个用来代表和操纵集合的统一架构。所有的集合框架都包含如下内容：

接口：是代表集合的抽象数据类型。例如 Collection、List、Set、Map 等。之所以定义多个接口，是为了以不同的方式操作集合对象
实现（类）：是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构，例如：ArrayList、LinkedList、HashSet、HashMap。
算法：是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序。这些算法被称为多态，那是因为相同的方法可以在相似的接口上有着不同的实现。

除了集合，该框架也定义了几个 Map 接口和类。Map 里存储的是键/值对。尽管 Map 不是集合，但是它们完全整合在集合中。

JDK1.2版本后,出现这个集合框架,到JDK1.5后,大幅度优化.

集合本质上是存储对象的容器
数组也能存储对象,数组弊端就是定长
解决数组的问题,开发出来集合框架,集合框架无需考虑长度
集合和数组的区别与共同点
- 集合,数组都是容器,都可以存储数据
- 集合只存储引用数据类型,不存储基本数据类型
- 数组可以存储基本类型,也可以存储引用类型
- 数组定长,集合容器变长

牢记 : 数据多了存数组,对象多了存集合

集合学习的关键点
- 怎么存储数据
- 怎么取出数据
- 选择哪种容器

1	Collection 接口 Collection 是最基本的集合接口，一个 Collection 代表一组 Object，即 Collection 的元素, Java不提供直接继承自Collection的类，只提供继承于的子接口(如List和set)。 Collection 接口存储一组不唯一，无序的对象。
2	List 接口 List接口是一个有序的 Collection，使用此接口能够精确的控制每个元素插入的位置，能够通过索引(元素在List中位置，类似于数组的下标)来访问List中的元素，第一个元素的索引为 0，而且允许有相同的元素。 List 接口存储一组不唯一，有序（插入顺序）的对象。
3	Set Set 具有与 Collection 完全一样的接口，只是行为上不同，Set 不保存重复的元素。 Set 接口存储一组唯一，无序的对象。
4	SortedSet 继承于Set保存有序的集合。
5	Map Map 接口存储一组键值对象，提供key（键）到value（值）的映射。
6	Map.Entry 描述在一个Map中的一个元素（键/值对）。是一个 Map 的内部接口。
7	SortedMap 继承于 Map，使 Key 保持在升序排列。
8	Enumeration 这是一个传统的接口和定义的方法，通过它可以枚举（一次获得一个）对象集合中的元素。这个传统接口已被迭代器取代。

集合框架的继承体系

Collection (集合) 接口单列集合,单身狗一次装一个类型
- List (列表) 接口
  - ArrayList (数组列表) 实现类（实现类代表可以 new）
  - LinkedList (链表) 实现类
  - Vector(数组列表) 实现类,过时了线程安全、慢
- Set (集) 接口
  - HashSet(哈希表) 实现类
    - LinkedHashSet(链表哈希表) 实现类,继承HashSet
  - TreeSet(红黑树) 实现类
Map (映射键值对) 接口双列集合虐狗的一次装俩
- HashMap(哈希表) 实现类
  - LinkedHashMap(链表哈希表) 实现类,继承HashMap
- TreeMap(红黑树) 实现类
- Hashtable(哈希表) 实现类,过时
  - Properties(哈希表)实现类, 继承Hashtable
- ConCurrentHashMap (哈希表) 线程相关
Iterator迭代器接口
泛型 Generic
- 写法
- 泛型类,泛型方法,泛型接口,泛型限定,泛型通配符
for(:) 循环 *** for(int i : arr){}

Collection接口

是所有单列集合的顶级接口,任何单列集合都是他的子接口,或者是实现类, 该接口中定义的方法,是所有单列集合的共性方法.

使用接口Collection的实现类ArrayList,创建对象.

Collection<E> 尖括号就是泛型,E我们要写,集合存储的数据类型 <String\Integer\Person>

Collection接口的常用方法

方法的定义	方法作用
boolean add(E)	元素添加到集合
void clear()	清空集合容器中的元素清空元素不是删除容器
boolean contains(E)	判断元素是否在集合中
boolean isEmpty()	判断集合的长度是不是0,是0返回true
int size()	返回集合的长度,集合中元素的个数
boolean remove(E)	移除集合中指定的元素,移除成功返回true
T[] toArray(T[] a)	集合转成数组泛型数组

add(E)

/**
*  boolean add(E) 元素添加到集合中
*  返回值,目前都是true
*/
public static void collectionAdd(){
    //接口多态创建集合容器对象,存储的数据类型是字符串
    Collection<String> coll = new ArrayList<>();
    //集合对象的方法add添加元素
    coll.add("hello");
    coll.add("world");
    coll.add("java");
    coll.add("money");
    coll.add("wife");
    /**
    *  输出语句中,输出集合对象,调用的是方法toString()
    *  看到的内容是一个完整的字符串, 不叫遍历
    */
    System.out.println(coll);
}

/* **************************************************************************** 
       * 输出语句中，输出的集合对象，调用的是方法 toString()
         * 看到的内容是一个完整的字符串，不是遍历*/

void clear(),

int size(),

boolean isEmpty()

    /**
     *  void clear() 清空集合中的所有元素
     *  int size() 集合的长度
     */
    public static void collectionClear(){
        Collection<Integer> coll = new ArrayList<>();
        coll.add(1);//需要传入Integer类型  传入1  自动装箱
        coll.add(2);
        coll.add(3);
        System.out.println(coll);
        System.out.println("集合的长度::"+ coll.size());//长度
        coll.clear();
        System.out.println(coll);
        System.out.println("集合的长度::"+ coll.size());
        System.out.println("集合是空吗?" + coll.isEmpty());//长度=0,isEmpty()返回true
    }

boolean contains(),

boolean remove()

/**
     *  boolean contains(E) 判断是否包含
     *  boolean remove(E) 移除元素
     */
public static void collectionContains(){
    //接口多态创建集合容器对象,存储的数据类型是字符串
    Collection<String> coll = new ArrayList<>();
    //集合对象的方法add添加元素
    coll.add("hello");
    coll.add("wife");
    coll.add("world");
    coll.add("java");
    coll.add("money");
    coll.add("wife");
    //判断集合中是否包含某个元素
    boolean b = coll.contains("world");
    System.out.println("b = " + b);

    //移除集合中的元素
    //删除成功返回true,如果有多个相同的对象,删除最先遇到的那个
    boolean b1 = coll.remove("wife");
    System.out.println("b1 = " + b1);
    System.out.println(coll);
}

Iterator接口

迭代器接口 Iterator , 为集合进行遍历的. 迭代器技术是所有Collection集合的通用遍历形式.

Iterator接口的抽象方法

boolean hasNext() 判断集合中是否有下一个可以遍历的元素,如果有返回true
E next() 获取集合中下一个元素
void remove() 移除遍历到的元素

获取迭代器接口实现类

迭代器就是为了遍历集合而产生. 集合的顶层接口Collection中定义了方法: 方法的名字就是 iterator() ,返回值是Iterator接口类型, 返回的是Iterator接口实现类的对象

Collection接口中的方法摘要 :
public Iterator iterator() ; 返回迭代器接口实现类的对象

使用的对象ArrayList,实现接口Collection,重写方法iterator();

public static void main(String[] args) {
    //迭代器遍历集合
    //接口多态创建集合容器对象,存储的数据类型是字符串
    Collection<String> coll = new ArrayList<>();
    //集合对象的方法add添加元素
    coll.add("hello");
    coll.add("world");
    coll.add("java");
    coll.add("money");
    coll.add("wife");
    //1 遍历 集合对象,调用方法iterator() 获取迭代器接口的实现类对象
    Iterator<String> it = coll.iterator();//迭代器的泛型跟随遍历对象
    //2 迭代器对象的方法,判断集合是否有下元素
    //boolean b = it.hasNext();
    //System.out.println(b);
    //3 迭代器对象的方法,取出元素
    //String str = it.next();
    //System.out.println(str);
    //条件,集合中有下一个元素就可以
    while ( it.hasNext() ){
        String str =  it.next();
        System.out.println(str);
    }

System.out.println("-------------------------------------------------------");
        for(Iterator<String> its = coll.iterator();  its.hasNext(); System.out.println(its.next())){
        }
}

迭代器的实现原理

每个集合容器,内部结构不同,但是迭代器都可以进行统一的遍历实现

结论 : 迭代器是隐藏在集合的内部的, 提供公共的访问方式, Iterator接口

//**********************************************************
interface Iterator{
    boolean hasNext();
    E next();
    void remove();
}
//**********************************************************
public class ArrayList {
    public Iterator iterator(){
        return  new Itr();
    }
    private class Itr implements Iterator{//内部类实现迭代器
         boolean hasNext(); //重写
    	 E next(); //重写
         void remove(); //重写
    }
}

并发修改异常

如何不发生这个异常

异常的产生原因 : 在迭代器遍历集合的过程中,使用了集合的功能,改变了集合的长度造成

在遍历一个集合的时候，在内部又添加集合的新元素会出现并发修改异常

public static void main(String[] args) {
    //迭代器遍历集合
    //接口多态创建集合容器对象,存储的数据类型是字符串
    Collection<String> coll = new ArrayList<>();
    //集合对象的方法add添加元素
    coll.add("hello");
    coll.add("world");
    coll.add("java");
    coll.add("money");
    coll.add("wife");
    //迭代器遍历集合
    Iterator<String> it = coll.iterator();
    while ( it.hasNext() ){
        String str = it.next();
        //判断,遍历到的集合元素是不是java
        if (str.equals("java")){
            //添加元素 出现并发修改异常
            coll.add("add");
        }
        System.out.println(str);
    }
}

集合存储自定义对象并迭代

public static void main(String[] args) {
    //创建集合,存储自定义的对象
    Collection<Person> coll = new ArrayList<>();
    //集合的方法add存储Person对象
    coll.add( new Person("张三",21) );//存储Person的时候可以使用匿名对象添加
    coll.add( new Person("李四",22) );
    coll.add( new Person("王五",23) );
    //迭代器遍历集合

    Iterator<Person> iterator = coll.iterator();
    while (iterator.hasNext()){
        Person person = iterator.next();
        System.out.println(person);
        System.out.println(person.getName());
    }
}

/**
 *  定义私有成员
 *  get set方法
 *  无参数构造方法   为反射提供方便
 *
 *  满足以上的三个条件 ,这个类,换一个名字,叫JavaBean
 */
public class Person   {
    private String name;
    private int age;
    public Person(){}

    public Person(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 "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

List接口

List接口,继承Collection接口,是单列集合, Collection接口中的方法在上方已经写过了

List接口的特点：索引、可重复、有序

这个接口的集合都具有索引
这个接口中的元素允许重复
这个接口中的元素是有序的
- 元素不会排序 ,有序指的是 ,元素存储和取出的顺序是一致的

List接口的所有实现类,都具有以上三个特征

List接口自己的方法 (带有索引)

add(int index ,E e)

/**
* List接口的方法 add(int index, E e)
* 指定的索引位置,添加元素
*
*   IndexOutOfBoundsException 集合越界异常  长度是size()
*   StringIndexOutOfBoundsException 字符串越界异常  长度是 length()
*   ArrayIndexOutOfBoundsException 数组越界异常  长度是 length
*/
public static void listAdd(){
    List<String> list = new ArrayList<>();
    list.add("a") ;//集合的尾部添加
    list.add("b");
    list.add("c");
    list.add("d");
    list.add("e");
    System.out.println(list);
    //指定的索引上,添加元素 ,3索引添加元素
    list.add(3,"QQ");
    System.out.println(list);
}

get(int index)

    /**
     *  List接口的方法 E get(int index)
     *  返回指定索引上的元素
     *  List集合可以使用for循环像数组一样的方式遍历
     */
    public static void listGet(){
        List<String> list = new ArrayList<>();
        list.add("a") ;//集合的尾部添加
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        //List接口方法get取出元素
        //String s = list.get(3);
        //System.out.println(s);
        for(int i = 0 ; i < list.size() ; i++){
            System.out.println(list.get(i));
        }
    }

set(int index,E e),

remove(int index)

/**
     * List接口方法
     *  E set (int index , E e) 修改指定索引上的元素,返回被修改之前的元素
     *  E remove(int index) 移除指定索引上的元素, 返回被移除之前的元素
     */
    public static void listSetRemove(){
        List<String> list = new ArrayList<>();
        list.add("a") ;//集合的尾部添加
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        System.out.println(list);
        //修改指定索引上的元素,3索引
        String str = list.set(3,"https://www.baidu.com");
        System.out.println(list);
        System.out.println(str);
        //删除指定索引上的元素,删除3索引
        str = list.remove(3);
        System.out.println(list);
        System.out.println(str);
    }

List集合的特有迭代器

List接口中的方法 listIterator() 返回迭代器,迭代器的接口是ListIterator,集合的专用迭代器.

ListIterator迭代器接口的方法
- boolean hasNext() 是否有下一个元素
- E next() 获取下一个元素
- boolean hasPrevious() 判断集合中是否有上一个元素,反向遍历
- E previous() 取出集合的上一个元素

    /**
     * List接口的方法:
     *   listIterator() List集合的特有迭代器
     *   反向遍历
     */
    public static void iterator(){
        List<String> list = new ArrayList<>();
        list.add("a") ;//集合的尾部添加
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        //获取特有迭代器接口实现类对象
        ListIterator<String> lit = list.listIterator();
        //先要正向遍历
        while (lit.hasNext()){
            String s = lit.next();
            System.out.println(s);
        }
        System.out.println("=============");
        //判断上一个元素
        while (lit.hasPrevious()){
            //取出元素
            String s = lit.previous();
            System.out.println(s);
        }
    }

List 接口的实现类的数据结构

链表结构

数组：
- 有索引,数组中元素的地址是连续,查询速度快
- 数组的长度为固定,新数组创建（原来的数组的1.5倍）,数组元素的复制,增删的效率慢
链表：
- 链表没有索引,采用对象之间内存地址记录的方式存储
- 查询元素,必须通过第一个节点依次查询,查询性能慢（JDK的优化：二分法查询）
- 增删元素,不会改变原有链表的结构,速度比较快