Java集合框架

Collection接口

（1）定义：

Collection是层次结构中的根接口，在实际编程中用List和Set作为Collection的子类接口，通过他们的具体实现类来使用集合。但Collection的方法对其子接口和实现类都适用。

（2）方法：

A:添加功能

boolean add();添加一个元素

boolean addAll();添加多个元素

B:删除功能

void clear();移除所有元素

boolean remove();移除一个元素

boolean removeAll();移除一个集合的元素

C:判断功能

boolean contains();判断集合中是否包含指定元素

Boolean containsAll();判断集合中是否包含指定集合元素

Boolean isEmpty();判断集合是否为空

D:获取功能

Iterator<E>iterator();迭代器模式

E:长度功能

int size();元素的个数

数组中没有length()方法，字符串有length()方法，集合没有length()方法

F:交集

Boolean retainAll();如果有交集返回true否则false

G:把集合转数组(了解)

Object[]toArray();

（3）Collection集合的通用遍历方法：

把集合转成数组遍历，for循环
public class CollectionDemo {
	public static void main(String[] args) {
		Collection<String> c=new ArrayList<String>();

		c.add("zhang");
		c.add("jian");
		c.add("hui");
		
		//把集合转换成数组
		Object[] objs= c.toArray();
		//for循环遍历
		for(int x=0;x<objs.length;x++){
			System.out.println(objs[x]);
		}
	}
}
迭代器遍历
public class IteratorDemo {
	public static void main(String[] args) {
		//创建集合对象,泛型限制类型
		Collection<String> c=new ArrayList<String>();
		
		c.add("zhang");
		c.add("jian");
		c.add("hui");
		
		//创建迭代器对象
		Iterator<String> it=c.iterator();
		//如果有元素可以迭代，则返回true
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		
		//使用for循环改进，迭代器作为for循环的判断条件，提高效率
		for(Iterator<String> it1=c.iterator();it1.hasNext();){
			System.out.println(it1.next());
		}
	}
}

增强for循环（适用于集合和数组的一种简便for循环）

格式：

for(元素的数据类型 变量名 : 数组或者Collection集合的对象) {

使用该变量即可，该变量其实就是数组或者集合中的元素。

}

上面的使用增强for改进：
for(String s:c){
    System.out.println(s);
}

总结：其实不管是while还是for其底层源码都是迭代器遍历的，但是在编码中经常会适用增强for循环。

（一）LIst接口

（1）特点：

• 有序的集合，指存储和取出是有序的而不是排序
• 元素可重复。

（2）特有功能：

A:添加

 voidadd(int index, E element) 在列表的指定位置插入指定元素（可选操作）

B:删除

Object  remove(int index) 移除列表中指定位置的元素（可选操作），将所有的后续元素向左移动（将其索引减1）。返回从列表中移除的元素。

C:获取

Object  get(int index)  返回列表中指定位置的元素。

D:迭代器

   ListIterator<E>listIterator()    返回列表中元素的列表迭代器（按适当顺序），是Iterator的子接口。

              Listiterator特有方法：hasPrevious()和previous()实现逆向遍历列表

E:修改

Object  set(int index, E element) 用指定元素替换列表中指定位置的元素（可选操作）。

（3）List特有遍历:

注意：在遍历的时候，使用什么方式遍历，就用什么添加元素，否则出现并发修改异常，因为迭代器是依赖集合而存在的，当遍历过程中添加元素后集合就改变了，而迭代器不知道，就会报错。
1.	迭代器遍历迭代器添加元素，元素添加到equals比较的元素后面。
2.	集合遍历集合添加元素（本例），元素添加到末尾。
public class ListIteratorDemo {
	public static void main(String[] args) {
		List<String> list=new ArrayList<String>();
		
		list.add("hello");
		list.add("world");
		list.add("java");
		//注意：容易出现并发修改异常的情况
		for(int x=0;x<list.size();x++){
			String s=list.get(x);
			if("world".equals(s)){
				list.add("javaee");
			}
			System.out.println(s);
		}
	}
}

List三个实现类的特点：

ArrayList（常用）

底层数据结构是数组，查询快，增删慢。

线程不安全，效率高。

Vector（使用少）

底层数据结构是数组，查询快，增删慢。

线程安全，效率低。

LinkedList

底层数据结构是链表，查询慢，增删快。

线程不安全，效率高。

（二）Set接口

（1）特点：无序集合(指顺序而非排序)，不包含重复元素（唯一）。无自己的特殊方法，同父类。

（2）HashSet类

底层数据结构是哈希表(是一个元素为链表的数组)，哈希表底层依赖两个方法：hashCode()和equals()保证元素的唯一性。

学生类
public class Student {
	private String name;
	private int age;
	
	无参构造
	带参构造
	get&set方法
	
	@Override
	/*快捷键生成hashCode和equals方法：Alt+Shift+s+h
	判断过程：
	1、先比较哈希值是否相同，在下面加入一个常量值，目的是防止不同的哈希值相加的结果相同但实际的值是不同的，比如：2+3=1+4，但2*2+3！=1*2+4，所以就是为了避免出现特殊情况。
	2、如果哈希值不同，执行equals方法，true元素重复，false添加元素
	*/
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
}
测试类
import java.util.HashSet;

public class HashSetDemo {
	public static void main(String[] args) {
		HashSet<Student> hs=new HashSet<Student>();
		
		Student s1=new Student("张建辉1",21);
		Student s3=new Student("张建辉3",23);
		Student s4=new Student("张建辉3",23);
		Student s5=new Student("惠小妹",25);
		Student s6=new Student("惠小妹",26);
		
		hs.add(s1);
		hs.add(s3);
		hs.add(s4);
		hs.add(s5);
		hs.add(s6);
		
		for(Student s:hs){
			System.out.println(s.getName()+"------------"+s.getAge());
		}
	}
}
/*输出结果：
	惠小妹------------25
	张建辉3------------23
	惠小妹------------26
	张建辉1------------21
证明Set存储和输出的顺序是不一样的，相同的元素不能重复添加，不重写hashCode和equals方法会报错。*/

