集合框架

集合框架

集合框架的三大类接口分别是List、Set、Map

一、Collection接口

Collection接口的子类是List接口和Set接口。

boolean add(Object o) ：向集合中添加元素

void clear()：清除集合中的所有元素

boolean isEmpty() ：判断集合是否为空

boolean contains(Object o) ： 判断集合中是否持有特定对象的引用

Iterartor iterator() ：返回一个Iterator对象，可以用来遍历集合中的元素

boolean remove(Object o) ：从集合中删除元素

int size() ：返回集合中元素的数目

Object[] toArray() ： 返回一个数组，该数组中包括集合中的所有元素

关于：Iterator() 和toArray() 方法都用于集合的所有的元素，前者返回一个Iterator对象，后者返回一个包含集合中所有元素的数组。

Collection没有get()方法来取得某个元素。只能通过iterator()遍历元素。

二、List接口

1.ArrayList

①存储一组可以重复、有序的集合；在堆里面开辟了一段连续的空间。

②创建对象：ArrayList list = new ArrayList();或者ArrayList<数据类型> list = new ArrayList<数据类型>();

③List接口中定义的各种常用方法

方法名称	说明
boolean add(Object o)	添加元素
void add(int index,Object o)	指定下标添加元素，下标必须存在
int size()	返回列表中的元素个数
Object get(int index)	返回指定下标位置处的元素，注意：取出的元素是Object类型，使用前需要进行强制类型转换
boolean contains(Object o)	判断列表中是否存在指定元素
boolean remove(Object o)	从列表中删除元素
Object remove(int index)	从列表中删除指定位置元素，起始下标位置从0开始

区别C#：删除指定下标用RemoveAt，删除指定值用Remove；在Java中删除值和下标都用remove方法，通过参数类型区分。

④遍历

//使用for循环
for (String i = 0; i < list.size(); i++) { 
	System.out.println(list.get(i));
}
//使用foreach
for (String num : list) {
	System.out.println(num);
}
//迭代器
//请继续看下文

2.LinkedList

①存储一组可以重复、有序的集合；特点：采用链式存储规则。

②创建对象：LinkedList list =new LinkedList();或者LinkedList <数据类型>list =new LinkedList <数据类型>();

③ArrayList有的方法LinkedList都有，并且操作一致。

LinkedList特有的方法：

方法名称	说明
void addFirst(Object o)	在列表的首部添加元素
void addLast(Object o)	在列表的末尾添加元素
Object getFirst()	返回列表中的第一个元素
Object getLast()	返回列表中的最后一个元素
Object removeFirst()	删除并返回列表中的第一个元素
Object removeLast()	删除并返回列表中的最后一个元素

④遍历

//使用for循环
for (String i = 0; i < list.size(); i++) {     
    System.out.println(list.get(i));
}
//使用foreach
for (String num : list) {    
    System.out.println(num);
}
//迭代器
//请继续看下文

3.ArrayList和LinkedList的区别

①相同点：实现List接口的类常用的是ArrayList和LinkedList，所以存储的数据都是有序、可以重复的。

②不同点:LinkedList在ArrayList的基础上增加了更多的方法，比如addFrist()、addLast()更加方便的从头部和尾

进行添加或者删除元素，LinkedList是双链列表，所以在插入元素或者删除元素这个方面LinkedList的性能

ArrayList的性能要好。

4.Vector

所有的操作跟ArrayList一样，存储方式、读写方式。

区别：ArrayList:Vector线程是安全的，ArrayList线程不安全。

Vector<Integer> veList = new Vector<Integer>(); 
veList.add(1); //存  
veList.get(0); //取，下标
		
ArrayList<Integer> aList = new ArrayList<Integer>(); 
aList.add(1);
aList.add(1);
aList.add(1);
for (int i = 0; i < aList.size(); i++) {
	System.out.println(aList.get(i));
}
for(int num : aList) {
	System.out.println(num);
}
Iterator<Integer> it = aList.iterator();
while(it.hasNext()) {
	System.out.println(it.next());
}

二、迭代器Iterator

使用迭代器遍历的步骤：

1、先将list对象转换为Iterator对象

Iterator<数据类型> it = list.iterator();

2、通过Iterator对象的hasNext方法判断是否有一个值

3 、通过Iterator对象的next方法取值

//使用迭代器遍历list集合
import java.util.Iterator;  //导包
Iterator it = list.iterator();
while(it.hasNext()){
    System.out.println(it.next());
}

