JAVA15 集合的概念、Collection接口、泛型相关、迭代器使用

集合

集合的概念
集合：就是一个存储数据的容器。
集合与数组一样，也是一个容器，与数组的区别：
1 数组长度固定，集合的长度不固定。
2 数组可以存储基本类型和引用类型，集合中存储的元素类型只能是引用类型。
集合的框架结构介绍

集合与数组的对比
相同点：
都是数据的容器，在一个数组或集合中可以存储多个数据
不同点：
元素：数组中的元素只能是相同，集合中的元素是任意的（泛型）
数组中可以存储基本类型和引用类型，集合只能存储引用类型
长度(元素个数)：
数组是定长的，一旦初始化长度就不可以修改
集合长度可以修改，可以删除元素和添加元素

Collection接口

Collection中常用的方法

//1创建Collection对象
		Collection collection=new ArrayList();
		//2操作
		//2.1添加
		collection.add("张三");
		collection.add("李四");
		collection.add("他二大爷");
		collection.add("他老爷");
		collection.add("七大妈");
		collection.add("张三");
		System.out.println("集合的元素个数:"+collection.size());
		//2.2删除
		//2.2.1删除一个
//		collection.remove("张三");
//		System.out.println("删除之后的数据个数:"+collection.size());
		//2.2.2清空
//		collection.clear();
//		System.out.println("清空之后:"+collection.size());
		
		
		//4判断
		//4.1判断是否存在
		boolean b=collection.contains("王五");
		boolean b2=collection.contains("他老爷");
		System.out.println(b);
		System.out.println(b2);
		//4.2判断是否为空
		System.out.println(collection.isEmpty());
	
		//5查找
		
		//6其他方法
		Collection c1=new ArrayList();
		c1.add("中国");
		c1.add("朝鲜");
		Collection c2=new ArrayList();
		c2.add("中国");
		c2.add("朝鲜");
		System.out.println("c1.equals(c2):"+c1.equals(c2));
		System.out.println("c1==c2:"+(c1==c2));
			Collection collection=new ArrayList();
		//1添加
		collection.add(111);//111自动装箱 new Integer(111)
		collection.add(222);
		collection.add("111");
		collection.add("222");
		//2删除
		System.out.println("元素的个数:"+collection.size());
		System.out.println("删除之前:"+collection);
		collection.remove("111");
		System.out.println("删除之后:"+collection.size());
		System.out.println("删除之后:"+collection);

泛型

什么是泛型
泛型就是可以表示一个广泛数据类型的类型参数（泛型只能表示引用类型）,把数据类型作为参数来传递。
形式参数：声明方法时，在方法的参数列表中声明，而且在方法体中会使用到，是一个未知的数据。
实际参数：调用方法时，实际传递的参数。
类型参数：在一个类中声明一个未知的数据类型，在类中可以使用这个类型，但是具体类型取决于实例化时传入的实际类型。
泛型的声明
1）泛型可以声明在类中：（泛型类）
注意：
1 ：<>表示泛型,E(Element)表示占位符代替一个数据类型 ,其他的名称T(Type) V(Value) K(Key)
2 可以写多个泛型参数，如果写多个中间用逗号隔开

public class 类名<标识符>{
	//类体
	//泛型可以在类中充当成员变量
	//泛型可以再类中充当方法的返回值
	//泛型可以在类中充当方法的参数
}

2）泛型可以声明在方法中：(泛型方法)

public static <标识符> void fun(){}

3）泛型可以声明在接口中：（泛型接口）

public interface 接口名<标识符>{
	
	//泛型可以充当接口中方法的返回值
	//泛型可以充当接口中方法的参数
}

案例1：

package com.qf.day15_2;
/**
 * 老师类
 * 泛型类
 * T 占位符:表示未知的数据类型
 * @author wgy
 *
 */
public class Teacher<T>{
	String name;
	int age;
	int workyear;
	T t;
	
	public void show() {
		System.out.println("姓名:"+name+" 年龄:"+age+" 工作年限:"+workyear+"  t:"+t);
	}
}

案例2：

