泛型与集合

泛型：

概述：泛型是带一个或多个类型参数的类或接口。（通过使用泛型我们就不用为每一种类型的数据写一个方法了。）

常用的类型参数名：E（表示元素）、K（表示键）、N（表示数字）、T（表示类型）、V（表示值）等。

定义格式：

修饰符 class 类名<代表泛型的变量> { }

例1： ArrayList集合（API）：

class ArrayList {

​ public boolean add(E e){

​ // 代码

​ }

​ public E get(int index){

​ }

}

例2： ArrayList list = new ArrayList();

class ArrayList{

​ public boolean add(String e){}

​ public String get(int index){}

}

泛型通配符：

泛型类型本身是一个Java类型，
当使用泛型接口或者泛型类时（例如List和ArrayList），传递的数据中，泛型类型不确定，可以通过通配符<?>表示，但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用

例：（遍历）

public void test(List<?> list){
for(int i = 0; i < list.size(); i++){
System.out.pritnln(list.get(i));
}
}
【因为不知道集合中元素的具体类型，只能使用<?>通配符表示，任意的java类都可以匹配。】

集合框架：

集合（Collection）是java中提供的一种容器，可以用来存储多个数据。

所有的集合框架都包含如下内容：（下图由网络搜索出）

接口：是代表集合的抽象数据类型，例如：Collection、List、Set、Map等。之所以定义多个接口，是为了以不同的方式操作集合对象。

实现(类)：是集合接口的具体实现，从本质上讲，它们是可重复使用的数据结构，例如：ArrayList,LinkedList,HashSet,HashMap.

算法：是实现集合接口的对象里的方法执行的一些有用的计算，例如搜索和排序，这些算法被称为多态

java的集合框架主要包含两种类型的容器，一种是集合(Collection),存储一个元素集合，另一种是图(Map),存储键值对映射。Collection接口又有三种子类型，List,Set和Queue,再下面是一些抽象类，然后是具体实现类，常用的有ArrayList,LinkedList,HashSet,LinkedHashSet等等。
基本操作：（书p216）

boolean add(E e):向 集合中添加元素e；

boolean remove(Object o):从集合中删除指定的元素；

