java：collection集合、Iterator迭代器、foreach 增强for、泛型

一、集合

架构

众所周知，Java的数组长度是固定的，但是在实际中某些情况，甲方是会变来变去的。这里引入Colleciton,集合的长度是可变的，而且类型可以是混合的。

• public boolean add(E e)： 把给定的对象添加到当前集合中 。
• public void clear() :清空集合中所有的元素。
• public boolean remove(E e): 把给定的对象在当前集合中删除。
• public boolean contains(E e): 判断当前集合中是否包含给定的对象。
• public boolean isEmpty(): 判断当前集合是否为空。
• public int size(): 返回集合中元素的个数。
• public Object[] toArray(): 把集合中的元素，存储到数组中。

混合类型的集合

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

public class test9 {	
		
	public static void main(String[] args)  {
		Collection coll = new ArrayList();
		coll.add("abc");
		coll.add('c');
		coll.add(5);//由于集合没有做任何限定，任何类型都可以给其中存放
		System.out.println(coll);
	}
}

输出

[abc, c, 5]

指定String类型的集合

package test;

import java.text.DateFormat;
import java.text.ParseException;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;
import java.util.logging.SimpleFormatter;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;

public class test9 {	
		
	public static void main(String[] args)  {
		// 创建集合对象 
    	// 使用多态形式
		//Collection<E> 变量名字=new ArrayList<E>(); 
		//ArrayList 可以换其他的
		Collection<String> collection=new ArrayList<String>();
		
		// 添加使用方法
    	collection.add("哈哈");
    	collection.add("test");
    	collection.add("333");
    	System.out.println(collection);
    	//输出 [哈哈, test, 333]
    	
    	//判断其中是否存在
    	System.out.println("判断 test 是否在集合中"+collection.contains("test"));
    	//输出判断 test 是否在集合中true
    	
    	collection.remove("333");
    	System.out.println(collection);
    	//输出[哈哈, test]
    	
    	System.out.println(collection.size());  	
    	//输出2
    	
    	Object[] objects=collection.toArray();
    	for (int i = 0; i < objects.length; i++) {
			System.out.println(objects[i]);			
		}
    	//输出
    	//2
    	//哈哈
    	//test
    	
    	collection.clear();
    	System.out.println(collection);
    	//输出[]
    	System.out.println(collection.isEmpty());
    	//输出true
    	
	}

}

二、Iterator迭代器

集合是个整体，没办法像a[3]这样取值处理（目前没学到），就要用Iterator迭代器来处理

下面介绍一下迭代的概念：

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

Iterator迭代器常用方法

• public E next():返回迭代的下一个元素。
• public boolean hasNext():如果仍有元素可以迭代，则返回 true。

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

public class test9 {	
		
	public static void main(String[] args)  {
		// 创建集合对象 
    	// 使用多态形式
		//Collection<E> 变量名字=new ArrayList<E>(); 
		//ArrayList 可以换其他的
		Collection<String> collection=new ArrayList<String>();
		
		// 添加使用方法
    	collection.add("哈哈");
    	collection.add("test");
    	collection.add("333");
    	
    	Iterator<String> iterator=collection.iterator();
    	
    	while (iterator.hasNext()) {
			String string=iterator.next();
			System.out.println(string);
			
		}  	
	}
}

原理：

当遍历集合时，首先通过调用t集合的iterator()方法获得迭代器对象，然后使用hashNext()方法判断集合中是否存在下一个元素，如果存在，则调用next()方法将元素取出，否则说明已到达了集合末尾，停止遍历元素。

三、foreach

1）普通的foreach

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

public class test9 {	
		
	public static void main(String[] args)  {
		Collection<String> collection=new ArrayList<String>();
		collection.add("嘻嘻");
		collection.add("呵呵");
		collection.add("233");
		//foreach
		for (String str : collection) {//接收变量str 代表被遍历到的集合元素
			System.out.println(str);
		}
    	
	}
}

2）不同类型的集合的foreach

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

public class test9 {	
		
	public static void main(String[] args)  {
		Collection collection=new ArrayList();
		collection.add("嘻嘻");
		collection.add('c');
		collection.add(233);
		
		for (Object Object : collection) {
			System.out.println("类型："+Object.getClass().getName()+"  值："+Object);
		}
	}
}

四、泛型

1、简单例子

集合虽然可以存放任意对象，只要把对象存储集合后，那么他们都会被提升为object类型，当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。但是看下面这个例子(与Iterator接口的对比)

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

public class test9 {	
		
	public static void main(String[] args)  {
		Collection coll = new ArrayList();
		coll.add("abc");
		coll.add("itcast");
		coll.add(5);//由于集合没有做任何限定，任何类型都可以给其中存放
		Iterator it = coll.iterator();
		while(it.hasNext()){
			//需要打印每个字符串的长度,就要把迭代出来的对象转成String类型
			String str = (String) it.next();
			System.out.println(str.length());
		}
	}
}

输出

3
6
Exception in thread “main” java.lang.ClassCastException: class java.lang.Integer cannot be cast to class java.lang.String (java.lang.Integer and java.lang.String are in module java.base of loader ‘bootstrap’)
at test/test.test9.main(test9.java:24)

可以看到，虽然我们是用了强制转换，但是Collection虽然可以存储各种对象，但实际上通常Collection只存储同一类型对象。就有会这种迷之BUG产生，那么就催生了泛型的产生
所以，最标准就是泛型里面 < E > 里面写的什么，迭代器取出来的就是什么类型
其实再上面的迭代器的例子，就已经使用了泛型

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

