集合测试
Collection
Test_1 ScannerTest
使用Scanner从键盘读取一行输入,去掉重复字符, 打印出不同字符
/***
* 使用Scanner从键盘读取一行输入,去掉其中重复字符, 打印出不同的那些字符
*/
public class ScannerTest {
public static void main(String[] args) {
//有序：HashSet<Character> hs = new LinkedHashSet<>();
HashSet<Character> hs = new HashSet<>();
Scanner sc = new Scanner(System.in);
String line = sc.nextLine();//接受获得的字符串
char[] arr = line.toCharArray();//字符串转换成字符数组
//把接收到的字符串遍历添加到集合
for (char c : arr) {
hs.add(c);
}
//遍历HashSet集合
for (Character h : hs) {
System.out.print(h + " ");
}
System.out.println();
}
}
输出结果:
aadddccccbbbbbggf
a b c d f g
Test_2 ArrayListTest
需求: 将ArrayList集合中的重复元素去掉
/**
* 需求: 将ArrayList集合中的重复元素去掉
*/
public class ArrayListTest {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("aaa");
list.add("aaa");
list.add("abc");
list.add("bbc");
list.add("bbc");
list.add("bbc");
list.add("world");
list.add("world");
list.add("hello");
for (String s : list) {
System.out.print(s + " ");
}
System.out.println();
getList(list);
}
private static void getList(ArrayList<String> list) {
HashSet<String> hs = new LinkedHashSet<>();//无序: HashSet<>()
hs.addAll(list);
//for (String s : list) {
// hs.add(s);
//}
list.clear();
list.addAll(hs);
System.out.println(list);
}
}
输出结果:
aaa aaa abc bbc bbc bbc world world hello
[aaa, abc, bbc, world, hello]
Test_3 RandomTest1
需求：编写一个程序，获取10个1至20的随机数，要求随机数不能重复。并把最终的随机数输出到控制台。
/**
* 需求：编写一个程序，获取10个1至20的随机数，要求随机数不能重复。
* 并把最终的随机数输出到控制台。
*/
public class RandomTest {
public static void main(String[] args) {
HashSet<Integer> hs = new HashSet<>();
Random random = new Random();
int count = 0;
while (hs.size() < 10) {
//获取随机数
int num = random.nextInt(20) + 1;//随机数上限 : 20
count++;
hs.add(num);
}
System.out.println("一共获得了" + count + "随机数");
for (Integer i : hs) {
System.out.print(i + " ");
}
System.out.println();
}
}
输出结果:
一共获得了12随机数
16 17 1 2 19 6 9 12 13 15
Test_4 RandomTest2
用一个大集合存入20个随机数字，然后筛选其中的偶数元素，放到小集合当中然后进行遍历输出
/**
* 用一个大集合存入20个随机数字，然后筛选其中的偶数元素，放到小集合当中然后进行遍历输出
*/
public class RandomList {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
List<Integer> list1 = new ArrayList<>();
for (int i = 0; i < 20; i++) {
list.add((int) (Math.random()*100));
}
for (Integer i : list) {
System.out.print(i + " ");
}
System.out.println();
for (Integer i : list) {
if (i % 2 == 0) {
list1.add(i);
}
}
for (Integer i : list1) {
System.out.print(i + " ");
}
System.out.println();
}
}
输出结果:
12 34 85 14 28 58 16 45 40 27 74 88 58 58 41 39 0 3 80 10
12 34 14 28 58 16 40 74 88 58 58 0 80 10
Test_5 ReceiveTest
程序启动后, 可以从键盘输入接收多个整数,直到输入quit时结束输入. 把所有输入的整数倒序排列打印
/***
* 程序启动后, 可以从键盘输入接收多个整数,
* 直到输入quit时结束输入. 把所有输入的整数倒序排列打印
*/
public class TreeSetTest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
TreeSet<Integer> ts = new TreeSet<>(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
int num = o2 - o1;//倒叙排列二叉树. 默认正序排列为从小到大
return num == 0 ? 1 : num;
}
});
while (true) {
String str = sc.nextLine();
if ("quit".equals(str)) break;
try {
int num = Integer.parseInt(str);//将数字字符串转换成数字
ts.add(num);
} catch (Exception e) {
System.out.println("error");
}
}
for (Integer t : ts) {
System.out.println(t);
}
}
}
输出结果:
12
123
222
1
quit
222
123
12
1
Test_6 AddListTest
需求：有一个集合，我想判断里面有没有"world"这个元素，如果有，就添加一个"javaee"元素，请写代码实现
/***
* 需求：我有一个集合，请问，我想判断里面有没有"world"这个元素
* 如果有，我就添加一个"javaee"元素，请写代码实现
*/
public class ListTest {
public static void main(String[] args) {
List list = new ArrayList();
list.add("a");
list.add("b");
list.add("world");
list.add("d");
list.add("e");
// == 判断是否指向同一个内存空间
// .equals 判断所指向的内存空间的值是否相同
//使用iterator 一边通过迭代器遍历list， 一边修改list，会出现并发异常
//Iterator it = list.iterator();
ListIterator it = list.listIterator();
while (it.hasNext()) {
String str = (String) it.next();
if ("world".equals(str)) {
it.add("javaee");
//list.add("javaee");
}
}
System.out.println(list);
/*
for (int i = 0; i < list.size(); i++) {
//Object --> String
String str = (String) list.get(i);
if ("world".equals(str)) {
list.add("javaee");
}
}
System.out.println(list);*/
/*
boolean f = list.contains("world");
if ("true".equals(f)) {
list.add("javaee");
}
System.out.println(list);*/
}
}
输出结果:
[a, b, world, javaee, d, e]
Test_7 SortTest
1-10个数字
奇数在后偶数在前
偶数降序，奇数升序
/**
* 1-10个数字
* 奇数在后偶数在前
* 偶数降序，奇数升序
*/
public class TreeSetSort2 {
public static void main(String[] args) {
Set<Integer> set = new TreeSet<>(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
if (o1 % 2 == 0) {
if (o2 % 2 == 0) {
return o2 - o1;
}else {
return -1;
}
}else {
if (o2 % 2 != 0) {
return o1 - o2;
}else {
return 1;
}
}
}
});
for (int i = 1; i <= 10; i++) {
set.add(i);
}
System.out.println(set);
}
}
输出结果:
[10, 8, 6, 4, 2, 1, 3, 5, 7, 9]
Map
Test_1 CountTest1
需求：统计字符串中每个字符出现的次数 HashMap实现
/***
* 需求：统计字符串中每个字符出现的次数 HashMap实现
*/
public class CountTest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
char[] arr = str.toCharArray(); //将输入的字符串转化成字符数组
HashMap<Character, Integer> map = new HashMap<>();
for (char c : arr) {
if (map.containsKey(c)) {
map.put(c, map.get(c) + 1);
}else {
map.put(c, 1);
}
}
for (Map.Entry<Character, Integer> entry : map.entrySet()) {
System.out.println(entry.getKey() + " : " + entry.getValue());
}
}
}
输出结果:
aabbccddd123321
a : 2
1 : 2
b : 2
2 : 2
c : 2
3 : 2
d : 3
/**
* 统计每个字符串出现的次数 TrreeMap实现
* String s = "aabbddccaefdd";
*/
public class TreeMapCount {
public static void main(String[] args) {
Map<Character, Integer> map = new TreeMap<>();
String s = "aabbddccaefdd";
char[] array = s.toCharArray();
for (char c : array) {
if (!map.containsKey(c)) {
map.put(c, 1);
}else {
map.put(c, map.get(c) + 1);
}
}
for (Character c : map.keySet()) {
System.out.println(c + " : " + map.get(c));
}
}
}
输出结果:
a : 3
b : 2
c : 2
d : 4
e : 1
f : 1
Test_2 CountTest2
在控制台输入一句英文：The hard part is not making the decision but it is living with it
- 每个单词之间用空白隔开。
- 使用HashMap统计该句英文中每个单词出现的次数
/***
* 在控制台输入一句英文：The hard part is not making the decision but it is living with it
* 每个单词之间用空白隔开。
* 使用HashMap统计该句英文中每个单词出现的次数
*/
public class TestWork1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//把输入的字符串统一转成小写单词处理
String line = sc.nextLine().toLowerCase();
String[] arr = line.split(" ");
Map<String, Integer> map = new HashMap();
for (String s : arr) {
if (!map.containsKey(s)) {
map.put(s, 1);
}else {
map.put(s, map.get(s) + 1);
}
}
for (Map.Entry<String, Integer> entry : map.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}
}
}
输出结果:
The hard part is not making the decision but it is living with it
the: 2
but: 1
with: 1
not: 1
making: 1
living: 1
decision: 1
part: 1
is: 2
hard: 1
it: 2
Test_3 DouDiZhu
斗地主
/**
* 斗地主
*/
public class DouDiZhu {
public static void main(String[] args) {
String[] color = {"♠", "♥", "♣", "♦"};
String[] number = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"};
Map<Integer, String> map = new HashMap<>();
List<Integer> list = new ArrayList<>();
//把颜色和数字组合放进map集合中
int index = 0;
for (String s : color) {
for (String s1 : number) {
map.put(index, s.concat(s1));
list.add(index);
index++;
}
}
//index++;
//存大小王
map.put(index, "小王");
list.add(index);
index++;
map.put(index, "大王");
list.add(index);
//System.out.println(map);
System.out.println(map.size());
//洗牌
Collections.shuffle(list);
//System.out.println(list);
//发牌 将list集合随机排列后放进三个玩家集合和一个底牌集合中 TreeSet在输出时会自动按照自然数排序 【中序遍历】
TreeSet<Integer> play1 = new TreeSet<>();
TreeSet<Integer> play2 = new TreeSet<>();
TreeSet<Integer> play3 = new TreeSet<>();
TreeSet<Integer> UnderCard = new TreeSet<>();
/*for (Integer i : list) {
System.out.print(i + " ");
}
System.out.println();*/
for (int i = 0; i < list.size(); i++) {
if (i >= list.size()-3) {
UnderCard.add(list.get(i));
}else if (i % 3 == 0) {
play1.add(list.get(i));
}else if (i % 3 == 1) {
play2.add(list.get(i));
}else
play3.add(list.get(i));
}
//玩家看牌
LookPoker(play1, map, "player1");
LookPoker(play2, map, "player2");
LookPoker(play3, map, "player3");
LookPoker(UnderCard, map, "UnderCard");
}
private static void LookPoker(TreeSet<Integer> player, Map<Integer, String> map, String playerName) {
System.out.print(playerName + ": ");
for (Integer i : player) {
System.out.print(map.get(i) + " ");
}
System.out.println();
}
}
输出结果[随机性]:
54
♠3 ♣3 ♠4 ♠6 ♣6 ♠7 ♦7 ♥8 ♦8 ♥9 ♣10 ♥J ♦Q ♣A ♥2 ♦2 大王
♥3 ♠5 ♥5 ♦5 ♥6 ♦6 ♥7 ♠8 ♦10 ♠J ♣J ♠Q ♣Q ♠K ♥K ♠A ♦A
♦3 ♣4 ♦4 ♣5 ♣7 ♣8 ♦9 ♠10 ♥10 ♦J ♥Q ♣K ♦K ♥A ♠2 ♣2 小王
♥4 ♠9 ♣9