import java.util.HashMap;
import java.util.Map;
public class A01_MapDemo1 {
public static void main(String[] args) {
/*
V put(K key,V value) 添加元素
V remove(Object key) 根据键删除键值对元素
void clear() 移除所有的键值对元素
boolean containsKey(Object key) 判断集合是否包含指定的键
boolean containsValue(Object value) 判断集合是否包含指定的值
boolean isEmpty() 判断集合是否为空
int size() 集合的长度，也就是集合中键值对的个数
*/
//1.创建Map集合的对象
Map m = new HashMap<>();
//2.添加元素
//put方法的细节：
//添加/覆盖
//在添加数据的时候，如果键不存在，那么直接把键值对对象添加到map集合当中,方法返回null
//在添加数据的时候，如果键是存在的，那么会把原有的键值对对象覆盖，会把被覆盖的值进行返回。
m.put("郭靖", "黄蓉");
m.put("韦小宝","沐剑屏");
m.put("尹志平","小龙女");
//String value2 = m.put("韦小宝", "双儿");
//System.out.println(value2);
//删除
//String result = m.remove("郭靖");//黄蓉
//System.out.println(result);
//清空
//m.clear();
//判断是否包含
/*boolean keyResult = m.containsKey("郭靖");
System.out.println(keyResult);
boolean valueResult = m.containsValue("小龙女2");
System.out.println(valueResult);*/
/* boolean result = m.isEmpty();
System.out.println(result);*/
int size = m.size();
System.out.println(size);
//3.打印集合
System.out.println(m);
}
}
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class A02_MapDemo2 {
public static void main(String[] args) {
//Map集合的第一种遍历方式
//三个课堂练习：
//
//练习一： 利用键找值的方式遍历map集合，要求：装着键的单列集合使用增强for的形式进行遍历
//练习二： 利用键找值的方式遍历map集合，要求：装着键的单列集合使用迭代器的形式进行遍历
//练习三： 利用键找值的方式遍历map集合，要求：装着键的单列集合使用lambda表达式的形式进行遍历
//1.创建Map集合的对象
Map map = new HashMap<>();
//2.添加元素
map.put("尹志平","小龙女");
map.put("郭靖","穆念慈");
map.put("欧阳克","黄蓉");
//3.通过键找值
//3.1获取所有的键，把这些键放到一个单列集合当中
Set keys = map.keySet();
//3.2遍历单列集合，得到每一个键
for (String key : keys) {
//System.out.println(key);
//3.3 利用map集合中的键获取对应的值 get
String value = map.get(key);
System.out.println(key + " = " + value);
}
}
}
import java.util.HashMap;
import java.util.Map;
public class A03_MapDemo3 {
public static void main(String[] args) {
//Map集合的第二种遍历方式
//三个课堂练习：
//
//练习一： 通过键值对对象进行遍历map集合，要求：装着键值对对象的单列集合使用增强for的形式进行遍历
//练习二： 通过键值对对象进行遍历map集合，要求：装着键值对对象的单列集合使用迭代器的形式进行遍历
//练习三： 通过键值对对象进行遍历map集合，要求：装着键值对对象的单列集合使用lambda的形式进行遍历
//1.创建Map集合的对象
Map map = new HashMap<>();
//2.添加元素
//键：人物的外号
//值：人物的名字
map.put("标枪选手", "马超");
map.put("人物挂件", "明世隐");
map.put("御龙骑士", "尹志平");
/* //3.Map集合的第二种遍历方式
//通过键值对对象进行遍历
//3.1 通过一个方法获取所有的键值对对象，返回一个Set集合
Set> entries = map.entrySet();
//3.2 遍历entries这个集合，去得到里面的每一个键值对对象
for (Map.Entry entry : entries) {//entry ---> "御龙骑士","尹志平"
//3.3 利用entry调用get方法获取键和值
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key + "=" + value);
}*/
//3.Map集合的第二种遍历方式
//通过键值对对象进行遍历
//3.1 通过一个方法获取所有的键值对对象，返回一个Set集合
//3.2 遍历entries这个集合，去得到里面的每一个键值对对象
for (Map.Entry entry : map.entrySet()) {//entry ---> "御龙骑士","尹志平"
//3.3 利用entry调用get方法获取键和值
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key + "=" + value);
}
}
}
import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;
public class A04_MapDemo4 {
public static void main(String[] args) {
//Map集合的第三种遍历方式
//1.创建Map集合的对象
Map map = new HashMap<>();
//2.添加元素
//键：人物的名字
//值：名人名言
map.put("鲁迅","这句话是我说的");
map.put("曹操","不可能绝对不可能");
map.put("刘备","接着奏乐接着舞");
map.put("柯镇恶","看我眼色行事");
//3.利用lambda表达式进行遍历
//底层：
//forEach其实就是利用第二种方式进行遍历，依次得到每一个键和值
//再调用accept方法
map.forEach(new BiConsumer() {
@Override
public void accept(String key, String value) {
System.out.println(key + "=" + value);
}
});
System.out.println("-----------------------------------");
map.forEach((String key, String value)->{
System.out.println(key + "=" + value);
}
);
System.out.println("-----------------------------------");
map.forEach((key, value)-> System.out.println(key + "=" + value));
}
}
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class A01_HashMapDemo1 {
public static void main(String[] args) {
/*
需求：创建一个HashMap集合，键是学生对象(Student)，值是籍贯(String)。
存储三个键值对元素，并遍历
要求：同姓名，同年龄认为是同一个学生
核心点：
HashMap的键位置如果存储的是自定义对象，需要重写hashCode和equals方法。
*/
//1.创建HashMap的对象
HashMap hm = new HashMap<>();
//2.创建三个学生对象
Student s1 = new Student("zhangsan",23);
Student s2 = new Student("lisi",24);
Student s3 = new Student("wangwu",25);
Student s4 = new Student("wangwu",25);
//3.添加元素
hm.put(s1,"江苏");
hm.put(s2,"浙江");
hm.put(s3,"福建");
hm.put(s4,"山东");
//4.遍历集合
Set keys = hm.keySet();
for (Student key : keys) {
String value = hm.get(key);
System.out.println(key + "=" + value);
}
System.out.println("--------------------------");
Set> entries = hm.entrySet();
for (Map.Entry entry : entries) {
Student key = entry.getKey();
String value = entry.getValue();
System.out.println(key + "=" + value);
}
System.out.println("--------------------------");
hm.forEach((student, s)-> System.out.println(student + "=" + s));
}
}
import java.util.*;
public class A02_HashMapDemo2 {
public static void main(String[] args) {
/*
某个班级80名学生，现在需要组成秋游活动，
班长提供了四个景点依次是（A、B、C、D）,
每个学生只能选择一个景点，请统计出最终哪个景点想去的人数最多。
*/
//1.需要先让同学们投票
//定义一个数组，存储4个景点
String[] arr = {"A","B","C","D"};
//利用随机数模拟80个同学的投票，并把投票的结果存储起来
ArrayList list = new ArrayList<>();
Random r = new Random();
for (int i = 0; i < 80; i++) {
int index = r.nextInt(arr.length);
list.add(arr[index]);
}
//2.如果要统计的东西比较多，不方便使用计数器思想
//我们可以定义map集合，利用集合进行统计。
HashMap hm = new HashMap<>();
for (String name : list) {
//判断当前的景点在map集合当中是否存在
if(hm.containsKey(name)){
//存在
//先获取当前景点已经被投票的次数
int count = hm.get(name);
//表示当前景点又被投了一次
count++;
//把新的次数再次添加到集合当中
hm.put(name,count);
}else{
//不存在
hm.put(name,1);
}
}
System.out.println(hm);
//3.求最大值
int max = 0;
Set> entries = hm.entrySet();
for (Map.Entry entry : entries) {
int count = entry.getValue();
if(count > max){
max = count;
}
}
System.out.println(max);
//4.判断哪个景点的次数跟最大值一样，如果一样，打印出来
for (Map.Entry entry : entries) {
int count = entry.getValue();
if(count == max){
System.out.println(entry.getKey());
}
}
}
}
import java.util.Objects;
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(int age) {
this.age = age;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age && Objects.equals(name, student.name);
}
@Override
public int hashCode() {
//return Objects.hash(name, age);
return name.hashCode();
}
public String toString() {
return "Student{name = " + name + ", age = " + age + "}";
}
}
import java.util.LinkedHashMap;
public class A01_LinkedHashMapDemo1 {
public static void main(String[] args) {
/*
LinkedHashMap:
由键决定：
有序、不重复、无索引。
有序：
保证存储和取出的顺序一致
原理：
底层数据结构是依然哈希表，只是每个键值对元素又额外的多了一个双链表的机制记录存储的顺序。
*/
//1.创建集合
LinkedHashMap lhm = new LinkedHashMap<>();
//2.添加元素
lhm.put("c",789);
lhm.put("b",456);
lhm.put("a",123);
lhm.put("a",111);
//3.打印集合
System.out.println(lhm);
}
}
import java.util.Comparator;
import java.util.TreeMap;
public class A01_TreeMapDemo1 {
public static void main(String[] args) {
/*
TreeMap集合：基本应用
需求1：
键：整数表示id
值：字符串表示商品名称
要求1：按照id的升序排列
要求2：按照id的降序排列
*/
//1.创建集合对象
//Integer Double 默认情况下都是按照升序排列的
//String 按照字母再ASCII码表中对应的数字升序进行排列
//abcdefg ...
TreeMap tm = new TreeMap<>(new Comparator() {
@Override
public int compare(Integer o1, Integer o2) {
//o1:当前要添加的元素
//o2：表示已经在红黑树中存在的元素
return o2 - o1;
}
});
//2.添加元素
tm.put(5,"可恰可乐");
tm.put(4,"雷碧");
tm.put(3,"九个核桃");
tm.put(2,"康帅傅");
tm.put(1,"粤利粤");
//3.打印集合
System.out.println(tm);
}
}
import java.util.TreeMap;
public class A02_TreeMapDemo2 {
public static void main(String[] args) {
/*
TreeMap集合：基本应用
需求2：
键：学生对象
值：籍贯
要求：按照学生年龄的升序排列，年龄一样按照姓名的字母排列，同姓名年龄视为同一个人。
*/
//1.创建集合
TreeMap tm = new TreeMap<>();
//2.创建三个学生对象
Student s1 = new Student("zhangsan",23);
Student s2 = new Student("lisi",24);
Student s3 = new Student("wangwu",25);
//3.添加元素
tm.put(s1,"江苏");
tm.put(s2,"天津");
tm.put(s3,"北京");
//4.打印集合
System.out.println(tm);
}
}
import java.util.StringJoiner;
import java.util.TreeMap;
public class A03_TreeMapDemo3 {
public static void main(String[] args) {
/* 需求：
字符串“aababcabcdabcde”
请统计字符串中每一个字符出现的次数，并按照以下格式输出
输出结果：
a（5）b（4）c（3）d（2）e（1）
新的统计思想：利用map集合进行统计
如果题目中没有要求对结果进行排序，默认使用HashMap
如果题目中要求对结果进行排序，请使用TreeMap
键：表示要统计的内容
值：表示次数
*/
//1.定义字符串
String s = "aababcabcdabcde";
//2.创建集合
TreeMap tm = new TreeMap<>();
//3.遍历字符串得到里面的每一个字符
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
//拿着c到集合中判断是否存在
//存在，表示当前字符又出现了一次
//不存在，表示当前字符是第一次出现
if(tm.containsKey(c)){
//存在
//先把已经出现的次数拿出来
int count = tm.get(c);
//当前字符又出现了一次
count++;
//把自增之后的结果再添加到集合当中
tm.put(c,count);
}else{
//不存在
tm.put(c,1);
}
}
//4.遍历集合，并按照指定的格式进行拼接
// a（5）b（4）c（3）d（2）e（1）
//StringBuilder sb = new StringBuilder();
//tm.forEach((key, value)->sb.append(key).append("(").append(value).append(")"));
StringJoiner sj = new StringJoiner("","","");
tm.forEach((key, value)->sj.add(key + "").add("(").add(value + "").add(")"));
System.out.println(sj);
}
}
public class Student implements Comparable{
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "Student{name = " + name + ", age = " + age + "}";
}
@Override
public int compareTo(Student o) {
//按照学生年龄的升序排列，年龄一样按照姓名的字母排列，同姓名年龄视为同一个人。
//this：表示当前要添加的元素
//o：表示已经在红黑树中存在的元素
//返回值：
//负数：表示当前要添加的元素是小的，存左边
//正数：表示当前要添加的元素是大的，存右边
//0：表示当前要添加的元素已经存在，舍弃
int i = this.getAge() - o.getAge();
i = i == 0 ? this.getName().compareTo(o.getName()) : i;
return i;
}
}
import java.util.HashMap;
public class HashMapDemo {
public static void main(String[] args) {
HashMap hm = new HashMap<>();
hm.put("aaa" , 111);
hm.put("bbb" , 222);
hm.put("ccc" , 333);
hm.put("ddd" , 444);
hm.put("eee" , 555);
}
}
import java.util.TreeMap;
public class TreeMapDemo {
public static void main(String[] args) {
TreeMap tm = new TreeMap<>();
tm.put(1, "aaa");
tm.put(2, "bbb");
tm.put(3, "ccc");
tm.put(4, "ddd");
System.out.println(tm);
}
}
public class ArgsDemo1 {
public static void main(String[] args) {
/*
假如需要定义一个方法求和，该方法可以灵活的完成如下需求：
计算2个数据的和
计算3个数据的和
计算4个数据的和
计算n个数据的和
*/
System.out.println(getSum(10,20));
System.out.println(getSum(10,20,30));
System.out.println(getSum(10,20,30,40));
}
//计算2个数据的和
public static int getSum(int a, int b) {
return a + b;
}
//计算3个数据的和
public static int getSum(int a, int b, int c) {
return a + b + c;
}
//计算4个数据的和
public static int getSum(int a, int b, int c, int d) {
return a + b + c + d;
}
}
public class ArgsDemo2 {
public static void main(String[] args) {
//计算n个数据的和
int[] arr = {1,2,3,4,5,6,7,8,9,10};
int sum = getSum(arr);
System.out.println(sum);
}
public static int getSum(int[] arr) {
int sum = 0;
for (int i : arr) {
sum = sum + i;
}
return sum;
}
}
public class ArgsDemo3 {
public static void main(String[] args) {
//JDK5
//可变参数
//方法形参的个数是可以发生变化的，0 1 2 3 ...
//格式：属性类型...名字
//int...args
int sum = getSum(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
System.out.println(sum);
}
//底层：
//可变参数底层就是一个数组
//只不过不需要我们自己创建了，Java会帮我们创建好
public static int getSum(int...args){
//System.out.println(args);//[I@119d7047
int sum = 0;
for (int i : args) {
sum = sum + i;
}
return sum;
}
}
public class ArgsDemo4 {
public static void main(String[] args) {
//可变参数的小细节：
//1.在方法的形参中最多只能写一个可变参数
//可变参数，理解为一个大胖子，有多少吃多少
//2.在方法的形参当中，如果出了可变参数以外，还有其他的形参，那么可变参数要写在最后
getSum(1,2,3,4,5,6,7,8,9,10);
}
public static int getSum( int a,int...args) {
return 0;
}
}
import java.util.ArrayList;
import java.util.Collections;
public class CollectionsDemo1 {
public static void main(String[] args) {
/*
public static 尖括号T boolean addAll(Collection尖括号T c, T... elements) 批量添加元素
public static void shuffle(List尖括号?list) 打乱List集合元素的顺序
*/
//addAll 批量添加元素
//1.创建集合对象
ArrayList尖括号String list = new ArrayList<>();
//2.批量添加元素
Collections.addAll(list,"abc","bcd","qwer","df","asdf","zxcv","1234","qwer");
//3.打印集合
System.out.println(list);
//shuffle 打乱
Collections.shuffle(list);
System.out.println(list);
}
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class CollectionsDemo2 {
public static void main(String[] args) {
/*
public static 尖括号T void sort(List尖括号T list) 排序
public static 尖括号T void sort(List尖括号T list, Comparator尖括号T c) 根据指定的规则进行排序
public static 尖括号T int binarySearch (List尖括号T list, T key) 以二分查找法查找元素
public static 尖括号T void copy(List尖括号T dest, List尖括号T src) 拷贝集合中的元素
public static 尖括号T int fill (List尖括号T list, T obj) 使用指定的元素填充集合
public static 尖括号T void max/min(Collection尖括号T coll) 根据默认的自然排序获取最大/小值
public static 尖括号T void swap(List尖括号? list, int i, int j) 交换集合中指定位置的元素
*/
System.out.println("-------------sort默认规则--------------------------");
//默认规则，需要重写Comparable接口compareTo方法。Integer已经实现，按照从小打大的顺序排列
//如果是自定义对象，需要自己指定规则
ArrayList list1 = new ArrayList<>();
Collections.addAll(list1, 10, 1, 2, 4, 8, 5, 9, 6, 7, 3);
Collections.sort(list1);
System.out.println(list1);
System.out.println("-------------sort自己指定规则规则--------------------------");
Collections.sort(list1, new Comparator() {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
});
System.out.println(list1);
Collections.sort(list1, (o1, o2) -> o2 - o1);
System.out.println(list1);
System.out.println("-------------binarySearch--------------------------");
//需要元素有序
ArrayList list2 = new ArrayList<>();
Collections.addAll(list2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
System.out.println(Collections.binarySearch(list2, 9));
System.out.println(Collections.binarySearch(list2, 1));
System.out.println(Collections.binarySearch(list2, 20));
System.out.println("-------------copy--------------------------");
//把list3中的元素拷贝到list4中
//会覆盖原来的元素
//注意点：如果list3的长度 > list4的长度，方法会报错
ArrayList list3 = new ArrayList<>();
ArrayList list4 = new ArrayList<>();
Collections.addAll(list3, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Collections.addAll(list4, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);
Collections.copy(list4, list3);
System.out.println(list3);
System.out.println(list4);
System.out.println("-------------fill--------------------------");
//把集合中现有的所有数据，都修改为指定数据
ArrayList list5 = new ArrayList<>();
Collections.addAll(list5, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Collections.fill(list5, 100);
System.out.println(list5);
System.out.println("-------------max/min--------------------------");
//求最大值或者最小值
ArrayList list6 = new ArrayList<>();
Collections.addAll(list6, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
System.out.println(Collections.max(list6));
System.out.println(Collections.min(list6));
System.out.println("-------------max/min指定规则--------------------------");
// String中默认是按照字母的abcdefg顺序进行排列的
// 现在我要求最长的字符串
// 默认的规则无法满足，可以自己指定规则
// 求指定规则的最大值或者最小值
ArrayList list7 = new ArrayList<>();
Collections.addAll(list7, "a","aa","aaa","aaaa");
System.out.println(Collections.max(list7, new Comparator() {
@Override
public int compare(String o1, String o2) {
return o1.length() - o2.length();
}
}));
System.out.println("-------------swap--------------------------");
ArrayList list8 = new ArrayList<>();
Collections.addAll(list8, 1, 2, 3);
Collections.swap(list8,0,2);
System.out.println(list8);
}
}
import java.util.ArrayList;
import java.util.Collections;
public class Test1 {
public static void main(String[] args) {
/* 班级里有N个学生，学生属性:姓名，年龄，性别。
实现随机点名器。*/
//1.定义集合
ArrayList list = new ArrayList<>();
//2.添加数据
Collections.addAll(list,"范闲","范建","范统","杜子腾","杜琦燕","宋合泛","侯笼藤","朱益群","朱穆朗玛峰","袁明媛");
//3.随机点名
/* Random r = new Random();
int index = r.nextInt(list.size());
String name = list.get(index);
System.out.println(name);*/
//打乱
Collections.shuffle(list);
String name = list.get(0);
System.out.println(name);
}
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;
public class Test2 {
public static void main(String[] args) {
/* 班级里有N个学生
要求：
70%的概率随机到男生
30%的概率随机到女生
"范闲","范建","范统","杜子腾","宋合泛","侯笼藤","朱益群","朱穆朗玛峰",
"杜琦燕","袁明媛","李猜","田蜜蜜",
*/
//1.创建集合
ArrayList list = new ArrayList<>();
//2.添加数据
Collections.addAll(list,1,1,1,1,1,1,1);
Collections.addAll(list,0,0,0);
//3.打乱集合中的数据
Collections.shuffle(list);
//4.从list集合中随机抽取0或者1
Random r = new Random();
int index = r.nextInt(list.size());
int number = list.get(index);
System.out.println(number);
//5.创建两个集合分别存储男生和女生的名字
ArrayList boyList = new ArrayList<>();
ArrayList girlList = new ArrayList<>();
Collections.addAll(boyList,"范闲","范建","范统","杜子腾","宋合泛","侯笼藤","朱益群","朱穆朗玛峰");
Collections.addAll(girlList,"杜琦燕","袁明媛","李猜","田蜜蜜");
//6.判断此时是从boyList里面抽取还是从girlList里面抽取
if(number == 1){
//boyList
int boyIndex = r.nextInt(boyList.size());
String name = boyList.get(boyIndex);
System.out.println(name);
}else{
//girlList
int girlIndex = r.nextInt(girlList.size());
String name = girlList.get(girlIndex);
System.out.println(name);
}
}
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;
public class Test3 {
public static void main(String[] args) {
/* 班级里有5个学生
要求：
被点到的学生不会再被点到。
但是如果班级中所有的学生都点完了，需要重新开启第二轮点名。*/
//1.定义集合
ArrayList list1 = new ArrayList<>();
//2.添加数据
Collections.addAll(list1, "范闲", "范建", "范统", "杜子腾", "杜琦燕", "宋合泛", "侯笼藤", "朱益群", "朱穆朗玛峰", "袁明媛");
//创建一个临时的集合，用来存已经被点到学生的名字
ArrayList list2 = new ArrayList<>();
//外循环：表示轮数
for (int i = 1; i <= 10; i++) {
System.out.println("=========第" + i + "轮点名开始了======================");
//3.获取集合的长度
int count = list1.size();
//4.随机点名
Random r = new Random();
//内循环：每一轮中随机循环抽取的过程
for (int j = 0; j < count; j++) {
int index = r.nextInt(list1.size());
String name = list1.remove(index);
list2.add(name);
System.out.println(name);
}
//此时表示一轮点名结束
//list1 空了 list2 10个学生的名字
list1.addAll(list2);
list2.clear();
}
}
}
import java.util.*;
public class Test4 {
public static void main(String[] args) {
/* 需求
定义一个Map集合，键用表示省份名称province，值表示市city，但是市会有多个。
添加完毕后，遍历结果格式如下：
江苏省 = 南京市，扬州市，苏州市，无锡市，常州市
湖北省 = 武汉市，孝感市，十堰市，宜昌市，鄂州市
河北省 = 石家庄市，唐山市，邢台市，保定市，张家口市*/
//1.创建Map集合
HashMap> hm = new HashMap<>();
//2.创建单列集合存储市
ArrayList city1 = new ArrayList<>();
city1.add("南京市");
city1.add("扬州市");
city1.add("苏州市");
city1.add("无锡市");
city1.add("常州市");
ArrayList city2 = new ArrayList<>();
city2.add("武汉市");
city2.add("孝感市");
city2.add("十堰市");
city2.add("宜昌市");
city2.add("鄂州市");
ArrayList city3 = new ArrayList<>();
city3.add("石家庄市");
city3.add("唐山市");
city3.add("邢台市");
city3.add("保定市");
city3.add("张家口市");
//3.把省份和多个市添加到map集合
hm.put("江苏省",city1);
hm.put("湖北省",city2);
hm.put("河北省",city3);
Set>> entries = hm.entrySet();
for (Map.Entry> entry : entries) {
//entry依次表示每一个键值对对象
String key = entry.getKey();
ArrayList value = entry.getValue();
StringJoiner sj = new StringJoiner(", ","","");
for (String city : value) {
sj.add(city);
}
System.out.println(key + " = " + sj);
}
}
}
public class App {
public static void main(String[] args) {
new Login();
}
}
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class CheatJFrame extends JFrame implements ActionListener {
JButton submit = new JButton("确定");
public CheatJFrame() {
//设置界面
initJframe();
//添加组件
initView();
//界面显示出来
this.setVisible(true);
}
@Override
public void actionPerformed(ActionEvent e) {
Object obj = e.getSource();
if(obj == submit){
this.setVisible(false);
new GameJFrame();
}
}
//添加组件
public void initView() {
JLabel cheat = new JLabel("作弊时刻");
cheat.setFont(new Font(null,1,30));
cheat.setBounds(130,10,130,30);
this.getContentPane().add(cheat);
JLabel hint1 = new JLabel("不会被点到的人");
hint1.setFont(new Font(null,0,20));
hint1.setBounds(30,100,140,30);
this.getContentPane().add(hint1);
JTextField noRollName = new JTextField();
noRollName.setBounds(180,100,140,30);
this.getContentPane().add(noRollName);
JLabel hint2 = new JLabel("第");
hint2.setFont(new Font(null,0,20));
hint2.setBounds(30,200,30,30);
this.getContentPane().add(hint2);
JTextField count = new JTextField();
count.setBounds(60,200,30,30);
this.getContentPane().add(count);
JLabel hint3 = new JLabel("次,一定会被点到的人是：");
hint3.setFont(new Font(null,0,20));
hint3.setBounds(100,200,230,30);
this.getContentPane().add(hint3);
JTextField rollName = new JTextField();
rollName.setBounds(210,240,100,30);
this.getContentPane().add(rollName);
submit.setFont(new Font(null,1,20));
submit.setBounds(110,300,150,50);
submit.setBackground(Color.WHITE);
submit.addActionListener(this);
this.getContentPane().add(submit);
}
//设置界面
public void initJframe() {
//设置标题
this.setTitle("随机点名器");
//设置大小
this.setSize(400, 500);
//设置关闭模式
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//设置窗口无法进行调节
this.setResizable(false);
//界面居中
this.setLocationRelativeTo(null);
//取消内部默认居中放置
this.setLayout(null);
//设置背景颜色
this.getContentPane().setBackground(Color.white);
this.setAlwaysOnTop(true);//置顶
}
}
import javax.swing.*;
import java.awt.*;
public class GameJFrame extends JFrame{
public GameJFrame() {
//设置界面
initJframe();
//添加组件
initView();
//界面显示出来
this.setVisible(true);
}
//添加组件
public void initView() {
JLabel countDown = new JLabel("倒计时：5秒");
countDown.setFont(new Font(null,1,50));
countDown.setBounds(50,50,300,60);
this.getContentPane().add(countDown);
JLabel namePrompt = new JLabel("中奖选手为：");
namePrompt.setFont(new Font(null,1,20));
namePrompt.setBounds(80,150,125,30);
this.getContentPane().add(namePrompt);
JLabel rollName = new JLabel("XXX");
rollName.setFont(new Font(null,1,20));
rollName.setBounds(200,150,125,30);
this.getContentPane().add(rollName);
JLabel rollImage = new JLabel(new ImageIcon("默认图片路径"));
rollImage.setBounds(87,200,210,210);
this.getContentPane().add(rollImage);
JButton start = new JButton("开始");
start.setFont(new Font(null,1,20));
start.setBounds(118,430,150,50);
start.setBackground(Color.WHITE);
//start.addActionListener(this);
this.getContentPane().add(start);
}
//设置界面
public void initJframe() {
//设置标题
this.setTitle("随机点名器");
//设置大小
this.setSize(400, 600);
//设置关闭模式
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//设置窗口无法进行调节
this.setResizable(false);
//界面居中
this.setLocationRelativeTo(null);
//取消内部默认居中放置
this.setLayout(null);
//设置背景颜色
this.getContentPane().setBackground(Color.white);
this.setAlwaysOnTop(true);//置顶
}
}
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class Login extends JFrame implements ActionListener {
JButton go = new JButton("Go");
public Login() {
//设置图标
setIconImage(Toolkit.getDefaultToolkit().getImage("doudizhu\\image2\\logo.jpg"));
//设置界面
initJframe();
//添加组件
initView();
//界面显示出来
this.setVisible(true);
}
@Override
public void actionPerformed(ActionEvent e) {
Object obj = e.getSource();
if(obj == go){
this.setVisible(false);
new CheatJFrame();
}
}
//添加组件
public void initView() {
JLabel image = new JLabel(new ImageIcon("doudizhu\\image2\\kit.jpg"));
image.setBounds(100,50,174,174);
this.getContentPane().add(image);
go.setFont(new Font(null,1,20));
go.setBounds(120,274,150,50);
go.setBackground(Color.WHITE);
go.addActionListener(this);
this.getContentPane().add(go);
}
//设置界面
public void initJframe() {
//设置标题
this.setTitle("随机点名器");
//设置大小
this.setSize(400, 500);
//设置关闭模式
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//设置窗口无法进行调节
this.setResizable(false);
//界面居中
this.setLocationRelativeTo(null);
//取消内部默认居中放置
this.setLayout(null);
//设置背景颜色
this.getContentPane().setBackground(Color.white);
this.setAlwaysOnTop(true);//置顶
}
}
public class App {
public static void main(String[] args) {
/*
完成控制台版的三步：
准备牌
洗牌
发牌
*/
new PokerGame();
}
}
import java.util.ArrayList;
import java.util.Collections;
public class PokerGame {
//牌盒
//♥3 ♣3
static ArrayList list = new ArrayList<>();
//静态代码块
//特点：随着类的加载而在加载的，而且只执行一次。
static {
//准备牌
// "♦", "♣", "♥", "♠"
// "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"
String[] color = {"♦", "♣", "♥", "♠" };
String[] number = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
for (String c : color) {
//c依次表示每一种花色
for (String n : number) {
//n 依次表示每一个数字
list.add(c + n);
}
}
list.add("小王");
list.add("大王");
}
public PokerGame(){
//洗牌
Collections.shuffle(list);
//发牌
ArrayList lord = new ArrayList<>();
ArrayList player1 = new ArrayList<>();
ArrayList player2 = new ArrayList<>();
ArrayList player3 = new ArrayList<>();
//遍历牌盒得到每一张牌
for (int i = 0; i < list.size(); i++) {
//i：索引
String poker = list.get(i);
if(i <= 2){
lord.add(poker);
continue;
}
//给三个玩家轮流发牌
if(i % 3 == 0){
player1.add(poker);
}else if(i % 3 == 1){
player2.add(poker);
}else{
player3.add(poker);
}
}
//看牌
lookPoker("底牌",lord);
lookPoker("钢脑壳",player1);
lookPoker("大帅比",player2);
lookPoker("蛋筒",player3);
}
/*
* 参数一：玩家的名字
* 参数二：每位玩家的牌
* */
public void lookPoker(String name, ArrayList list){
System.out.print(name + ": ");
for (String poker : list) {
System.out.print(poker + " ");
}
System.out.println();
}
}
public class App {
public static void main(String[] args) {
/*
完成控制台版的四步：
准备牌
洗牌
发牌
排序
*/
new PokerGame();
}
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;
public class PokerGame {
//牌盒 Map
//此时我们只要把牌跟序号产生对应关系就可以了，不需要按照序号进行排序，所以只要HashMap就可以了
static HashMap hm = new HashMap<>();
static ArrayList list = new ArrayList<>();
static {
String[] color = {"♦", "♣", "♥", "♠"};
String[] number = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
//序号
int serialNumber = 1;
//细节
for (String n : number) {
//依次表示每一个数字
for (String c : color) {
//依次表示每一个花色
hm.put(serialNumber, c + n);
list.add(serialNumber);
serialNumber++;
}
}
hm.put(serialNumber, "小王");
list.add(serialNumber);
serialNumber++;
hm.put(serialNumber, "大王");
list.add(serialNumber);
}
public PokerGame() {
//洗牌
Collections.shuffle(list);
//发牌
TreeSet lord = new TreeSet<>();
TreeSet player1 = new TreeSet<>();
TreeSet player2 = new TreeSet<>();
TreeSet player3 = new TreeSet<>();
for (int i = 0; i < list.size(); i++) {
//i :依次表示集合中的每一个索引
//list.get(i)元素：牌的序号
int serialNumber = list.get(i);
if(i <= 2){
lord.add(serialNumber);
continue;
}
if(i % 3 == 0){
player1.add(serialNumber);
}else if(i % 3 == 1){
player2.add(serialNumber);
}else{
player3.add(serialNumber);
}
}
//看牌
lookPoker("底牌",lord);
lookPoker("钢脑壳",player1);
lookPoker("大帅比",player2);
lookPoker("蛋筒",player3);
}
/*
* 参数一：玩家的名字
* 参数二：牌的序号
* */
public void lookPoker(String name, TreeSet ts){
System.out.print(name + ": ");
//遍历TreeSet集合得到每一个序号，再拿着序号到Map集合中去找真正的牌
for (int serialNumber : ts) {
String poker = hm.get(serialNumber);
System.out.print(poker + " ");
}
System.out.println();
}
}
public class App {
public static void main(String[] args) {
new PokerGame();
}
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
public class PokerGame {
//牌盒
static ArrayList list = new ArrayList<>();
//创建一个集合，用来添加牌的价值
static HashMap hm = new HashMap<>();
static {
//准备牌
String[] color = {"♦", "♣", "♥", "♠"};
String[] number = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
for (String c : color) {
for (String n : number) {
list.add(c + n);
}
}
list.add(" 小王");
list.add(" 大王");
//指定牌的价值
//牌上的数字到Map集合中判断是否存在
//存在，获取价值
//不存在，本身的数字就是价值
hm.put("J", 11);
hm.put("Q", 12);
hm.put("K", 13);
hm.put("A", 14);
hm.put("2", 15);
hm.put("小王", 50);
hm.put("大王", 100);
}
public PokerGame() {
//洗牌
Collections.shuffle(list);
//发牌
ArrayList lord = new ArrayList<>();
ArrayList player1 = new ArrayList<>();
ArrayList player2 = new ArrayList<>();
ArrayList player3 = new ArrayList<>();
for (int i = 0; i < list.size(); i++) {
String poker = list.get(i);
//发底牌
if (i <= 2) {
lord.add(poker);
continue;
}
//给三个玩家轮流发牌
if (i % 3 == 0) {
player1.add(poker);
} else if (i % 3 == 1) {
player2.add(poker);
} else {
player3.add(poker);
}
}
//排序
order(lord);
order(player1);
order(player2);
order(player3);
//看牌
lookPoker("底牌",lord);
lookPoker("钢脑壳",player1);
lookPoker("大帅比",player2);
lookPoker("蛋筒",player3);
}
/*
* 参数一：玩家的名字
* 参数二：每位玩家的牌
* */
public void lookPoker(String name, ArrayList list){
System.out.print(name + ": ");
for (String poker : list) {
System.out.print(poker + " ");
}
System.out.println();
}
//利用牌的价值进行排序
//参数：集合
//♥5 ♥3 ♥6 ♥7 ♥9
public void order(ArrayList list){
Collections.sort(list, new Comparator() {
//Array.sort （插入排序 + 二分查找）
@Override
public int compare(String o1, String o2) {
//o1：表示当前要插入到有序序列中的牌
//o2：表示已经在有序序列中存在的牌
//负数：o1小 插入到前面
//正数：o1大 插入到后面
//0：o1的数字跟o2的数字是一样的，需要按照花色再次排序
//1.计算o1的花色和价值 大王
String color1 = o1.substring(0, 1);
int value1 = getValue(o1);
//2.计算o2的花色和价值
String color2 = o2.substring(0, 1);
int value2 = getValue(o2);
//3.比较o1和o2的价值 ♥3 ♠3
int i = value1 - value2;
return i == 0 ? color1.compareTo(color2) : i;
}
});
}
//计算牌的价值
//参数：牌
//返回值：价值
public int getValue(String poker){//♥3
//获取牌上的数字
String number = poker.substring(1);//把这里截取出来的结果，让这个结果再Map集合中存在 “ 大王”
//拿着数字到map集合中判断是否存在
if(hm.containsKey(number)){
//存在，获取价值
return hm.get(number);
}else{
//不存在，类型转换
return Integer.parseInt(number);
}
}
}
单词
