18_集合_第1天(Collection、迭代器、泛型)

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/w1103693423/article/details/78982916

第18天 集合

  1. 集合

    1. 集合介绍

集合,集合是java中提供的一种容器,可以用来存储多个数据。

在前面的学习中,我们知道数据多了,可以使用数组存放或者使用ArrayList集合进行存放数据。那么,集合和数组既然都是容器,它们有啥区别呢?

  • 数组的长度是固定的。集合的长度是可变的。
  • 集合中存储的元素必须是引用类型数据
  1. ArrayList集合存储元素

我们来回顾下,使用ArrayList集合存储元素并遍历的过程。

  • 练习一:ArrayList集合存储5个int类型元素

public static void main(String[] args) {

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

    list.add(111);

    list.add(222);

    list.add(333);

    list.add(444);

    list.add(555);

    for(int i=0; i<list.size(); i++){

System.out.println(list.get(i));

}

}

  • 练习二:ArrayList集合存储5个Person类型元素

public static void main(String[] args) {

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

    list.add(new Person("小强"));

    list.add(new Person("老王"));

    list.add(new Person("小虎"));

    list.add(new Person("小泽"));

    list.add(new Person("小红"));

    for(int i=0; i<list.size(); i++){

        Person p = list.get(i);

System.out.println(p);

}

}

  1. 集合的继承实现关系

查看ArrayList类发现它继承了抽象类AbstractList同时实现接口List,而List接口又继承了Collection接口。Collection接口为最顶层集合接口了。 采集,聚集

源代码:

interface List extends Collection {

}

public class ArrayList extends AbstractList implements List{

}

这说明我们在使用ArrayList类时,该类已经把所有抽象方法进行了重写。那么,实现Collection接口的所有子类都会进行方法重写。

  • Collecton接口常用的子接口有:List接口、Set接口
  • List接口常用的子类有:ArrayList类、LinkedList类
  • Set接口常用的子类有:HashSet类、LinkedHashSet类

  1. Collection接口概述

既然Collection接口是集合中的顶层接口,那么它中定义的所有功能子类都可以使用。查阅API中描述的Collection接口。Collection 层次结构中的根接口。Collection 表示一组对象,这些对象也称为 collection 的元素。一些 collection 允许有重复的元素,而另一些则不允许。一些 collection 是有序的,而另一些则是无序的。

继续查阅API,发现Collection接口中很多集合的操作方法,那么这些方法都具体能做什么呢?

  1. Collection接口的基本方法

这里我们不关心具体创建的Collection中的那个子类对象,这里重点演示的是Collection接口中的方法。

创建集合的格式:

方式1Collection<元素类型> 变量名 = new ArrayList<元素类型>();

方式2Collection 变量名 = new ArrayList();

  • 方式1创建的集合,只能存储<>中指定的元素类型,该方式为常用方式
  • 方式2创建的集合,集合的元素类型默认为Object类型,即任何类型的元素都可以存储。

 

演示Collection接口中的方法

//创建集合

Collection coll = new ArrayList();

 

//1,往集合中添加对象元素。add(E e)方法,E代表创建集合时所指定的数据类型如<String>,那么,E就代表String类型;创建集合时若没有指定数据类型,那么,E就代表Object类型。

coll.add("itcast1");

coll.add("itcast2");

coll.add("itcast3");        

//把集合打印一下。

System.out.println(coll); //打印结果为:[itcast1, itcast2, itcast3]

System.out.println(coll.toString()); //打印结果为:[itcast1, itcast2, itcast3]

 

//2,从集合中删除元素。remove(Object o)方法

coll.remove("itcast2");        

//删除后,集合元素为[itcast1, itcast3]

 

//3,判断集合中是否包含指定元素。contains(Object o)方法

System.out.println(coll.contains("itcast1"));

//打印结果为true

System.out.println(coll.contains("itcast2"));

//打印结果为false

    

//4,获取集合元素个数。size()方法

System.out.println(coll.size());

//打印结果为2

 

//5,返回包含集合中所有元素的数组。toArray()方法

String[] array = coll.toArray();

//数组中的元素为{"itcast1", "itcast3"}

 

//6,清除集合元素。remove()方法

coll.clear();

//清空后,集合元素为[],代表没有元素

  1. Iterator迭代器

    1. Iterator迭代器概述

