关于java集合的练习
练习一：Collection集合练习
一、产生10个1-100的随机数，并放到一个数组中，把数组中大于等于10的数字放到一个list集合中，并打印到控制台。
public class Topic1 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
int arr[] = new int[10];
Random ra = new Random();
for (int i = 0; i < arr.length; i++) {
arr[i]=ra.nextInt(100)+1;
if (arr[i]>=10)
list.add(arr[i]);
}
System.out.println(list);
}
}
练习二：Collection集合练习
一、定义一个方法listTest(ArrayList<Integer> al, Integer s)，要求返回s在al里面第一次出现的索引，如果s没出现过返回-1。
public class Topic2 {
public static void main(String[] args) {
ArrayList<Integer> arrayList = new ArrayList<>();
arrayList.add(1);
arrayList.add(2);
arrayList.add(6);
arrayList.add(4);
arrayList.add(9);
System.out.println("索引值为:"+listTest(arrayList,4));
}
public static int listTest(ArrayList<Integer> al, Integer s){
for (int i = 0; i < al.size(); i++) {
if (al.get(i)==s)
return i;
}
return -1;
}
}
练习三：LinkedList使用
已知数组存放一批QQ号码，QQ号码最长为11位，最短为5位String[] strs = {"12345","67891","12347809933","98765432102","67891","12347809933"}。
将该数组里面的所有qq号都存放在LinkedList中，将list中重复元素删除，将list中所有元素分别用迭代器和增强for循环打印出来。
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.LinkedList; /*
* 已知数组存放一批QQ号码，QQ号码最长为11位，最短为5位String[] strs = {"12345","67891","12347809933","98765432102","67891","12347809933"}。
将该数组里面的所有qq号都存放在LinkedList中，将list中重复元素删除，将list中所有元素分别用迭代器和增强for循环打印出来。 * */
public class Topic3 {
public static void main(String[] args) {
String[] strs = {"12345","67891","12347809933","98765432102","67891","12347809933"};
LinkedHashSet<String> set = method01(strs);
//方式1
// System.out.println(set);
//方式2
// System.out.println(method02(strs));
//迭代器打印
Iterator<String> it = method01(strs).iterator();
while (it.hasNext()){
String value = it.next();
System.out.print(value+" ");
}
System.out.println();
//增强for打印
for (String s : method02(strs)) {
System.out.print(s+" ");
} }
//方式2
private static LinkedList<String> method02(String[] strs) {
LinkedList<String> list = new LinkedList<>();
for (int i = 0; i < strs.length; i++) {
list.add(strs[i]); }
int flag =1;// 0为找不到,1为找到
//如果此元素在,除了本次位置的其他元素内找到,则删除该元素.
for (int i = 0; i < list.size(); i++) {
//判断这个元素之后的元素 是否与这个元素相等. 是则删除,不是则继续执行.
for(int j=i+1;j<list.size();j++){
if (list.get(i).equals(list.get(j))){
list.remove(j);
}
}
} return list;
}
//方式1
private static LinkedHashSet<String> method01(String[] strs) {
LinkedHashSet<String> set = new LinkedHashSet<>();
for (int i = 0; i < strs.length; i++) {
set.add(strs[i]);
}
return set;
}
}
练习四：HashSet的使用
双色球规则：双色球每注投注号码由6个红色球号码和1个蓝色球号码组成。红色球号码从1—33中选择；蓝色球号码从1—16中选择；请随机生成一注双色球号码。（要求同色号码不重复）
import java.util.ArrayList;
import java.util.Random;
/*
* */
public class Topic4 {
public static void main(String[] args) {
String stringArr[] = new String[7];
//先确定蓝球位置 标记为flag.
int flag = 0;
Random ra = new Random();
int blueBallIndex = ra.nextInt(7);
stringArr[blueBallIndex]=method2();
for (int i = 0; i < stringArr.length; i++) {
if(i==blueBallIndex)
continue;
stringArr[i]=method1();
}
//for循环打印
for (int i = 0; i < stringArr.length; i++) {
System.out.print(stringArr[i]+" ");
}
} //method1 返回红球字符串
public static String method1(){
ArrayList<String> arrayList = new ArrayList<>();
for (int i = 0; i < 33; i++) {
Integer temp = (i+1);
arrayList.add(temp.toString());
}
Random ra = new Random();
int randomValue = ra.nextInt(33);
return "红球"+arrayList.get(randomValue);
}
//method2 返回蓝球字符串
public static String method2(){
ArrayList<String> arrayList = new ArrayList<>();
for (int i = 0; i < 16; i++) {
Integer temp = (i+1);
arrayList.add(temp.toString());
}
Random ra = new Random();
int randomValue = ra.nextInt(16);
return "蓝球"+arrayList.get(randomValue);
} }
练习五：Comparable和Comparator的使用
分别用Comparable和Comparator两个接口对下列四位同学的成绩做降序排序，如果成绩一样，那在成绩排序的基础上按照年龄由小到大排序。
|
姓名（String） |
年龄（int） |
分数（float） |
|
liusan |
20 |
90.0F |
|
lisi |
22 |
90.0F |
|
wangwu |
20 |
99.0F |
|
sunliu |
22 |
100.0F |
编写一个Student类用来实现Comparable<Student>接口,并在其中重写CompareTo(Student o)方法
package topic5;
public class Student implements Comparable<Student> {
private String name;
private int age;
private float sorce;
public Student() {
}
public Student(String name, int age, float sorce) {
this.name = name;
this.age = age;
this.sorce = sorce;
}
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;
}
public float getSorce() {
return sorce;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", sorce=" + sorce +
'}';
}
public void setSorce(float sorce) {
this.sorce = sorce;
}
/*
*
* */
@Override
public int compareTo(Student o) {
//定义一个中间变量判断成绩的大小 如果成绩相等 比较年龄
int result = (int)(o.getSorce() - this.getSorce());
if(result==0){
result = o.getAge()-this.getAge();
}
return result;
// return (int)(o.getSorce() - this.getSorce());
}
}
在主函数中使用Comparable 与 Comparetor分别对ArrayList进行排序.
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator; /*
* 分别用Comparable和Comparator两个接口对下列四位同学的成绩做降序排序，如果成绩一样，那在成绩排序的基础上按照年龄由小到大排序。
姓名（String） 年龄（int） 分数（float）
liusan 20 90.0F
lisi 22 90.0F
wangwu 20 99.0F
sunliu 22 100.0F * */
public class Topic5 {
public static void main(String[] args) {
Student stu1 = new Student("liusan",20,90.0f);
Student stu2 = new Student("lisi",22,90.0f);
Student stu3 = new Student("wangwu",20,90.0f);
Student stu4 = new Student("sunliu",20,100.0f);
System.out.println("升序排序");
ArrayList<Student > arr = new ArrayList<>();
arr.add(stu1);
arr.add(stu2);
arr.add(stu3);
arr.add(stu4);
Collections.sort(arr);
System.out.println(arr);
//打乱重新写方法排序
Collections.shuffle(arr);
//写一个Compelator方法
Collections.sort(arr, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
int result = (int)(o2.getSorce() - o1.getSorce());
if(result==0){
result = o2.getAge()-o1.getAge();
}
return result; }
});
System.out.println("升序排序");
System.out.println(arr); }
}
练习六：Map集合的使用（一）
一、现在有一个map集合如下：
Map<Integer,String> map = new HashMap<Integer, String>();
map.put(1, "张三丰");
map.put(2, "周芷若");
map.put(3, "汪峰");
map.put(4, "灭绝师太");
要求：
1.遍历集合，并将序号与对应人名打印。
2.向该map集合中插入一个编码为5姓名为李晓红的信息
3.移除该map中的编号为1的信息
4.将map集合中编号为2的姓名信息修改为"周林"
import java.util.HashMap;
import java.util.Map;
import java.util.Set; /*
* 一、现在有一个map集合如下：
Map<Integer,String> map = new HashMap<Integer, String>();
map.put(1, "张三丰");
map.put(2, "周芷若");
map.put(3, "汪峰");
map.put(4, "灭绝师太"); *要求：
1.遍历集合，并将序号与对应人名打印。
2.向该map集合中插入一个编码为5姓名为李晓红的信息
3.移除该map中的编号为1的信息
4.将map集合中编号为2的姓名信息修改为"周林" *
* */
public class Topic6 {
public static void main(String[] args) {
Map<Integer,String> map = new HashMap<Integer, String>();
map.put(1, "张三丰");
map.put(2, "周芷若");
map.put(3, "汪峰");
map.put(4, "灭绝师太");
//1.遍历集合，并将序号与对应人名打印。
for(Map.Entry<Integer,String> entry:map.entrySet()){
System.out.println(entry.getKey()+ " "+ entry.getValue());
}
System.out.println("================");
//3.移除该map中的编号为1的信息
map.remove(1);
for(Map.Entry<Integer,String> entry:map.entrySet()){
System.out.println(entry.getKey()+ " "+ entry.getValue());
}
System.out.println("================");
//4.将map集合中编号为2的姓名信息修改为"周林"
map.put(2,"周林");
for(Map.Entry<Integer,String> entry:map.entrySet()){
System.out.println(entry.getKey()+ " "+ entry.getValue());
}
}
}
练习七：Map集合的使用（二）
一、有2个数组，第一个数组内容为：[黑龙江省,浙江省,江西省,广东省,福建省]，第二个数组为：[哈尔滨,杭州,南昌,广州,福州]，将第一个数组元素作为key，第二个数组元素作为value存储到Map集合中。如{黑龙江省=哈尔滨, 浙江省=杭州, …}。
import java.util.HashMap;
import java.util.Map; /*
* 二、有2个数组，第一个数组内容为：[黑龙江省,浙江省,江西省,广东省,福建省]，第二个数组为：[哈尔滨,杭州,南昌,广州,福州]，将第一个数组元素作为key，
* 第二个数组元素作为value存储到Map集合中。如{黑龙江省=哈尔滨, 浙江省=杭州, …}。
* */
public class Topic7 {
public static void main(String[] args) {
String str1[] = {"黑龙江省","浙江省","江西省","广东省","福建省"};
String str2[] = {"哈尔滨","杭州","南昌","广州","福州"};
HashMap<String,String> map = new HashMap<>();
for (int i = 0; i < str1.length; i++) {
for (int j = 0; j < str2.length; j++) {
map.put(str1[i],str2[j]);
}
}
System.out.print("{");
for (Map.Entry<String,String> entry: map.entrySet()){
System.out.printf("%s=%s,",entry.getKey(),entry.getValue());
}
System.out.println("}");
}
}
练习八：Map集合的使用（三）
一、定义一个泛型为String类型的List集合，统计该集合中每个字符（注意，不是字符串）出现的次数。例如：集合中有”abc”、”bcd”两个元素，程序最终输出结果为：“a = 1,b = 2,c = 2,d = 1”。
import java.util.*; /*
* 三、定义一个泛型为String类型的List集合，统计该集合中每个字符（注意，不是字符串）出现的次数。
* 例如：集合中有”abc”、”bcd”两个元素，
* 程序最终输出结果为：“a = 1,b = 2,c = 2,d = 1”。
* */
public class Topic8 {
public static void main(String[] args) {
//定义一个String类型的List集合,用来存储题目给定的字符串
LinkedList<String> list = new LinkedList<>();
list.add("abc");
list.add("bcd");
//将集合中的两个元素进行拼接,调用method1(String str) 进行统计,筛选.
String str = list.get(0)+list.get(1);
method1(str);
}
private static void method1(String str) { //1. 创建Map集合,key是字符串中的字符,value是字符的个数
//由于HashMap具有筛选功能,可以帮助我们对字符进行统计.
HashMap<Character,Integer> map = new HashMap<>();
//2.将形式参数传递过来的字符串使用toCharArray()的方法转换成Char类型的字符数组.c用来遍历获取字符数组中的每一个值.
for(char c :str.toCharArray()){
//对于字符串"abcbcd"为例,char c =a; map.containKey(a)为false,执行:号后的1
//map.put(a,1); 这样就将a字符与对应的数量添加到了map集合中.
map.put(c,map.containsKey(c)?map.get(c)+1:1);
}
//获取最后一个key
Set<Character> chrs = map.keySet();
List list = new ArrayList(chrs);
char lastKey = (char)(list.get(list.size()-1));
//char lastKey = (char)list.lastIndexOf("d");
// System.out.println(lastKey);
for(Map.Entry<Character,Integer> entry : map.entrySet()){
char key = entry.getKey();
int value = entry.getValue();
//如果是最后一个key直接打印key与value结束.
if (key == lastKey)
{
System.out.println(key+"="+value);
break;
}
//如果不是最后一个,打印 key与value和一个逗号分隔
System.out.print(key+"="+value+","); } }
}
练习九：Map集合的使用（四）
一、利用Map，完成下面的功能：
从命令行读入一个字符串，表示一个年份，输出该年的世界杯冠军是哪支球队。如果该 年没有举办世界杯，则输出：没有举办世界杯。
//tips:参阅Map接口containsKey(Object key)方法
二、在原有世界杯Map 的基础上，增加如下功能： 读入一支球队的名字，输出该球队夺冠的年份列表。 例如，读入“巴西”，应当输出 1958 1962 1970 1994 2002 读入“荷兰”，应当输出 没有获得过世界杯
//tips:参阅Map接口containsValue(Object value)方法
示例：
附：历届世界杯冠军
|
届数 |
举办年份 |
举办地点 |
冠军 |
|
1930年 |
乌拉圭 |
乌拉圭 |
|
|
第二届 |
1934年 |
意大利 |
意大利 |
|
第三届 |
1938年 |
法国 |
意大利 |
|
第四届 |
1950年 |
巴西 |
乌拉圭 |
|
第五届 |
1954年 |
瑞士 |
西德 |
|
第六届 |
1958年 |
瑞典 |
巴西 |
|
第七届 |
1962年 |
智利 |
巴西 |
|
第八届 |
1966年 |
英格兰 |
英格兰 |
|
第九届 |
1970年 |
墨西哥 |
巴西 |
|
第十届 |
1974年 |
前西德 |
西德 |
|
第十一届 |
1978年 |
阿根廷 |
阿根廷 |
|
第十二届 |
1982年 |
西班牙 |
意大利 |
|
第十三届 |
1986年 |
墨西哥 |
阿根廷 |
|
第十四届 |
1990年 |
意大利 |
西德 |
|
第十五届 |
1994年 |
美国 |
巴西 |
|
第十六届 |
1998年 |
法国 |
法国 |
|
第十七届 |
2002年 |
韩日 |
巴西 |
|
第十八届 |
2006年 |
德国 |
意大利 |
|
第十九届 |
2010年 |
南非 |
西班牙 |
|
第二十届 |
2014年 |
巴西 |
德国 |
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner; public class Topic9 {
public static void main(String[] args) {
HashMap<Integer,String> map = new HashMap<>();
map.put(1930,"乌拉圭");
map.put(1934,"意大利");
map.put(1938,"意大利");
map.put(1950,"乌拉圭");
map.put(1954,"西德");
map.put(1958,"巴西");
map.put(1962,"巴西");
map.put(1966,"英格兰");
map.put(1970,"巴西");
map.put(1974,"西德");
map.put(1978,"阿根廷");
map.put(1982,"意大利");
map.put(1986,"阿根廷");
map.put(1990,"西德");
map.put(1994,"巴西");
map.put(1998,"法国");
map.put(2002,"巴西");
map.put(2006,"意大利");
map.put(2010,"西班牙");
map.put(2014,"德国");
System.out.println("请输入年份:");
Scanner sc = new Scanner(System.in);
int inputNum = sc.nextInt();
for (Map.Entry<Integer,String> entry: map.entrySet()){
int key = entry.getKey();
String value = entry.getValue();
if (inputNum==key)
System.out.println(key+"年获得世界杯冠军的是:"+value);
}
String temp = sc.nextLine();
System.out.println("请输入国家名称");
String inputStr = sc.nextLine();
int flag = 0;//标记没有夺冠
for (Map.Entry<Integer,String> entry: map.entrySet()){
if(entry.getValue().equals(inputStr)){
System.out.println(entry.getKey()+".");
flag=1;
}
}
if(flag==0){
System.out.println("没有获得过世界杯");
} }
}
练习十：综合练习
1.站编号和站名对应关系如下：
1=朱辛庄
2=育知路
3=平西府
4=回龙观东大街
5=霍营
//....
将以上对应关系的数据存储到map集合中，key：表示站编号，value：表示站名，并遍历打印(可以不按顺序打印)：
第10站: 森林公园南门
第6站: 育新
第12站: 奥体中心
第13站: 北土城
//...
2.计算地铁票价规则：
总行程 3站内（包含3站）收费3元，
3站以上但不超过5站（包含5站）的收费4元，
5站以上的，在4元的基础上，每多1站增加2元，
10元封顶；
3.打印格式（需要对键盘录入的上车站和到达站进行判断，如果没有该站，提示重新输入，直到站名存在为止）：
注意：每站需要2分钟
请输入上车站：
沙河
您输入的上车站：沙河不存在，请重新输入上车站：
上地
您输入的上车站：上地不存在，请重新输入上车站：
朱辛庄
请输入到达站：
沙河
您输入的到达站：沙河不存在，请重新输入到达站：
西二旗
您输入的到达站：西二旗不存在，请重新输入到达站：
西小口
从朱辛庄到西小口共经过6站收费6元，大约需要 12分钟
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Scanner; public class Topic10 {
public static void main(String[] args) {
/*创建一个LinkedHashMap用来存储地铁站编号 以及 地铁站名称*/
LinkedHashMap<Integer, String> map = new LinkedHashMap<>();
map.put(1, "朱辛庄");
map.put(2, "育知路");
map.put(3, "平西府");
map.put(4, "回龙观东大街");
map.put(5, "霍营");
map.put(6, "育新");
map.put(7, "西小口");
map.put(8, "永泰庄");
map.put(9, "林萃桥");
map.put(10, "森林公园南门");
map.put(11, "奥林匹克公园");
map.put(12, "奥体中心");
map.put(13, "北土城"); //声明上车时的地铁站 和 下车时的地铁站
String upStation;
String downStation; Scanner sc = new Scanner(System.in);
//声明上车时的key,下车时的key
int beforeKey = 0, afterKey = 0;
//无限循环判断用户输入
// 1.如果输入不合法继续请求用户输入
// 2.如果输入合法就记录 上车的地铁站名称 以及 上错车的地铁站编号
// break跳出无限循环.
for (; ; ) {
System.out.println("请输入上车的车站:");
upStation = sc.nextLine();
if (map.containsValue(upStation)) {
System.out.println("请上车!");
for (Map.Entry<Integer, String> entry : map.entrySet()) {
if (entry.getValue().equals(upStation)) {
//记录本次车站的key值
beforeKey = entry.getKey(); }
}
// System.out.println(beforeKey);
break;
}
else {
System.out.println(upStation + "不存在,请重新输入上车站:");
} }
//==============================================
//当上车的地铁站输入正确,并正确记录后
//请求用户输入
for (; ; ) {
System.out.println("请输入下车的车站:");
downStation = sc.nextLine();
if (map.containsValue(downStation)) {
System.out.println("请上车!");
for (Map.Entry<Integer, String> entry : map.entrySet()) {
if (entry.getValue().equals(downStation)) {
//记录本次车站的key值
afterKey = entry.getKey(); }
}
// System.out.println(beforeKey);
break;
}
else {
System.out.println(downStation + "不存在,请重新输入下车站:");
} }
/*
* 总行程 3站内（包含3站）收费3元，
3站以上但不超过5站（包含5站）的收费4元，
5站以上的，在4元的基础上，每多1站增加2元，
10元封顶； * */
int value = afterKey - beforeKey;
int prize=0;
int time=0;
if (value<=3)
{
prize=3; }
else if(value>3 &&value<=5)
{
prize=4; }
else if (value>5 && value<=9)
{
prize=(value-5)*2+4;
//如果prize计算的价格超过了10R,则将10赋值给prize
if (prize>=10)
prize=10;
}
else
prize=10;
System.out.printf("从%s到%s经过%d站收费%d元,大约需要%d分钟\n",upStation,downStation,value,prize,value*2); }
}