public class test9 {	
		
	public static void main(String[] args)  {
		// 创建集合对象 
    	// 使用多态形式
		//Collection<E> 变量名字=new ArrayList<E>(); 
		//ArrayList 可以换其他的
		Collection<String> collection=new ArrayList<String>();
		
		// 添加使用方法
    	collection.add("哈哈");
    	collection.add("test");
    	collection.add("333");
    	
    	Iterator<String> iterator=collection.iterator();
    	
    	while (iterator.hasNext()) {
			String string=iterator.next();
			System.out.println(string);
			
		}  	
	}
}

这玩意就已经是泛型了，这是一个普通的基础的泛型

2、自定义泛型

当某个傻逼甲方突然要改一个对象的属性时，我们要重写很多代码，要改类型，然后函数也要改类型，但是用了自定义泛型后，可以避免这些麻烦

public class Generic<E> {
	E name;

	// 构造方法
	public Generic(E name) {
		this.name = name;
	}

	// 设置属性变量
	public void setName(E name) {
		this.name = name;
	}

	// 获得属性变量
	public E getName() {
		return name;
	}
}


public class demo1 {

	public static void main(String[] args) {
		// 创建Generic对象，泛型使用Integer类型
		Generic<Integer> gc1 = new Generic<Integer>(123);
		System.out.println(gc1.getName());

		// 创建Generic对象，泛型使用String类型
		Generic<String> gc2 = new Generic<String>("小明");
		System.out.println(gc2.getName());

	}

}

123
小明

可以看出，Generic类定义了泛型，我们可以用string或者integer类型来构造属性，用来给不确定的类使用

3、泛型方法

public class demo1 {

	public static void main(String[] args) {
		test("String");
		test(123);
		test(true);
	}

	private static <E> void test(E e) {
		// TODO 自动生成的方法存根
		System.out.println(e.getClass().getName());//输出类型
	}

}

java.lang.String
java.lang.Integer
java.lang.Boolean

4、泛型接口

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

1)接口用泛型，定义类时已经确定泛型类型

//泛型接口
public interface GenericInterface<E>{
	public abstract void getType(E e);
}

//Generic类已经确定要用String类型了
public class Generic implements GenericInterface<String>{

	@Override
	public void getType(String e) {
		// TODO 自动生成的方法存根
		System.out.println(e+" "+e.getClass().getName());
	}
	
}

public class demo1 {

	public static void main(String[] args) {
		Generic generic=new Generic();
		generic.getType("小明");
	}

}

小明 java.lang.String

2)接口用泛型，定义类时还不确定用什么类型，创建对象的时候才决定泛型类型

public interface GenericInterface<E>{
	public abstract void getType(E e);
}

public class Generic<E> implements GenericInterface<E> {

	@Override
	public void getType(E e) {
		// TODO 自动生成的方法存根
		System.out.println(e + " " + e.getClass().getName());
	}

}

public class demo1 {

	public static void main(String[] args) {
		Generic<Integer> generic=new Generic<Integer>();
		generic.getType(123);
	}

}

123 java.lang.Integer

5、泛型通配符

当使用泛型类或者接口传递数据（函数传递数据）的时候，泛型不确定，可以用通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。
泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。

package restudy;

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

public class demo1 {

	public static void main(String[] args) {
		Collection<Integer> list1 = new ArrayList<Integer>();
		list1.add(1);
		list1.add(2);
		printArr(list1);
		
		Collection<String> list2 = new ArrayList<String>();
		list2.add("小明");
		list2.add("小兰");
		printArr(list2);

	}

	//该函数要接受任意类型的泛型
	private static void printArr(Collection<?> collection) {
		//Iterator要接受的是什么类型也不知道，也可以用?通配符
		Iterator<?> iterator = collection.iterator();
		while (iterator.hasNext()) {
			Object o = iterator.next();//得到的都是object类型
			System.out.println(o + "  " + o.getClass().getName());

		}
	}

}

1 java.lang.Integer
2 java.lang.Integer
小明 java.lang.String
小兰 java.lang.String

6、受限泛型

之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。

泛型的上限：

• 格式： 类型名称 <? extends 类 > 对象名称
• 意义： 只能接收该类型及其子类

泛型的下限：

• 格式： 类型名称 <? super 类 > 对象名称
• 意义： 只能接收该类型及其父类型

已经知道继承关系：
Integer extends Number extends Object
String extends Object

package restudy;

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

public class demo1 {

	public static void main(String[] args) {
		Collection<Integer> list1 = new ArrayList<Integer>();
		Collection<String> list2 = new ArrayList<String>();
		Collection<Number> list3 = new ArrayList<Number>();
		Collection<Object> list4 = new ArrayList<Object>();

		getElement(list1);
		// getElement(list2);// 报错,因为String不是number子类
		getElement(list3);
		// getElement(list4);// 报错，因为Object是Number父类而不是子类

		// getElement2(list1);// 报错，因为Integer是Number子类不是其父类
		// getElement2(list2);// 报错，,因为String不是number父类
		getElement2(list3);
		getElement2(list4);

	}

	// 这个方法的参数必须是Number类型或者其 子 类才能使用
	private static void getElement(Collection<? extends Number> collection) {
		// TODO 自动生成的方法存根

	}

	// 这个方法的参数必须是Number类型或者其 父 类才能使用
	private static void getElement2(Collection<? super Number> collection) {
		// TODO 自动生成的方法存根

	}

}