java中提供了很多个集合,它们在存储元素时,采用的存储方式不同。我们要取出这些集合中的元素,可通过一种通用的获取方式来完成。

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

集合中把这种取元素的方式描述在Iterator接口中。Iterator接口的常用方法如下:

  • hasNext()方法:用来判断集合中是否有下一个元素可以迭代。如果返回true,说明可以迭代。
  • next()方法:用来返回迭代的下一个元素,并把指针向后移动一位。

     

    迭代集合元素图解:

  1. Iterator迭代方式的代码体现

在Collection接口描述了一个抽象方法iterator方法,所有Collection子类都实现了这个方法,并且有自己的迭代形式。

进行代码演示:

//1,创建集合对象。

Collection<String> coll = new ArrayList<String>();

coll.add("abc1");

coll.add("abc2");

coll.add("abc3");

coll.add("abc4");

 

//2.获取容器的迭代器对象。通过iterator方法。

Iterator it = coll.iterator();

 

//3,使用具体的迭代器对象获取集合中的元素。参阅迭代器的方法

while(it.hasNext()){

    System.out.println(it.next());

}

 

/*

迭代器for循环的形式的使用

for (Iterator it = coll.iterator(); it.hasNext(); ) {

    System.out.println(it.next());

}

*/

注意:在进行集合元素取出时,如果集合中已经没有元素了,还继续使用迭代器的next方法,将会发生java.util.NoSuchElementException没有集合元素的错误。

  1. 集合元素的向下转型

学习到这里,基本知道了Collection接口的简单使用。可是集合中可以存储任何对象,那么存放进去的数据都是还是原来类型吗?不是了,提升成了Object。

在使用集合时,我们需要注意以下几点:

  • 集合中存储其实都是对象的地址。
  • 集合中可以存储基本数值吗?jdk1.5版本以后可以存储了。因为出现了基本类型包装类,它提供了自动装箱操作(基本类型à对象),这样,集合中的元素就是基本数值的包装类对象。
  • 存储时提升了Object。取出时要使用元素的特有内容,必须向下转型。

Collection coll = new ArrayList();

coll.add("abc");

coll.add("aabbcc");

coll.add("shitcast");

Iterator it = coll.iterator();

while (it.hasNext()) {

    //由于元素被存放进集合后全部被提升为Object类型

//当需要使用子类对象特有方法时,需要向下转型

    String str = (String) it.next();

    System.out.println(str.length());

}

注意:如果集合中存放的是多个对象,这时进行向下转型会发生类型转换异常。

 

提示:Iterator接口也可以使用<>来控制迭代元素的类型的。代码演示如下:

Collection<String> coll = new ArrayList<String>();

coll.add("abc");

coll.add("aabbcc");

coll.add("shitcast");

Iterator<String> it = coll.iterator();

while (it.hasNext()) {

    String str = it.next();

//当使用Iterator<String>控制元素类型后,就不需要强转了。获取到的元素直接就是String类型

    System.out.println(str.length());

}

 

 

  1. 增强for循环

增强for循环是JDK1.5以后出来的一个高级for循环,专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器,所以在遍历的过程中,不能对集合中的元素进行增删操作。

格式:

for(元素的数据类型 变量 : Collection集合or数组){

}

它用于遍历Collection和数组。通常只进行遍历元素,不要在遍历的过程中对集合元素进行增删操作。

练习一:遍历数组

int[] arr = new int[]{11,22,33};

for (int n : arr) {//变量n代表被遍历到的数组元素

    System.out.println(n);

}

 

练习二:遍历集合

Collection<String> coll = new ArrayList<String>();

coll.add("itcast1");

coll.add("itcast2");

coll.add("itcast3");

coll.add("itcast4");

for(String str : coll){//变量Str代表被遍历到的集合元素

    System.out.println(str);

}

增强for循环和老式的for循环有什么区别?

注意:新for循环必须有被遍历的目标。目标只能是Collection或者是数组。

建议:遍历数组时,如果仅为遍历,可以使用增强for如果要对数组的元素进行 操作,使用老式for循环可以通过角标操作。

  1. 泛型

    1. 泛型的引入

在前面学习集合时,我们都知道集合中是可以存放任意对象的,只要把对象存储集合后,那么这时他们都会被提升成Object类型。当我们在取出每一个对象,并且进行相应的操作,这时必须采用类型转换。比如下面程序:

