Collection集合、Iterator迭代器、泛型

阳光穿透心脏的1/2处 2022-12-06 05:41 229阅读 0赞

# 1、Collection集合 #

## 1.1、集合概述 ##

集合：集合是Java中提供的一种容器技术，可以用来存储多个数据。

集合和数组都是容器技术，它们区别是：  
●数组的长度是固定的，集合的长度是可变的  
●数组中存储的是同一类型的元素，可以存储基本数据类型值，集合存储的都是对象，而且对象的类型可以不一致，在开发中一般当对象多的时候，使用集合进行存储。

## 1.2、集合框架 ##

Java提供了满足各种需求的API，在使用这些API前，首先了解其继承与接口的操作架构，才能了解何时用哪个类，以及类之间如何彼此合作，从而达到灵活运用。

集合按照其存储结构可以分为两大类，分别是：单列集合java.util.Collection和双列集合java.util.Map，本章主要学习Collection集合。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZsdWNreV9sb25n_size_16_color_FFFFFF_t_70_pic_center]  
Collection：单列集合类的根接口，用于存储一系列符合某种规则的元素，它由两个重要的子接口，分别是：java.util.List和java.util.Set。其中，List的特点是：元素有序(会按照添加的顺序进行元素的输出)，而且可以重复（重复指的是内容一致）；Set的特点是：元素无序（输出时无序），而且元素不可以重复。

List接口的主要实现类：

1.  java.util.ArrayList
2.  java.util.LinkedList
3.  java.util.Vector

Set接口的主要实现类：

1.  java.util.HashSet
2.  java.util.LinkedHashSet
3.  java.util.TreeSet

集合本身是一个工具类，它存放在java.util包中。

## 1.3、Collection常用功能 ##

Collection是所有单列集合的父接口，因此在Collection中定义了单列集合通用的一些方法，这些方法可用于操作所有的单列集合。方法如下：  
●public boolean add(E e)：把给定的对象添加到当前集合中  
● public boolean addAll(Collection<? extends E> c)：将指定集合中的所有元素添加到此集合  
● public void clear()：从此集合中删除所有元素（可选操作）。.  
● public boolean contains(Object o) ：如果此集合包含指定的元素，则返回 true 。  
● public boolean isEmpty()：判断当前集合是否为空  
● public boolean remove(Object o)：从该集合中删除指定元素的单个实例（如果存在）（可选操作）。  
● public int size()：返回集合中元素的个数  
● public Object\[\] toArray()：把集合中的元素，存储到数组中

package com.bdit;
    
    import java.util.ArrayList;
    import java.util.Collection;
    
    /*
    Collection集合方法的应用
     */
    public class Test1 {
        
        public static void main(String[] args) {
        
            Collection c1=new ArrayList();
            //添加元素到集合中
            c1.add("zhangsan");
            c1.add(100);//
            c1.add(96.69);
            c1.add(false);
            System.out.println("是否为空："+c1.isEmpty());
            System.out.println("是否包含："+c1.contains(1000));
            System.out.println("移除元素:"+c1.remove(100));
            System.out.println("元素的个数："+c1.size());
            Collection c2=new ArrayList();
            c2.addAll(c1);
            System.out.println(c2);
        }
    }

# 2、Iterator迭代器 #

## 2.1、Iterator接口 ##

在程序开发中，经常需要遍历集合的所有元素，针对这种情况，JDK专门提供了一个接口java.util.Iterator。Iterator接口也是java集合中的一员，但它与Collection、Map接口有所不同。Collectionu接口与Map接口主要用于存储元素。而Iterator主要用于迭代访问(即遍历)Collection中的元素，因此Iterator对象也被称为迭代器。

想要遍历Collection集合，那么就要获取该集合迭代器完成迭代操作。  
●public Iterator iterator()：获取集合对应的迭代器，用来遍历集合中的元素

