集合、迭代器、增强for循环、泛型

1集合

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

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

1.1ArrayList集合存储元素（复习）

例：

public class Person {
	private String name;
	private int age;
	public Person() {
		super();
	}
	public Person(String name, int age) {
		super();
		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;
	}
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
}

import java.util.ArrayList;
public class Test1 {
	public static void main(String[] args) {
		//集合复习：存储基本数据类型
		ArrayList<Double> arr1=new ArrayList<Double>();
		arr1.add(1.6);
		arr1.add(2.3);
		arr1.add(3.6);

		for(int i=0;i<arr1.size();i++){
			System.out.print(arr1.get(i)+" ");
		}

		System.out.println();

		//集合存储引用数据类型
		ArrayList<Person> arr2=new ArrayList<Person>();
		arr2.add(new Person("张三",18));//存匿名对象
		arr2.add(new Person("小红帽",8));
		arr2.add(new Person("大灰狼",55));

		for(int i=0;i<arr2.size();i++){
			System.out.println(arr2.get(i)); //调用toString方法，已重写
		}
	}
}

1.2集合的继承实现关系

常用的：

1.3 Collection接口

Collection接口是集合中的顶层接口，它中定义的所有功能子类都可以使用。

Collection 是层次结构中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。

（这里的有序不是指元素在值上的排序，而是指存、取的顺序一致，怎么存就怎么取，有索引下标）

1.3.1 Collection常用方法

Collection是接口，所以全是抽象方法。

需要用多态new对象。

例：

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

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

		//添加元素
		col.add("中国");
		col.add("你好");
		col.add("java");

		//判断集合中是否包含某元素
		boolean flag=col.contains("java");
		if(flag){
			System.out.println("true，包含元素");
		}		

		//移除元素
		boolean dels=col.remove("你好"); //这个是返回布尔值
		if(dels){
			System.out.println("移除成功");
		}		

		//向下转型
		ArrayList<String> arr=null; //定义成全局，不然遍历时取不到
		if(col instanceof ArrayList){
			arr=(ArrayList<String>)col;
		}

		System.out.println();

		//遍历
		System.out.println("遍历结果：");
		for(int i=0;i<arr.size();i++){
			System.out.print(arr.get(i)+" ");
		}

		System.out.println();
		System.out.println();

		//转成数组
		Object[] strs=col.toArray();
		System.out.println("遍历数组：");
		for(int i=0;i<strs.length;i++){
			//String str=(String)strs[i];//这里是Object型数组，如果想转成String数组，不能直接强转，要给元素转型
			System.out.print(strs[i]+" ");
		}

		System.out.println();
		System.out.println();

		//清除内容
		col.clear();
		System.out.println("清除后：");
		for(int i=0;i<arr.size();i++){
			System.out.print(arr.get(i)+" ");
		}
	}
}

注意：

1注意方法的返回值类型

2一定要指定泛型，不然还要强转

例：会有警告

1.4 Iterator迭代器

1.4.1定义

java中提供了很多个集合，它们在存储元素时，采用的存储方式不同。

List有序（有下标索引），set无序（看上面的继承体系图）

要取出这些集合中的元素，可通过一种通用的获取方式来完成。

迭代定义：

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

集合中把这种取元素的方式描述在Iterator接口中。

1.4.2 Iterator接口的常用方法

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

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

1.4.3 Iterator接口的对象

Iterable对象里有一个iterator() 方法，可以返回Iterator对象，Collection继承了这个方法，那么其子类或实现类就都有了这个方法，可以用这个方法创建Iterator对象。

例：（Iterator接口也可以使用<>来控制迭代元素的类型的）

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

public class IteratorTest {
	public static void main(String[] args) {
		Collection<Integer> col=new ArrayList<Integer>();
		col.add(1);
		col.add(2);
		col.add(3);
		col.add(4);

		//获取迭代器对象
		Iterator<Integer> it=col.iterator();

		//循环
		while(it.hasNext()){
			int i=it.next(); //自动拆箱
			System.out.println(i);
		}
	}
}

注意：

1）next()只能用一次，再调用，指针还会往后走，想判断，要先把值获取到，再判断值。

例：

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

public class I2 {
	public static void main(String[] args) {
		Collection<Integer> col=new ArrayList<Integer>();
		col.add(1);
		col.add(2);
		col.add(3);
		col.add(4);

		//获取迭代器对象
		Iterator<Integer> it=col.iterator();		

		//用循环
		while(it.hasNext()){
			if(it.next()==2){
				System.out.println(it.next());
			}
		}
	}
}

说明next()又向后走了，所以要改成这样：

while(it.hasNext()){
int i=it.next();
	if(i==2){
		System.out.println(i);
	}
}

还可以for循环，但不常用

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

public class I2 {
	public static void main(String[] args) {
		Collection<Integer> col=new ArrayList<Integer>();
		col.add(1);
		col.add(2);
		col.add(3);
		col.add(4);

		for(Iterator<Integer> it=col.iterator();it.hasNext();){
			System.out.println(it.next());
		}
	}
}

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

例：

1.5集合元素的向下转型

集合中可以存储任何对象，那么存放进去的数据就不再是原来的类型了，而是提升成了Object。

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

 

3增强for循环

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

3.1格式：

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

}

例：

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

