集合+泛型

前言
Collection接口
- Arraylist集合操作
- 集合实例--斗地主
- 数组的特点
- - 数组和集合的区别
- List集合
- - LinkedList集合
- Set集合
- 比较器
Map
- HashSet和TreeSet比较
- Map接口中的常用方法
- 斗地主综合案例升级版(添加看牌时排序功能)
彩蛋

前言

近来在学习算法，刚入门算法，属实是有点吃力，一个力扣的简单题目做一个多小时，悔当初没有好好学算法，当初以为只要学好一门语言和框架就可以了，但是后来发现算法是灵魂，算法不精通那不管学什么也都是捉襟见肘啊。但java这方面的知识也不能落下呀，最近打算开发一个汇总Java SE的项目，于是先来博客把那些重点的知识再串一下吧，今天先从集合+泛型开始，集合那可是相当重要啊！话不多说，整起~

Collection接口

Java集合框架的根是两个接口：Collection和Map，根据Collection和Map的架构，Java中的集合可以分为3类：List是有序集合，他会记录每次添加元素的顺序，元素可以重复；Set是无序集合，不记录元素添加的顺序，元素不可以重复；Map是键值对的集合，每个元素都有键Key和值value对应组成，键值和取值分别存储，键值是无序集合Set，取值是有序集合List。
collenction是单列集合最顶级的接口

注：新建对象的时候可以用new 对象名().var，回车，即可。
迭代器是Collection集合通用的取出数据的方式。

Collection<String> c = new ArrarList<>();
c.add("吴哥"); c.add("海哥");
Iterator it = c.iterator();
while(it.hasNext()){String n = (String)it.next();System.out.println(n);}

Arraylist集合操作

