集合、迭代器、泛型：

集合：

　　我们为什么要学集合呢?主要是有很多时候我们程序在开发阶段，我们根本不知道到底需要多少个数量的对象，甚至不知道准确类型。这时候我们通常可以用集合来解决以上出现的情况。

　　数组跟集合的区别，首先数组里的元素类型是同意的，长度也是固定的。而集合里的元素是可以是多个类型的，数量长度也是不限的。

　　除了 map 系列的集合，大部分集合都实现了 Iterator 接口，这是一个用于遍历集合中元素的接口，主要hashNext(),next(),remove()三种方法。它的一个子接口 ListIterator 在它的基础上又添加了三种方法，分别是 add(),previous(),hasPrevious()。也就是说如果实现 Iterator 接口，那么在遍历集合中元素的时候，只能往后遍历，被遍历后的元素不会再被遍历到，通常无序集合实现的都是这个接口，比如HashSet；而那些元素有序的集合，实现的一般都是 LinkedIterator接口，实现这个接口的集合可以双向遍历，既可以通过next()访问下一个元素，又可以通过previous()访问前一个 元素，比如ArrayList。

　　抽象类的使用，如果要自己实现一个集合类，去实现那些抽象的接口会非常麻烦，工作量很大。这个时候就可以使用抽象类，这些抽象类中给我们提供了许多现成的实现，我们只需要根据自己的需求重写一些方法或者添加一些方法就可以实现自己需要的集合类，工作量大大降低。

下面想一些遍历集合的用法：

//向List集合中添加元素
List<String> list=["老五"];
//从List集合中获取元素
String item=list[0]; 
​
//向Set集合对象中添加元素
Set<String> set={"老五"}; 
​
//向Map集合中添加对象
Map<String,Integer> map={"老六":1}; 
//从Map集合中获取对象
int value=map["老六"]; 

迭代器：

作用：提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示。

主要解决：

1、不同的方式来遍历整个整合对象。

2、访问一个聚合对象的内容而无须暴露它的内部表示。

3、为遍历不同的聚合结构提供一个统一的接口。

何时使用：遍历一个聚合对象。

解决：把在元素之间游走的责任交给迭代器，而不是聚合对象。

关键代码：定义接口：hasNext, next。

优点：

1、它支持以不同的方式遍历一个聚合对象。

2、迭代器简化了聚合类。

3、在同一个聚合上可以有多个遍历。

4、在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。

缺点：

由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。

下面是一个简单的使用迭代器遍历集合：

public static void main(String[] args) {
//创建集合对象
Collection c = new ArrayList();
//添加元素
​
c.add(new Student("老五", 17));
c.add(new Student("老六", 18));
c.add(new Student("老七", 19));
//构造迭代器
Iterator it=c.iterator();
//使用迭代器遍历元素
while (it.hasNext()) {
Student s = (Student) it.next();
System.out.println(s.getName()+" 学号 ："+s.getId());
}
}

以上代码你会发现会有很多警告，这样子我们的代码安全隐患就很大了，如果要消除警告我们就需要 用到泛型。

泛型：

什么是泛型呢？泛型就是“参数化类型”，泛型是一种独立的技术，是JDK1.5之后引入的新特性，是一种将元素的数据类型在编译时就确定元素的类型，一旦确定类型，泛型相关的类、接口和方法所有的类型都会被统一。

泛型的作用：

1、可以解决安全隐患问题，如果集合存储的是任意类型，那么我们必须对Object的所有之类进行判断，这样的话安全隐患就永远存在。

2、如果我们添加一个新的不同类型的元素，那么就不能完全遍历完。

泛型格式：

<T> 这里的 T 可以说其它大写字母，但是必须是引用类型，如果是基本类型必须存放包装类类型。

一般的泛型分类：

泛型类、泛型接口、泛型方法

泛型类：

public class FanXing {
public static void main(String[] args) {
//确定泛型类型，下面我们确定的泛型类型String、Inteher，如果多加另外一个类型就就会出现报错
        GenericMy<String, Integer> g = new GenericMy<String, Integer>();
g.setE("老五");
System.out.println(g.getE());
g.setT(17);
System.out.println(g.getT());
}
}
//定义泛型类
class GenericMy<E,T> {
private E e;
private T t;
public E getE() {
return e;
}
public void setE(E e) {
this.e = e;
}
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}

以上一个普通泛型类的运用。

泛型接口：

代码格式：[访问权限]<泛型标示> 泛型标示 方法名称([泛型标示 参数名称])

public class GenercInterface {
public static void main(String[] args) {
GenercIn<String> gi =new GenercInImpl();
String s = gi.getAbc();
System.out.println(s);
}
}
//在接口上定义泛型
interface GenercIn<E>{
public E getAbc() ;
}
//实现接口
class GenercInImpl implements GenercIn<String> {
private String s = "您好！";
@Override
public String getAbc() {
return s;
}
public void set(String e) {
this.s= e;
}
}

上面代码就是泛型接口代码

泛型方法如下：

public static void main(String[] args) {
//创建对象
GenercFangFa<String> gff =new GenercFangFa<String>();
//调用泛型方法
gff.scc("老五",18);
System.out.println();
//调用泛型方法
gff.scc(17,17.5);
System.out.println();
}

}
//定义泛型类
class GenercFangFa<T> {
private T t;
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
//定义泛型方法
public <E,K> void scc(E e,K k) {
System.out.println(e);
System.out.println(k);
}
}

以上泛型方法，在我们调用泛型方法时才会确定类型，非常的灵活。同时泛型的参数可以有多个类型。

