你需要的是什麼，直接評論留言。
分享是一種美德，分享更快樂！
1:map(掌握)
(1)将鍵映射到值的對象。一個映射不能包含重複的鍵；每個鍵最多隻能映射到一個值。
(2)map和collection的差別?
a:map 存儲的是鍵值對形式的元素，鍵唯一，值可以重複。夫妻對
b:collection 存儲的是單獨出現的元素，子接口set元素唯一，子接口list元素可重複。光棍
(3)map接口功能概述(自己補齊)
a:添加功能
b:删除功能
c:判斷功能
d:擷取功能
e:長度功能
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);
}
(4)map集合的周遊
a:鍵找值
a:擷取所有鍵的集合
b:周遊鍵的集合,得到每一個鍵
c:根據鍵到集合中去找值
b:鍵值對對象找鍵和值
a:擷取所有的鍵值對對象的集合
b:周遊鍵值對對象的集合，擷取每一個鍵值對對象
c:根據鍵值對對象去擷取鍵和值
代碼展現：
map<string,string> hm = new hashmap<string,string>();
hm.put("it002","hello");
hm.put("it003","world");
hm.put("it001","java");
//方式1 鍵找值
set<string> set = hm.keyset();
for(string key : set) {
string value = hm.get(key);
system.out.println(key+"---"+value);
import java.util.set;
* map集合的周遊。
* map -- 夫妻對
* 思路：
a:把所有的丈夫給集中起來。
b:周遊丈夫的集合，擷取得到每一個丈夫。
c:讓丈夫去找自己的妻子。
* 轉換：
a:擷取所有的鍵
b:周遊鍵的集合，擷取得到每一個鍵
c:根據鍵去找值
public class mapdemo3 {
// 建立元素并添加到集合
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);
//方式2 鍵值對對象找鍵和值
set<map.entry<string,string>> set2 = hm.entryset();
for(map.entry<string,string> me : set2) {
string key = me.getkey();
string value = me.getvalue();
a:擷取所有結婚證的集合
b:周遊結婚證的集合，得到每一個結婚證
c:根據結婚證擷取丈夫和妻子
a:擷取所有鍵值對對象的集合
b:周遊鍵值對對象的集合，得到每一個鍵值對對象
c:根據鍵值對對象擷取鍵和值
* 這裡面最麻煩的就是鍵值對對象如何表示呢?
* 看看我們開始的一個方法：
set<map.entry<k,v>> entryset()：傳回的是鍵值對對象的集合
public class mapdemo4 {
// 擷取所有鍵值對對象的集合
set<map.entry<string, string>> set = map.entryset();
// 周遊鍵值對對象的集合，得到每一個鍵值對對象
for (map.entry<string, string> me : set) {
// 根據鍵值對對象擷取鍵和值
(5)hashmap集合的練習
a:hashmap<string,string>
package cn.itcast_02;
* hashmap:是基于哈希表的map接口實作。
* 哈希表的作用是用來保證鍵的唯一性的。
* hashmap<string,string>
* 鍵：string
* 值：string
public class hashmapdemo {
hashmap<string, string> hm = new hashmap<string, string>();
// 建立元素并添加元素
// string key1 = "it001";
// string value1 = "馬雲";
// hm.put(key1, value1);
hm.put("it001", "馬雲");
hm.put("it003", "馬化騰");
hm.put("it004", "喬布斯");
hm.put("it005", "張朝陽");
hm.put("it002", "裘伯君"); // wps
hm.put("it001", "比爾蓋茨");
b:hashmap<integer,string>
* hashmap<integer,string>
* 鍵：integer
public class hashmapdemo2 {
hashmap<integer, string> hm = new hashmap<integer, string>();
// integer i = new integer(27);
// integer i = 27;
// string s = "林青霞";
// hm.put(i, s);
hm.put(27, "林青霞");
hm.put(30, "風清揚");
hm.put(28, "劉意");
hm.put(29, "林青霞");
// 下面的寫法是八進制，但是不能出現8以上的單個資料
// hm.put(003, "hello");
// hm.put(006, "hello");
// hm.put(007, "hello");
// hm.put(008, "hello");
set<integer> set = hm.keyset();
for (integer key : set) {
// 下面這種方式僅僅是集合的元素的字元串表示
// system.out.println("hm:" + hm);
c:hashmap<string,student>
public class student {
private string name;
private int age;
public student() {
super();
public student(string name, int age) {
this.name = name;
this.age = age;
public string getname() {
return name;
public void setname(string name) {
public int getage() {
return age;
public void setage(int 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;
public boolean equals(object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getclass() != obj.getclass())
student other = (student) obj;
if (age != other.age)
if (name == null) {
if (other.name != null)
} else if (!name.equals(other.name))
* hashmap<string,student>
學号
* 值：student 學生對象
public class hashmapdemo3 {
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);
// 注意了：這次值不是字元串了
// string value = hm.get(key);
student value = hm.get(key);
system.out.println(key + "---" + value.getname() + "---"
+ value.getage());
d:hashmap<student,string>
* hashmap<student,string>
* 鍵：student
要求：如果兩個對象的成員變量值都相同，則為同一個對象。
public class hashmapdemo4 {
hashmap<student, string> hm = new hashmap<student, string>();
student s1 = new student("貂蟬", 27);
student s2 = new student("王昭君", 30);
student s3 = new student("西施", 33);
student s4 = new student("楊玉環", 35);
student s5 = new student("貂蟬", 27);
hm.put(s1, "8888");
hm.put(s2, "6666");
hm.put(s3, "5555");
hm.put(s4, "7777");
hm.put(s5, "9999");
set<student> set = hm.keyset();
for (student key : set) {
system.out.println(key.getname() + "---" + key.getage() + "---"
+ value);
(6)linkedhashmap集合的特點
package cn.itcast_03;
import java.util.linkedhashmap;
* linkedhashmap:是map接口的哈希表和連結清單實作，具有可預知的疊代順序。
* 由哈希表保證鍵的唯一性
* 由連結清單保證鍵盤的有序(存儲和取出的順序一緻)
public class linkedhashmapdemo {
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");
(7)treemap集合的練習
a:treemap<string,string>
package cn.itcast_04;
import java.util.treemap;
* treemap:是基于紅黑樹的map接口的實作。
public class treemapdemo {
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();
string value = tm.get(key);
b:treemap<student,string>
import java.util.comparator;
* treemap<student,string>
* 鍵:student
public class treemapdemo2 {
treemap<student, string> tm = new treemap<student, string>(
new comparator<student>() {
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();
(8)hashtable和hashmap的差別?
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 {
// 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);
(9)案例
a:統計一個字元串中每個字元出現的次數
package cn.itcast_05;
import java.util.scanner;
* 需求 ："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)
// 定義一個字元串(可以改進為鍵盤錄入)
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);
b:集合的嵌套周遊
a:hashmap嵌套hashmap
* hashmap嵌套hashmap
* 傳智播客
jc
基礎班
陳玉樓
20
高躍
22
jy
就業班
李傑
21
曹石磊
23
* 先存儲元素，然後周遊元素
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);
b:hashmap嵌套arraylist
import java.util.arraylist;
*需求：
*假設hashmap集合的元素是arraylist。有3個。
*每一個arraylist集合的值是字元串。
*元素我已經完成，請周遊。
*結果：
三國演義
呂布
周瑜
笑傲江湖
令狐沖
林平之
神雕俠侶
郭靖
楊過
public class hashmapincludearraylistdemo {
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);
for(string key : set){
system.out.println(key);
arraylist<string> value = hm.get(key);
for(string s : value){
system.out.println("\t"+s);
c:arraylist嵌套hashmap
arraylist集合嵌套hashmap集合并周遊。
需求：
假設arraylist集合的元素是hashmap。有3個。
每一個hashmap集合的鍵和值都是字元串。
元素我已經完成，請周遊。
結果：
周瑜---小喬
呂布---貂蟬
郭靖---黃蓉
楊過---小龍女
令狐沖---任盈盈
林平之---嶽靈珊
public class arraylistincludehashmapdemo {
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);
hashmap<string, string> hm2 = new hashmap<string, string>();
hm2.put("郭靖", "黃蓉");
hm2.put("楊過", "小龍女");
array.add(hm2);
hashmap<string, string> hm3 = new hashmap<string, string>();
hm3.put("令狐沖", "任盈盈");
hm3.put("林平之", "嶽靈珊");
array.add(hm3);
for (hashmap<string, string> hm : array) {
d:多層嵌套
package cn.itcast_06;
* 為了更符合要求：
這次的資料就看成是學生對象。
bj
北京校區
林青霞
27
風清揚
30
趙雅芝
28
武鑫
29
sh
上海校區
郭美美
犀利哥
羅玉鳳
馬征
gz
廣州校區
王力宏
李靜磊
32
郎朗
31
柳岩
33
xa
西安校區
範冰冰
劉意
李冰冰
張志豪
// 建立大集合
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>> shczbkmap = new hashmap<string, arraylist<student>>();
arraylist<student> array7 = new arraylist<student>();
student s13 = new student("郭美美", 20);
student s14 = new student("犀利哥", 22);
array7.add(s13);
array7.add(s14);
arraylist<student> array8 = new arraylist<student>();
student s15 = new student("羅玉鳳", 21);
student s16 = new student("馬征", 23);
array8.add(s15);
array8.add(s16);
shczbkmap.put("基礎班", array7);
shczbkmap.put("就業班", array8);
czbkmap.put("上海校區", shczbkmap);
// 廣州校區資料
hashmap<string, arraylist<student>> gzczbkmap = new hashmap<string, arraylist<student>>();
arraylist<student> array5 = new arraylist<student>();
student s9 = new student("王力宏", 30);
student s10 = new student("李靜磊", 32);
array5.add(s9);
array5.add(s10);
arraylist<student> array6 = new arraylist<student>();
student s11 = new student("朗朗", 31);
student s12 = new student("柳岩", 33);
array6.add(s11);
array6.add(s12);
gzczbkmap.put("基礎班", array5);
gzczbkmap.put("就業班", array6);
czbkmap.put("廣州校區", gzczbkmap);
// 西安校區資料
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);
for (string czbkmapkey : czbkmapset) {
hashmap<string, arraylist<student>> czbkmapvalue = czbkmap
.get(czbkmapkey);
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());
2:collections(了解)
(1)是針對集合進行操作的工具類
(2)面試題：collection和collections的差別
a:collection 是單列集合的頂層接口，有兩個子接口list和set
b:collections 是針對集合進行操作的工具類，可以對集合進行排序和查找等
(3)常見的幾個小方法：
a:public static <t> void sort(list<t> list)
b:public static <t> int binarysearch(list<?> list,t key)
c:public static <t> t max(collection<?> coll)
d:public static void reverse(list<?> list)
e:public static void shuffle(list<?> list)
import java.util.collections;
import java.util.list;
* 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 {
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);
//public static void shuffle(list<?> list):随機置換
collections.shuffle(list);
(4)案例
a:arraylist集合存儲自定義對象的排序
/**
* @author administrator
public class student implements comparable<student> {
public int compareto(student s) {
int num = this.age - s.age;
int num2 = num == 0 ? this.name.compareto(s.name) : num;
* collections可以針對arraylist存儲基本包裝類的元素排序，存儲自定義對象可不可以排序呢?
list<student> list = new arraylist<student>();
student s3 = new student("劉曉曲", 28);
student s5 = new student("林青霞", 27);
// 添加元素對象
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
list.add(s5);
// 排序
// 自然排序
// 比較器排序
// 如果同時有自然排序和比較器排序，以比較器排序為主
collections.sort(list, new comparator<student>() {
int num = s2.getage() - s1.getage();
int num2 = num == 0 ? s1.getname().compareto(s2.getname())
: num;
for (student s : list) {
system.out.println(s.getname() + "---" + s.getage());
b:模拟鬥地主洗牌和發牌
* 模拟鬥地主洗牌和發牌
a:建立一個牌盒
b:裝牌
c:洗牌
d:發牌
e:看牌
public class pokerdemo {
// 建立一個牌盒
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();
c:模拟鬥地主洗牌和發牌并對牌進行排序
import java.util.treeset;
a:建立一個hashmap集合
b:建立一個arraylist集合
c:建立花色數組和點數數組
d:從0開始往hashmap裡面存儲編号，并存儲對應的牌
* 同時往arraylist裡面存儲編号即可。
* e:洗牌(洗的是編号)
* f:發牌(發的也是編号，為了保證編号是排序的，就建立treeset集合接收)
* g:看牌(周遊treeset集合，擷取編号，到hashmap集合找對應的牌)
// 建立一個hashmap集合
// 建立一個arraylist集合
arraylist<integer> array = new arraylist<integer>();
// 建立花色數組和點數數組
string[] colors = { "?", "?", "?", "?" };黑桃，紅桃，梅花，方片由于txt格式不能顯示是以？代替
string[] numbers = { "3", "4", "5", "6", "7", "8", "9", "10", "j", "q",
"k", "a", "2", };
// 從0開始往hashmap裡面存儲編号，并存儲對應的牌,同時往arraylist裡面存儲編号即可。
int index = 0;
string poker = color.concat(number);
hm.put(index, poker);
array.add(index);
index++;
hm.put(index, "小王");
hm.put(index, "大王");
// 洗牌(洗的是編号)
// 發牌(發的也是編号，為了保證編号是排序的，就建立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>();
// 看牌(周遊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) {
for (integer key : ts) {
system.out.print(value + " ");
java幫幫交流群