集合 ArrayList 集合的继承实现关系 Collection Iterator迭代器增强for循环泛型集合的向下转型

最新推荐文章于 2022-12-13 14:38:36 发布

taotaoSi

最新推荐文章于 2022-12-13 14:38:36 发布

阅读量1.1k

点赞数

分类专栏： Java基础文章标签： Collection Iterator迭代器泛型增强for循环集合

本文链接：https://blog.csdn.net/taotaoSi/article/details/79370661

版权

Java基础专栏收录该内容

12 篇文章 0 订阅

订阅专栏

1.集合介绍

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

我们知道数据多了，可以使用数组存放或者使用ArrayList集合进行存放数据。那么，集合和数组既然都是容器，它们有啥区别呢？

数组的长度是固定的。集合的长度是可变的。

集合中存储的元素必须是引用类型数据

2. ArrayList集合存储元素

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);
}

3. 集合的继承实现关系

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

源代码：
interface List extends Collection {
}
public class ArrayList extends AbstractList implements List{
}

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

l Collecton接口常用的子接口有：List接口、Set接口

l List接口常用的子类有：ArrayList类、LinkedList类

l Set接口常用的子类有：HashSet类、LinkedHashSet类

4.Collection接口概述

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

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

Collection接口的基本方法

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

创建集合的格式：

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

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

l 方式1创建的集合，只能存储<>中指定的元素类型，该方式为常用方式

l 方式2创建的集合，集合的元素类型默认为Object类型，即任何类型的元素都可以存储。

演示Collection接口中的方法

//创建集合
Collection coll = new ArrayList();

//1,往集合中添加对象元素。add(E e)方法，E代表创建集合时所指定的数据类型如<String>，那么，E就代表String类型；创建集合时若没有指定数据类型，那么，E就代表Object类型。
coll.add("t1");
coll.add("t2");
coll.add("t3");		
//把集合打印一下。
System.out.println(coll); //打印结果为：[t1, t2, t3]
System.out.println(coll.toString()); //打印结果为：[t1, t2, t3]

//2,从集合中删除元素。remove(Object o)方法
coll.remove("t2");		
//删除后，集合元素为[t1, t3]

//3,判断集合中是否包含指定元素。contains(Object o)方法
System.out.println(coll.contains("t1"));
//打印结果为true
System.out.println(coll.contains("t2"));
//打印结果为false
	
//4,获取集合元素个数。size()方法
System.out.println(coll.size());
//打印结果为2

//5,返回包含集合中所有元素的数组。toArray()方法
String[] array = coll.toArray();
//数组中的元素为{"t1", "t3"}

//6,清除集合元素。remove()方法
coll.clear();
//清空后，集合元素为[]，代表没有元素

Iterator迭代器

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

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

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

hasNext（）方法：用来判断集合中是否有下一个元素可以迭代。如果返回true,说明可以迭代。

next（）方法：用来返回迭代的下一个元素，并把指针向后移动一位。

迭代集合元素图解：

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没有集合元素的错误。

集合元素的向下转型

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

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

l 集合中存储其实都是对象的地址。

l 集合中可以存储基本数值吗？jdk1.5版本以后可以存储了。因为出现了基本类型包装类，它提供了自动装箱操作（基本类型à对象），这样，集合中的元素就是基本数值的包装类对象。

l 存储时提升了Object。取出时要使用元素的特有内容，必须向下转型。

Collection coll = new ArrayList();
coll.add("abc");
coll.add("aabbcc");
coll.add("ffffff");
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("fffff");
Iterator<String> it = coll.iterator();
while (it.hasNext()) {
	String str =  it.next(); 
//当使用Iterator<String>控制元素类型后，就不需要强转了。获取到的元素直接就是String类型
	System.out.println(str.length());
}

增强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("t1");
coll.add("t2");
coll.add("t3");
coll.add("t4");
for(String str : coll){//变量Str代表被遍历到的集合元素
System.out.println(str);

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

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

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

泛型的引入

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

public class GenericDemo {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("abc");
		list.add("sdf");
		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。怎么来解决这个问题呢？使用集合时，必须明确集合中元素的类型。这种方式称为：泛型。

泛型的定义与使用

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

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

4.2.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){  }
}

4.2.2含有泛型的方法
定义格式：修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }
例如，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){  }

4.2.3含有泛型的接口
	定义格式：修饰符 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();
}

使用泛型的好处

将运行时期的ClassCastException，转移到了编译时期变成了编译失败。

避免了类型强转的麻烦。

演示下列代码：

public class GenericDemo {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("abc");
		list.add("sdf");
		//list.add(5);//当集合明确类型后，存放类型不一致就会编译报错
		//集合已经明确具体存放的元素类型，那么在使用迭代器的时候，迭代器也同样会知道具体遍历元素类型
		Iterator<String> it = list.iterator();
		while(it.hasNext()){
	String str = it.next();
//当使用Iterator<String>控制元素类型后，就不需要强转了。获取到的元素直接就是String类型
			System.out.println(str.length());
		}
	}
}

泛型通配符

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

代码演示：

定义迭代集合元素的方法

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类中的共性方法，集合中元素自身方法无法使用。

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

常用方法：

l boolean add(Object e) 把给定的对象添加到当前集合中

l void clear() 清空集合中所有的元素

l boolean remove(Object o) 把给定的对象在当前集合中删除

l boolean contains(Object o) 判断当前集合中是否包含给定的对象

l boolean isEmpty() 判断当前集合是否为空

l Iterator iterator() 迭代器，用来遍历集合中的元素的

l int size() 返回集合中元素的个数

l Object[] toArray() 把集合中的元素，存储到数组中

l Iterator: 迭代器

l Object next()返回迭代的下一个元素

l boolean hasNext()如果仍有元素可以迭代，则返回 true。

l 增强for

简化数组和Collection集合的遍历

格式：

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

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

}

好处：简化遍历

l 泛型：用来约束数据的数据类型

l 泛型的格式：

<数据类型>

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

l 泛型的好处

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

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

l 泛型高级(通配符):

l ? extends E 上限限定,传递E类对象, E的子类对象

l ? Super E 下限限定,传递E类对象,E的父类对象

taotaoSi

关注

0
点赞
踩
11

收藏

觉得还不错? 一键收藏
0
评论
集合 ArrayList 集合的继承实现关系 Collection Iterator迭代器增强for循环泛型集合的向下转型

1.集合介绍集合，集合是java中提供的一种容器，可以用来存储多个数据。我们知道数据多了，可以使用数组存放或者使用ArrayList集合进行存放数据。那么，集合和数组既然都是容器，它们有啥区别呢？数组的长度是固定的。集合的长度是可变的。集合中存储的元素必须是引用类型数据2. ArrayList集合存储元素public static void main(String[] ...
复制链接

扫一扫