三、Set接口

1.HashSet

①存储一组不可以重复、无序的集合；存储方式类似数组，插入数据没有顺序。

②创建对象：HashSet<数据类型> hashSet = new HashSet<数据类型>();或者HashSethashSet = new HashSet();

③继承父接口，没有独有的方法。

HashSet<Integer> hashSet = new HashSet<Integer>();
hashSet.add(10);
hashSet.add(10);
hashSet.add(2); 
hashSet.add(1); 
hashSet.add(100); 
System.out.println("长度：" + hashSet.size());   //输出长度：4，Set不允许添加重复的元素，但是不会异常。

④遍历

注意：不能通过for循环遍历，Hash是无序的，那么不存在下标。

//使用foreach
for (int num : hashSet) {
	System.out.println(num);
}
//使用迭代器Iterator
Iterator<Integer> it = hashSet.iterator();
while(it.hasNext()) {
	System.out.println(it.next());
}

⑤使用Set给List去重

ArrayList<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(1);
list.add(2);
list.add(2);
HashSet<Integer> set = new HashSet<Integer>(list);
for (int num : set) {
	System.out.println(num);
}

2.TreeSet

①存储一组不可以重复、无序的集合；以树形结构图存储，实现SortedSet接口。

②创建对象：TreeSet<数据类型> set = new TreeSet<数据类型>();或者TreeSet set = new TreeSet();

TreeSet<Integer> tset = new TreeSet<Integer>();
tset.add(1);
tset.add(120);
tset.add(20);
tset.add(12);
Iterator<Integer> it = tset.iterator();
while(it.hasNext()) {
	System.out.print(it.next()+"\t");
}

输出：1 12 20 120

特点：排序和唯一。

四、Map接口

1.存储方式：key-value

2.Map的常用方法

方法名称	说明
Object put(Object key,Object value)	添加元素，注意：key必须是唯一的，但是值可以重复。
Object get(Object key)	根据键返回关联的值，若不存在指定的键，则返回null
Object remove(Object key)	删除指定的键映射的"键-值对"
int size()	返回元素个数
Set keySet()	返回键的集合
Collection values()	返回值的集合
boolean containsKey(Object key)	若存在指定的键映射的键-值对，则返回true
boolean isEmpty()	若不存在键-值映射关系，则返回true，否则返回false
void clear()	清除所有元素

3.HashMap

①创建对象：Map map = new HashMap();或者Map<数据类型, 数据类型> map1 = new HashMap<数据类型, 数据类型>();

②方法

HashMap<String, String> map = new HashMap<String, String>();
map.put("key", "value");
map.put("key1", "value1");
map.put("key1", "value2");
System.out.println("取值：" + map.get("key"));   //value
System.out.println("长度：" + map2.size());     //长度：3
//1、遍历key
Iterator<String> itKey = setkey.iterator();
while(itKey.hasNext()) {
	String key = itKey.next();
	System.out.println(key + "，value：" + map2.get(key));
}
for(String key : setkey) {
	System.out.println(key);
}
//2、遍历value
for(String va : valuesList) {
	System.out.println(va);
}
Iterator<String> valuesIt = valuesList.iterator();
while(valuesIt.hasNext()) {
System.out.println(valuesIt.next());
}
map2.remove("key"); //根据key移除

注意：key可以重复，那么会直接覆盖之前的，其实就是修改值了。

4.HashTable

操作和HashMap一致。

注意以下几点：

①HashTable是线程安全的；HashMap是线程不安全的，但是速度快。

②HashTable不允许null值（key和value都不允许），如果存在则运行报错；HashMap允许null值（key和value都允许）。

5.ConcurrentHashMap

特点：类似HashTable，线程安全，性能优化。

6.TreeMap

特点：以树形结构图存储，对键进行排序【二叉树算法】；不能以null为key，但是null可以为value。

TreeMap<String, String> treeMap= new TreeMap<String, String>();
treeMap.put("1",  "a");
treeMap.put("1",  "b");//添加重复键，覆盖以前key对应的value
treeMap.put("3",  "b");
treeMap.put("0",  "c");
treeMap.put("9",  "d");
treeMap.put("7",  "e");
//treeMap.put(null,  "c");  //不能以null作为key，运行错误
		
for (String	key : treeMap.keySet()) {
	System.out.println("key:" + key + ", value:" + treeMap.get(key));	
}  

运行结果：

key:0, value:c
key:1, value:b
key:3, value:b
key:7, value:e
key:9, value:d