Java笔记 - 集合类

• 当需要在程序中记录单个数据的时候，声明变量记录
  当需要在程序中记录多个类型相同的数据时，声明数组记录
  当需要在程序中记录多个类型不同的数据时，构造对象记录
  当需要在程序中记录多个类型不同的对象时，使用集合来处理

数组和集合的比较

• 数组的特点
  1.数组本质上就是一段连续的内存空间，用于记录多个类型相同的数据
  2.数组一旦声明完毕，则内存空间固定不变
  3.执行插入和删除操作的时候不方便，可能会移动大量元素从而导致效率变低
  4.支持下标访问，可以实现随机访问
  5.数组中的元素可以是基本数据类型，也可以是引用数据类型
• 集合的特点
  1.内存空间可以不连续，数据类型可以不相同
  2.集合的内存空间可以动态调整
  3.集合的插入和删除操作可以不移动大量元素
  4.部分支持下标访问
  5.集合中的元素必须是引用数据类型

集合类

集合是在计算机中用于存储一种或多种引用数据类型，并且长度可变的容器
容器就是用来存储和组织其他对象的对象

Collection集合

Java语言中集合的框架顶层是：Collection集合、Map集合
其中Collection集合操作元素的基本单位是：单个元素
其中Map集合操作元素的基本单位是：单对元素

集合常用方法

1. add（E e）将指定对象存储到容器中
2. addAll() 将指定集合中的元素添加到调用该方法的集合中
3. size() 返回列表中的元素数
4. contains(Object o) 判断集合中是否包含参数指定的单个元素
5. containsAll(Collection<?> c) 表示判断集合中是否包含指定元素的整体
6. remove(int index) 移除列表中指定位置的元素
7. removeAll(Collection<?> c) 从列表中移除指定collection中包含的其所有元素
8. clear() 从列表中移除所有元素
9. isEmpty() 如果列表不包含元素，则返回true
10. set(int index, E element) 将集合中指定位置的元素进行替换
11. toArray() 将集合转换为数组
12. retainAll(Collection<?> c) 计算两个集合的交集并保留到当前集合中，若集合内容发生改变则返回true，否则返回false

List集合

List继承自Collection接口，有序元素可重复的集合

• List集合的实现类：
  （1）ArrayList
  数组实现，查找快，增删慢
  （2）LinkList
  链表实现，增删快，查找慢
  （3）Vector
  基于数组实现，线程同步的遗留集合类，和ArrayList原理相同，但线程安全，效率低
  （4）Stack
  后进先出

Queue 队列

add和remove在失败的时候回抛出异常（不推荐）
（1）offer() 添加元素
（2）poll() 返回第一个元素并在队列中删除
（3）element() 返回第一个元素
（4）peek() 返回第一个元素

Set集合

Set集合是用于无序存储不可重复的元素集合

• Set集合的实现类：

1. HashSet
   HashSet是基于哈希表的Set集合
   （1）需要使用hashCode算法计算元素的hash值
   （2）基于哈希表做实现
   （3）实现了Set接口

   HashSet集合存储步骤：
   （1）使用哈希算法设计元素对应的哈希值，使用此哈希值作为地址存储
   （2）判断此哈希值对应的位置上是否已经存有元素
   （3）若没有就将元素存储在该位置上
   （4）若有则使用equals方法判断两个对象是否相等，如果相等就不存储，不相等则与上一个元素存在一起

2. LinkedHashSet
   是基于双向链表和哈希表、继承自HashSet的Set集合
   特点：有序、不可重复

3. TreeSet
   基于红黑树，实现了Set集合，具有排序功能的Set集合

排序接口

• Comparable接口
  使实现类自身具备某种比较规则以便对其对象进行自然排序的接口。
  自然排序：是要求自定义类实现Comparable接口并重写其compareTo(T o)方法，在此方法中依据xx属性进行排序的算法

• Comparator比较器
  在外部自定义比较规则以便容器对其存储的数据进行定制排序的对象
  定制排序：要求自定义类实现Comparator接口并重写compare(T o1, T o2)方法，在此方法中依据xx属性进行排序的算法，也称为比较器排序

• Comparable接口
  实现该接口的类具有排序功能，需要重写compareTo(T o)方法，使用当前对象和参数对象进行比较

• Comparator接口
  不会对集合中存储的元素进行修改，需要自定义比较器类实现该接口，重写compare(T o1, T o2)方法，比较两个参数对象，需要将比较器对象以参数形式传入集合的构造器中

集合选择

• List：如果需要保留存储顺序并保留重复的元素，推荐使用List集合
  （1）ArrayList：若查询比较多，推荐使用
  （2）LinkedList：若存取较多，推荐使用
  （3）Vector：若需要线程安全，推荐使用
• Set：如果不需要保留存储顺序并需要去掉重复的元素，推荐使用Set集合
  （1）TreeSet：若需要将元素排序，推荐使用
  （2）HashSet：如果不需要使用排序，推荐使用HashSet，比TreeSet效率高
  （3）LinkedHashSet：若需要保留存储顺序，又需要去除重复的元素，推荐使用