迭代的概念：  
●迭代，即Collection集合元素的通用获取方式，在去元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续再判断，如果还有就继续取出来，一直把集合中所有的元素全部取出。这种取出方式专业术语称为迭代。  
●Iterator常用方法：

1.  public E next()：返回迭代的下一个元素
2.  public E next()：返回迭代的下一个元素

package com.bdit;
    
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    
    /*
    Itertor迭代器
     */
    public class Test2 {
        
        public static void main(String[] args) {
        
            Collection c1=new ArrayList();
            c1.add("刘备");
            c1.add("关羽");
            c1.add("张飞");
            c1.add("赵子龙");
            c1.add("黄盖");
    
            System.out.println(c1);
    
            //获取集合的迭代器对象
            Iterator it=c1.iterator();
            while(it.hasNext()){
        
                System.out.println(it.next());
            }
    
            //此处会发生java.util.NoSuchElementException
            //如果迭代完毕后，继续调用next方法，将会发生以上异常
            System.out.println(it.next());
        }
    }

## 2.2、迭代器的实现原理 ##

当遍历集合时，首先通过调用集合的iterator()方法获取迭代器对象，然后使用hashNext()方法判断集合中是否存在下一个元素。如果存在，则调用next()方法将元素取出，否则说明已经到达了集合末尾，停止遍历元素。  
Iterator迭代器对象在遍历集合时，内部采用指针的方式来跟踪集合中的元素，为了更好的理解迭代器的工作原理，可以参考一下下列图片：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZsdWNreV9sb25n_size_16_color_FFFFFF_t_70_pic_center 1]  
在调用iterator的next()方法之前，迭代器的索引位于第一个元素之前，不指向任何元素。当第一次调用迭代器的next方法后，迭代器的索引会向后移动一位，指向第一个元素并将该元素返回，当再次调用next()方法时，迭代器的索引会指向第二个元素并将该元素返回，以此类推，直到hasNext()方法返回false，表示到达了集合的末尾，终止对元素的遍历。

## 2.3、增强for循环 ##

增强for循环(也称for each循环)是JDK1.5以后新增的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历过程中，不能对集合中元素进行其它操作。  
【使用增强的for循环，无法直接获取每个元素的下标值】  
【增强的for循环，只适合用来对数组或集合中的元素进行遍历操作】

package com.bdit;
    
    import java.util.ArrayList;
    import java.util.Collection;
    
    public class Test3 {
        
        public static void main(String[] args) {
        
            Collection c1=new ArrayList();
            c1.add("刘备");
            c1.add("关羽");
            c1.add("张飞");
            c1.add("赵子龙");
            c1.add("黄盖");
    
    		//增强for循环
            for(Object str:c1){
        
                System.out.println(str.toString());
            }
        }
    }

# 3、泛型 #

## 3.1、泛型概念 ##

集合中可以存放任意对象的，只要把对象存储到集合后，那么这时对象都会被提升(向上转型)为Object类型。当我们在取出每一个对象，并且进行相应操作，这时必须采用类型转换(向下转型)。  
观察下面代码：

package com.bdit;
    
    import java.util.ArrayList;
    import java.util.Collection;
    
    /*
    往集合中添加自定义类对象
     */
    public class Test4 {
        
        public static void main(String[] args) {
        
            Collection c1=new ArrayList();
            c1.add(new Student(1001,"张三",22));
            c1.add(new Student(1002,"李四",23));
            c1.add(new Student(1003,"王五",24));
            c1.add(new Student(1004,"赵六",25));
    		//for(Object obj:c1){
        
    		//Test4 student=(Test4)obj;
    		//System.out.println(student);
    		//}
            for(Object obj:c1){
        
                Student student=(Student)obj;
                System.out.println(student);
            }
    
        }
    }