public class GenericDemo {

    public static void main(String[] args) {

        List list = new ArrayList();

        list.add("abc");

        list.add("itcast");

        list.add(5);//由于集合没有做任何限定,任何类型都可以给其中存放

        Iterator it = list.iterator();

        while(it.hasNext()){

            //需要打印每个字符串的长度,就要把迭代出来的对象转成String类型

            String str = (String) it.next();

            System.out.println(str.length());

        }

    }

}

 

程序在运行时发生了问题java.lang.ClassCastException

为什么会发生类型转换异常呢?我们来分析下:

由于集合中什么类型的元素都可以存储。导致取出时,如果出现强转就会引发运行时 ClassCastException。怎么来解决这个问题呢?使用集合时,必须明确集合中元素的类型。这种方式称为:泛型。

  1. 泛型的定义与使用

我们在集合中会大量使用到泛型,这里来完整地学习泛型知识。

泛型,用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。

  1. 含有泛型的类

    定义格式:修饰符 class 类名<代表泛型的变量> { }

  • 例如,API中的ArrayList集合:

class ArrayList<E>{

public boolean add(E e){ }

    public E get(int index){ }

}

 

    使用格式:创建对象时,确定泛型的类型

  • 例如,ArrayList<String> list = new ArrayList<String>();

此时,变量E的值就是String类型

class ArrayList<String>{

public boolean add(String e){ }

    public String get(int index){ }

}

  • 例如,ArrayList<Integer> list = new ArrayList<Integer>();

此时,变量E的值就是Integer类型

class ArrayList<Integer>{

public boolean add(Integer e){ }

    public Integer get(int index){ }

}

 

  1. 含有泛型的方法

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

  • 例如,API中的ArrayList集合中的方法:

public <T> T[] toArray(T[] a){ }

//该方法,用来把集合元素存储到指定数据类型的数组中,返回已存储集合元素的数组

 

使用格式:调用方法时,确定泛型的类型

  • 例如

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

    String[] arr = new String[100];

    String[] result = list.toArray(arr);

此时,变量T的值就是String类型。变量T,可以与定义集合的泛型不同

public <String> String[] toArray(String[] a){ }

  • 例如

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

    Integer[] arr = new Integer[100];

    Integer [] result = list.toArray(arr);

此时,变量T的值就是Integer类型。变量T,可以与定义集合的泛型不同

public <Integer> Integer[] toArray(Integer[] a){ }

 

  1. 含有泛型的接口

    定义格式:修饰符 interface接口名<代表泛型的变量> { }

  • 例如,API中的Iterator迭代器接口

public interface Iterator<E> {

    public abstract E next();

}

    

使用格式:

1、定义类时确定泛型的类型

  • 例如

public final class Scanner implements Iterator<String> {

public String next(){ }

}

此时,变量E的值就是String类型。

 

2、始终不确定泛型的类型,直到创建对象时,确定泛型的类型

  • 例如

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

    Iterator<String> it = list.iterator();

此时,变量E的值就是String类型。

public interface Iterator<String> {

    public abstract String next();

}

 

 

  1. 使用泛型的好处

  • 将运行时期的ClassCastException,转移到了编译时期变成了编译失败。
  • 避免了类型强转的麻烦。

演示下列代码:

public class GenericDemo {

    public static void main(String[] args) {

        List<String> list = new ArrayList<String>();

        list.add("abc");

        list.add("itcast");

        //list.add(5);//当集合明确类型后,存放类型不一致就会编译报错

        //集合已经明确具体存放的元素类型,那么在使用迭代器的时候,迭代器也同样会知道具体遍历元素类型

        Iterator<String> it = list.iterator();

        while(it.hasNext()){

    String str = it.next();

//当使用Iterator<String>控制元素类型后,就不需要强转了。获取到的元素直接就是String类型

            System.out.println(str.length());

        }

    }

}

  1. 泛型通配符

泛型是在限定数据类型,当在集合或者其他地方使用到泛型后,那么这时一旦明确泛型的数据类型,那么在使用的时候只能给其传递和数据类型匹配的类型,否则就会报错。

代码演示:

  • 定义迭代集合元素的方法

public static void printCollection(Collection<Person> list) {

    Iterator<Person> it = list.iterator();

    while (it.hasNext()) {

        System.out.println(it.next());

    }

}

  • 调用方法

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

