Java基础练习（十一）LidkedList使用，Set集合使用，Map集合使用

1、一、产生10个1-100的随机数，并放到一个数组中，

把数组中大于等于10的数字放到一个list集合中，并打印到控制台。

import java.util.ArrayList;
import java.util.List;

public class Test01 {
    public static void main(String[] args) {
        int[] a=new int[10];
        int c=0;
        while(true){
            int b=(int)Math.round(Math.random()*100);
            a[c]=b;
            c++;
            if(c>9){
                break;
            }
        }
        List<Integer> list=new ArrayList<>();
        for (int i:a){
            if(i>10){
                list.add(i);
            }
        }
        list.forEach((o)->{
            System.out.println(o);
        });
    }
}

2、LinkedList使用

已知数组存放一批QQ号码，QQ号码最长为11位，最短为5位String[] strs = {“12345”,“67891”,“12347809933”,“98765432102”,“67891”,“12347809933”}。

将该数组里面的所有qq号都存放在LinkedList中，将list中重复元素删除，

将list中所有元素分别用迭代器和增强for循环打印出来。

import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;

public class Test02 {
    public static void main(String[] args) {
        String[] strs = {"12345","67891","12347809933",
                         "98765432102","67891","12347809933"};
        
        LinkedList<String> strings = new LinkedList<>();

        for (String  s:strs) {
            strings.add(s);
        }
        //Set集合自动去重
        HashSet<String> strings1 = new HashSet<>();
        for (String s:strings){
            strings1.add(s);
        }

        Iterator<String> iterator = strings1.iterator();
       while ( iterator.hasNext()){
           String s=iterator.next();
           System.out.print(s+",");
       }
        
        System.out.println();

       for (String s:strings1){
           System.out.print(s+",");
       }
    }
}

3、双色球规则：双色球每注投注号码由6个红色球号码和1个蓝色球号码组成。

红色球号码从1—33中选择；蓝色球号码从1—16中选择；

请随机生成一注双色球号码。（要求同色号码不重复）

package PracticeDisizhou.lx0805.lx03;

import java.util.HashSet;

public class Test {
    public static void main(String[] args) {
        //一个蓝色球号码
        int b=0;
       while (true){
          b=(int)Math.round(Math.random()*100);
          if (b>0&&b<17){
              break;
          }
       }

       int rednum=0;//记录红球个数
        int red=0;//红球号码
        
        //使用Set存放红球号码，防止重复
        HashSet<Integer> integers = new HashSet<>();
        while (true){
            red=(int)Math.round(Math.random()*100);
            if(red<34&&red>0){
                integers.add(red);
            }
            if(integers.size()>=6){
                break;
            }
        }

        //输出一注双色球号码
        for(int i:integers){
            System.out.print(i+",");
        }
        System.out.println(b);
    }
}

4、现在有一个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;

public class Test {
    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, "灭绝师太");

        //第一种map集合遍历
        Set<Integer> integers = map.keySet();
        for (Integer integer:integers){
            String s=map.get(integer);
            System.out.println(integer+","+s);
        }

        System.out.println("---------------------");

        map.put(5,"李晓红");
        //第二种map集合遍历
        Set<Map.Entry<Integer, String>> entries = map.entrySet();
        for (Map.Entry entry:entries){
            System.out.println(entry.getKey()+","+entry.getValue());
        }

        System.out.println("--------------");

        map.remove(2,"周芷若");

        Set<Integer> integers1 = map.keySet();
        for (Integer integer:integers){
            String s=map.get(integer);
            System.out.println(integer+","+s);
        }
        System.out.println("---------------------");
        map.put(2,"周林");
        Set<Map.Entry<Integer, String>> entries1 = map.entrySet();
        for (Map.Entry entry:entries1){
            System.out.println(entry.getKey()+","+entry.getValue());
        }
    }
}

5、有2个数组，第一个数组内容为：[黑龙江省,浙江省,江西省,广东省,福建省]，

第二个数组为：[哈尔滨,杭州,南昌,广州,福州]，

将第一个数组元素作为key，第二个数组元素作为value存储到Map集合中。

如{黑龙江省=哈尔滨, 浙江省=杭州, …}。

package PracticeDisizhou.lx0805.lx05;

import java.util.HashMap;
import java.util.Set;

public class Test05 {
    public static void main(String[] args) {
        String[] s1={ "黑龙江省","浙江省","江西省","广东省","福建省" };
        String[] s2={"哈尔滨","杭州","南昌","广州","福州"};

        HashMap<String, String> stringStringHashMap = new HashMap<>();

        for (int i = 0; i <s1.length ; i++) {
            stringStringHashMap.put(s1[i],s2[i]);
        }

        Set<String> strings = stringStringHashMap.keySet();
        for (String s:strings){
             String s3=stringStringHashMap.get(s);
            System.out.println(s+"="+s3);
        }
    }
}

6、定义一个泛型为String类型的List集合，

统计该集合中每个字符（注意，不是字符串）出现的次数。

例如：集合中有”abc”、”bcd”两个元素，

