集合框架

由⼀组类和接⼝组成的⼀个体系。

Collection 集合框架

最基本的接⼝，⼀个 Collection 可以存储⼀组⽆序、不唯⼀的对象，实际开发中不会直接使⽤ Collection 进⾏开发。

List是 Collection 的⼀个⼦接⼝，存储⼀组有序、不唯⼀的对象，集合框架中最常⽤的接⼝之⼀。

List  接口的实现类 ：ArrayList、LinkedList

Set  是 Collection 的⼀个⼦接⼝，存储⼀组⽆序、唯⼀的对象。

Set 接口的实现类：TreeSet、HashSet、LinkedHashSet

Map 独⽴于 Collection 的另外⼀个接⼝，存储⼀组键值对象(key-value)，通过键到值的映射。

Map 接口的实现类：HashMap、TreeMap、Hashtable

Iterator ⽤来输出集合元素的接⼝，⼀般适⽤于⽆序集合。

//获取集合的迭代器 将集合内的元素输出

Iterator iterator =set.iterator();while(iterator.hasNext()){

System.out.println(iterator.next());

}

Enumeration 更能与 Iterator ⼀样，已经被 Iterator 所取代。

SortedSet Set 的⼦接⼝，可以对 Set 集合中的元素进⾏排序。

SortedMap Map 的⼦接⼝，可以对 Map 集合中的元素进⾏排序。

Queue 队列接⼝，此接⼝可以实现对列操作。

Map.Entry Map 内部的接⼝，描述 Map 中的⼀个键值对元素。

Collection 常⽤的⽅法

int size() 返回集合的⻓度

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

boolean contains(Object o) 判断集合中是否存在 o

Iterator iterator() 返回迭代器Object[] toArray() 将集合转为数组

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

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

boolean remove(int index) 从集合中删除下标是 index 的元素

System.out.println(list.size());//输出list集合的长度

System.out.println(list.isEmpty());//判断list集合是否为空

System.out.println(list.contains(1));//判断list集合是否包含元素 1

Object[] array= list.toArray();//将一个集合 转成一个数组

System.out.println(array);

list.remove(1);//删除下标为1的元素

list.remove("java");//删除集合中的java元素

System.out.println(list);

System.out.println("##########################");

Vector 是⼀个早期的 List 的实现类，⽤法基本与 ArrayList ⼀致。

Stack 是⼀个栈的数据结构的实现，栈的特点是“后进先出”，“先进后出”。

♦ push 将数据压如到栈中。

♦ peek 取出栈顶元素，以复制的形式。

♦ pop 取出/移除栈顶元素。

LinkedList 实现了⼀个“先进先出”的队列，不但要保存⾃⼰的数据，同时要保存前驱节点、后继节点的

位置信息，所有需要更多的内存空间。

//list 实现的一个先进先出的队列

LinkedList list1=newLinkedList();

list1.add("How");

list1.add("are");

list1.add("you");

System.out.println(list1);

ist.offer("JavaSE");

System.out.println(list);

list.add(1,"List");

System.out.println(list);

System.out.println(list.getLast());

System.out.println(list.get(1));

栈和队列的区别

Stack stack = newStack();

stack.push(1);

stack.push(2);

stack.push(3);

stack.push(4);

stack.push(5);for(int i=0;i<5;i++){

System.out.println(stack.pop());

}

System.out.println("****************");

LinkedList list= newLinkedList();

list.add(1);

list.add(2);

list.add(3);

list.add(4);

list.add(5);for(int i=0;i<5;i++){

System.out.println(list.pop());

}

Queue 队列，要求存⼊的数据必须是有序的，所以如果要存⼊⾃定义数据类型，则需要实现

Comparable 接⼝，⾃定义的类就具备了排序的功能。

public class User implementsComparable {private intid;privateString name;public intgetId() {returnid;

}public void setId(intid) {this.id =id;

}publicString getName() {returnname;

}public voidsetName(String name) {this.name =name;

}public User(intid, String name) {this.id =id;this.name =name;

}/*** 0 表示相等

* 1 表示this⽐o⼤

* -1 表示this⽐o⼩

*@paramo

*@return

*/@Overridepublic intcompareTo(Object o) {

User user=(User) o;if(this.id

}if(this.id>user.id){return -1;

}if(this.id ==user.id){return 0;

}return 0;

}

}Queue queue= newPriorityQueue();

User user= new User(1,"张三");

User user1= new User(2,"李四");

queue.add(user);

queue.add(user1);

System.out.println(queue);

Set 集合框架

Set 是 Collection 另外⼀个常⽤的⼦接⼝，Set 接⼝以散列的形式来存储数据，元素没有顺序(1、不能

通过下标取出元素，2、遍历集合，元素的输出是随机的)可以存储⼀组唯⼀、⽆序的数据。

实际开发中，不能直接实例化 Set。

HashSet、LinkedHashSet、TreeSet

HashSet 存储⼀组⽆序且唯⼀的数据，⽆序是指存⼊的顺序和取出的顺序没有关系。

Set set = newHashSet();

set.add("Java");

set.add("Hello");

set.add("World");

System.out.println(set.size());

Iterator iterator=set.iterator();while(iterator.hasNext()){

System.out.println(iterator.next());

}

set.remove("Hello");

iterator=set.iterator();while(iterator.hasNext()){

System.out.println(iterator.next());

}

LinkedHashSet 存储⼀组有序且唯⼀的数据，这⾥的有序不是说可以通过下标取数据，LinkedHashSet