程序在运行时发生了问题java.lang.ClassCastException。为什么会发生类型转换异常呢？分析：  
由于集合中什么类型的元素都可以存储，导致取出时强转引发运行时ClassCastException。怎么来解决这个问题呢？Collection虽然可以存储各种对象，但实际上通常Collection只存储一种类型即Object类型。因此在JDK5之后，新增了泛型(Generic)语法，让你在设计API时可以指定类或方法支持泛型，这样我们使用API的时候就变得更为简洁，并通过了编译时期的语法检查。

泛型：可以在类或方法中预支地使用未知的类型。

一般在创建对象时，将未知类型确定为具体类型，当没有指定泛型时，默认类型为Object类型。

## 3.2、使用泛型的好处 ##

泛型有哪些好处：

1.  将运行时期的ClassCastException，转移到编译时期，编译失败
2.  避免了类型强转的麻烦

## 3.3、泛型的定义与使用 ##

#### 消除类型转换 ####

集合类<泛型类型> 对象名=new 集合类<>();

package com.bdit;
    
    import java.util.ArrayList;
    import java.util.Collection;
    
    /*
    泛型
     */
    public class Test5 {
        
        public static void main(String[] args) {
        
            Collection<Student> c1=new ArrayList<>();
            c1.add(new Student(1001,"张三",22));
            c1.add(new Student(1002,"李四",23));
            c1.add(new Student(1003,"王五",24));
            c1.add(new Student(1004,"赵六",25));
    
            for (Student stu:c1){
        
                System.out.println(stu);
            }
        }
    }

#### 定义和使用含有泛型的类 ####

定义格式：

修饰符 class 类名<代表泛型的变量>{
        
    
    }

自定义泛型类：

package com.bdit;
    /*
    自定义泛型类
     */
    public class Test6 {
        
        public static void main(String[] args) {
        
            MyClass<String> myClass=new MyClass<>();
            myClass.setName("张三");
            System.out.println(myClass.getName());
        }
    }
    
    class MyClass<MVP>{
        
        private MVP name;
    
        public void setName(MVP name){
        
            this.name=name;
        }
    
        public MVP getName(){
        
            return name;
        }
    }

在创建泛型类的对象时，必须给泛型类型确定为具体类型  
例如：MyClass myClass=new MyClass<>();  
在此类中MVP就相当于是泛型变量，那么创建对象时传递过来的具体类型，会把泛型类中所有使用到泛型变量的地方，替换为具体类型。

#### 含有泛型的方法 ####

定义格式：

修饰符 <代表泛型的变量> 返回值类型 方法名(参数列表){
        
    
    }

package com.bdit;
    /*
    泛型方法
     */
    public class Test7 {
        
        public static void main(String[] args) {
        
            Test7 test7=new Test7();
            test7.show("张三");
    
            System.out.println(test7.show2(100));
        }
        public <M> void show(M m){
        
            System.out.println(m.getClass());
        }
    
        public <M> M show2(M m){
        
            System.out.println(m.getClass());
            return m;
        }
    }

【无论使用泛型类、泛型方法、泛型接口，传递的泛型类型只能是引用类型】

#### 含有泛型的接口 ####

定义格式：

修饰符 interface 接口名<代表泛型的变量>{
        
    }

package com.bdit;
    /*
    泛型接口
     */
    public class Test8 {
        
        public static void main(String[] args) {
        
            MyImpl1<String> myImpl1=new MyImpl1<>();
            myImpl1.add("张三");
        }
    }
    
    interface MyInter<E>{
        
        public void add(E e);
    
        public E get();
    }
    
    //定义实现类
    class MyImpl1<E> implements MyInter<E>{
        
    
    
        @Override
        public void add(E e) {
        
    
        }
    
        @Override
        public E get() {
        
            return null;
        }
    }

【不能直接new泛型变量的对象,因为无法保证泛型变量就一定是类】

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZsdWNreV9sb25n_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/b5a878d49d3249efa38f7df1506c64cc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZsdWNreV9sb25n_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/1a0aef2600214f6fa23933ba3fbb2614.png