集合：

　　我们为什么要学集合呢?主要是有很多时候我们程序在开发阶段，我们根本不知道到底需要多少个数量的对象，甚至不知道准确类型。这时候我们通常可以用集合来解决以上出现的情况。

　　数组跟集合的区别，首先数组里的元素类型是同意的，长度也是固定的。而集合里的元素是可以是多个类型的，数量长度也是不限的。

　　除了 map 系列的集合，大部分集合都实现了 Iterator 接口，这是一个用于遍历集合中元素的接口，主要hashNext(),next(),remove()三种方法。它的一个子接口 ListIterator 在它的基础上又添加了三种方法，分别是 add(),previous(),hasPrevious()。也就是说如果实现 Iterator 接口，那么在遍历集合中元素的时候，只能往后遍历，被遍历后的元素不会再被遍历到，通常无序集合实现的都是这个接口，比如HashSet；而那些元素有序的集合，实现的一般都是 LinkedIterator接口，实现这个接口的集合可以双向遍历，既可以通过next()访问下一个元素，又可以通过previous()访问前一个 元素，比如ArrayList。

　　抽象类的使用，如果要自己实现一个集合类，去实现那些抽象的接口会非常麻烦，工作量很大。这个时候就可以使用抽象类，这些抽象类中给我们提供了许多现成的实现，我们只需要根据自己的需求重写一些方法或者添加一些方法就可以实现自己需要的集合类，工作量大大降低。

下面想一些遍历集合的用法：

//向List集合中添加元素
List<String> list=["老五"];
//从List集合中获取元素
String item=list[0]; 
​
//向Set集合对象中添加元素
Set<String> set={"老五"}; 
​
//向Map集合中添加对象
Map<String,Integer> map={"老六":1}; 
//从Map集合中获取对象
int value=map["老六"]; 

迭代器：

作用：提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示。

主要解决：

1、不同的方式来遍历整个整合对象。

2、访问一个聚合对象的内容而无须暴露它的内部表示。

3、为遍历不同的聚合结构提供一个统一的接口。

何时使用：遍历一个聚合对象。

解决：把在元素之间游走的责任交给迭代器，而不是聚合对象。

关键代码：定义接口：hasNext, next。

优点：

1、它支持以不同的方式遍历一个聚合对象。

2、迭代器简化了聚合类。

3、在同一个聚合上可以有多个遍历。

4、在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。

缺点：

由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。

下面是一个简单的使用迭代器遍历集合：

public static void main(String[] args) {
//创建集合对象
Collection c = new ArrayList();
//添加元素
​
c.add(new Student("老五", 17));
c.add(new Student("老六", 18));
c.add(new Student("老七", 19));
//构造迭代器
Iterator it=c.iterator();
//使用迭代器遍历元素
while (it.hasNext()) {
Student s = (Student) it.next();
System.out.println(s.getName()+" 学号 ："+s.getId());
}
}

以上代码你会发现会有很多警告，这样子我们的代码安全隐患就很大了，如果要消除警告我们就需要 用到泛型。

泛型：

什么是泛型呢？泛型就是“参数化类型”，泛型是一种独立的技术，是JDK1.5之后引入的新特性，是一种将元素的数据类型在编译时就确定元素的类型，一旦确定类型，泛型相关的类、接口和方法所有的类型都会被统一。

泛型的作用：

1、可以解决安全隐患问题，如果集合存储的是任意类型，那么我们必须对Object的所有之类进行判断，这样的话安全隐患就永远存在。

2、如果我们添加一个新的不同类型的元素，那么就不能完全遍历完。

泛型格式：

<T> 这里的 T 可以说其它大写字母，但是必须是引用类型，如果是基本类型必须存放包装类类型。

一般的泛型分类：

泛型类、泛型接口、泛型方法

泛型类：

public class FanXing {
public static void main(String[] args) {
//确定泛型类型，下面我们确定的泛型类型String、Inteher，如果多加另外一个类型就就会出现报错
        GenericMy<String, Integer> g = new GenericMy<String, Integer>();
g.setE("老五");
System.out.println(g.getE());
g.setT(17);
System.out.println(g.getT());
}
}
//定义泛型类
class GenericMy<E,T> {
private E e;
private T t;
public E getE() {
return e;
}
public void setE(E e) {
this.e = e;
}
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}

以上一个普通泛型类的运用。

泛型接口：

代码格式：[访问权限]<泛型标示> 泛型标示 方法名称([泛型标示 参数名称])

public class GenercInterface {
public static void main(String[] args) {
GenercIn<String> gi =new GenercInImpl();
String s = gi.getAbc();
System.out.println(s);
}
}
//在接口上定义泛型
interface GenercIn<E>{
public E getAbc() ;
}
//实现接口
class GenercInImpl implements GenercIn<String> {
private String s = "您好！";
@Override
public String getAbc() {
return s;
}
public void set(String e) {
this.s= e;
}
}

上面代码就是泛型接口代码

泛型方法如下：

public static void main(String[] args) {
//创建对象
GenercFangFa<String> gff =new GenercFangFa<String>();
//调用泛型方法
gff.scc("老五",18);
System.out.println();
//调用泛型方法
gff.scc(17,17.5);
System.out.println();
}

}
//定义泛型类
class GenercFangFa<T> {
private T t;
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
//定义泛型方法
public <E,K> void scc(E e,K k) {
System.out.println(e);
System.out.println(k);
}
}

以上泛型方法，在我们调用泛型方法时才会确定类型，非常的灵活。同时泛型的参数可以有多个类型。