程序最终输出结果为：“a = 1,b = 2,c = 2,d = 1”。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

public class Test06 {
    public static void main(String[] args) {
        ArrayList<Character> arrayList = new ArrayList<Character>();
        String s="adadadwqdassfdsgsasdafdafsadfxcz";

        //将字符串转为字符数组后遍历其元素存储到list集合中
        char[] c=s.toCharArray();
        for (char c1:c){
            arrayList.add(c1);
        }

        //统计字符出现的次数
        //创建一个Map集合，字符作为键，字符出现的次数为值，当遇到相同的键时，值加加
        HashMap<Character, Integer> map = new HashMap<>();
        for (char c1:arrayList){
            //定义i记录字符数
            int i;
            //判断集合中是否含有该键
            if(map.containsKey(c1)){
                i=map.get(c1);
                i++;
                map.put(c1,i);
            }else {
                //第一次出现的设置键值为1
                map.put(c1,1);
            }
        }
        Set<Character> characters = map.keySet();

        for (char c1:characters){
            int i=map.get(c1);
            System.out.println(c1+"有"+i+"个");
        }
    }
}

7、利用Map，完成下面的功能：

（1）从命令行读入一个字符串，表示一个年份，

输出该年的世界杯冠军是哪支球队。

如果该 年没有举办世界杯，则输出：没有举办世界杯。

（2）在原有世界杯Map 的基础上，增加如下功能：

读入一支球队的名字，输出该球队夺冠的年份列表。

例如，读入“巴西”，应当输出 1958 1962 1970 1994 2002

读入“荷兰”，应当输出 没有获得过世界杯

附：历届世界杯冠军

届数

举办年份

举办地点

冠军

第一届

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.Scanner;
import java.util.Set;

public class Test {
   public static HashMap<String, String> map = new HashMap<>();

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入年份");
        String next = scanner.next();
        String s=next+"年";
        functionOne(s);
        System.out.println("------------");
        System.out.println("请输入国家");
        String next1 = scanner.next();
        functionTwo(next1);

    }
    public static void  functionOne(String s){
        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年","德国");

        if(map.containsKey(s)){
            System.out.println(map.get(s));
        }else {
            System.out.println(s+"年没有举办世界杯");
        }

    }
    public static   void  functionTwo(String s){

        if (map.containsValue(s)){
            Set<String> strings = map.keySet();
            for (String s2:strings){
                String s3=map.get(s2);
                if (s3.equals(s)){
                    System.out.print(s2+",");
                }
            }
        }else {
            System.out.println(s+"没有获得过世界杯");
        }
    }
}

8、综合练习

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.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

public class Text {


    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1,"朱辛庄");
        map.put(2,"育知路");
        map.put(3,"平西府");
        map.put(4,"回龙观东大街");
        map.put(5,"霍营");
        map.put(6,"星星乐园");
        map.put(7,"西小口");
        map.put(10,"森林公园南门");
        map.put(11,"育新");
        map.put(12,"奥体中心");
        map.put(13,"北土城");

        System.out.println("------------------");

        Set<Map.Entry<Integer, String>> entries = map.entrySet();
        for(Map.Entry entry:entries){
            System.out.println(entry.getKey()+"="+entry.getValue());
        }
        System.out.println("-----------------");
        function(map);
    }
//计算票价
    public static  int getMoney(int count){
        int money=0;
        //if单分支与多分支的区别；
        if (count==0){
            money=0;
        }
        else if(count<=3){
            money=3;
        }else if(count<=5){
            money=4;
        }else {
            money=4+(count-5)*2;
        }

        if (money>10){
            money=10;
        }

        return  money;
    }
    //打印
    public  static  void  function(HashMap<Integer,String> map){
        String upt="";//上车站
        String outt="";//下车站

        Scanner scanner = new Scanner(System.in);
        //输入错误重新输入，输入对了跳出循环
        while (true){
            System.out.println("请输入上车站：");
            upt=scanner.next();
            if (map.containsValue(upt)){
                break;
            }else {
                System.out.println("您输入的上车站："+upt+"不存在，请重新输入上车站：");

            }
        }

        while (true){
            System.out.println("请输入下车站");
            outt=scanner.next();
            if (map.containsValue(outt)){
                break;
            }else {
                System.out.println("您输入的下车站："+outt+"不存在，请重新输入下车站：");
            }
        }

        int count=0;//经过几站
        int start=0;//始发站
        int end=0;//终点站
        //找到输入的站名对应的站序号
        Set<Integer> integers = map.keySet();
        for (Integer integer:integers){
            String s=map.get(integer);
            if (s.equals(upt)){
              start=integer;
            }
            if(s.equals(outt)){
                end=integer;
            }
        }

        if(start>end){
            count=start-end;
        }else {
            count=end-start;
        }

        int money = getMoney(count);//票价

        int time=count*2;//时间
        System.out.println("从"+upt+"到"+outt+"共经过"+count+"站收费"+money+"元，大约需要 "+time+"分钟");
    }
}