Map集合

Map集合存储元素的特点以键值对形式存储元素，容器框架

• Map集合的实现类

1. HashMap
   基于哈希表实现的，线程不安全的Map容器

   • 特点：
     （1）基于哈希表实现
     （2）key不允许重复，值可重复
     （3）底层是数组+链表结构
     （4）允许null键和null值
     （5）线程不安全
   • HashMap的常用方法
     V put(K key, V value) - 添加数据，如果先前包含该键的映射，则替换旧值
     V get(Object key) - 返回指定键所映射的值
     entrySet() - 返回此地址中包含的映射的Set集合
     Set keySet() - 返回集合中包含的键的Set集合
     values() - 返回集合中包含的值得Collection集合
     V remove(Object key) - 从该集合中删除指定键的映射

2. LinkedHashMap
   继承自HashMap，基于双向链表存储有序的Map容器

3. Hashtable
   基于散列表实现，线程安全的Map容器

   • 特点：
     （1）不允许null键和null值
     （2）线程安全

• HashMap与Hashtable的区别
  1.继承的父类不同
  2.线程安全性不同
  3.是否允许null值
  4.遍历内容实现不同：都可以获得集合使用Interator，Hashtable还可以获取Enumeration

4. TreeMap
   基于红黑树实现，具有排序功能的Map容器
   • 特点：
     （1）底层是红黑树
     （2）不允许null值和null键
     （3）针对键进行排序而不是针对值
     （4）线程不安全

集合工具类

• Collections 用于操作集合的工具类
  注意：在使用Collections工具类之前，必须导入java.util包

Collections类的常用方法

1. void sort() - 对集合中存储的元素进行排序
2. shuffle() - 对集合中存储的元素进行随机排列
3. reverse() - 将集合中存储的元素位置进行倒置
4. max() - 获取集合中存储的最大元素
5. min() - 获取集合中存储的最小元素
6. indexOfSubList() - 获取指定子列表在整个列表中第一次出现的位置
7. lastIndexOfSubList() - 获取指定子列表在整个列表中最后一次出现的位置
8. binarySearch() - 二分查找

注意：所有的方法都是用static关键字修饰，使用Collections.xxx（）进行调用

案例：斗地主游戏，实现洗牌、发牌
Cards.java

public class Cards implements Comparable<Cards>{

private String color;
private String number;
private int sort;

public String getColor() {
	return color;
}
public void setColor(String color) {
	this.color = color;
}
public String getNumber() {
	return number;
}
public void setNumber(String number) {
	this.number = number;
}
public int getSort() {
	return sort;
}
public void setSort(int sort) {
	this.sort = sort;
}
public Cards(String color, String number, int sort) {
	super();
	this.color = color;
	this.number = number;
	this.sort = sort;
}
public Cards() {
	super();
}
@Override
public String toString() {
	return color+number;
}
@Override
public int compareTo(Cards o) {

	return this.sort-o.sort;
}

}

Pokers.java

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

public class Pokers {

LinkedList<Cards> list = new LinkedList<>();

String[] colors = {"♥", "♦", "♠", "♣"};

String[] number = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};


public Pokers(){
	
	for (int i = 0; i < colors.length; i++) {
		for (int j = 0; j < number.length; j++) {
	
			list.add(new Cards(colors[i], number[j], j));
		}
	}
	
	list.add(new Cards("", "大王", 100));
	list.add(new Cards("", "小王", 99));
	
}



public LinkedList<Cards> shuffle(LinkedList<Cards> list2) {
	
	Collections.shuffle(list2);
	
	return list2;
}

public LinkedList<Cards> deal(LinkedList<Cards> shuffle, List<Cards> list1, List<Cards> list2, List<Cards> list3) {

	while(shuffle.size() > 3){
		list1.add(shuffle.removeFirst());
		list2.add(shuffle.removeFirst());
		list3.add(shuffle.removeFirst());
	    }
	
	Collections.sort(list1);
	Collections.sort(list2);
	Collections.sort(list3);
	
	return shuffle;
}

public LinkedList<Cards> getList() {
	// TODO Auto-generated method stub
	return list;
    }

}

Main.java

import java.util.ArrayList; 
import java.util.LinkedList;
import java.util.List;

public class Main {

public static void main(String[] args) {
	
	List<Cards> list1 = new ArrayList<>();
	List<Cards> list2 = new ArrayList<>();
	List<Cards> list3 = new ArrayList<>();
	
	Pokers pokers = new Pokers();
	
	LinkedList<Cards> list = pokers.getList();
	
	LinkedList<Cards> shuffle = pokers.shuffle(list);
	System.out.println(shuffle);
	
	LinkedList<Cards> cards = pokers.deal(shuffle,list1,list2,list3);

	System.out.println("1"+list1);
	System.out.println("2"+list2);
	System.out.println("3"+list3);
	System.out.println("底牌"+cards);
	
    }	
}