public class forTest {
	public static void main(String[] args) {
		Collection<String> col=new ArrayList<String>();
		col.add("你好");
		col.add("快乐");		

		//使用增强for
		for(String str:col){
			System.out.println(str); //取到的就是String对象
		}

		//使用增强for遍历数组
		int[] arr={1,2,3,4,5};
		for(int i:arr){
			System.out.print(i+" "); //i就是每个值
		}
	}
}

3.2对比：

1）迭代器只能迭代集合，增强for能遍历集合和数组。

2）新for循环必须有被遍历的目标。目标只能是Collection或者是数组。只用来遍历，不进行任何操作。

遍历数组时，如果仅为遍历，可以使用增强for。

如果要对数组的元素进行操作，使用老式for循环，（因为可以通过下标操作）

3.3总结：

遍历集合：三种方式

遍历数组：两种方式

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

public class Test1 {
	public static void main(String[] args) {
		showList();
		showArr();
	}

	public static void showList(){
		Collection<String> col=new ArrayList<String>();
		col.add("abc");
		col.add("ABC");
		col.add("12345");

		//for循环遍历
		System.out.println("for循环遍历集合：");
		ArrayList<String> arr=null;
		if(col instanceof ArrayList){
			arr=(ArrayList<String>)col;
		}
		for(int i=0;i<arr.size();i++){
			System.out.print(arr.get(i)+"\t");
		}

		//迭代器
		System.out.println();
		System.out.println("迭代器集合：");
		Iterator<String> it=col.iterator();
		while(it.hasNext()){
			System.out.print(it.next()+"\t");
		}

		//增强for
		System.out.println();
		System.out.println("增强for遍历集合：");
		for(String str:col){
			System.out.print(str+"\t");
		}
	}

	public static void showArr(){
		System.out.println();
		int[] arr={1,2,3,4,5};

		System.out.println("普通for遍历数组：");
		for(int i=0;i<arr.length;i++){
			System.out.print(arr[i]+" ");
		}

		System.out.println();
		System.out.println("增强for遍历数组：");
		for(int i:arr){
			System.out.print(i+" ");
		}
	}
}

4泛型

前面一些例子，集合中是可以存放任意对象的，提升成Object类型，这时容易发生

ClassCastException类型转换异常，泛型就是为了解决这个问题。

4.1定义

使用集合时，必须明确集合中元素的类型，这种方式称为泛型。

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

定义格式：

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

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

E就是一个变量，是element的意思，在什么时候明确：

1）实现或继承时明确

Public class MyList<String> implements list<E>{}

Public class MyList<E> implements list<String>{}

2）new对象时明确

Api中带<E>的方法都是如此

4.2使用泛型的好处

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

Tips:

泛型：又叫伪泛型，编译时不进.class文件   （注释也不进）

只在java代码中对集合存储数据类型进行约束

4.3泛型通配符

当定义方法时，无法确定具体集合中的元素类型是什么，可以使用泛型通配符<?>，用来占空。

例：

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

public class Test02 {
	public static void main(String[] args) {
		ArrayList<String> arr=new ArrayList<String>();
		arr.add("中国");
		arr.add("java");

		HashSet<Integer> set=new HashSet<Integer>();
		set.add(1);
		set.add(2);

		showAll(arr);
		showAll(set);
	}

	//泛型通配符
	public static void showAll(Collection<?> col){
		Iterator<?> it=col.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
	}
}

但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。(可以向下转型，但是太麻烦了)

4.4泛型限定

泛型里面没有向上向下转型的概念。所以要定好。

限定泛型的上限：

格式：? extends E

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

限定泛型的下限：

格式：? super E

? 代表接收E类型或者E的父类型的元素（父类型，不只是父类）

例：

//员工类
public abstract class Emp {
	public abstract void work();
}

//经理类
public class Manager extends Emp{
	public void work() {
		System.out.println("经理管理");
	}
}

//服务员类
public class Waiter extends Emp{
	public void work() {
		System.out.println("服务员上菜");
	}
}

//厨师类
public class Cooker extends Emp{
	public void work() {
		System.out.println("厨师炒菜");
	}
}

　　

import java.util.ArrayList;

public class Test03 {
	//四个类：员工，经理，服务员，厨师 都有work方法
	//传入三个类调用其work方法
	public static void main(String[] args) {
		Manager m=new Manager();
		ArrayList<Manager> arr1=new ArrayList<Manager>();
		arr1.add(m);

		Waiter w=new Waiter();
		ArrayList<Waiter> arr2=new ArrayList<Waiter>();
		arr2.add(w);

		Cooker c=new Cooker();
		ArrayList<Cooker> arr3=new ArrayList<Cooker>();
		arr3.add(c);

		working(arr1);
		working(arr2);
		working(arr3);

		ArrayList<Object> arr4=new ArrayList<Object>();
		arr4.add("这是一个Object类型的数据");
		arr4.add("这是一个Object类型的数据2");
		working2(arr4);

	}
	public static void working(ArrayList<? extends Emp> arr){ //限定泛型的上限
		Emp emp=arr.get(0);
		emp.work();
	}

	public static void working2(ArrayList<? super Emp> arr){ //限定泛型的下限
		for(int i=0;i<arr.size();i++){
			System.out.println(arr.get(i));
		}
	}
}

这里如果是接口，也可以用extends。