集合
集合是存储对象的数据集合容器
数组和集合的区别
数组只能存储同一种数据类型，集合可以存放多重数组类型
数组长度固定不利于未知类型和数据的解析，集合是不定长的
两个特殊集合
栈
栈是Vector的一个子类，它实现了一个标准的后进先出的栈。
先进后出(FILO)
//集合是存储对象的数据集合容器
//数组是同一种类型数据集合
//栈 --> 集合一种存储方式
Stack a = new Stack();
//入栈
a.push("fd");
a.push(10); //会自动装箱
a.push("hi的饿");
a.push('A');
//出栈
char c = (char)a.pop();
String d = (String)a.pop();
int e = (int)a.pop();
System.out.println(c); //A
System.out.println(d); //hi的饿
System.out.println(e); //10
System.out.println(a.pop()); //fd
System.out.println("<---------->");
队列
队列是一种特殊的线性表，它只允许在表的前端进行删除操作，而在表的后端进行插入操作。 先进先出（FIFO）
//队列是一种特殊的线性表，它只允许在表的前端进行删除操作，而在表的后端进行插入操作
Queue q = new LinkedList();
//插入 offer
q.offer(10);
q.offer("fddf");
q.offer('d');
//删除 poll
System.out.println(q.poll()); //10
System.out.println(q.poll()); //fddf
System.out.println(q.poll()); //d
System.out.println(q.poll()); //null
System.out.println(q.poll()); //null
集合的分布
结构图：
思维导图：
数组和链表的存储方式
数组：有索引和data两部分组成
链表：有data和指向下一个数据的指针地址两部分组成。
Vector、ArrayList都是以数组的形式存储在内存中，所以查询效率高，新增和删除效率不高，但是Vector内很多方法都加上了同步关键字synchronized，所以线程是安全的，ArrayList线程不安全。
LinkedList则是以链表的形式进行存储，所以查询效率低，新增和删除效率高，并且线程不安全。
Collection接口
Collection是最基本的集合接口，一个Collection代表一组Object,即Collection的元素，Java不提供直接继承自Collection的类，只提供继承于的子接口（如List和Set）
Collection的方法有：
List系列
Arraylist数组实现，查找快，增删满
//集合的顺序存储结构
//面向接口
List list = new ArrayList();
ArrayList list2 = new ArrayList();
//集合里面的内容称之为元素（element）
list.add(10);
list.add("a");
list.add("dfd");
list2.add("hhh");
list2.add("a");
list2.add("hhh");
list.addAll(list2);
list.remove("hhh"); //remove 只删除出现的第一个
ArrayList list3 = new ArrayList();
list3.add("a");
list.removeAll(list3); //removeAll对表集合元素去删除，将对应的集合所有出现该元素的内容全部清除。
// list.clear(); //清空
System.out.println(list.isEmpty()); //判断集合是否为空 false
System.out.println(list.contains("dfd")); //判断集合是否包含指定对象 true
System.out.println(list.containsAll(list2)); //判断集合是否包含 false
for (Object object : list) {
System.out.print(object + "\t"); //10 dfd hhh
}
System.out.println();
System.out.println(list.size()); //返回集合容器的大小
Object[] obj = list.toArray(); //集合转数组
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i)); //返回此列表指定位置的元素
}
System.out.println("<----------->");
//利用迭代器的方法
Iterator it = list.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
Set系列
Set没有索引的方式去获取对应的元素
保证元素唯一性的方式依赖于：hashCode()与equals()方法。
//Set 无序，不可重复
//HashSet 支持null 内容无序
//TreeSet 不支持nulll 按字典排序
// LinkedHashSet 支持null 带存储顺序
// Set没有索引的方式去获取对应的元素
// 保证元素唯一性的方式依赖于：hashCode()与equals()方法。
Set st = new LinkedHashSet();
st.add(10);
st.add('d');
st.add("A");
st.add("地方");
st.add("厄特特");
st.add(null);
st.add(null);
st.add("A");
st.add("dfd");
//使用迭代器方式
Iterator it = st.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
// System.out.println(st.getClass().getName()); //java.util.HashSet
// System.out.println(st.getClass().getName()); //java.util.TreeSet，TreeSet存放简单的同一类型的数据
// System.out.println(st.getClass().getName()); //java.util.LinkedHashSet
// for (Object o : st) {
// System.out.println(o);
// }
Map
键值对、键唯一、值不唯一
HashMap<String, String> a = new HashMap<>();
//存储值，值可以重复，键不可以重复，钥匙和门
a.put("1","A");
a.put("2","B");
a.put("3","J");
a.put("4","J");
a.put("5","df");
a.put(null,"ij");
//通过key键，获取值。
System.out.println(a.get("3")); //J
System.out.println(a.get("4")); //J
System.out.println(a.remove("2")); //B
System.out.println(a.get("2")); //null
System.out.println("<---------->");
//遍历
//先获取map的key集合
Set<String> set = a.keySet();
for (String object : set ) {
System.out.println(a.get(object));
}
集合工具类
Collections
//集合的一系列方法
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
list.add(10);
list.add(1);
list.add(9);
list.add(3);
list.add(5);
Collections.sort(list);
System.out.println(list); //[1, 3, 5, 9, 10]
Collections.sort(list,new Comparator<Integer>(){
@Override
public int compare(Integer o1, Integer o2) {
// System.out.println(o1 + ":" + o2);
if(o1 <o2){
return 1;
}
// public int compare(String o1, String o2)：比较其两个参数的顺序。
//
// 两个对象比较的结果有三种：大于，等于，小于。
//
// 如果要按照升序排序，
// 则o1 小于o2，返回（负数），相等返回0，01大于02返回（正数）
// 如果要按照降序 排序
// 则o1 小于o2，返回（正数），相等返回0，01大于02返回（负数）
return -1;
}
});
System.out.println(list); //[10, 9, 5, 3, 1]
Collections.shuffle(list); //打乱排序，变成随机
System.out.println(list);
斗地主发牌，一次17张。
public static void main(String[] args) {
String hua[] = {"♦","♣","♥","♠"};
String shuzi[] = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
List<String> list = new ArrayList<String>();
//数组转集合
List<String> hua_1 = new ArrayList<>();
for (int i = 0; i < hua.length; i++) {
hua_1.add(hua[i]);
}
List<String> shuzi_1 = new ArrayList<>();
for (int i = 0; i < shuzi.length; i++) {
shuzi_1.add(shuzi[i]);
}
for (int i = 0; i < hua.length; i++) {
for (int j = 0; j < shuzi.length; j++) {
list.add(hua[i] + shuzi[j]);
}
}
list.add("大王");
list.add("小王");
Collections.shuffle(list); //打乱
List<String> list2 = new ArrayList<String>();
for (int i = 0; i < 17; i++) {
list2.add(list.remove(0)); //一次发牌17张
}
System.out.println(list2);
Collections.sort(list2, new Comparator<String>() { //对发好的牌进行排序
@Override
public int compare(String o1, String o2) {
String o1_hua = o1.substring(0, 1);
String o1_shuzi = o1.substring(1);
String o2_hua = o2.substring(0, 1);
String o2_shuzi = o2.substring(1);
int index_j = shuzi_1.indexOf(o1_shuzi);
int index_j_1 = shuzi_1.indexOf(o2_shuzi);
if (index_j < index_j_1){ // 先判断数字
return 1;
}else if (index_j == index_j_1){
int index_o = hua_1.indexOf(o1_hua);
int index_o_1 = hua_1.indexOf(o2_hua);
if (index_o <index_o_1){
return 1;
}
}
return -1;
}
});
//解决大小王排序的问题
boolean s = list2.remove("小王");
boolean s2 = list2.remove("大王");
if (s){
list2.add(0,"小王");
}if (s2){
list2.add(0,"大王");
}
System.out.println(list2);
}
集合运算
//集合运算
HashSet<String> st = new HashSet<String>();
List<String> st2 = new ArrayList<String>();
//学过化学
st.add("张三");
st.add("李四");
st.add("王五");
//学过物理
st2.add("小米");
st2.add("李华");
st2.add("王五");
// st.retainAll(st2); //取交集
// st.addAll(st2); //取合集
st.removeAll(st2); //取差集
System.out.println(st);