（3）TreeSet类

底层数据结构是红黑树(是一个自平衡的二叉树)

a:自然排序(让元素所属的类实现Comparable接口)

学生类
public class Student implements Comparable<Student>{
	private String name;
	private int age;
	
	无参构造
	带参构造
	get&set方法
	
	@Override
	public int compareTo(Student s) {
		//首要条件，年龄从小到大
		int num=this.age-s.age;
		//次要条件姓名的长度
		int num2=num==0?this.name.length()-s.name.length():num;
		int num3=num== 0?this.name.compareTo(s.name):num2;//判断是否重复元素
		return num3;
	}
	
}
测试类
import java.util.TreeSet;

public class TreeSetDemo {
	public static void main(String[] args) {
		TreeSet<Student> ts=new TreeSet<Student>();
		
		Student s1=new Student("张建",1);
		Student s2=new Student("张",4);
		Student s3=new Student("张建辉",2);
		Student s4=new Student("张建辉1",2);
		Student s5=new Student("张建辉22",2);

		ts.add(s2);
		ts.add(s1);
		ts.add(s3);
		ts.add(s4);
		ts.add(s5);
	
		for(Student s:ts){
			System.out.println(s.getName()+"---"+s.getAge());
		}
	}
}
/*输出结果：
	张建---1
	张建辉---2
	张建辉1---2
	张建辉22---2
	张---4
证明需要在Student类中给出排序的条件，没有则报错。自然排序如果集合中添加得是相同类型元素，如数字、字母可以不用给出排序条件，自动按顺序排，
但是自定义对象必须给出如何排序的条件 */

b:比较器排序（让集合构造方法接收Comparator的实现类对象）

/*
省略学生类，学生类中包括get set方法
*/
import java.util.TreeSet;

public class TreeSetDemo2 {
	public static void main(String[] args) {
		//Comparator是一个接口，需要的是一个接口的实现类的对象，采用匿名内部类。
		TreeSet<Student> ts=new TreeSet<Student>(new Comparator<Student>(){
			@Override
			public int compare(Student s1, Student s2) {
				//主要条件根据名字长度
				int num=s1.getName().length()-s.getName().length();
				//比较元素是否相同
				int num2=num==0?s1.getName().compareTo(s2.getName()):num;
				//次要条件年龄排序
				int num3=num2==0?s1.getAge()-s2.getAge():num2;
				return num3;	
			}
		});
		
		Student s1=new Student2("z",1);
		Student s2=new Student2("zh",2);
		Student s3=new Student2("zha",3);
		Student s4=new Student2("zha",4);
		Student s5=new Student2("zha",4);
		
		ts.add(s1);
		ts.add(s2);
		ts.add(s4);
		ts.add(s3);
		ts.add(s5);
		
		for(Student s:ts){
			System.out.println(s.getName()+"---"+s.getAge());
		}
	}
}
/*输出结果：
	z---1
	zh---2
	zha---3
	zha---4
证明TreeSet集合内部元素的唯一性，以及排序方式。*/

Map接口

(1)理解：

将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。键相当于Set集合，值相当于list集合，数组中有二维数组，集合中没有二维集合，但是Map集合却有点二维的感觉。

(2)Map和Collection的区别?

A:Map 存储的是键值对形式的元素，键唯一，值可以重复。（学号和姓名的关系）

B:Collection 存储的是单独出现的元素，子接口Set元素唯一，子接口List元素可重复。

C:Map是双列的，Collocation是单列的，

 

(3)Map接口的方法

A:添加功能

V put(k key,v value);添加元素

如果键是第一次存储，就直接存储键值对，返回null

如果键不是第一次存储，就用值把以前的值替换掉，返回以前的值。

B:删除功能

void clear();移除所有键值对

V remove(Object key);根据键删除键值对元素，并把值返回        

C:判断功能

boolean containsKey(Object key); 判断集合是否包含指定键

boolean containsValue(Object value);判断集合是否包含指定值

D:获取功能

set<Map.Entry<K,V>>entrySet();返回此映射中包含的映射关系的Set视图。

Set<K> keySet();获取集合中所有键的集合

V get(Object key);根据键获取值

Collocation<V>value();获取集合中所有值的集合

E:长度功能

int size();返回集合中键值对的对数

（4）Map集合的遍历

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapDemo2 {
	public static void main(String[] args) {
		//定义map集合
		Map<String,String> map=new HashMap<String,String>();
		
		map.put("小明", "小玲 ");
		map.put("小明", "小玲");

		//方法1：
		//获取所有的键的集合
		Set<String> set=map.keySet();
		for(String key:set){
			String value=map.get(key);
			System.out.println(key+"\t"+value);
			
		}
		
		//方法2：
		//个人理解：将键值对包装为一个对象给出索引值，Set是一个索引值的集合
		Set<Map.Entry<String,String>>set=map.entrySet();
		//个人理解：遍历每一个索引，得到对象，对象调用getkey()和getvalue方法得到每一个键和值
		for(Map.Entry<String,String> me:set){
			System.out.println(me.getKey()+"\t"+me.getValue());
		}
		
		
	}
}

（一）HashMap类

特点同HashSet

（二）LinkedHashMap类

特点同LinkedSet

（三）TreeMap类

特点同TreeSet