Java：map集合，字符出现次数，ArrayList中嵌套HashMap等遍历，斗地主，分牌
// 1."一闪一闪亮晶晶，满天都是小星星",使用map集合计算每个字符出现了多少次
package a;
import java.util.HashMap;
import java.util.Set;
public class lizi {
public static void main(String[] args) {
String zijidingyidezifuchuan = "一闪一闪亮晶晶，满天都是小星星";
HashMap<Object, Integer> HashMapduixiang1 = new HashMap<Object, Integer>();
for (int i = 0; i < zijidingyidezifuchuan.length(); i++) {
if (HashMapduixiang1.containsKey(zijidingyidezifuchuan.charAt(i))) {
int value = HashMapduixiang1.get(zijidingyidezifuchuan.charAt(i));
value += 1;
HashMapduixiang1.put(zijidingyidezifuchuan.charAt(i), value);
} else {
HashMapduixiang1.put(zijidingyidezifuchuan.charAt(i), 1);
}
}
Set<Object> set = HashMapduixiang1.keySet();
for (Object o : set) {
System.out.println("字符" + o + "出现了 " + HashMapduixiang1.get(o) + "次");
}
}
}
// 2.声明ArrayList中嵌套HashMap，遍历出来
package a;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
public class lizi {
public static void main(String[] args) {
HashMap<Integer, String> HashMapduixiang1 = new HashMap<Integer, String>();
HashMapduixiang1.put(1, " 1诗书");
HashMapduixiang1.put(2, "2画唱");
HashMapduixiang1.put(3, "3歌手");
HashMapduixiang1.put(4, "4舞者");
HashMap<Integer, String> HashMapduixiang2 = new HashMap<Integer, String>();
HashMapduixiang2.put(11, "11up主");
HashMapduixiang2.put(22, "22作家");
HashMapduixiang2.put(33, "33最强最好机器人的制作者");
HashMapduixiang2.put(44, "44作曲人");
HashMap<Integer, String> HashMapduixiang3 = new HashMap<Integer, String>();
HashMapduixiang3.put(111, "111作词人");
HashMapduixiang3.put(222, "222CEO");
HashMapduixiang3.put(333, "333董事长");
HashMapduixiang3.put(444, "444伟人");
ArrayList<HashMap<Integer, String>> ArrayListHashMapduixiang1 =
new ArrayList<HashMap<Integer, String>>();
ArrayListHashMapduixiang1.add(HashMapduixiang1);
ArrayListHashMapduixiang1.add(HashMapduixiang2);
ArrayListHashMapduixiang1.add(HashMapduixiang3);
for (int ALHMxiabiao = 0; ALHMxiabiao < ArrayListHashMapduixiang1.size(); ALHMxiabiao++) {
HashMap<Integer, String> HashMapduixiang4 = ArrayListHashMapduixiang1
.get(ALHMxiabiao);
Set<Integer> HashMapduixiang4_zhongdekey = HashMapduixiang4
.keySet();
for (Integer HMxiabiao : HashMapduixiang4_zhongdekey) {
System.out.print("第" + (ALHMxiabiao + 1) + "个hashmap的内容为"
+ HashMapduixiang4.get(HMxiabiao) + "\t");
}
System.out.println();
}
}
}
3.声明学生类和HashMap，使用HashMap存储学生类，使用2种遍历方式遍历出学生信息
方法一：
package a;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class lizi {
public static void main(String[] args) {
HashMap<student, String> HSduixiang = new HashMap<student, String>();
HSduixiang.put(new student("诗书", 22), "点赞省");
HSduixiang.put(new student("画唱", 25), "投币省");
HSduixiang.put(new student("帅哥", 24), "项省");
HSduixiang.put(new student("伟人", 26), "河省");
HSduixiang.put(new student("酷哥", 24), "江省");
System.out.println("第一种取出方式 ketSet:");
Set<student> keySet = HSduixiang.keySet();
Iterator<student> tiquchudeKey1 = keySet.iterator();
while (tiquchudeKey1.hasNext()) {
student Student_name_age1 = tiquchudeKey1.next();
String addr = HSduixiang.get(Student_name_age1);
System.out.println(Student_name_age1 + "---" + addr);
}
System.out
.println("HSduixiang.get(Student_name_age)中的Student_name_age这里充当了Key，\n"
+ "就像引索，用关键词搜索出要相关的内容一样，这里的相关内容是地址addr");
System.out.println();
System.out.println("第二种取出方式entrySet:");
Set<Map.Entry<student, String>> entrySet = HSduixiang.entrySet();
Iterator<Map.Entry<student, String>> tiquchudeKey2 = entrySet
.iterator();
while (tiquchudeKey2.hasNext()) {
Map.Entry<student, String> yongMEdedaodeshujv = tiquchudeKey2
.next();
student Student_name_age2 = yongMEdedaodeshujv.getKey();
String addr = yongMEdedaodeshujv.getValue();
System.out.println(Student_name_age2 + "=====" + addr);
}
}
}
class student {
private int age;
private String name;
student(String name, int age) {
this.name = name;
this.age = age;
}
public int getAge() {
return age;
}
public String getName() {
return name;
}
@Override
public String toString() {
return name + ":" + age;
}
}
方法二详析：
/*
每一个学生都有对应归属地。
学生Student 地址 String。
学生属性：姓名，年龄。
注意：姓名和年龄相同的视为同一个学生。
保证学生的唯一性。
步骤：
1、描述学生。
2、定义map容器，将学生作为键，地址作为值，存入。
3、获取map集合中的元素。
*/
package a;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class lizi {
public static void main(String[] args) {
HashMap<class_Student, String> HSduixiang = new HashMap<class_Student, String>();
HSduixiang.put(new class_Student("张三", 22), "北京");
HSduixiang.put(new class_Student("李四", 25), "上海");
HSduixiang.put(new class_Student("王五", 24), "香港");
HSduixiang.put(new class_Student("小张", 24), "烟台");
HSduixiang.put(new class_Student("小李", 26), "济南");
System.out.println("第一种取出方式 ketSet:");
Set<class_Student> keySet = HSduixiang.keySet();
Iterator<class_Student> tiquchudeKey1 = keySet.iterator();
while (tiquchudeKey1.hasNext()) {
class_Student Student_name_age1 = tiquchudeKey1.next();
String addr = HSduixiang.get(Student_name_age1);
System.out.println(Student_name_age1 + "---" + addr);
}
System.out
.println("HSduixiang.get(Student_name_age)中的Student_name_age这里充当了Key，\n"
+ "就像引索，用关键词搜索出要相关的内容一样，这里的相关内容是地址addr");
System.out.println();
System.out.println("第二种取出方式entrySet:");
Set<Map.Entry<class_Student, String>> entrySet = HSduixiang.entrySet();
Iterator<Map.Entry<class_Student, String>> tiquchudeKey2 = entrySet.iterator();
while (tiquchudeKey2.hasNext()) {
Map.Entry<class_Student, String> yongMEdedaodeshujv = tiquchudeKey2.next();
class_Student Student_name_age2 = yongMEdedaodeshujv.getKey();
String addr = yongMEdedaodeshujv.getValue();
System.out.println(Student_name_age2 + "=====" + addr);
}
}
}
class class_Student implements Comparable<class_Student> {
private int age;
private String name;
class_Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int compareTo(class_Student s) {
// TODO 自动生成的方法存根：
int num = new Integer(this.age).compareTo(new Integer(s.age));
if (num == 0)
return this.name.compareTo(s.name);
return num;
}
@Override
public boolean equals(Object obj) {
if (!(obj instanceof class_Student))
throw new ClassCastException("类型不匹配");
class_Student s = (class_Student) obj;
return this.name.equals(s.name) && this.age == age;
}
public int getAge() {
return age;
}
public String getName() {
return name;
}
// 保证键的唯一性：
@Override
public int hashCode() {
return name.hashCode() + age * 34;
}
@Override
public String toString() {
return name + ":" + age;
}
}
4.一副牌是54张，三个人斗地主，进行分牌，分给每个人牌，并且还有有底牌
方法三（共4种方法，我在另一篇专栏写过了）：
package a;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Random;
public class lizi {
public static void main(String[] args) {
String[] Stringchucundepai = new String[] { "♥A", "♥2", "♥3", "♥4",
"♥5", "♥6", "♥7", "♥8", "♥9", "♥10", "♥J", "♥Q", "♥K", "♠A",
"♠2", "♠3", "♠4", "♠5", "♠6", "♠7", "♠8", "♠9", "♠10", "♠J",
"♠Q", "♠K", "♦A", "♦2", "♦3", "♦4", "♦5", "♦6", "♦7", "♦8",
"♦9", "♦10", "♦J", "♦Q", "♦K", "♣A", "♣2", "♣3", "♣4", "♣5",
"♣6", "♣7", "♣8", "♣9", "♣10", "♣J", "♣Q", "♣K" };
HashMap<String, Integer> HSchucundejiadepai = new HashMap<>();
HashMap<String, Integer> HSchucundeyidepai = new HashMap<>();
HashMap<String, Integer> HSchucundebingdepai = new HashMap<>();
ArrayList<String> yongALchucundeshuju = new ArrayList<String>();
for (int i = 0; i < Stringchucundepai.length; i++) {
yongALchucundeshuju.add(Stringchucundepai[i]);
}
yongALchucundeshuju.add("大王");
yongALchucundeshuju.add("小王");
Random suijishu = new Random();
String fangzidawangxiaowangchongfu = null;
for (int k = 0; k < 100; k++) {
int zongpaishu = yongALchucundeshuju.size();
int yongRandomdedaodesuijishu1 = suijishu.nextInt(zongpaishu);
int yongRandomdedaodesuijishu2 = suijishu.nextInt(zongpaishu);
if (yongRandomdedaodesuijishu1 == yongRandomdedaodesuijishu2)
continue;
{
fangzidawangxiaowangchongfu = yongALchucundeshuju
.get(yongRandomdedaodesuijishu1);
yongALchucundeshuju.set(yongRandomdedaodesuijishu1,
yongALchucundeshuju.get(yongRandomdedaodesuijishu2));
yongALchucundeshuju.set(yongRandomdedaodesuijishu2,
fangzidawangxiaowangchongfu);
}
}
ArrayList<String> yongALchucundejiadepai = new ArrayList<String>();
ArrayList<String> yongALchucundeyidedepai = new ArrayList<String>();
ArrayList<String> yongALchucundebingdepai = new ArrayList<String>();
ArrayList<String> yongALchucundedipai = new ArrayList<String>();
for (int i = 0; i < yongALchucundeshuju.size(); i++) {
if (i >= yongALchucundeshuju.size() - 3) {
yongALchucundedipai.add(yongALchucundeshuju.get(i));
} else if (i % 3 == 0) {
yongALchucundejiadepai.add(yongALchucundeshuju.get(i));
} else if (i % 3 == 1) {
yongALchucundeyidedepai.add(yongALchucundeshuju.get(i));
} else if (i % 3 == 2) {
yongALchucundebingdepai.add(yongALchucundeshuju.get(i));
}
}
System.out.println("底牌：" + yongALchucundedipai);
System.out.println("甲被发到的牌：" + yongALchucundejiadepai);
System.out.println("乙被发到的牌：" + yongALchucundeyidedepai);
System.out.println("丙被发到的牌：" + yongALchucundebingdepai);
}
}
方法详析：
package a;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Random;
public class lizi {
public static void main(String[] args) {
String[] Stringchucundepai = new String[] { "A", "2", "3", "4", "5",
"6", "7", "8", "9", "10", "J", "Q", "K" };
HashMap<String, Integer> HSchucundejiadepai = new HashMap<>();
HashMap<String, Integer> HSchucundeyidepai = new HashMap<>();
HashMap<String, Integer> HSchucundebingdepai = new HashMap<>();
/*HashMap无序储存，所以可以随机，概率相等且公平
* 个人理解:HSchucundejiadepai是用HashMap储存的甲的牌<String, Integer>为泛型的应用,
* 表明只储存String和Integer类型的数据
*/
ArrayList<String> yongALchucundeshuju = new ArrayList<String>();
/*
* 个人理解:这里的<String>为泛型,是规定集合可储存范围条件的,
* ArrayList<String>表明只储存String到ArrayList里面
*/
for (int i = 0; i < Stringchucundepai.length; i++) {
/* Stringchucundepai.length=13 */
yongALchucundeshuju.add(Stringchucundepai[i]);
yongALchucundeshuju.add(Stringchucundepai[i]);
yongALchucundeshuju.add(Stringchucundepai[i]);
yongALchucundeshuju.add(Stringchucundepai[i]);
/*
* 用add和for循环,在"(用ArrayList储存的String数据)yongALchucundeshuju"中添加了
* 4个"Stringchucundepai[0]("A")到Stringchucundepai[12]("K")",13*4=52
*/
}
yongALchucundeshuju.add("大王");
yongALchucundeshuju.add("小王");
/*
* 用add在"(用ArrayList储存的String数据)yongALchucundeshuju"中添加了
* "大王","小王",13*4+2=54
*/
Random suijishu = new Random();
/* suijishu为用Random得到的随机数 */
String fangzidawangxiaowangchongfu = null;/*
* fangzidawangxiaowangchongfu是防止
* "大王"
* "小王"等重复的，这种先在for外面设null的方法可常用于防重复
*/
for (int k = 0; k < 100; k++) {
int zongpaishu = yongALchucundeshuju.size();
/* yongALchucundeshuju.size()=13*4+2=54,zongpaishu为总牌数 */
int yongRandomdedaodesuijishu1 = suijishu.nextInt(zongpaishu);
/*
* suijishu为随机数, nextInt用于规定随机数suijishu可取值得范围,这里是zongpaishu,即54。
* nextInt(54)等同于nextInt(54)+0,就是0到54(含头不含尾),即为0到53(含头含尾)
* “yongRandomdedaodesuijishu1”是“用Random得到的随机数1”
*/
int yongRandomdedaodesuijishu2 = suijishu.nextInt(zongpaishu);
if (yongRandomdedaodesuijishu1 == yongRandomdedaodesuijishu2)
continue;/*
* 这里continue表明当用Random得到的随机数1=用Random得到的随机数2时，
* 跳过当次循环中剩下的语句，执行下一次循环（即不执行且不出现“用Random得到的随机数1=
* 用Random得到的随机数2”的情况， 其他的{}中的语句会执行 ,
*/
/*
* continue和break有点类似，区别在于continue只是终止本次循环，接着还执行后面的循环，break则完全终止循环。
*
* 可以理解为continue是跳过当次循环中剩下的语句，执行下一次循环。
*/
{
fangzidawangxiaowangchongfu = yongALchucundeshuju
.get(yongRandomdedaodesuijishu1);
/* 这里有一个赋值的过程，就像进行两个变量a和b，用c进行交换a和b的值，防止a，b在赋值时相等
* 不信，可以把fangzidawangxiaowangchongfu改为yongALchucundeshuju
.get(yongRandomdedaodesuijishu1)，保证会重复 */
yongALchucundeshuju.set(yongRandomdedaodesuijishu1,
yongALchucundeshuju.get(yongRandomdedaodesuijishu2));
yongALchucundeshuju.set(yongRandomdedaodesuijishu2,
fangzidawangxiaowangchongfu);
}/*
* 个人理解:set用于插入数据,这里往yongALchucundeshuju中插入
* yongRandomdedaodesuijishu1（int类型）,
* yongALchucundeshuju.get(yongRandomdedaodesuijishu2)
* （yongRandomdedaodesuijishu2这里为下标，含头含尾的0到53）
* 等数据，yongALchucundeshuju 储存了得到的数据,要用时就拿出来
*/
}
ArrayList<String> yongALchucundejiadepai = new ArrayList<String>();
ArrayList<String> yongALchucundeyidedepai = new ArrayList<String>();
ArrayList<String> yongALchucundebingdepai = new ArrayList<String>();
ArrayList<String> yongALchucundedipai = new ArrayList<String>();
for (int i = 0; i < yongALchucundeshuju.size(); i++) {
/* yongALchucundeshuju.size() =54 */
if (i >= yongALchucundeshuju.size() - 3) {
/* yongALchucundeshuju.size() - 3=54-3=52 */
yongALchucundedipai.add(yongALchucundeshuju.get(i));
/*
* yongALchucundedipai为用ArrayList储存的底牌，i可为含头含尾的0到53
* yongALchucundeshuju.get(i)就可为含头含尾的4组“"A", "2", "3", "4", "5",
* "6", "7", "8", "9", "10", "J", "Q", "K"”和一组"大王","小王"
*/
} else if (i % 3 == 0) {
/*
* i % 3 == 0表明可被3整除余数为0， 在含头含尾的下标0到53中，出现i % 3 == 0和出现i % 3 ==
* 1和 出现i % 3 == 2的概率互相相同，“0,1，2”,“3，4，5”,......“51，52，53”
* 编程，电脑，大脑等就是“储存和取出”
*/
yongALchucundejiadepai.add(yongALchucundeshuju.get(i));
} else if (i % 3 == 1) {
yongALchucundeyidedepai.add(yongALchucundeshuju.get(i));
} else if (i % 3 == 2) {
yongALchucundebingdepai.add(yongALchucundeshuju.get(i));
}
}
System.out.println("底牌：" + yongALchucundedipai);
System.out.println("甲被发到的牌：" + yongALchucundejiadepai);
System.out.println("乙被发到的牌：" + yongALchucundeyidedepai);
System.out.println("丙被发到的牌：" + yongALchucundebingdepai);
System.out.println("1代表♥, 2代表♠, 3代表♦,4代表♣");
for (String str : yongALchucundejiadepai) {
/* yongALchucundejiadepai用ArrayList储存的甲的牌,有随机个下标值 */
if (HSchucundejiadepai.containsKey(str)) {
HSchucundejiadepai.put(str, HSchucundejiadepai.get(str) + 1);
} else
HSchucundejiadepai.put(str, 1);
}
System.out.println("甲被发到的牌对应图形情况：" + HSchucundejiadepai);
for (String str : yongALchucundeyidedepai) {
/* yongALchucundejiadepai用ArrayList储存的乙的牌,有随机个下标值 */
if (HSchucundeyidepai.containsKey(str)) {
HSchucundeyidepai.put(str, HSchucundeyidepai.get(str) + 1);
} else
HSchucundeyidepai.put(str, 1);
}
System.out.println("乙被发到的牌对应图形情况：" + HSchucundeyidepai);
for (String str : yongALchucundebingdepai) {
/* yongALchucundejiadepai用ArrayList储存的丙的牌,有随机个下标值 */
if (HSchucundebingdepai.containsKey(str)) {
HSchucundebingdepai.put(str, HSchucundebingdepai.get(str) + 1);
} else
HSchucundebingdepai.put(str, 1);
}
System.out.println("丙被发到的牌对应图形情况：" + HSchucundebingdepai);
}
}
