1. 簡單練習HashSet集合-產生1到20，10個不重複的隨機數
//1.建立Random物件
Random r = new Random();
//2.因為儲存不重複的，我們用HashSet集合
//這裡泛型為什麼用Integer知道嗎！
HashSet<Integer> hs = new HashSet<>();
//3.迴圈條件hs.size()<10;
while (hs.size() < 10){
//4.通過Random方法獲取隨機數
//r.nextInt(20):獲取到的是0到19的隨機數--左開右閉的
hs.add(r.nextInt(20) + 1);
}
System.out.println(hs);
2. 集合小練習
#練習一:
//需求:使用Scanner輸入，去掉輸入中的重複字元，列印不同的字元
//1.建立Scanner物件
Scanner sc = new Scanner(System.in);
System.out.println("請輸入一串字元:");
//2.建立hashSet物件
HashSet<Character> hs = new HashSet<>();
//3.用字串接收這個輸入值，並將字串轉為字元陣列
String str = sc.nextLine();
char[] arr = str.toCharArray();
//4.遍歷字元陣列並加入到hs中
for (Character c : arr){
hs.add(c);
}
System.out.println(hs);
#練習二:
//需求:給有重複元素的ArrayList集合建立一個去重方法，直接呼叫就好
ArrayList<String> list = new ArrayList<>();
list.add("tmac");
list.add("tmac");
list.add("kobe");
list.add("kobe");
list.add("kg");
list.add("kg");
list.add("jiangjun");
list.add("jiangjun");
System.out.println(list);
System.out.println("去重之前的值");
//呼叫封裝的去重方法
cancelReptList(list);
System.out.println(list);
System.out.println("去重之後的值");
}
//封裝的去重方法
public static void cancelReptList(List<String> list){
//1.建立LinkedHashSet物件,這裡面不能儲存重複值
LinkedHashSet<String> hs = new LinkedHashSet<>();
//2.將list加到hs中，就可以在hs中去除重複值了
hs.addAll(list);
//3.將list清空
list.clear();
//4.將去重後的hs加入到list中
list.addAll(hs);
}
3. TreeSet集合的簡單使用
//1.TreeSet集合是對元素進行排序且保證元素唯一的
//只用LinkedHashSet是保證怎麼存就怎麼取，且去重的
TreeSet<Integer> ts = new TreeSet<>();//從小到大排序
ts.add(78);
ts.add(45);
ts.add(109);
ts.add(23);
ts.add(12);
System.out.println(ts);
//2.TreeSet集合儲存自定義物件
TreeSet<Student> ts1 = new TreeSet<>();
ts1.add(new Student("tmac",23));
ts1.add(new Student("kobe",13));
ts1.add(new Student("king",34));
ts1.add(new Student("jiangjun",45));
//我們儲存的是自定義物件，TreeSet是對元素排序的，我們看看會怎麼回事
System.out.println(ts1);
//報錯崩潰:java.lang.ClassCastException:型別無法匹配。我們解決方法是
//實現一個compable介面，就是要告訴TreeSet按照什麼要求對Student排序
//延展:
//TreeSet底層是二叉樹結構
4. Map集合的概述和特點和iOS的字典很像
//1.建立一個map
Map<String,Integer> map = new HashMap<>();
//新增元素的方法put--put方法是有返回值的，返回值就是這個值的型別
Integer i1 = map.put("tmac",19);
map.put("kobe",37);
map.put("kiii",98);
map.put("kdjf",88);
Integer i2 = map.put("tmac",39);
System.out.println(map);//看這個列印發現鍵和值是對應的，但是列印出來順序是無序的
System.out.println(i1);
System.out.println(i2);
//對比i1和i2的列印值，說明我們呢put方法的返回值只返回被覆蓋的鍵對應的值
//在Map中鍵的值是唯一的，我們重複為一個鍵新增值，就會覆蓋原有值，並返回
System.out.println("1---------------------");
//2.根據鍵刪除值，返回被刪除的值
Integer i3 = map.remove("tmac");
System.out.println(i3);
map.put("jj",45);
map.put("cc",44);
//根據鍵和值刪除，返回刪除成功與否
boolean b1 = map.remove("jj",45);
System.out.println(b1);
System.out.println("2------------------");
//3.清除所有元素
// map.clear();
//4.判斷功能
//map.containsKey():是否包含這個key
//map.containsValue():是否包含這個值
map.isEmpty();//是否為空
//5.獲取集合中所有的值
Collection<Integer> c = map.values();
System.out.println(c);
//6.map.size():元素個數--一對鍵值才是一個長度
5. Map集合的遍歷—鍵找值
//1. Map集合遍歷--鍵找值(map中沒有迭代器)
Map<String,Integer> map = new HashMap<>();
map.put("jj",67);
map.put("ji",45);
map.put("qq",32);
map.put("aa",13);
map.put("cc",38);
//根據鍵獲取值
//Integer i = map.get("jj");
//第一種遍歷方法
//獲取所有鍵的集合
Set<String> keySet = map.keySet();//這個set集合中就有迭代器了
Iterator<String> it = keySet.iterator();
while (it.hasNext()){
String str = it.next();
Integer i1 = map.get(str);
System.out.println(i1);
}
System.out.println("-----------------------");
//第二種 增強for迴圈遍歷
for (String str : map.keySet()){
Integer i2 = map.get(str);
System.out.println(i2);
}
6. Map使用鍵值對物件找鍵和值
//Map集合鍵值對物件找鍵和值
Map<String,String> map = new HashMap<>();
map.put("jj","maidi");
map.put("qq","tmac");
map.put("bb","kobe");
map.put("vv","king");
map.put("cc","polo");
System.out.println(map);
//獲取鍵值對物件
//Map.Entry說明Entry是Map的內部介面
Set<Map.Entry<String,String>> entrySet = map.entrySet();
System.out.println(entrySet);//現在列印出來和這個map是一樣的
//利用迭代器來遍歷entrySet
Iterator<Map.Entry<String,String>> it = entrySet.iterator();
while (it.hasNext()){
//獲得每一個entry物件
Map.Entry<String,String> en = it.next();
//獲取key和值
String key = en.getKey();
String value = en.getValue();
System.out.println(key);
System.out.println(value);
}
System.out.println("下面是增強for迴圈的結果");
//用增強for迴圈解決
for (Map.Entry<String,String> en : entrySet){
String key = en.getKey();
String value = en.getValue();
System.out.println(key);
System.out.println(value);
}
7. LinkedHashMap
//LinkedHashMap
LinkedHashMap<String,Integer> lhm = new LinkedHashMap<>();
lhm.put("t",3);
lhm.put("j",5);
lhm.put("w",2);
lhm.put("i",5);
System.out.println(lhm);
//列印出來發現是怎麼存怎麼取的
8.
//TreeMap集合--第一種比較，重寫自定義類的方法
TreeMap<Student,String> tm = new TreeMap<>();
tm.put(new Student("tmac",19),"成都");
tm.put(new Student("tma",123),"上海");
tm.put(new Student("tm",13),"北京");
tm.put(new Student("t",18),"廣州");
System.out.println(tm);
//在這裡列印tm是會報錯的，因為TreeMap會對這個鍵進行排序，現在
//我們的鍵是自定義的學生物件，所以不知道怎麼排序，所以我們要去在自定義類中
//去實現這個Comparable介面
//這樣還是比較複雜的，我們有傳比較器的構造方法
System.out.println("1----------------------");
#自定義類中的操作
public class Student implements Comparable<Student> //實現介面
//重寫介面中的方法
//實現這個Comparable<Student>介面，告訴這個TreeMap怎麼去比較這個Student
@Override
public int compareTo(Student s) {
int num = this.age - s.age;
return num == 0 ? this.name.compareTo(s.name) : num;
//以比較年齡為主要條件，姓名為次要條件
}
#第二種比較方法—傳入匿名內部類
//在我們建立這個tm1時，就傳一個匿名內部類，並重寫裡面的方法
TreeMap<Student,String> tm1 = new TreeMap<>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
int num = o1.getName().compareTo(o2.getName());//前面這個比較是按照碼錶值比較的(可以傳入中文試試)
return num == 0 ? o1.getAge() - o2.getAge() : num;//首要按姓名排序，其次年齡
}
});
tm1.put(new Student("蔣介石",19),"成都");
tm1.put(new Student("曾國藩",89),"上海");
tm1.put(new Student("易中天",13),"北京");
tm1.put(new Student("邋遢大王",18),"廣州");
System.out.println(tm1);
9. 統計字串中字元出現的次數
//小練習--統計字串中字元出現的次數
//1.定義一個字串
String str = "aaaaaahhhhhhhbbbbbbbddddddduuuuuuiiiiiiii";
//2.將字串轉為字元陣列
char[] charr = str.toCharArray();
//3.定義雙列集合，儲存字串及字串出現的次數
HashMap<Character,Integer> hs = new HashMap<>();
//4.遍歷字元陣列中所有字元，並將每個字元存入集合中
for (char c : charr){
//儲存過程中要判斷，如果集合中不包含這個key，就將鍵和值存入，且值為1.如果包含，就將值加1
// if (!hs.containsKey(c)){
// hs.put(c,1);
// }else{
// hs.put(c, hs.get(c) + 1);
// }
hs.put(c, hs.containsKey(c) ? hs.get(c) + 1 : 1 );
//三目運算子:表示式？ 結果1 : 結果2 (表示式為真，執行結果1,否則執行結果2)
}
System.out.println(hs);
10. HashMap巢狀HashMap
//HashMap巢狀HashMap
//定義一個班級
HashMap<Student, String> hm88 = new HashMap<>();
hm88.put(new Student("孫悟空", 23), "fd");
hm88.put(new Student("泰森", 24), "dd");
hm88.put(new Student("麥斯", 25), "dd");
hm88.put(new Student("科比", 26), "fgd");
//定義另一個班級
HashMap<Student, String> hm99 = new HashMap<>();
hm99.put(new Student("Ã∆…Æ", 1023), "±±æ©");
hm99.put(new Student("ÀÔŒÚø’",1024), "±±æ©");
hm99.put(new Student("÷Ì∞ÀΩ‰",1025), "…œ∫£");
hm99.put(new Student("…≥∫Õ…–",1026), "π„÷›");
//再定義一個HashMap來存，注意鍵--就是HashMap
HashMap<HashMap<Student, String>, String> hm = new HashMap<>();
hm.put(hm88, "µ⁄88∆⁄ª˘¥°∞‡");
hm.put(hm99, "µ⁄99∆⁄ª˘¥°∞‡");
//遍歷
for(HashMap<Student, String> h : hm.keySet()) {
String value = hm.get(h);
for(Student key : h.keySet()) {
String value2 = h.get(key);
System.out.println(key + "=" + value2 + "=" + value);
}
}
11. HashMap和Hashtable的簡單區別
//HashMap和Hashtable的區別
/*共同點:底層都是hash演算法，都是雙列集合
不同點:
HashMap:是執行緒不安全的，效率高
2.可以儲存null鍵和null值
Hashtable:是執行緒安全的，效率低
2.不能儲存null鍵和null值
*/
12. 集合框架Collections工具類簡單使用
//集合框架Collections工具類
/*
public static <T> void sort(List<T> list):排序
public static <T> int binarySearch(List<?> list,T key):二分查詢法
public static <T> T max(Collection<?> coll):獲取最大值
public static void reverse(List<?> list)
public static void shuffle(List<?> list)
*/
//1.排序
ArrayList<String> list = new ArrayList<>();
list.add("d");
list.add("c");
list.add("a");
list.add("b");
System.out.println(list);//ArrayList是怎麼存怎麼取的
System.out.println("排序之後");
//集合工具類Collections的類方法
Collections.sort(list);
System.out.println(list);
System.out.println("1-------------------------");
//2.二分查詢法--根據值返回值在集合中的索引
//我們用個有序的集合
ArrayList<String> list1 = new ArrayList<>();
list1.add("a");
list1.add("c");
list1.add("e");
list1.add("g");
list1.add("k");
list1.add("m");
list1.add("y");
int num = Collections.binarySearch(list1,"c");
int num1 = Collections.binarySearch(list1,"k");
System.out.println(num);
System.out.println(num1);
System.out.println("2------------------------------");
//3. 獲取最大值
String str = Collections.max(list1);
System.out.println(str);
System.out.println("3-------------------------------");
//4. 反轉
Collections.reverse(list1);
System.out.println(list1);
System.out.println("4--------------------------------");
//5. 洗牌--打亂
Collections.shuffle(list1);
System.out.println(list1);
13. 鬥地主隨機發牌實現
//鬥地主發牌小遊戲
//1.建立一個集合物件，將所有撲克存進去
//牌號
String[] num = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
//花色
String[] color = {"紅桃","黑桃","方片","梅花"};
ArrayList<String> poker = new ArrayList<>();
//拼接花色和數字
for (String s1 : color){
for (String s2 : num){
//拼接
String s3 = s1.concat(s2);
poker.add(s3);//一副撲克的基本骨架有了
}
}
//System.out.println(poker);
//新增大小王
poker.add("小王");
poker.add("大王");
System.out.println(poker.size());
//2.洗牌
Collections.shuffle(poker);
//3.發牌--我們需要三個集合當做三個玩家的牌,建立一個集合作為底牌的集合
ArrayList<String> tmac = new ArrayList<>();
ArrayList<String> kobe = new ArrayList<>();
ArrayList<String> mine = new ArrayList<>();
ArrayList<String> dipai = new ArrayList<>();
//for迴圈發牌
for (int i = 0; i < poker.size(); i++){
//先新增底牌
if (i >= poker.size() - 3){
dipai.add(poker.get(i));
}else if(i % 3 == 0){
//i%3:這個好好想想--在剩餘的51張牌中，有17個下標是可以將3整除的
tmac.add(poker.get(i));
}else if(i % 3 == 1){
kobe.add(poker.get(i));
}else{
mine.add(poker.get(i));
}
}
//4.看牌
System.out.println(tmac);
System.out.println(kobe);
System.out.println(mine);
System.out.println(dipai);