关于java集合的练习

时间:2022-08-28 15:59:02

关于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); }
}