依然没有下标概念，这⾥的有序是指存⼊的顺序和取出的顺序⼀致。Set set = new LinkedHashSet();

set.add("Java");

set.add("Hello");

set.add("World");

set.add("JavaSE");

set.add("JavaME");

set.add("JavaEE");

Iterator iterator=set.iterator();while(iterator.hasNext()){

System.out.println(iterator.next());

}

LinkedHashSet 判断两个对象是否相等：

1、判断 hashcode 是否相等，如果不相等，就认为是两个对象不相等。

如果 hashcode 相等，再来执⾏判断 2。

2、通过 equals ⽅法判断是否相等。

TreeSet 保存⼀组有序且唯⼀的数据，这⾥的有序是指集合内部会⾃动给所有的元素进⾏升序排列，⽆

论按照什么样的顺序存⼊数据，输出的时候⼀定是按照升序进⾏输出。

HashSet：存⼊的顺序和输出顺序没有关联，输出是随机的。

LinkedHashSet：存⼊顺序和输出顺序⼀致。

TreeSet：⽆论什么顺序存⼊，输出⼀定是升序。

Set set = newTreeSet();

People people= new People(1,"张三");

People people1= new People(2,"李四");

People people2= new People(3,"王五");

set.add(people);

set.add(people1);

set.add(people2);

Iterator iterator=set.iterator();while(iterator.hasNext()){

System.out.println(iterator.next());

}public class People implementsComparable {private intid;privateString name;public intgetId() {returnid;

}public void setId(intid) {this.id =id;

}publicString getName() {returnname;

}public voidsetName(String name) {this.name =name;

}public People(intid, String name) {this.id =id;this.name =name;

}

@OverridepublicString toString() {return "People{" +

"id=" + id +

", name='" + name + '\'' +

'}';

}

@OverridepublicintcompareTo(Object o) {

People people=(People) o;int num = 0;if(this.id>people.id){

num= 1;

}if(this.id

num= -1;

}returnnum;

}

}

Map集合框架

Map 是完全独⽴于 Collection 的另外⼀套体系，Set、List、Collection 只能操作单个元素，每⼀次的存

取操作只能针对⼀个元素，Map 可以操作⼀对元素，key-value 的映射。

K：key

V：value

常⽤⽅法：

int size() 获取集合的⻓度

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

boolean containsKey(Object key) 判断集合中是否存在某个 key 值

boolean containsValue(Object value) 判断集合是否存在某个 value

V get(Object key) 取出集合中 key 对应的 value

V put(Object key,Object value) 向集合存储⼀组 key-value 值

V remove(Object key) 删除集合中 key 对应的 value

void clear() 清空集合

Set keySet() 取出集合中所有的 key，组成⼀个 Set 返回

Collection values() 取出集合中所有的 value，组成⼀个 Collection 返回

HashMap：存储⼀组⽆序，key 不可重复，value 可重复的元素。

Hashtable：存储⼀组⽆序，key 不可重复，value 可重复的元素。

TreeMap：存储⼀组有序(key)，key 不可重复，value 可重复的元素。

Map map = newHashMap();

map.put("h","Hello");

map.put("w","World");

map.put("j","Java");

map.put("s","JavaSE");

map.put("m","JavaME");

map.put("e","JavaEE");

System.out.println(map);

map.remove("m");

System.out.println(map);

map.put("jj","Java");

System.out.println(map);

System.out.println(map.containsKey("jj"));

System.out.println(map.containsValue("Java"));

Set keys=map.keySet();

System.out.println(keys);//遍历

Iterator iterator =keys.iterator();while(iterator.hasNext()){

String key=(String) iterator.next();

System.out.println(key+"-"+map.get(key));

}

Collection values=map.values();for(Object value:values){

System.out.println(value);

}

HashMap 和 Hashtable ⽤法⼀样，Hashtable 较早推出的⼀个 API(Application Interface) 应⽤程序接

⼝，Hashtable 是线程安全的，但是性能较低，HashMap 线程不安全，但是性能更⾼。

Map map = newHashtable();

map.put("h","Hello");

map.put("w","World");

map.put("j","Java");

map.put("s","JavaSE");

map.put("m","JavaME");

map.put("e","JavaEE");

System.out.println(map);

map.remove("m");

System.out.println(map);

map.put("jj","Java");

System.out.println(map);

System.out.println(map.containsKey("jj"));

System.out.println(map.containsValue("Java"));

Set keys=map.keySet();

System.out.println(keys);//遍历Iterator iterator = keys.iterator();

while(iterator.hasNext()){

String key=(String) iterator.next();

System.out.println(key+"-"+map.get(key));

}

Collection values=map.values();for(Object value:values){

System.out.println(value);

}

TreeMap 可以按照 key 值对数据进⾏排序。

public class Pet implementsComparable {private intage;public Pet(intage) {this.age =age;

}

@Overridepublic intcompareTo(Object o) {

Pet pet=(Pet) o;if(this.age>pet.age){return 1;

}if(this.age

}return 0;

}

@OverridepublicString toString() {return "Pet{" +

"age=" + age +

'}';

}

}

Map map= newTreeMap();

Pet pet1= new Pet(1);

map.put(pet1,"Hello");

Pet pet2= new Pet(2);map.put(pet2,"World");

Pet pet3= new Pet(3);

map.put(pet3,"Java");

Pet pet4= new Pet(4);

map.put(pet4,"JavaSE");

Pet pet5= new Pet(5);

map.put(pet5,"JavaME");

Pet pet6= new Pet(6);

map.put(pet6,"JavaEE");

System.out.println(map);

♦