泛型
package com.oracle.demo01;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Demo01 {
public static void main(String[] args) {
Map<String, String> map=new HashMap<>();
map.put("欣欣", "萌萌");
map.put("萌萌", "欣欣");
map.put("小欣", "小萌");
Set<String> set1=map.keySet();
Iterator<String> it=set1.iterator();
while (it.hasNext()) {
String key=it.next();
String value=map.get(key);
System.out.println(key+" "+value);
}
}
}
运行结果：
1.1 泛型通配符
泛型是在限定数据类型，当在集合或者其他地方使用到泛型后，那么这时一旦明确泛型的数据类型，那么在使用的时候只能给其传递和数据类型匹配的类型，否则就会报错。
调用方法：
Collection<Student> list = new ArrayList<Student>();
printCollection(list);
实现了可迭代任意元素类型集合的方法
public static void printCollection(Collection<?> list) {
Iterator<?> it = list.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
总结：
当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。
1.2 泛型限定
限定泛型的上限：
格式：? extends E
? 代表接收E类型或者E的子类型的元素
例如，泛型限定为：? extends Person
则 ? 代表接收Person类型或者Person子类型的元素
限定泛型的下限：
格式：? super E
? 代表接收E类型或者E的父类型的元素
例子：修改下面的方法，使该方法可以打印学生和工人的集合
class Student extends Person{ }
class Worker extends Person{ }
public static void printCollection(Collection<?> list) {
Iterator<?> it = list.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}}
找到学生和工人的共性类型Person。那么，泛型的限定可以这样书写：
? extends Person : 接收Person类型或者Person的子类型。修改方法如下：
public static void printCollection(Collection<? extends Person> list) {
Iterator<? extends Person> it = list.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
package com.oracle.arraylist;
public class Emp {
private String name;
private int 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;
}
}
package com.oracle.arraylist;
public class Chushi extends Emp {
}
package com.oracle.arraylist;
public class FuWuYuan extends Emp {
}
package com.oracle.arraylist;
public class Manager extends Emp{
}
package com.oracle.arraylist;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
public class Test {
public static void main(String[] args) {
ArrayList<Chushi> arr=new ArrayList<Chushi>();
HashSet<FuWuYuan> set=new HashSet<FuWuYuan>();
ArrayList<Manager> arr2=new ArrayList<Manager>();
}
//写一个通用方法来遍历这三个集合
//泛型没有多态这一说法<E> E
//泛型限定符 ?
public static void get(Collection<? extends Emp> coll){
}
}
List接口
Collection中的常用几个子类（List集合、Set集合）
2.1 List接口介绍
有序的 collection（也称为序列）用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。与 set 不同，列表通常允许重复的元素。
总结：
List接口：
- 1. 是一个元素存取有序的集合
- 2. 是一个带有索引(下标)的集合，通过索引就可以精确的操作集合中的元素
- 3. 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素
List接口的常用子类有：
ArrayList集合
LinkedList集合
2.2 List接口中常用的方法
增加元素方法
add(Object e)：向集合末尾处，添加指定的元素
add(int index, Object e)：向集合指定索引处，添加指定的元素，原有元素依次后移
删除元素删除
remove(Object e)：将指定元素对象，从集合中删除，返回值为被删除的元素
remove(int index)：将指定索引处的元素，从集合中删除，返回值为被删除的元素
替换元素方法
set(int index, Object e)：将指定索引处的元素，替换成指定的元素，返回值为替换前的元素
查询元素方法
get(int index)：获取指定索引处的元素，并返回该元素
package com.oracle.List;
import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
public class Demo01 {
public static void main(String[] args) {
List<String> list=new ArrayList<String>();
list.add("a");
list.add("b");
list.add("c");
list.add(1,"e");
//遍历
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
//删除指定位置上的元素
list.remove(0);//0为下标
System.out.println("=========");
//遍历
for(String i : list){
System.out.println(i);
}
System.out.println("======================");
//修改指定位置上的元素
list.set(1, "你好吗？");
Iterator<String> it=list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
运行结果:
2.2.1 Iterator的并发修改异常
并发修改异常解决办法：在迭代时，不要使用集合的方法操作元素。
那么想要在迭代时对元素操作咋办？通过ListIterator迭代器操作元素是可以的，ListIterator的出现，解决了使用Iterator迭代过程中可能会发生的错误情况。
2.3 List集合存储数据的结构
堆栈，采用该结构的集合，对元素的存取有如下的特点：
先进后出（即，存进去的元素，要在它后面的元素依次取出后，才能取出该元素）。例如，子弹压进弹夹，先压进去的子弹在下面，后压进去的子弹在上面，当开枪时，先弹出上面的子弹，然后才能弹出下面的子弹。
栈的入口、出口的都是栈的顶端位置
压栈：就是存元素。即，把元素存储到栈的顶端位置，栈中已有元素依次向栈底方向移动一个位置。
弹栈：就是取元素。即，把栈的顶端位置元素取出，栈中已有元素依次向栈顶方向移动一个位置。
特点：先进后出
队列，采用该结构的集合，对元素的存取有如下的特点：
先进先出（即，存进去的元素，要在后它前面的元素依次取出后，才能取出该元素）。例如，安检。排成一列，每个人依次检查，只有前面的人全部检查完毕后，才能排到当前的人进行检查。
队列的入口、出口各占一侧。例如，下图中的左侧为入口，右侧为出口。
数组，采用该结构的集合，对元素的存取有如下的特点：
查找元素快：通过索引，可以快速访问指定位置的元素
增删元素慢：
指定索引位置增加元素：需要创建一个新数组，将指定新元素存储在指定索引位置，再把原数组元素根据索引，复制到新数组对应索引的位置。如下图
指定索引位置删除元素：需要创建一个新数组，把原数组元素根据索引，复制到新数组对应索引的位置，原数组中指定索引位置元素不复制到新数组中。如下图
链表，采用该结构的集合，对元素的存取有如下的特点：
多个节点之间，通过地址进行连接。例如，多个人手拉手，每个人使用自己的右手拉住下个人的左手，依次类推，这样多个人就连在一起了。
查找元素慢：想查找某个元素，需要通过连接的节点，依次向后查找指定元素
增删元素快：
增加元素：操作如左图，只需要修改连接下个元素的地址即可。
删除元素：操作如右图，只需要修改连接下个元素的地址即可。
2.4 ArrayList集合
arrayList集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。
LinkedList集合(list的子接口)
LinkedList集合数据存储的结构是链表结构。方便元素添加、删除的集合。实际开发中对一个集合元素的添加与删除经常涉及到首尾操作，而LinkedList提供了大量首尾操作的方法。
2.5 Vector集合（枚举Enumeration）
Vector集合数据存储的结构是数组结构，Vector中提供了一个独特的取出方式，就是枚举Enumeration，它其实就是早期的迭代器Vector集合已被ArrayList替代
Vector常见的方法：
Enumeration枚举常见的方法：
Vector集合对ArrayList集合使用的对比
