day18-----------集合框架(map集合)（傳智視頻）
Map集合的獲取功能測試java
package cn.itcast_01;
import java.util.HashMap;
import java.util.Map;
/*
* 做爲學生來講，是根據學號來區分不一樣的學生的，那麼假設我如今已經知道了學生的學號，我要根據學號去獲取學生姓名，請問怎麼作呢?
* 若是採用前面講解過的集合，咱們只能把學號和學生姓名做爲一個對象的成員，而後存儲整個對象，未來遍歷的時候，判斷，獲取對應的名稱。
* 可是呢，若是我都能把學生姓名拿出來了，我還須要根據編號去找嗎?
* 針對咱們目前的這種需求：僅僅知道學號，就想知道學生姓名的狀況，Java就提供了一種新的集合 Map。
* 經過查看API，咱們知道Map集合的一個最大的特色，就是它能夠存儲鍵值對的元素。這個時候存儲咱們上面的需求，就能夠這樣作
* 學號1 姓名1
* 學號2 姓名2
* 學號3 姓名3
* 學號2(不行)姓名4
* 學號4 姓名4
* Map集合的特色：
* 將鍵映射到值的對象。一個映射不能包含重複的鍵；每一個鍵最多隻能映射到一個值。
*
* Map集合和Collection集合的區別?
* Map集合存儲元素是成對出現的，Map集合的鍵是惟一的，值是可重複的。能夠把這個理解爲：夫妻對
* Collection集合存儲元素是單獨出現的，Collection的兒子Set是惟一的，List是可重複的。能夠把這個理解爲：光棍(11.11)
*
* 注意：
* Map集合的數據結構值針對鍵有效，跟值無關
* HashMap，TreeMap等會講。
* Collection集合的數據結構是針對元素有效
*
* Map集合的功能概述：
* 1:添加功能
* V put(K key,V value):添加元素。這個其實還有另外一個功能?先不告訴你，等會講
* 若是鍵是第一次存儲，就直接存儲元素，返回null
* 若是鍵不是第一次存在，就用值把之前的值替換掉，返回之前的值
* 2:刪除功能
* void clear():移除全部的鍵值對元素
* V remove(Object key)：根據鍵刪除鍵值對元素，並把值返回
* 3:判斷功能
* boolean containsKey(Object key)：判斷集合是否包含指定的鍵
* boolean containsValue(Object value):判斷集合是否包含指定的值
* boolean isEmpty()：判斷集合是否爲空
* 4:獲取功能
* Set<Map.Entry<K,V>> entrySet():???
* V get(Object key):根據鍵獲取值
* Set<K> keySet():獲取集合中全部鍵的集合
* Collection<V> values():獲取集合中全部值的集合
* 5：長度功能
* int size()：返回集合中的鍵值對的對數
*/
public class MapDemo {
public static void main(String[] args) {
// 建立集合對象
Map<String, String> map = new HashMap<String, String>();
// 添加元素
// V put(K key,V value):添加元素。這個其實還有另外一個功能?先不告訴你，等會講
// System.out.println("put:" + map.put("文章", "馬伊俐"));
// System.out.println("put:" + map.put("文章", "姚笛"));
map.put("鄧超", "孫儷");
map.put("黃曉明", "楊穎");
map.put("周杰倫", "蔡依林");
map.put("劉愷威", "楊冪");
// void clear():移除全部的鍵值對元素
// map.clear();
// V remove(Object key)：根據鍵刪除鍵值對元素，並把值返回
// System.out.println("remove:" + map.remove("黃曉明"));
// System.out.println("remove:" + map.remove("黃曉波"));
// boolean containsKey(Object key)：判斷集合是否包含指定的鍵
// System.out.println("containsKey:" + map.containsKey("黃曉明"));
// System.out.println("containsKey:" + map.containsKey("黃曉波"));
// boolean isEmpty()：判斷集合是否爲空
// System.out.println("isEmpty:"+map.isEmpty());
//int size()：返回集合中的鍵值對的對數
System.out.println("size:"+map.size());
// 輸出集合名稱
System.out.println("map:" + map);
}
}
map集合的獲取功能測試：
android
package cn.itcast_01;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/*
* 獲取功能：
* V get(Object key):根據鍵獲取值
* Set<K> keySet():獲取集合中全部鍵的集合
* Collection<V> values():獲取集合中全部值的集合
*/
public class MapDemo2 {
public static void main(String[] args) {
// 建立集合對象
Map<String, String> map = new HashMap<String, String>();
// 建立元素並添加元素
map.put("鄧超", "孫儷");
map.put("黃曉明", "楊穎");
map.put("周杰倫", "蔡依林");
map.put("劉愷威", "楊冪");
// V get(Object key):根據鍵獲取值
System.out.println("get:" + map.get("周杰倫"));
System.out.println("get:" + map.get("周杰")); // 返回null
System.out.println("----------------------");
// Set<K> keySet():獲取集合中全部鍵的集合
Set<String> set = map.keySet();
for (String key : set) {
System.out.println(key);
}
System.out.println("----------------------");
// Collection<V> values():獲取集合中全部值的集合
Collection<String> con = map.values();
for (String value : con) {
System.out.println(value);
}
}
}
Map集合的遍歷之鍵找值
面試
package cn.itcast_01;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/*
* Map集合的遍歷。
* Map -- 夫妻對
* 思路：
* A:把全部的丈夫給集中起來。
* B:遍歷丈夫的集合，獲取獲得每個丈夫。
* C:讓丈夫去找本身的妻子。
*
* 轉換：
* A:獲取全部的鍵
* B:遍歷鍵的集合，獲取獲得每個鍵
* C:根據鍵去找值
*/
public class MapDemo3 {
public static void main(String[] args) {
// 建立集合對象
Map<String, String> map = new HashMap<String, String>();
// 建立元素並添加到集合
map.put("楊過", "小龍女");
map.put("郭靖", "黃蓉");
map.put("楊康", "穆念慈");
map.put("陳玄風", "梅超風");
// 遍歷
// 獲取全部的鍵
Set<String> set = map.keySet();
// 遍歷鍵的集合，獲取獲得每個鍵
for (String key : set) {
// 根據鍵去找值
String value = map.get(key);
System.out.println(key + "---" + value);
}
}
}
Map集合的遍歷之鍵值對對象找鍵和值
數組
package cn.itcast_01;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/*
* Map集合的遍歷。
* Map -- 夫妻對
*
* 思路：
* A:獲取全部結婚證的集合
* B:遍歷結婚證的集合，獲得每個結婚證
* C:根據結婚證獲取丈夫和妻子
*
* 轉換：
* A:獲取全部鍵值對對象的集合
* B:遍歷鍵值對對象的集合，獲得每個鍵值對對象
* C:根據鍵值對對象獲取鍵和值
*
* 這裏面最麻煩的就是鍵值對對象如何表示呢?
* 看看咱們開始的一個方法：
* Set<Map.Entry<K,V>> entrySet()：返回的是鍵值對對象的集合
*/
public class MapDemo4 {
public static void main(String[] args) {
// 建立集合對象
Map<String, String> map = new HashMap<String, String>();
// 建立元素並添加到集合
map.put("楊過", "小龍女");
map.put("郭靖", "黃蓉");
map.put("楊康", "穆念慈");
map.put("陳玄風", "梅超風");
// 獲取全部鍵值對對象的集合
Set<Map.Entry<String, String>> set = map.entrySet();
// 遍歷鍵值對對象的集合，獲得每個鍵值對對象
for (Map.Entry<String, String> me : set) {
// 根據鍵值對對象獲取鍵和值
String key = me.getKey();
String value = me.getValue();
System.out.println(key + "---" + value);
}
}
}
HashMap集合鍵是String值是Student的案例
安全
package cn.itcast_02;
public class Student {
private String name;
private int age;
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
package cn.itcast_02;
import java.util.HashMap;
import java.util.Set;
/*
* HashMap<String,Student>
* 鍵：String 學號
* 值：Student 學生對象
*/
public class HashMapDemo3 {
public static void main(String[] args) {
// 建立集合對象
HashMap<String, Student> hm = new HashMap<String, Student>();
// 建立學生對象
Student s1 = new Student("周星馳", 58);
Student s2 = new Student("劉德華", 55);
Student s3 = new Student("梁朝偉", 54);
Student s4 = new Student("劉嘉玲", 50);
// 添加元素
hm.put("9527", s1);
hm.put("9522", s2);
hm.put("9524", s3);
hm.put("9529", s4);
// 遍歷
Set<String> set = hm.keySet();
for (String key : set) {
// 注意了：此次值不是字符串了
// String value = hm.get(key);
Student value = hm.get(key);
System.out.println(key + "---" + value.getName() + "---"
+ value.getAge());
}
}
}
LinkedHashMap數據結構
package cn.itcast_03;
import java.util.LinkedHashMap;
import java.util.Set;
/*
* LinkedHashMap:是Map接口的哈希表和連接列表實現，具備可預知的迭代順序。
* 由哈希表保證鍵的惟一性
* 由鏈表保證鍵盤的有序(存儲和取出的順序一致)
*/
public class LinkedHashMapDemo {
public static void main(String[] args) {
// 建立集合對象
LinkedHashMap<String, String> hm = new LinkedHashMap<String, String>();
// 建立並添加元素
hm.put("2345", "hello");
hm.put("1234", "world");
hm.put("3456", "java");
hm.put("1234", "javaee");
hm.put("3456", "android");
// 遍歷
Set<String> set = hm.keySet();
for (String key : set) {
String value = hm.get(key);
System.out.println(key + "---" + value);
}
}
}
TreeMap集合鍵是String值是String的案例
app
package cn.itcast_04;
import java.util.Set;
import java.util.TreeMap;
/*
* TreeMap:是基於紅黑樹的Map接口的實現。
*
* HashMap<String,String>
* 鍵：String
* 值：String
*/
public class TreeMapDemo {
public static void main(String[] args) {
// 建立集合對象
TreeMap<String, String> tm = new TreeMap<String, String>();
// 建立元素並添加元素
tm.put("hello", "你好");
tm.put("world", "世界");
tm.put("java", "爪哇");
tm.put("world", "世界2");
tm.put("javaee", "爪哇EE");
// 遍歷集合
Set<String> set = tm.keySet();
for (String key : set) {
String value = tm.get(key);
System.out.println(key + "---" + value);
}
}
}
TreeMap集合 鍵是Student 值是String的案例
ide
package cn.itcast_04;
public class Student {
private String name;
private int age;
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
package cn.itcast_04;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeMap;
/*
* TreeMap<Student,String>
* 鍵:Student
* 值：String
*/
public class TreeMapDemo2 {
public static void main(String[] args) {
// 建立集合對象
TreeMap<Student, String> tm = new TreeMap<Student, String>(
new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
// 主要條件
int num = s1.getAge() - s2.getAge();
// 次要條件
int num2 = num == 0 ? s1.getName().compareTo(
s2.getName()) : num;
return num2;
}
});
// 建立學生對象
Student s1 = new Student("潘安", 30);
Student s2 = new Student("柳下惠", 35);
Student s3 = new Student("唐伯虎", 33);
Student s4 = new Student("燕青", 32);
Student s5 = new Student("唐伯虎", 33);
// 存儲元素
tm.put(s1, "宋朝");
tm.put(s2, "元朝");
tm.put(s3, "明朝");
tm.put(s4, "清朝");
tm.put(s5, "漢朝");
// 遍歷
Set<Student> set = tm.keySet();
for (Student key : set) {
String value = tm.get(key);
System.out.println(key.getName() + "---" + key.getAge() + "---"
+ value);
}
}
}
統計字符串中每一個字符出現的次數案例代碼實現
工具
package cn.itcast_05;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;
/*
* 需求 ："aababcabcdabcde",獲取字符串中每個字母出現的次數要求結果:a(5)b(4)c(3)d(2)e(1)
*
* 分析：
* A:定義一個字符串(能夠改進爲鍵盤錄入)
* B:定義一個TreeMap集合
* 鍵:Character
* 值：Integer
* C:把字符串轉換爲字符數組
* D:遍歷字符數組，獲得每個字符
* E:拿剛纔獲得的字符做爲鍵到集合中去找值，看返回值
* 是null:說明該鍵不存在，就把該字符做爲鍵，1做爲值存儲
* 不是null:說明該鍵存在，就把值加1，而後重寫存儲該鍵和值
* F:定義字符串緩衝區變量
* G:遍歷集合，獲得鍵和值，進行按照要求拼接
* H:把字符串緩衝區轉換爲字符串輸出
*
* 錄入：linqingxia
* 結果：result:a(1)g(1)i(3)l(1)n(2)q(1)x(1)
*/
public class TreeMapDemo {
public static void main(String[] args) {
// 定義一個字符串(能夠改進爲鍵盤錄入)
Scanner sc = new Scanner(System.in);
System.out.println("請輸入一個字符串：");
String line = sc.nextLine();
// 定義一個TreeMap集合
TreeMap<Character, Integer> tm = new TreeMap<Character, Integer>();
//把字符串轉換爲字符數組
char[] chs = line.toCharArray();
//遍歷字符數組，獲得每個字符
for(char ch : chs){
//拿剛纔獲得的字符做爲鍵到集合中去找值，看返回值
Integer i = tm.get(ch);
//是null:說明該鍵不存在，就把該字符做爲鍵，1做爲值存儲
if(i == null){
tm.put(ch, 1);
}else {
//不是null:說明該鍵存在，就把值加1，而後重寫存儲該鍵和值
i++;
tm.put(ch,i);
}
}
//定義字符串緩衝區變量
StringBuilder sb= new StringBuilder();
//遍歷集合，獲得鍵和值，進行按照要求拼接
Set<Character> set = tm.keySet();
for(Character key : set){
Integer value = tm.get(key);
sb.append(key).append("(").append(value).append(")");
}
//把字符串緩衝區轉換爲字符串輸出
String result = sb.toString();
System.out.println("result:"+result);
}
}
HashMap集合嵌套HashMap集合的案例
測試
package cn.itcast_05;
import java.util.HashMap;
import java.util.Set;
/*
* HashMap嵌套HashMap
*
* 傳智播客
* jc 基礎班
* 陳玉樓 20
* 高躍 22
* jy 就業班
* 李傑 21
* 曹石磊 23
*
* 先存儲元素，而後遍歷元素
*/
public class HashMapDemo2 {
public static void main(String[] args) {
// 建立集合對象
HashMap<String, HashMap<String, Integer>> czbkMap = new HashMap<String, HashMap<String, Integer>>();
// 建立基礎班集合對象
HashMap<String, Integer> jcMap = new HashMap<String, Integer>();
// 添加元素
jcMap.put("陳玉樓", 20);
jcMap.put("高躍", 22);
// 把基礎班添加到大集合
czbkMap.put("jc", jcMap);
// 建立就業班集合對象
HashMap<String, Integer> jyMap = new HashMap<String, Integer>();
// 添加元素
jyMap.put("李傑", 21);
jyMap.put("曹石磊", 23);
// 把基礎班添加到大集合
czbkMap.put("jy", jyMap);
//遍歷集合
Set<String> czbkMapSet = czbkMap.keySet();
for(String czbkMapKey : czbkMapSet){
System.out.println(czbkMapKey);
HashMap<String, Integer> czbkMapValue = czbkMap.get(czbkMapKey);
Set<String> czbkMapValueSet = czbkMapValue.keySet();
for(String czbkMapValueKey : czbkMapValueSet){
Integer czbkMapValueValue = czbkMapValue.get(czbkMapValueKey);
System.out.println("\t"+czbkMapValueKey+"---"+czbkMapValueValue);
}
}
}
}
HashMap集合嵌套ArrayList集合的案例
package cn.itcast_05;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
/*
*需求：
*假設HashMap集合的元素是ArrayList。有3個。
*每個ArrayList集合的值是字符串。
*元素我已經完成，請遍歷。
*結果：
* 三國演義
* 呂布
* 周瑜
* 笑傲江湖
* 令狐沖
* 林平之
* 神鵰俠侶
* 郭靖
* 楊過
*/
public class HashMapIncludeArrayListDemo {
public static void main(String[] args) {
// 建立集合對象
HashMap<String, ArrayList<String>> hm = new HashMap<String, ArrayList<String>>();
// 建立元素集合1
ArrayList<String> array1 = new ArrayList<String>();
array1.add("呂布");
array1.add("周瑜");
hm.put("三國演義", array1);
// 建立元素集合2
ArrayList<String> array2 = new ArrayList<String>();
array2.add("令狐沖");
array2.add("林平之");
hm.put("笑傲江湖", array2);
// 建立元素集合3
ArrayList<String> array3 = new ArrayList<String>();
array3.add("郭靖");
array3.add("楊過");
hm.put("神鵰俠侶", array3);
//遍歷集合
Set<String> set = hm.keySet();
for(String key : set){
System.out.println(key);
ArrayList<String> value = hm.get(key);
for(String s : value){
System.out.println("\t"+s);
}
}
}
}
ArrayList集合嵌套HashMap集合的案例
package cn.itcast_05;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
/*
ArrayList集合嵌套HashMap集合並遍歷。
需求：
假設ArrayList集合的元素是HashMap。有3個。
每個HashMap集合的鍵和值都是字符串。
元素我已經完成，請遍歷。
結果：
周瑜---小喬
呂布---貂蟬
郭靖---黃蓉
楊過---小龍女
令狐沖---任盈盈
林平之---嶽靈珊
*/
public class ArrayListIncludeHashMapDemo {
public static void main(String[] args) {
// 建立集合對象
ArrayList<HashMap<String, String>> array = new ArrayList<HashMap<String, String>>();
// 建立元素1
HashMap<String, String> hm1 = new HashMap<String, String>();
hm1.put("周瑜", "小喬");
hm1.put("呂布", "貂蟬");
// 把元素添加到array裏面
array.add(hm1);
// 建立元素1
HashMap<String, String> hm2 = new HashMap<String, String>();
hm2.put("郭靖", "黃蓉");
hm2.put("楊過", "小龍女");
// 把元素添加到array裏面
array.add(hm2);
// 建立元素1
HashMap<String, String> hm3 = new HashMap<String, String>();
hm3.put("令狐沖", "任盈盈");
hm3.put("林平之", "嶽靈珊");
// 把元素添加到array裏面
array.add(hm3);
// 遍歷
for (HashMap<String, String> hm : array) {
Set<String> set = hm.keySet();
for (String key : set) {
String value = hm.get(key);
System.out.println(key + "---" + value);
}
}
}
}
集合多層嵌套的代碼體現
package cn.itcast_06;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
/*
* 爲了更符合要求：
* 此次的數據就當作是學生對象。
*
* 傳智播客
* bj 北京校區
* jc 基礎班
* 林青霞 27
* 風清揚 30
* jy 就業班
* 趙雅芝 28
* 武鑫 29
* sh 上海校區
* jc 基礎班
* 郭美美 20
* 犀利哥 22
* jy 就業班
* 羅玉鳳 21
* 馬徵 23
* gz 廣州校區
* jc 基礎班
* 王力宏 30
* 李靜磊 32
* jy 就業班
* 郎朗 31
* 柳巖 33
* xa 西安校區
* jc 基礎班
* 范冰冰 27
* 劉意 30
* jy 就業班
* 李冰冰 28
* 張志豪 29
*/
public class HashMapDemo {
public static void main(String[] args) {
// 建立大集合
HashMap<String, HashMap<String, ArrayList<Student>>> czbkMap = new HashMap<String, HashMap<String, ArrayList<Student>>>();
// 北京校區數據
HashMap<String, ArrayList<Student>> bjCzbkMap = new HashMap<String, ArrayList<Student>>();
ArrayList<Student> array1 = new ArrayList<Student>();
Student s1 = new Student("林青霞", 27);
Student s2 = new Student("風清揚", 30);
array1.add(s1);
array1.add(s2);
ArrayList<Student> array2 = new ArrayList<Student>();
Student s3 = new Student("趙雅芝", 28);
Student s4 = new Student("武鑫", 29);
array2.add(s3);
array2.add(s4);
bjCzbkMap.put("基礎班", array1);
bjCzbkMap.put("就業班", array2);
czbkMap.put("北京校區", bjCzbkMap);
// 晚上能夠本身練習一下
// 上海校區數據本身作
// 廣州校區數據本身作
// 西安校區數據
HashMap<String, ArrayList<Student>> xaCzbkMap = new HashMap<String, ArrayList<Student>>();
ArrayList<Student> array3 = new ArrayList<Student>();
Student s5 = new Student("范冰冰", 27);
Student s6 = new Student("劉意", 30);
array3.add(s5);
array3.add(s6);
ArrayList<Student> array4 = new ArrayList<Student>();
Student s7 = new Student("李冰冰", 28);
Student s8 = new Student("張志豪", 29);
array4.add(s7);
array4.add(s8);
xaCzbkMap.put("基礎班", array3);
xaCzbkMap.put("就業班", array4);
czbkMap.put("西安校區", xaCzbkMap);
// 遍歷集合
Set<String> czbkMapSet = czbkMap.keySet();
for (String czbkMapKey : czbkMapSet) {
System.out.println(czbkMapKey);
HashMap<String, ArrayList<Student>> czbkMapValue = czbkMap
.get(czbkMapKey);
Set<String> czbkMapValueSet = czbkMapValue.keySet();
for (String czbkMapValueKey : czbkMapValueSet) {
System.out.println("\t" + czbkMapValueKey);
ArrayList<Student> czbkMapValueValue = czbkMapValue
.get(czbkMapValueKey);
for (Student s : czbkMapValueValue) {
System.out.println("\t\t" + s.getName() + "---"
+ s.getAge());
}
}
}
}
}
package cn.itcast_07;
import java.util.Hashtable;
/*
* 1:Hashtable和HashMap的區別?
* Hashtable:線程安全，效率低。不容許null鍵和null值
* HashMap:線程不安全，效率高。容許null鍵和null值
*
* 2:List,Set,Map等接口是否都繼承子Map接口?
* List，Set不是繼承自Map接口，它們繼承自Collection接口
* Map接口自己就是一個頂層接口
*/
public class HashtableDemo {
public static void main(String[] args) {
// HashMap<String, String> hm = new HashMap<String, String>();
Hashtable<String, String> hm = new Hashtable<String, String>();
hm.put("it001", "hello");
// hm.put(null, "world"); //NullPointerException
// hm.put("java", null); // NullPointerException
System.out.println(hm);
}
}
Collections工具類的經常使用方法
package cn.itcast_01;
import java.util.Collections;
import java.util.List;
import java.util.ArrayList;
/*
* Collections:是針對集合進行操做的工具類，都是靜態方法。
*
* 面試題：
* Collection和Collections的區別?
* Collection:是單列集合的頂層接口，有子接口List和Set。
* 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):隨機置換
*/
public class CollectionsDemo {
public static void main(String[] args) {
// 建立集合對象
List<Integer> list = new ArrayList<Integer>();
// 添加元素
list.add(30);
list.add(20);
list.add(50);
list.add(10);
list.add(40);
System.out.println("list:" + list);
// public static <T> void sort(List<T> list)：排序 默認狀況下是天然順序。
// Collections.sort(list);
// System.out.println("list:" + list);
// [10, 20, 30, 40, 50]
// public static <T> int binarySearch(List<?> list,T key):二分查找
// System.out
// .println("binarySearch:" + Collections.binarySearch(list, 30));
// System.out.println("binarySearch:"
// + Collections.binarySearch(list, 300));
// public static <T> T max(Collection<?> coll):最大值
// System.out.println("max:"+Collections.max(list));
// public static void reverse(List<?> list):反轉
// Collections.reverse(list);
// System.out.println("list:" + list);
//public static void shuffle(List<?> list):隨機置換
Collections.shuffle(list);
System.out.println("list:" + list);
}
}
ArrayList存儲自定義對象並排序案例
package cn.itcast_02;
/**
* @author Administrator
*
*/
public class Student implements Comparable<Student> {
private String name;
private int age;
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public int compareTo(Student s) {
int num = this.age - s.age;
int num2 = num == 0 ? this.name.compareTo(s.name) : num;
return num2;
}
}
package cn.itcast_02;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/*
* Collections能夠針對ArrayList存儲基本包裝類的元素排序，存儲自定義對象可不能夠排序呢?
*/
public class CollectionsDemo {
public static void main(String[] args) {
// 建立集合對象
List<Student> list = new ArrayList<Student>();
// 建立學生對象
Student s1 = new Student("林青霞", 27);
Student s2 = new Student("風清揚", 30);
Student s3 = new Student("劉曉曲", 28);
Student s4 = new Student("武鑫", 29);
Student s5 = new Student("林青霞", 27);
// 添加元素對象
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
list.add(s5);
// 排序
// 天然排序
// Collections.sort(list);
// 比較器排序
// 若是同時有天然排序和比較器排序，以比較器排序爲主
Collections.sort(list, new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
int num = s2.getAge() - s1.getAge();
int num2 = num == 0 ? s1.getName().compareTo(s2.getName())
: num;
return num2;
}
});
// 遍歷集合
for (Student s : list) {
System.out.println(s.getName() + "---" + s.getAge());
}
}
}
模擬鬥地主洗牌和發牌
package cn.itcast_03;
import java.util.ArrayList;
import java.util.Collections;
/*
* 模擬鬥地主洗牌和發牌
*
* 分析：
* A:建立一個牌盒
* B:裝牌
* C:洗牌
* D:發牌
* E:看牌
*/
public class PokerDemo {
public static void main(String[] args) {
// 建立一個牌盒
ArrayList<String> array = new ArrayList<String>();
// 裝牌
// 黑桃A,黑桃2,黑桃3,...黑桃K
// 紅桃A,...
// 梅花A,...
// 方塊A,...
// 定義一個花色數組
String[] colors = { "♠", "♥", "♣", "♦" };
// 定義一個點數數組
String[] numbers = { "A", "2", "3", "4", "5", "6", "7", "8", "9", "10",
"J", "Q", "K" };
// 裝牌
for (String color : colors) {
for (String number : numbers) {
array.add(color.concat(number));
}
}
array.add("小王");
array.add("大王");
// 洗牌
Collections.shuffle(array);
// System.out.println("array:" + array);
// 發牌
ArrayList<String> fengQingYang = new ArrayList<String>();
ArrayList<String> linQingXia = new ArrayList<String>();
ArrayList<String> liuYi = new ArrayList<String>();
ArrayList<String> diPai = new ArrayList<String>();
for (int x = 0; x < array.size(); x++) {
if (x >= array.size() - 3) {
diPai.add(array.get(x));
} else if (x % 3 == 0) {
fengQingYang.add(array.get(x));
} else if (x % 3 == 1) {
linQingXia.add(array.get(x));
} else if (x % 3 == 2) {
liuYi.add(array.get(x));
}
}
// 看牌
lookPoker("風清揚", fengQingYang);
lookPoker("林青霞", linQingXia);
lookPoker("劉意", liuYi);
lookPoker("底牌", diPai);
}
public static void lookPoker(String name, ArrayList<String> array) {
System.out.print(name + "的牌是：");
for (String s : array) {
System.out.print(s + " ");
}
System.out.println();
}
}
模擬鬥地主洗牌和發牌並對牌進行排序的代碼實現：
package cn.itcast_04;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;
/*
* 思路：
* A:建立一個HashMap集合
* B:建立一個ArrayList集合
* C:建立花色數組和點數數組
* D:從0開始往HashMap裏面存儲編號，並存儲對應的牌
* 同時往ArrayList裏面存儲編號便可。
* E:洗牌(洗的是編號)
* F:發牌(發的也是編號，爲了保證編號是排序的，就建立TreeSet集合接收)
* G:看牌(遍歷TreeSet集合，獲取編號，到HashMap集合找對應的牌)
*/
public class PokerDemo {
public static void main(String[] args) {
// 建立一個HashMap集合
HashMap<Integer, String> hm = new HashMap<Integer, String>();
// 建立一個ArrayList集合
ArrayList<Integer> array = new ArrayList<Integer>();
// 建立花色數組和點數數組
// 定義一個花色數組
String[] colors = { "♠", "♥", "♣", "♦" };
// 定義一個點數數組
String[] numbers = { "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q",
"K", "A", "2", };
// 從0開始往HashMap裏面存儲編號，並存儲對應的牌,同時往ArrayList裏面存儲編號便可。
int index = 0;
for (String number : numbers) {
for (String color : colors) {
String poker = color.concat(number);
hm.put(index, poker);
array.add(index);
index++;
}
}
hm.put(index, "小王");
array.add(index);
index++;
hm.put(index, "大王");
array.add(index);
// 洗牌(洗的是編號)
Collections.shuffle(array);
// 發牌(發的也是編號，爲了保證編號是排序的，就建立TreeSet集合接收)
TreeSet<Integer> fengQingYang = new TreeSet<Integer>();
TreeSet<Integer> linQingXia = new TreeSet<Integer>();
TreeSet<Integer> liuYi = new TreeSet<Integer>();
TreeSet<Integer> diPai = new TreeSet<Integer>();
for (int x = 0; x < array.size(); x++) {
if (x >= array.size() - 3) {
diPai.add(array.get(x));
} else if (x % 3 == 0) {
fengQingYang.add(array.get(x));
} else if (x % 3 == 1) {
linQingXia.add(array.get(x));
} else if (x % 3 == 2) {
liuYi.add(array.get(x));
}
}
// 看牌(遍歷TreeSet集合，獲取編號，到HashMap集合找對應的牌)
lookPoker("風清揚", fengQingYang, hm);
lookPoker("林青霞", linQingXia, hm);
lookPoker("劉意", liuYi, hm);
lookPoker("底牌", diPai, hm);
}
// 寫看牌的功能
public static void lookPoker(String name, TreeSet<Integer> ts,
HashMap<Integer, String> hm) {
System.out.print(name + "的牌是：");
for (Integer key : ts) {
String value = hm.get(key);
System.out.print(value + " ");
}
System.out.println();
}
}
相關文章
- 1. day15-----------集合框架（傳智視頻）
- 2. day18 集合框架（JCF）
- 3. day18<集合框架+>
- 4. java day18 雙列集合Map
- 5. 集合框架Map
- 6. 【Java集合】集合框架Collection和Map
- 7. Java 集合框架之List集合，Set集合，Map集合
- 8. Day18 03.19 下 集合框架 ArrayList LinkedList
- 9. day18 Set集合
- 10. Java 集合框架之 Map
- 更多相關文章...
- • Scala Set(集合) - Scala教程
- • C# 集合（Collection） - C#教程
- • ☆技術問答集錦（13）Java Instrument原理
- • Flink 數據傳輸及反壓詳解
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