printCollection(list);

上面调用方法语句属于语法错误,因为泛型限定不一致。方法要的是Collection<Person>类型,传入的是Collection<Student>,二者类型不匹配。

 

上述定义的printCollection方法中,由于定义的是打印集合的功能,应该是可以打印任意集合中元素的。但定义方法时,根本无法确定具体集合中的元素类型是什么。为了解决这个"无法确定具体集合中的元素类型"问题,java中,为我们提供了泛型的通配符<?>

  • 对上面的方法,进行修改后,实现了可迭代任意元素类型集合的方法

public static void printCollection(Collection<?> list) {

    Iterator<?> it = list.iterator();

    while (it.hasNext()) {

        System.out.println(it.next());

    }

}

 

  • 总结一下:

当使用泛型类或者接口时,传递的数据中,泛型类型不确定,可以通过通配符<?>表示。但是一旦使用泛型的通配符后,只能使用Object类中的共性方法,集合中元素自身方法无法使用。

  1. 泛型限定

上述打印集合的功能,看似很强大,可以打印任意集合,可是问题也来了。如果想要对被打印的集合中的元素类型进行限制,只在指定的一些类型,进行打印。怎么做呢?

要解决这个问题,我们就要学习泛型的限定。

  • 限定泛型的上限:
    • 格式:? extends E

      ? 代表接收E类型或者E的子类型的元素

    • 例如,泛型限定为:? extends Person

      则 ? 代表接收Person类型或者Person子类型的元素

 

  • 限定泛型的下限:
    • 格式:? super E

      ? 代表接收E类型或者E的父类型的元素

    • 例如,泛型限定为:? super Student

      则 ? 代表接收Student类型或者Student父类型的元素

       

  • 练习:修改下面的方法,使该方法可以打印学生和工人的集合

class Student extends Person{ }

class Worker extends Person{ }

 

public static void printCollection(Collection<?> list) {

    Iterator<?> it = list.iterator();

    while (it.hasNext()) {

        System.out.println(it.next());

    }

}

 

分析一下,我们可以找到学生和工人的共性类型Person。那么,泛型的限定可以这样书写:

? extends Person : 接收Person类型或者Person的子类型。修改方法如下:

public static void printCollection(Collection<? extends Person> list) {

    Iterator<? extends Person> it = list.iterator();

    while (it.hasNext()) {

        System.out.println(it.next());

    }

}

 

  1. 总结

    1. 知识点总结

  • Collection:集合的顶层接口,定义了集合中通用的功能方法

    常用方法:

    • boolean add(Object e) 把给定的对象添加到当前集合中
    • void clear() 清空集合中所有的元素
    • boolean remove(Object o) 把给定的对象在当前集合中删除
    • boolean contains(Object o) 判断当前集合中是否包含给定的对象
    • boolean isEmpty() 判断当前集合是否为空
    • Iterator iterator() 迭代器,用来遍历集合中的元素的
    • int size() 返回集合中元素的个数
    • Object[] toArray() 把集合中的元素,存储到数组中
  • Iterator: 迭代器
    • Object next()返回迭代的下一个元素
    • boolean hasNext()如果仍有元素可以迭代,则返回 true。
  • 增强for

    简化数组和Collection集合的遍历

    格式:

        for(元素数据类型 变量 : 数组或者Collection集合) {

            使用变量即可,该变量就是元素

        }

    好处:简化遍历

  • 泛型: 用来约束数据的数据类型
    • 泛型的格式:

        <数据类型>

        泛型可以使用在 类,接口,方法上

  • 泛型的好处

        A:将运行期遇到的问题转移到了编译期

        B:省去了类型强转的麻烦

  • 泛型高级(通配符):
    • 泛型通配符<?>

    泛型类型不确定时,可以通过通配符<?>表示。但是一旦使用泛型的通配符后,只能使用Object类中的共性方法,集合中元素自身方法无法使用。

    • <? extends E>

                向上限定,E及其子类

                ? extends Animal

                ? 代表的就是Animal类本身或者是Animal类的子类

  • <? super E>

                向下限定,E及其父类

                ? super Animal

                ? 代表的就是Animal类本身或者是Animal类的父类

阅读更多
换一批

没有更多推荐了,返回首页