package cn.gather;import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;public class collection {/***创建一个AeeayList集合，用到了多态的概念，* 泛型是String* 分别使用while迭代器遍历集合和增强for循环遍历集合*/public static void main(String[] args ){Collection<String> c = new ArrayList<>();c.add("王虎");//添加数据c.add("刘华");c.add("黄花");System.out.println(c.size());//返回集合的个数System.out.println(c.isEmpty());//判断集合是否为空System.out.println(c.contains("刘华"));//判断集合是否包含"刘华"System.out.println(c.remove("刘华"));//删除刘华System.out.println(c.size());Iterator<String> is = c.iterator();//调用接口的实现类while (is.hasNext()){//判断集合中有无数据String em = is.next();//将数据取出，并移到下一个数据上System.out.println(em);}c.clear();//清除集合数据，但不是删除集合System.out.println(c);test01();//调用方法test02();}private static void test02(){ArrayList<String> em = new ArrayList<>();em.add("花花");em.add("呼呼");em.add("黄乎乎");for (String i:em) {System.out.println(i);}}private static void test01(){int[] arr = {1,2,3,4,5};//建立int数组for (int i : arr) {//for增强循环System.out.print(" "+i);}System.out.println();}
}

集合实例–斗地主

代码如下：

package cn.gather;import java.util.ArrayList;
import java.util.Collections;/*** 斗地主案例* 1.准备牌* 2.洗牌* 3.发牌* 4.看牌*/
public class DouDiZhu {public static void main(String[] args ){/*** 1.准备牌*///定义一个可以存储54张牌的ArrayList的集合，集合泛型是StringArrayList<String> poker = new ArrayList<>();//定义两个数组。一个存储花色，一个存储数字String[] colors ={"♥","♠","♣","♦"};String[] numbers = {"2","A","K","Q","J","10","9","8","7","6","5","4","3"};//先将两个大王和小王存储到集合poker当中poker.add("大王");poker.add("小王");//将花色数组和数字数组组合成52张牌for (String color:colors) {for (String number:numbers) {poker.add(color+number);}}//System.out.println(poker);/*** 2.洗牌* 使用集合工具类Collection中的方法* static void shuffle(list<?> list)使用默认的方法进行乱序存放*/Collections.shuffle(poker);//System.out.println(poker);/*** 3.发牌*///定义四个集合，分别是存放三个人的牌和底牌ArrayList<String> player01 = new ArrayList<>();ArrayList<String> player02 = new ArrayList<>();ArrayList<String> player03 = new ArrayList<>();ArrayList<String> dipai = new ArrayList<>();/*** 遍历集合获取每一张牌* 然后根据i模除3等于多少发到对应人的手里* 如果i>=51，则把最后三张发给底牌,因为是从0开始的所以是51而不是52，一共是到53*/for (int i = 0; i < poker.size(); i++) {String s = poker.get(i);if (i>=51){dipai.add(s);}else if (i%3==0){player01.add(s);}else if (i%3==1){player02.add(s);}else if (i%3==2){player03.add(s);}}/*** 4.看牌*/System.out.println(player01);System.out.println(player02);System.out.println(player03);System.out.println(dipai);}
}

数组的特点

数组和集合的区别

数组长度固定，集合长度不固定。数组类型固定，集合类型不固定。数组查找效率高，因为他的地址是连续的，通过索引可以快速找到某一个元素，但是数组的增删是效率极低的，因为其长度固定，所以增删的时候需要新建一个数组然后将原数组内容复制过来。
链表查询慢，增删快与数组刚好相反：，单链表是上个节点记得下个节点的地址，但下个节点记不住上个节点的地址，所以单向。增删元素只需改变节点的自身地址和下一个的地址即可。

树形结构，红黑树查询速度非常之快：

List集合

关于List集合为什么是“List list = new ArrayList();”定义而不是"Collection list = new ArrayList<>();"这样定义，原因是因为多态，后者运用了多态机制，无法调用ArrayList自身的方法和属性，还有就是List和Set集合的共同特点形成了Collection接口，Collection接口没有带索引的方法，List有带索引的方法。

List接口中的ArrayList接口适合查找，因为ArrayList是基于数组的操作，带有索引，不适合增删。LinKedList接口是基于链表的，适合增删，每次查找都从头开始，查找效率极低，当然还有更快的查询方式，在这里只是相比而言。

//三种遍历数组的方法********************
//for遍历
for (int i = 0; i < list.size(); i++) {String s1 = list.get(i);System.out.println(s1);
}
System.out.println("--------------");
//迭代器遍历
Iterator<String> it = list.iterator();
while (it.hasNext()){String em = it.next();System.out.println(em);
}
System.out.println("--------------");
//增强for遍历
for (String i :list) {System.out.println(i);
}

LinkedList集合

Set集合

package cn.gather;import java.util.*;/*** List集合：具有索引，可以有重复的数据，可以使用任何方式遍历结果。* Set集合：没有索引，也没有带有索引的方法，不能使用普通的for循环遍历，也不能有重复的数据*/
public class DemoList {public static void main(String[] args ){//arraylist();//linkedlist();hashset();}/***HashSet特点：* 1.不允许重复* 2.没有索引，也没有带索引的方法* 3.是一个无序的集合，也就是插入和输出的顺序不一致* 4，底层实现是一个哈希表，哈希表查询的速度非常快*/private static void hashset() {HashSet<Integer> set = new HashSet<>();//使用.add方法插入数据到哈希表中，add方法是Collection继承给Set接口的set.add(1);set.add(2);set.add(3);set.add(1);//使用迭代器遍历Iterator<Integer> it = set.iterator();while (it.hasNext()){Integer em = it.next();System.out.println(em);}System.out.println("--------------");//使用增强for循环遍历for (Integer i : set) {System.out.println(i);}}/***LinkedList集合，是基于链表的集合，适合增删，都有带有索引的方法*/private static void linkedlist() {LinkedList<String> link = new LinkedList<>();link.push("a");link.addFirst("a");link.add("b");//System.out.println(link.removeFirst());System.out.println(link.removeFirst());System.out.println(link.pop());System.out.println(link.getFirst());System.out.println(link);}/***ArrayList集合是基于数组产生的，具有索引，常用作查找功能*/private  static void arraylist(){List<String> list = new ArrayList<>();list.add("a");list.add("b");list.add("c");list.add("a");System.out.println(list);list.add(3,"2");System.out.println(list);String s = list.get(2);System.out.println(s);list.remove(1);list.set(2,"d");System.out.println(list);System.out.println("--------------");//for遍历for (int i = 0; i < list.size(); i++) {String s1 = list.get(i);System.out.println(s1);}System.out.println("--------------");//迭代器遍历Iterator<String> it = list.iterator();while (it.hasNext()){String em = it.next();System.out.println(em);}System.out.println("--------------");//增强for遍历for (String i :list) {System.out.println(i);}}
}

哈希表对于没有定义的数据类型如User、Student必须重写Hashcode和equals方法

package cn.gather;import java.util.*;/*** List集合：具有索引，可以有重复的数据，可以使用任何方式遍历结果。* Set集合：没有索引，也没有带有索引的方法，不能使用普通的for循环遍历，也不能有重复的数据*/
public class DemoList {public static void main(String[] args ){//arraylist();//linkedlist();//hashset();/* HashSet<Person> set = new HashSet<>();//哈希表对于没有定义的数据类型需要重写Hashcode和equals方法Person p1 = new Person("刘哥" ,23);Person p2 = new Person("刘哥" ,23);Person p3 = new Person("海哥" ,28);set.add(p1);set.add(p2);set.add(p3);System.out.println(set);*/add(1,2,3,4,5,6);mand(1,2,3,4,5,"sd","das",23);}private static  void mand(Object...arr){System.out.println(arr);for (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);}}private  static int add(int...arr){System.out.println(arr);System.out.println(arr.length);int sum = 0;for (int i = 0; i < arr.length; i++) {sum = sum + arr[i];}System.out.println(sum);return 0;}/***HashSet特点：* 1.不允许重复* 2.没有索引，也没有带索引的方法* 3.是一个无序的集合，也就是插入和输出的顺序不一致* 4，底层实现是一个哈希表，哈希表查询的速度非常快*/private static void hashset() {HashSet<Integer> set = new HashSet<>();//使用.add方法插入数据到哈希表中，add方法是Collection继承给Set接口的set.add(1);set.add(2);set.add(3);set.add(1);//使用迭代器遍历Iterator<Integer> it = set.iterator();while (it.hasNext()){Integer em = it.next();System.out.println(em);}System.out.println("--------------");//使用增强for循环遍历for (Integer i : set) {System.out.println(i);}}/***LinkedList集合，是基于链表的集合，适合增删，都有带有索引的方法*/private static void linkedlist() {LinkedList<String> link = new LinkedList<>();link.push("a");link.addFirst("a");link.add("b");//System.out.println(link.removeFirst());System.out.println(link.removeFirst());System.out.println(link.pop());System.out.println(link.getFirst());System.out.println(link);}/***ArrayList集合是基于数组产生的，具有索引，常用作查找功能*/private  static void arraylist(){List<String> list = new ArrayList<>();list.add("a");list.add("b");list.add("c");list.add("a");System.out.println(list);list.add(3,"2");System.out.println(list);String s = list.get(2);System.out.println(s);list.remove(1);list.set(2,"d");System.out.println(list);System.out.println("--------------");//for遍历for (int i = 0; i < list.size(); i++) {String s1 = list.get(i);System.out.println(s1);}System.out.println("--------------");//迭代器遍历Iterator<String> it = list.iterator();while (it.hasNext()){String em = it.next();System.out.println(em);}System.out.println("--------------");//增强for遍历for (String i :list) {System.out.println(i);}}
}

可变参数：

//在集合中添加多个元素，并将其打乱
ArrayList<String> list01 = new ArrayList<>();
//在集合中添加多个元素 addall()
Collections.addAll(list,"1","a","heihua","b","df");
Collections.shuffle(list);

ArrayList<Integer> list01 = new ArrayList<>();
Collections.addAll(list01,1,2,3,3,2,7,4,5);
Collections.sort(list01);
System.out.println(list01);ArrayList<String> list02 = new ArrayList<>();
Collections.addAll(list02,"c","g","a","me");
Collections.sort(list02);
System.out.println(list02);ArrayList<Person> list03 = new ArrayList<>();//自己定义的类并没有重写Comp..。。方法
list03.add(new Person("张三",35));
list03.add(new Person("赵六",10));
list03.add(new Person("五把",33));
Collections.sort(list03);
System.out.println(list03);********************************
//自己定义的类没有默认的排序，需要重写CompareTo方法
/*
重写CompareTo方法
更改排序规则*/
@Override
public int compareTo(Person o) {//自定义排序规则，比较年龄排序return this.Age - o.Age;//升序
}

比较器

Map

HashSet和TreeSet比较

如果需要排序就用TreeSet，如果不需要比较就用HashSet。HashMap的运行速度比较快，如果不需要按照排序的话还是推荐HashMap。

Map接口中的常用方法

//Map集合迭代必须先转换成set集合再进行迭代
HashMap<String,String> map = new HashMap<>();
map.put("张飞","张翼德");
map.put("刘备","刘玄德");
map.put("曹操","曹孟德");
map.put("赵云","赵子龙");
map.put("周瑜","周公瑾");// System.out.println(map.remove("张飞"));
System.out.println(map);
//System.out.println(map.get("关羽"));
//System.out.println(map.containsKey("关羽"));
**********************
//第一种遍历方法
Set<String> set = map.keySet();
for (String i : set) {String s = map.get(i);System.out.println(i+"="+s);
}
**********************
//第二种遍历方法
Set<Map.Entry<String, String>> set = map.entrySet();
for (Map.Entry i : set) {System.out.println(i.getKey() + "=" + i.getValue());
}

关于Map集合存入Student的时候，如果key是Student那么student类必须重写equals和hashcode方法，如果key是String类则不用，这和上面的一个道理，如果自己定义的类牵扯到重复值的问题，那么久必须重写equals和hashcode方法。
代码如下：

//String类型做Key的值，不需要重写，Java自带
HashMap<String,Student> map = new HashMap<>();
map.put("张飞",new Student("张翼德",35));
map.put("孙权",new Student("孙仲谋",35));
map.put("袁绍",new Student("袁本初",35));
map.put("张飞",new Student("张",35));
//Student类做Key的值，必须重写方法
HashMap<Student,String> map = new HashMap<>();
map.put(new Student("张飞",23),"张翼德");
map.put(new Student("马超",23),"马孟起");
map.put(new Student("鲁肃",23),"鲁子敬");
map.put(new Student("张飞",23),"张");
//利用增强for循环来遍历HashMap集合
for (Map.Entry i:map.entrySet()) {System.out.println(i.getKey() + "=" + i.getValue());
}

package cn.gather;import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;/***计算字符串中每个字符出现的次数* 1.使用Scanner获取字符* 2.创建map集合，key是字符串中的字符，value是字符出现的次数* 3.通过字符串遍历，取出每一个元素* 4.使用获取到得字符与map集合中的key判断有没有* 5.key如果存在，在获取value，value++，不存在put方法，添加key和value，value=1；* 6.遍历map集合输出结果*/
public class DenoMapTest {public static void main(String[] args ){//输入一个字符串Scanner input = new Scanner(System.in);System.out.println("请输入一个集合：");String x = input.next();//建立Map集合HashMap<Character,Integer> map = new HashMap<>();//先将输入的字符串转化成一个字符串数组对数组进行遍历，与集合中的key进行比较，有的话value加一，没有的话用put存入for (char i: x.toCharArray()) {if (map.containsKey(i)){Integer d = map.get(i);d++;map.put(i,d);}else {map.put(i,1);}}//Map集合不能直接迭代，需要转化一下，我这里用了entryset类进行遍历for (Map.Entry i:map.entrySet()) {System.out.println(i.getKey() + "=" + i.getValue());}}
}

斗地主综合案例升级版(添加看牌时排序功能)