本文详细介绍了Java集合框架的体系结构，包括Collection、List、Set、Map等核心接口及其实现类的特点与用法，并提供了丰富的代码示例。
目录
1.集合框架
概述
集合框架是一个用来代表和操纵集合的统一架构。所有的集合框架都包含如下内容：
接口：是代表集合的抽象数据类型。接口允许集合独立操纵其代表细节。在面向对象的语言，接口通常形参一个层次。
实现（类）：是集合接口的具体表现。从本质上讲，它们是可以重复使用的数据结构。
算法：是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序
这种算法被称为多态，那是因为相同的方法可以在相似的接口有着不同的实现。
集合的特点
1.集合只用于存储对象
2.集合的长度是可变的
3.集合可以存储不同类型的对象
Java集合框架体系
集合接口
集合框架定义了一些接口。本表提供了一些重点接口的概述：
2.Collection
特点
用来存储对象的容器虽然有很多但结构不同，但是都具备着共性，可以不断向上抽取，最终就形成了集合框架，该框架的顶层之一就是Collection接口。该接口定义了集合框架中最共性的功能。最终使用的时候，其实使用的是该框架最子类的对象。
Iterable接口允许对象“foreach”语句的目标，即该集合对象允许迭代。
类集合接口Collection是Interable的子接口，Collection有两个子接口：
List（列表），Set（集）
List：元素存取是有序的，可存放重复元素。
Set：元素存取是无序的，不可以存放重复元素
Collection接口的方法
package Collection;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionText {
public static void main(String[] args) {
//1.定义第一个集合
Collection coll= new ArrayList();
coll.add("abc");
coll.add(new String("ddd"));
coll.add(123);//自动装箱
//将集合coll 输出
System.out.println(coll);
//2.定义第二个集合
Collection newColl = new ArrayList();
newColl.add("abc");
newColl.add("456");
//将集合coll中的元素添加到nenwColl集合中
newColl.addAll(coll);
System.out.println(newColl);
//3.删除newColl中的元素
// newColl.remove("abc");//移除一个
// System.out.println(newColl);
// newColl.clear();//清除所有
// System.out.println(newColl);
//4.判断集合元素
boolean bool = newColl.contains("abc");
System.out.println("newColl包含元素abc" + bool);
//5.取交集
Boolean retain = coll.retainAll(newColl);
System.out.println("取交集后的结果：");
System.out.println("cool的内容" + coll);
System.out.println("newColl的内容" + newColl);
System.out.println("交集后的结果" + retain);
}
}
3.List
概述
List是Collection接口的子接口，元素存取是有序的，可以存放重复元素。
常用子类
ArrayList：内部是数组数据结构，是不同步的。查询的速度快；
LinkedList：内部是链表数据结构，是不同步的。增删速度很快；’、
List接口的方法
package Collection;
import java.util.ArrayList;
import java.util.List;
public class ListText {
public static void main(String[] args) {
//1.定义一个List
List list = new ArrayList<>();
//2.添加元素
list.add("Tom");
list.add("Jerry");
list.add("Spike");
System.out.println("list内容"+list);
//3.插入元素
list.add(1,"Tyke");
System.out.println("list新内容"+list);
//4.删除元素
Object remObj = list.remove(2);
System.out.println("删除元素" + list);
//5.修改元素
Object setObj =list.set(1,"Nike");//返回修改之前的
System.out.println("修改元素"+setObj);
System.out.println("修改list后的内容"+list);
//6.获取元素
Object getObj = list.get(0);
System.out.println("获取元素：" + getObj);
//7.获取子列表
List subl = list.subList(1,2);//下标范围左闭右开
System.out.println("获取子列表元素内容" + subl);
}List接口的遍历
package Collection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListText {
/**\
* 第一种方式 使用for循环遍历
* @param list
*/
public static void sortList(List list){
for(int i = 0;i<list.size();i++){
System.out.println("list的索引为"+ "i" + "元素的内容"+list.get(i));
}
}
/**
* 第二种方式 使用forEach循环
* @param list
*/
public static void sortList2(List list){
for(Object obj: list){
System.out.println("list的元素内容"+obj);
}
}
/**
* 第三种方式 使用集合自由的Iterator循环遍历
* @param list
*/
public static void sortList3(List list){
//获取对象集合进行迭代的迭代器
Iterator iterator = list.iterator();
//取出迭代的下一个元素
Object obj = iterator.next();
System.out.println("list的元素内容为" + obj);
}
public static void main(String[] args) {
//1.定义一个List
List list = new ArrayList<>();
//2.添加元素
list.add("Tom");
list.add("Jerry");
list.add("Spike");
// System.out.println("list内容"+list);
System.out.println("第一种方式 使用for循环遍历");
sortList(list);
System.out.println("第二种方式 使用forEach循环遍历");
sortList2(list);
System.out.println("第三种方式 使用集合自有的Iterator循环遍历");
sortList3(list);LinkedList类
概述：LinkedList内部是链表数据结构，允许有null（空）元素。LinkedList查找效率低。
常用方法
package Collection;
import java.util.LinkedList;
public class LinkedListText {
public static void main(String[] args) {
//1.定义List
LinkedList list = new LinkedList();
list.add("Tom");
list.add("Jerry");
list.add("Tyke");
System.out.println("list中的元素" + list);
//2.添加元素
list.addFirst("add-one");
list.addLast("add-Two");
System.out.println("使用add像list中添加首尾元素" + list);
list.offerFirst("add-one");
list.offerLast("add-Two");
System.out.println("使用add像list中添加首尾元素" + list);
//3.获取元素
Object getFirst = list.getFirst();
Object getLast = list.getLast();
System.out.println("使用get获得收元素" + getFirst);
System.out.println("使用get获得收元素" + getLast);
System.out.println(list);
Object peekFirst = list.peekFirst();
Object peekLast = list.peekLast();
System.out.println(list);
//5.移除元素
Object removeFirst = list.removeFirst();
Object removeLast = list.removeLast();
System.out.println(list);
Object poolFirst = list.pollFirst();
Object poolLast = list.pollLast();
System.out.println(list);
}
}
4.Set
概述
Set是Collection接口的子接口，元素存取是无序的，不可以存放重复元素
Set接口中的方法和Collection一致。
常用子类
1.HashSet：不能保证迭代的顺序与插入的顺序一致；
2.LinkedHashSet：迭代器输出与插入的顺序保持一致；
package Collection;
import java.util.HashSet;
import java.util.LinkedHashSet;
public class SetText {
public static void main(String[] args) {
//1.定义HashSet
HashSet hs = new HashSet();
hs.add("Tom");
hs.add("Tom");
hs.add("Tom");
hs.add("Tom");
hs.add("Jerry");
hs.add("123");
hs.add(false);
//1.定义HashSet
LinkedHashSet lhs = new LinkedHashSet();
lhs.add("Tom");
lhs.add("Tom");
lhs.add("Tom");
lhs.add("Tom");
lhs.add("Jerry");
lhs.add("123");
lhs.add(false);
//3.打印set中的内容
System.out.println("HashSet的元素内容"+hs);
System.out.println("LinkedHashSet的元素内容"+lhs);
}
}
3.TreeSet
//4.TreeSet
TreeSet ts = new TreeSet();
ts.add(20);
ts.add(18);
ts.add(16);
ts.add(15);
ts.add(20);
ts.add(21);
System.out.println("TreeSet的元素内容"+ts);5.Map
概述
Map集合类用于存储元素（称作"键"和“值”），其中每一个减射到一个值。
一个映射不能包含重复的键；每个键最多只能映射到一个值。
常用子类
HashMap：内部结构是哈希表，不是同步的。允许null作为键，null作为值；
TreeMap：内部结构二叉树，不是同步的。可以对Map集合中的键进行排序；
常用方法
package Collection;
import java.util.HashMap;
public class MapText {
public static void main(String[] args) {
//1.定义HashMap
HashMap map = new HashMap();
//2.给Map添加元素-返回与key关联的上一个元素
Object putOne = map.put("one",111);
Object putTwo = map.put("Two",222);
//此时，将有的value进行替换
Object putThree = map.put("Two",333);
//3.打印输出
System.out.println(putOne);
System.out.println(putTwo);
System.out.println("与keytwo关联的上个元素" + putThree);
//4.判断map中的key是否包含“one”
System.out.println(map.containsKey("one"));
System.out.println(map.containsValue(333));
//5.输出map中的元素
Object ObjVal = map.get("one");
System.out.println("获取map中的key为one的值"+ObjVal);
int num = map.size();
System.out.println("map中元素的个数"+num);
}
}Map接口常用方法
package Collection;
import java.util.*;
public class MapText {
/**
* 第一种方式
* 通过keySet获取map中的元素
* @param map
*/
public static void map1(Map map) {
Set keySet = map.keySet();
Iterator it = keySet.iterator();
while (it.hasNext()) {
Object key = it.next();
Object value = map.get(key);
System.out.println(key + ":" + value);
}
}
/**
* 第二种方式
* 通过entrySet获取map中的元素
*
* @param map
*/
public static void map2(Map map) {
Set<Map.Entry<Object, Object>> entrySet = map.entrySet();
Iterator<Map.Entry<Object, Object>> it = entrySet.iterator();
while (it.hasNext()) {
Map.Entry<Object, Object> me = it.next();
Object key = me.getKey();
Object value = me.getValue();
System.out.println(key + ":" + value);
}
}
public static void map3(Map map){
Collection<Object> values = map.values();
//v可能不是唯一的
Iterator <Object> it = values.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
public static void main(String[] args) {
//1.定义HashMap
HashMap map = new HashMap();
//2.给Map添加元素-返回与key关联的上一个元素
Object putOne = map.put("one", 111);
Object putTwo = map.put("Two", 222);
//此时，将有的value进行替换
Object putThree = map.put("Two", 333);
//3.打印输出
System.out.println(putOne);
System.out.println(putTwo);
System.out.println("与keytwo关联的上个元素" + putThree);
//4.判断map中的key是否包含“one”
System.out.println(map.containsKey("one"));
System.out.println(map.containsValue(333));
//5.输出map中的元素
Object ObjVal = map.get("one");
System.out.println("获取map中的key为one的值" + ObjVal);
int num = map.size();
System.out.println("map中元素的个数" + num);
System.out.println("--------获取map中所有的元素-----------");
System.out.println("第一种方式:通过keySet获取map中的元素");
map1(map);
System.out.println("第二种方式:通过entrySet获取map中的元素");
map2(map);
System.out.println("第三种方式:通过value获取map中的元素");
map3(map);
}
}
扫一扫
571
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