package com.qf.day15_2;
/**
 * 学生类
 * @author wgy
 *
 */
public class Student {
	String name;
	int age;
	
	public void show(String s) {
		System.out.println("姓名:"+name+" 年龄:"+age+"   "+s);
	}
	
	/**
	 * 泛型方法  
	 * T 占位符  表示一种未知的数据类型
	 * T type
	 * E
	 * K
	 * V
	 */
	public <T> void fun(T t) {
		System.out.println(t);
	}
}

案例3：

package com.qf.day15_2;
/**
 * 接口
 * 泛型的
 * @author wgy
 *
 */
public interface MyCollection<T> {
	void add(T t);
	void remove(T t);
	T get();
}


package com.qf.day15_2;

public class MyArray<T> implements MyCollection<T>{

	@Override
	public void add(T t) {
		// TODO Auto-generated method stub
		System.out.println("添加了:"+t);
	}

	@Override
	public void remove(T t) {
		// TODO Auto-generated method stub
		System.out.println("删除了:"+t);
	}

	@Override
	public T get() {
		// TODO Auto-generated method stub
		return null;
	}

}

案例4

package com.qf.day15_3;

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

import javax.net.ssl.SSLContext;

public class Demo1 {
	public static void main(String[] args) {
		//创建泛型对象  元素类型String
		Collection<String> coll=new ArrayList<String>();
		//1添加
		coll.add("苹果");
		coll.add("桔子");
		coll.add("芒果");
		coll.add("西瓜");
		System.out.println("元素个数:"+coll.size());
		System.out.println(coll);
		//2删除
//		coll.remove("苹果");
//		System.out.println("删除之后");
//		System.out.println(coll);
		//3遍历
		//3.1增强for
		System.out.println("---------增强for--------");
		for(String s:coll) {
			System.out.println(s);
		}
		System.out.println("---------迭代器--------");
		Iterator<String> it=coll.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		
	}
}

说明
1）标识符(占位符)：只要是一个合法的标识符即可，一般情况下，只使用一个大写字母表示泛型
例：public class Person{} E(Element) K(key) V(value)
2）泛型的类型与声明的类或接口不需要有任何的关系
3）泛型可以在类中充当任何的成员
4）泛型具体类型取决于实例化对象时传入的实际类型

泛型使用时的注意事项
1）泛型不能在类中声明静态属性、常量
final修饰的属性必须在声明的同时初始化，所以泛型不能声明常量。
static修饰的属性是静态属性，先于对象，泛型类型取决于创建对象时传入的实际类型，所以泛型不能声明静态属性
综上所述：不能使用泛型声明静态属性、常量

2）泛型不能在类中初始化数组，但是可以声明数组
初始化数组时需要给元素进行分配空间,但是泛型类型不确定无法分配空间

3）在类中不能使用泛型声明参数个数相同的重载方法
当一个类中有两个泛型时，创建对象时，两个泛型使用相同类型替换，那么重载方法就是相同的方法（同名，参数列表也相同）

4）使用不同实际类型创建出的泛型类对象的引用不可以相互赋值

受限泛型
1）<?>：表示任意类型
2）<? extends T>：表示T类或者T类的子类
3）<? super T>：表示T类或者T类的父类

泛型应用在集合上
泛型在集合中应用，表示的是集合中元素的类型

迭代器

迭代器的工作原理
迭代器相当于一个游标，最初获取迭代器时，迭代器的位置在所有元素的前面，每迭代一个元素，迭代器向后移动一个位置
迭代器的使用

//第三种遍历的方法
		Iterator<Student> i=list.iterator();
		//hasNext,有没有下一个值
		while(i.hasNext()){
			//i.next（）返回的是对象，而且没执行一次，指针就会向下走一次
			System.out.println(i.next().toString());
			
		}	

注意点：
1.每次迭代获取前(调用next())，应该判断是否有这个元素（hasNext()），如果有再获取，如果没有救不要获取，如果强行获取，就报错：java.util.NoSuchElementException
2.迭代器在工作期间,集合本身就不要去更改集合的结构。但是迭代器对象自己可以删除。（功能慎用）