Java泛型、List接口整理

泛型

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. 1.         是一个元素存取有序的集合
2. 2.         是一个带有索引(下标)的集合，通过索引就可以精确的操作集合中的元素
3. 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集合使用的对比