boolean contains(Object o）: 返回集合中是否包含指定元素o；

boolean isEmpty(): 返回集合是否为空，即不包含元素；
int size(): 返回集合中包含的元素个数。
Iterator iterator（）：返回包含所有元素的迭代器对象；

default void forEach（Consumer<?super T>action）：从父接口继承的方法，在集合的每个元素上执行指定的操作。

例：

import java.util.ArrayList;

import java.util.Collection;

public class Demo1Collection {

public static void main(String[] args) {

Collection c = new ArrayList();

c.add("他");

c.add("她");

c.add("它");

System.out.println(c);

System.out.println("判断 他 是否在集合中"+c.contains("他"));

System.out.println("删除她："+c.remove("她"));

System.out.println("操作之后集合中元素:"+c);

System.out.println("集合中有"+c.size()+"个元素");

Object[] objects = c.toArray();

for (int i = 0; i < objects.length; i++) {

System.out.println(objects[i]);

}

c.clear();

System.out.println("集合中内容为："+c);

System.out.println(c.isEmpty());

}

}

List接口：（collection子接口）

特点：是有序的集合，集合中每个元素都有对应的顺序序列。

List接口中常用子类：

ArrayList：最常用的线性表实现类，通过数组实现的集合对象；

                 构造方法【ArrayList();    ArrayList(Collection c);   ArrayList(int initialCapacity)】

LinkedList：底层的数据结构是链表，增删速度快。取出List集合中元素的方式：

Vector: 底层的数据结构就是数组，与ArrayList相同，不同点：线程安全，默认大小10，每次扩充1倍，Vector无论查询和增删都巨慢。（还有Stack）

List遍历方式：

// 创建集合对象
List<String> arrayList = new ArrayList<String>();
// 往集合的指定位置上添加给定的元素
arrayList.add(0, "a");
arrayList.add(1, "b");
arrayList.add(2, "c");
arrayList.add("d");
// 第一种遍历方式
for (int i = 0; i < arrayList.size(); i++) {
System.out.println(arrayList.get(i));
}
// 第二种遍历方式
for (String arr : arrayList) {
System.out.println(arr);
}
// 第三种遍历
Iterator<String> iter = arrayList.iterator();
while (iter.hasNext()) {
String s = (String) iter.next();
System.out.println(s);
}

Set接口（无序，元素不可重复）

Collection子接口，Set无法记住添加的顺序，不允许包含重复的元素。

常用子类：

HashSet：散列存放无序，每次重新散列;

               构造方法【HashSet();  HashSet(Collection c);  HshSet(int initialCapacity);  HashSet(int initialCapacity,float loadFactor)】

TreeSet：不允许存储重复值，可排序，实现一种树集合（红-黑树）

LinkedHashSet：有序存放，带链表的

Set遍历方式：

public static void main(String[] args) {
Set<String> s = new HashSet<String>();
s.add("fff");
s.add("jkl");
s.add("eric");
s.add("loc");
s.add("hy");
s.add("tes");
System.out.println("第一种遍历方式");
Frist(s);
System.out.println("第二种遍历方式1");
Second1(s);
System.out.println("第一种遍历方式2");
Second2(s);
System.out.println("第一种遍历方式3");
Second3(s);

}
private static void Second3(Set<String> s) {
// 第三种情况：自己创建的数组大于集合元素的个数，这样会把前几个位置填充，剩下的返回null。
String[] ss = new String[10];
s.toArray(ss);
for (int i = 0; i < ss.length; i++) {
System.out.print(ss[i] + " ");
}
}
private static void Second2(Set<String> s) {
// 第二种情况：自己创建的数组大小正好等于集合的元素个数，这样就不用创建新的数组，返回的和创建的是同一个数组。
String[] ss = new String[6];
s.toArray(ss);
for (int i = 0; i < ss.length; i++) {
System.out.print(ss[i] + " ");
}
}

private static void Second1(Set<String> s) {
// 第二种遍历方式，含泛型的数组
// 第一种情况，自己创建的数组大小<小于集合的元素个数，这种情况会在集合内部产生一个新的数组，将之返回
String[] ss = new String[2];
String[] i1 = s.toArray(ss);
for (int i = 0; i < ss.length; i++) {
System.out.print(ss[i] + " ");
}
System.out.println("\n" + Arrays.toString(i1));
}

private static void Frist(Set<String> s) {
// 第一种遍历方式：
Object[] o = s.toArray();
for (int i = 0; i < o.length; i++) {
System.out.print(o[i] + " ");
}
System.out.println();
}

Map集合（键值对）

Map接口存储一组成对的键（key）-值（value）对象，key要求不允许重复，可无序，value允许重复，也可无序。HahMap是其最常用的实现类。

实现类：

HashMap:【HashMap();  HshMap(int initialCapacity);   HashMap(Map m) 】

TreeMap:【TreeMap();  TreeMap(int initialCapacity);   TreeMap(Map m) 】

注意：

1). 数据添加到HashMap集合后，所有数据类型将转换成Object类型，所有从其中获取数据时需要进行强制类型转换

2).HashMap不保证映射的顺序，特别是不保证顺序恒久不变。

Map 遍历：

Map<String, Object> map = new HashMap<String, Object>();
map.put("name", "小王");
map.put("sex", "女");
map.put("age", "18");
map.put("phone", "11111111111111");

//第一种遍历方式：在for循环中使用entries实现Map的遍历
for(Map.Entry<String, Object> entry : map.entrySet()){
String mapKey = entry.getKey();
Object mapValue = entry.getValue();
System.out.println(mapKey+":"+mapValue);
}

//第二种遍历方式：在for循环中遍历key或者values，
//一般适用于只需要map中的key或者value时使用，在性能上比使用entrySet较好
//key
for(String key : map.keySet()){
System.out.println(key);
}
//value
for(Object value : map.values()){
System.out.println(value);
}

//第三种遍历方式：通过Iterator遍历
Iterator<Entry<String, Object>> entries = map.entrySet().iterator();
while(entries.hasNext()){
Entry<String, Object> entry = entries.next();
String key = entry.getKey();
Object value = entry.getValue();
System.out.println(key+":"+value);
}

//第四种遍历方式：通过键找值遍历，这种方式的效率比较低，因为本身从键取值是耗时的操作
for(String key : map.keySet()){
Object value = map.get(key);
System.out.println(key+":"+value);
}