Java集合大致可分为：List,Set,Map,Queue
List:有序，可重复
Set:无序（输出和插入顺序不一定一致），不可重复
Map:映射关系,根据key去访问value
Queue:队列，先进先出(FIFO)
集合类只能存储对象
List<int> //错误 List<Integer>
Collection体系结构
圆圈表示:interface
长方形表示：class
带三角的实线代表继承关系，使用关键字extends
带三角的虚线代表实现关系，使用关键字implements
Iterable
iterable定义了iterator()，forEach(Consumer<? super T> action)
这2个方法用于遍历元素
1.forEach方法遍历集合
Consumer是一个函数式接口，只有一个accept(T t)方法，可以使用Lambda表达式
public static void main(String[] args){
Collection<String> coll = new HashSet<>();
//在集合中添加10个元素
for(int i=0;i<10;i++){
coll.add("小王"+i);
}
//使用forEach遍历集合
coll.forEach(name->System.out.println(name));
}
输出（因为HashSet并未实现SortedSet接口，所以里边的元素是无序的）
2.iterator()遍历集合
集合类使用iterator()方法，会返回一个Iterator
Iterator接口主要用于遍历Collection中的元素
有上边的4个方法，其中forEachRemaining()用来使用Lambda表达式来遍历集合
2.1不使用Lambda表达式
public static void main(String[] args){
Collection<String> coll = new ArrayList<>();
//在集合中添加10个元素
for(int i=0;i<10;i++){
coll.add("小王"+i);
}
//获得一个iterator
Iterator<String> iterator = coll.iterator();
//iterator中是否还有下一个元素
while(iterator.hasNext()){
//返回集合中的下一个元素
String name = iterator.next();
System.out.println(name);
//删除一个元素
if("小王5".equals(name)){
iterator.remove();
}
//更改iterator中元素，但是集合中的元素没有改变
//因此可以得出集合传给iterator的是元素的值，而不是引用
name = "李四";
}
System.out.println(coll.contains("小王5"));
}
注意在使用iterator迭代集合元素的过程中（不要在while循环里边改coll），不要改变集合中的元素，否则会产生ConcurrentModificationException
2.2使用Lambda表达式
public static void main(String[] args){
Collection<String> coll = new ArrayList<>();
//在集合中添加10个元素
for(int i=0;i<10;i++){
coll.add("小王"+i);
}
//获得一个iterator
Iterator<String> iterator = coll.iterator();
iterator.forEachRemaining(name->System.out.println(name));
}
3.使用foreach循环来遍历元素
public static void main(String[] args){
Collection<String> coll = new ArrayList<>();
//在集合中添加10个元素
for(int i=0;i<10;i++){
coll.add("小王"+i);
}
for(String name:coll){
System.out.println(name);
}
}
注意在使用foreach遍历集合元素的过程中（不要在for循环里边改coll），不要改变集合中的元素，否则会产生ConcurrentModificationException
Collection
Collection中的操作可以操作所有的List,Set,Queue
public static void main(String[] args){
Collection<String> coll = new ArrayList<>();
//在集合中添加一个元素
coll.add("张三");
//返回true
System.out.println(coll.contains("张三"));
//返回1
System.out.println(coll.size());
//删除元素
coll.remove("张三");
//返回0
System.out.println(coll.size());
//在集合中添加10个元素
for(int i=0;i<10;i++){
coll.add("小王"+i);
}
//把集合转换成数组
String[] array = coll.toArray(new String[10]);
System.out.println(array[5]);
}
Set
特点是不允许包含重复元素，继承自Collection接口，没有添加额外方法
1.HashSet
特点
不保证有序
线程不安全，有2个线程同时修改HashSet时，需要通过代码同步
集合元素可以是null
数据结构：散列表
HashSet判定2个元素相等的条件是：1.equals()方法比较相等 2.hashCode()返回值相等
class A{
@Override
public boolean equals(Object obj) {
return true;
}
}
class B{
@Override
public int hashCode() {
return 1;
}
@Override
public boolean equals(Object obj) {
return true;
}
}
class C{
@Override
public int hashCode() {
return 2;
}
}
public class Test {
public static void main(String[] args){
Set<Object> set = new HashSet<>();
//仅equals()相同
set.add(new A());
set.add(new A());
//hashCode(),equals()均相同
set.add(new B());
set.add(new B());
//仅hashCode()相同
set.add(new C());
set.add(new C());
for(Object a : set){
System.out.println(a);
}
}
输出
可以看出只有B,equals和hashCode都相同时，HashSet才会认为这2个元素使同一个元素
当hashCode相同时，HashSet会把多个元素放在一个bucket中，构成同义词链表，会减慢访问速度
因此，使用HashSet时，要保证2个对象equals返回true时，hashCode也要返回true
2.TreeSet
特点
排过序
线程不安全，有2个线程同时修改HashSet时，需要通过代码同步
数据结构：红黑树
TreeSet的排序规则
2.1自然排序 （默认）
调用集合元素的compareTo(Object obj)方法比较元素大小关系，然后按元素大小升序排列
a.compareTo(b)
a>b,返回正数
a=b,返回0
a<b,返回负数
使用TreeSet时，要保证2个对象equals返回true时，a.compareTo(b)要返回0
因此在向TreeSet中添加元素时，要实现Comparable接口，否则抛出ClassCashException
public static void main(String[] args){ //Integer已经实现Comparable接口
TreeSet<Integer> set = new TreeSet<>();
set.add(5);
set.add(4);
set.add(9);
set.add(2);
for(Integer i : set){
System.out.println(i);
}
}
输出
2.2通过Comparator接口（函数式接口）
compare(a,b)
返回正数,a>b
返回0,a=b
返回负数,a<b
实现逆序，返回相反的数就行了
public static void main(String[] args) { //使用TreeSet(Comparator<? super E> comparator)构造
TreeSet<Integer> set = new TreeSet<>(
(num1,num2)-> {
if (num1 < num2)
return 1;
if(num1 > num2)
return -1;
return 0;
}
);
set.add(9);
set.add(1);
set.add(3);
for (int num : set){
System.out.println(num);
}
}
输出
3.EnumSet
所有元素必须是enum类型
EnumSet是有序的
不允许放入null
没有构造器， 通过静态方法获得EnumSet
List
特点是元素有序，可重复，继承自Collection接口，还添加了一些根据索引操作元素的方法
List判断2个元素相等的条件是equals方法返回true
set方法只能用于修改集合中已经存在的值，不能新增加元素。
使用List的sort方法进行排序
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("张三");
list.add("李小四");
list.add("王大少爷");
//集合的顺序是张三，李小四，王大少爷
list.sort(
((o1, o2) ->{
if(o1.length() < o2.length())
return 1;
if(o1.length() == o2.length())
return 0;
return -1;
} )
);
for (String s: list) {
System.out.println(s);
}
}
输出
使用ListIterator迭代
ListIterator()方法返回一个ListIterator,ListIterator增加了向前迭代元素的方法，以及添加元素的方法
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("张三");
list.add("李小四");
list.add("王大少爷");
//集合的顺序是张三，李小四，王大少爷
ListIterator<String> listIterator = list.listIterator();
//注意这里调用add方法采用的是头插法
listIterator.add("周杰伦");
System.out.println(list);
while(listIterator.hasNext()){
listIterator.next();
}
System.out.println("你还想怎么样啊，到底了");
System.out.println("========================");
System.out.println("我还能反着遍历元素啊");
while(listIterator.hasPrevious()){
System.out.println(listIterator.previous());
}
}
输出
ArrayList,Vector
ArrayList,Vector是List的2个典型实现，调用不带参数构造方法，initialCapacity=10；带参数的构造方法，自己指定initialCapacity
ArrayList不是线程安全的，Vector是线程安全的
Queue
数据结构：队列（FIFO）
不允许随机访问
element()方法返回头元素，不删除集合中元素
peek()方法返回头元素或者null，不删除集合中元素
poll()方法返回头元素或者null,删除集合中元素
1.PriorityQueue
按元素大小重新排序，因此取出头元素时，是最小的元素
PriorityQueue不允许插入null
PriorityQueue对元素的排序方法同样有2种，自然排序和定制排序，思路和TreeSet一样
2.Deque和ArrayDeque
Deque代表一个双端队列
它们功能相同，区别是对失败情况的处理不同。一套接口遇到失败就会抛出异常，另一套遇到失败会返回特殊值（false或null）
ArrayDeque底层也是数组，数组长度默认是16
ArrayDeque可以作为栈和队列使用（推荐）
作为栈时使用下面2个方法操作元素
作为队列时使用下面方法操作元素
LinkedList
实现了List和Deque 2个接口，底层是链表，随机访问效率较差，插入删除效率高
LinkedList采用迭代器方式遍历效率高，ArrayList,Vector使用get效率高
Map体系结构
Map
Key:无序，不可重复->组成一个keySet
Value:有序，可重复->组成一个List
public static void main(String[] args){
Map<Integer,String> map = new HashMap<Integer,String>();
//添加元素
map.put(1,"张三");
map.put(2,"李四");
map.put(3,"王五");
//key是唯一的，如果放入相同的key，会把现有的覆盖
map.put(3,"赵子龙");
//输出赵子龙
System.out.println(map.get(3));
//删除赵子龙
map.remove(3);
//遍历
for (int i : map.keySet()){
System.out.println(map.get(i));
}
}
HashMap,Hashtable
区别：1.HashMap线程不安全，Hashtable线程安全
2.HashMap可以使用null作为key和value（由于key是不可重复的，因此key只能有1个可以为null，value可以有无数个），Hashtable不可以
判定key和value是否相等
判定key相等通过equals()方法和hashCode()方法，判定value相等通过equals()方法
class MyKey{
private int key;
public MyKey(int key){
this.key = key;
}
@Override
public boolean equals(Object obj) {
MyKey k = (MyKey) obj;
if(key == k.key)
return true;
return false;
}
@Override
public int hashCode() {
return key;
}
}
public class Test {
public static void main(String[] args){
Map<MyKey,String> map = new HashMap<>();
map.put(new MyKey(1),"张三");
map.put(new MyKey(2),"李四");
//key相同，会覆盖原来的
map.put(new MyKey(1),"周杰伦");
//输出{[email protected]=周杰伦, [email protected]=李四}
System.out.println(map);
//返回true
System.out.println(map.containsValue("李四"));
}
}
LinkedHashMap
LinkedHashMap使用双向链表维护key,确保key插入顺序与迭代顺序一致
Properties
Properties相当于一个key,value都是String的Map
使用Properties读取配置文件
public static void main(String[] args){
Properties properties = new Properties();
try {
properties.load(new InputStreamReader(new FileInputStream("properties"),"utf-8"));
System.out.println(properties);
} catch (IOException e) {
e.printStackTrace();
}
}
TreeMap
数据结构：红黑树
每个key-value对作为红黑树节点
2种排序方式：自然排序和定制排序（看key，与TreeSet判等规则一致）
WeakHashMap
与HashMap区别：WeakHashMap的key中保存的是弱引用，HashMap中保存的是强引用
如果WeakHashMap中的key没有被其他强引用变量引用，这些key有可能被GC回收
IdentityHashMap
与HashMap区别：IdentityHashMap只有当key1 == key2 才认为2个key相等，HashMap两个key的equals,hashCode相等即相等
工具类Collections
对List的操作
public static void main(String[] args){
List<Integer> list = new ArrayList<>();
for (int i=0; i<10;i++){
list.add(i);
}
//输出[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
System.out.println(list);
//逆序
Collections.reverse(list);
//输出[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
System.out.println(list);
//随机排序
Collections.shuffle(list);
System.out.println(list);
//升序排序
Collections.sort(list);
System.out.println(list);
//二分查找指定元素位置，List必须有序
System.out.println(Collections.binarySearch(list,5));
}
查找Collection最大最小值
public static void main(String[] args){
Collection<Integer> c = new HashSet<>();
for (int i=0;i<10;i++){
c.add(i);
}
//最大值9
System.out.println(Collections.max(c));
//最小值0
System.out.println(Collections.min(c));
}
同步集合
通过上面3个方法得到同步后的集合，确保线程安全
原文地址：https://www.cnblogs.com/vshen999/p/8365947.html