2021-08-05 Java练习题

1、一、产生10个1-100的随机数，并放到一个数组中，把数组中大于等于10的数字放到一个list集合中，并打印到控制台。

package learn.java;

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

/**
 * @author Peter Cheung
 * @user PerCheung
 * @date 2021/8/5 17:50
 * <p>
 * 产生10个1-100的随机数，并放到一个数组中，
 * 把数组中大于等于10的数字放到一个list集合中，并打印到控制台。
 */
public class RandomList {
    public static void main(String[] args) {
        Random r = new Random();
        int max = 100;
        int min = 1;
        int[] a = new int[10];
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            a[i] = r.nextInt(max) % (max - min + 1) + min;
            if (a[i] >= 10) {
                list.add(a[i]);
            }
        }
        list.forEach((i) -> System.out.print(i + " "));
    }
}

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

已知数组存放一批QQ号码，QQ号码最长为11位，最短为5位String[] strs = {“12345”,“67891”,“12347809933”,“98765432102”,“67891”,“12347809933”}。将该数组里面的所有qq号都存放在LinkedList中，将list中重复元素删除，将list中所有元素分别用迭代器和增强for循环打印出来。

package learn.java;

import java.util.*;

/**
 * @author Peter Cheung
 * @user PerCheung
 * @date 2021/8/5 17:59
 * <p>
 * 2、LinkedList使用
 * 已知数组存放一批QQ号码，QQ号码最长为11位，最短为5位
 * String[] strs =
 * {"12345","67891","12347809933","98765432102","67891","12347809933"}。
 * <p>
 * 将该数组里面的所有qq号都存放在LinkedList中，
 * 将list中重复元素删除，将list中所有元素分别用迭代器和增强for循环打印出来。
 */
public class LinkListQQ {
    public static void main(String[] args) {
        String[] strs = {"12345", "67891", "12347809933", "98765432102", "67891", "12347809933"};
        LinkedList<String> list = new LinkedList<>(Arrays.asList(strs));
        Set<String> set = new HashSet<>(list);
        list.clear();
        list.addAll(set);
        //迭代器
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            System.out.print(it.next()+" ");
        }
        System.out.println();
        //增强for循环
        for (String s : list) {
            System.out.print(s + " ");
        }
    }
}

3、双色球规则：双色球每注投注号码由6个红色球号码和1个蓝色球号码组成。红色球号码从1—33中选择；蓝色球号码从1—16中选择；请随机生成一注双色球号码。（要求同色号码不重复）

package learn.java;

import java.util.HashSet;
import java.util.Random;
import java.util.Set;

/**
 * @author Peter Cheung
 * @user PerCheung
 * @date 2021/8/5 18:18
 *
 * 3、双色球规则：
 * 双色球每注投注号码由6个红色球号码和1个蓝色球号码组成。
 * 红色球号码从1—33中选择；蓝色球号码从1—16中选择；
 * 请随机生成一注双色球号码。（要求同色号码不重复）
 */
public class TCball {
    public static void main(String[] args) {
        Random r = new Random();
        int redMax = 33;
        int blueMax =16;
        int min = 1;
        int blue = r.nextInt(blueMax) % (blueMax - min + 1) + min;
        Set<Integer> set = new HashSet<>();
        while(true) {
            if (set.size()<=6){
                set.add(r.nextInt(redMax) % (redMax - min + 1) + min);
            }else{
                break;
            }
        }
        set.forEach((i)-> System.out.print(i+" "));
        System.out.print(blue);
    }
}

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的姓名信息修改为"周林"

package learn.java;

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

/**
 * @author Peter Cheung
 * @user PerCheung
 * @date 2021/8/5 18:29
 * <p>
 * 4、现在有一个map集合如下：
 * <p>
 * Map<Integer,String> map = new HashMap<Integer, String>();
 * map.put(1, "张三丰");
 * map.put(2, "周芷若");
 * map.put(3, "汪峰");
 * map.put(4, "灭绝师太");
 * <p>
 * 要求：
 * <p>
 * 1）.遍历集合，并将序号与对应人名打印。
 * <p>
 * 2）.向该map集合中插入一个编码为5姓名为李晓红的信息
 * <p>
 * 3）.移除该map中的编号为1的信息
 * <p>
 * 4）.将map集合中编号为2的姓名信息修改为"周林"
 */
public class MapPractice {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "张三丰");
        map.put(2, "周芷若");
        map.put(3, "汪峰");
        map.put(4, "灭绝师太");

        Set<Map.Entry<Integer, String>> entries = map.entrySet();
        for (Map.Entry<Integer, String> entry : entries) {
            System.out.println(entry.getKey() + "." + entry.getValue());
        }
        map.put(5, "李晓红");
        map.remove(1);
        map.put(2, "周林");
    }
}

5、有2个数组，第一个数组内容为：[黑龙江省,浙江省,江西省,广东省,福建省]，第二个数组为：[哈尔滨,杭州,南昌,广州,福州]，将第一个数组元素作为key，第二个数组元素作为value存储到Map集合中。如{黑龙江省=哈尔滨, 浙江省=杭州, …}。

package learn.java;

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

/**
 * @author Peter Cheung
 * @user PerCheung
 * @date 2021/8/5 20:10
 * <p>
 * 有2个数组，第一个数组内容为：[黑龙江省,浙江省,江西省,广东省,福建省]，
 * 第二个数组为：[哈尔滨,杭州,南昌,广州,福州]，
 * 将第一个数组元素作为key，第二个数组元素作为value存储到Map集合中。
 * 如{黑龙江省=哈尔滨, 浙江省=杭州, …}。
 */
public class province {
    public static void main(String[] args) {
        String[] p = {"黑龙江省", "浙江省", "江西省", "广东省", "福建省"};
        String[] c = {"哈尔滨", "杭州", "南昌", "广州", "福州"};
        Map<String, String> map = new HashMap<>();
        for (int i = p.length - 1; i >=0; i--) {
            map.put(p[i], c[i]);
        }
        Set<String> mapSet = map.keySet();
        for (String k : mapSet) {
            System.out.println(k + "=" + map.get(k));
        }

    }
}

6、定义一个泛型为String类型的List集合，统计该集合中每个字符（注意，不是字符串）出现的次数。例如：集合中有”abc”、”bcd”两个元素，程序最终输出结果为：“a = 1,b = 2,c = 2,d = 1”。

package learn.java;
import java.util.ArrayList;
import java.util.*;

/**
 * @author Peter Cheung
 * @user PerCheung
 * @date 2021/8/5 20:31
 * <p>
 * 6、定义一个泛型为String类型的List集合，
 * 统计该集合中每个字符（注意，不是字符串）出现的次数。
 * 例如：集合中有”abc”、”bcd”两个元素，程序最终输出结果为：“a = 1,b = 2,c = 2,d = 1”。
 */
public class statistics {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("abc");
        list.add("bcd");
        list.add("bcdgy");
        list.add("bvgcd");
        list.add("bcadd");
        Map<Character, Integer> map = new HashMap<>();
        for (String s : list) {
            //取出每个字符串
            //把字符串变成字符
            char[] c = s.toCharArray();
            //把字符和相对应的次数导入Map集合
            for (char ci : c) {
                //如果该char字符已经导入过，次数加1
                if (map.containsKey(ci)) {
                    map.put(ci, map.get(ci) + 1);
                } else {
                    //如果没导入过初始化次数为1
                    map.put(ci, 1);
                }
            }
        }
        Set<Map.Entry<Character, Integer>> mapSet = map.entrySet();
        for (Map.Entry<Character, Integer> entry : mapSet) {
            System.out.print(entry.getKey()+"="+entry.getValue()+" ");
        }

    }
}

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

（1）从命令行读入一个字符串，表示一个年份，输出该年的世界杯冠军是哪支球队。如果该 年没有举办世界杯，则输出：没有举办世界杯。

（2）在原有世界杯Map 的基础上，增加如下功能： 读入一支球队的名字，输出该球队夺冠的年份列表。 例如，读入“巴西”，应当输出 1958 1962 1970 1994 2002 读入“荷兰”，应当输出 没有获得过世界杯

附：历届世界杯冠军

届数 举办年份 举办地点 冠军

第一届 1930年 乌拉圭 乌拉圭

第二届 1934年 意大利 意大利
…

package learn.java;

/**
 * @author Peter Cheung
 * @user PerCheung
 * @date 2021/8/5 21:26
 * <p>
 * 利用Map，完成下面的功能：
 * <p>
 * （1）从命令行读入一个字符串，
 * 表示一个年份，输出该年的世界杯冠军是哪支球队。
 * 如果该 年没有举办世界杯，则输出：没有举办世界杯。
 * <p>
 * （2）在原有世界杯Map 的基础上，增加如下功能：
 * 读入一支球队的名字，输出该球队夺冠的年份列表。
 * 例如，读入“巴西”，
 * 应当输出 1958 1962 1970 1994 2002
 * 读入“荷兰”，
 * 应当输出 没有获得过世界杯
 * <p>
 * 届数
 * <p>
 * 举办年份
 * <p>
 * 举办地点
 * <p>
 * 冠军
 */
public class WorldCup {
    private int sessions;
    private int year;
    private String place;
    private String champion;

    public WorldCup() {
    }

    ;

    public WorldCup(int sessions, int year, String place, String champion) {
        this.sessions = sessions;
        this.year = year;
        this.place = place;
        this.champion = champion;
    }

    @Override
    public String toString() {
        return "WorldCup{" +
                "sessions=" + sessions +
                ", year=" + year +
                ", place='" + place + '\'' +
                ", champion='" + champion + '\'' +
                '}';
    }

    public int getSessions() {
        return sessions;
    }

    public void setSessions(int sessions) {
        this.sessions = sessions;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public String getPlace() {
        return place;
    }

    public void setPlace(String place) {
        this.place = place;
    }

    public String getChampion() {
        return champion;
    }

    public void setChampion(String champion) {
        this.champion = champion;
    }
}

package learn.java;

import java.util.*;

/**
 * @author Peter Cheung
 * @user PerCheung
 * @date 2021/8/5 21:35
 * <p>
 * 利用Map，完成下面的功能：
 * <p>
 * （1）从命令行读入一个字符串，
 * 表示一个年份，输出该年的世界杯冠军是哪支球队。
 * 如果该 年没有举办世界杯，则输出：没有举办世界杯。
 * <p>
 * （2）在原有世界杯Map 的基础上，增加如下功能：
 * 读入一支球队的名字，输出该球队夺冠的年份列表。
 * 例如，读入“巴西”，应当输出 1958 1962 1970 1994 2002
 * 读入“荷兰”，应当输出 没有获得过世界杯
 */
public class worldCupJ {
    private static final Map<Integer, WorldCup> maps = new HashMap<>(16, 0.75F);

    //通过年份获取冠军
    public static WorldCup getWorldCupYear(Integer year) {
        if (year <= 0) {
            return null;
        }
        // 先判断是否有这个key
        if (maps.containsKey(year)) {
            return maps.get(year);
        }
        return null;
    }

    //通过国家的名字去获取冠军的年份
    public static List<Integer> getYearsByCountry(String countryName) {
        if (countryName == null || countryName.isEmpty()) {
            return null;
        }
        // 准备一个装年份的容器
        List<Integer> years = new ArrayList<>();
        // 把maps的值全部拿到
        Collection<WorldCup> values = maps.values();
        // 遍历values
        for (WorldCup value : values) {
            if (value.getChampion().equals(countryName)) {
                // 有冠军
                years.add(value.getYear());
            }
        }
        return years;
    }

    public static void whenChampion() {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入年份：");
        int year = scanner.nextInt();
        WorldCup champion = getWorldCupYear(year);
        if (champion == null) {
            System.out.println(year + "这年没有冠军！");
        } else {
            System.out.println(year + "这年的冠军是：" + champion.getChampion());
        }
    }

    public static void whoChampion() {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入国家的而名字：");
        String countryName = scanner.nextLine();
        List<Integer> years = getYearsByCountry(countryName);
        if (years == null || years.size() == 0) {
            System.out.println("这个国家没有得过冠军");
        } else {
            System.out.println(years);
        }
    }

    public static void whatOperation() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("1.输入年份知道谁赢得了世界杯。");
        System.out.println("2.输入国家名了解他赢得了几次世界杯。");
        System.out.print("你想选择什么（输入1或者2进行选择）：");
        int o = scanner.nextInt();
        switch (o) {
            case 1:
                whenChampion();
                break;
            case 2:
                whoChampion();
                break;
            default:
                System.out.println("输错了，请重输。");
                whatOperation();
        }
        whatOperation();
    }

    public static void main(String[] args) {
        maps.put(2014, new WorldCup(20, 2014, "巴西", "德国"));
        maps.put(2010, new WorldCup(19, 2010, "南非", "西班牙"));
        maps.put(2006, new WorldCup(18, 2006, "德国", "意大利"));
        maps.put(2002, new WorldCup(17, 2002, "韩日", "巴西"));
        maps.put(1998, new WorldCup(16, 1998, "法国", "法国"));
        maps.put(1994, new WorldCup(15, 1994, "美国", "巴西"));
        maps.put(1990, new WorldCup(14, 1990, "意大利", "西德"));
        maps.put(1986, new WorldCup(13, 1986, "墨西哥", "阿根廷"));
        maps.put(1982, new WorldCup(12, 1982, "西班牙", "意大利"));
        maps.put(1978, new WorldCup(11, 1978, "阿根廷", "阿根廷"));
        maps.put(1974, new WorldCup(10, 1974, "前西德", "西德"));
        maps.put(1970, new WorldCup(9, 1970, "墨西哥", "巴西"));
        maps.put(1966, new WorldCup(8, 1966, "英格兰", "英格兰"));
        maps.put(1962, new WorldCup(7, 1962, "智利", "巴西"));
        maps.put(1958, new WorldCup(6, 1958, "瑞典", "巴西"));
        maps.put(1954, new WorldCup(5, 1954, "瑞士", "西德"));
        maps.put(1950, new WorldCup(4, 1950, "巴西", "乌拉圭"));
        maps.put(1938, new WorldCup(3, 1938, "法国", "意大利"));
        maps.put(1934, new WorldCup(2, 1934, "意大利", "意大利"));
        maps.put(1930, new WorldCup(1, 1930, "乌拉圭", "乌拉圭"));

        whatOperation();
    }
}

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分钟

package learn.java;

import java.util.*;

/**
 * @author Peter Cheung
 * @user PerCheung
 * @date 2021/8/5 23:15
 * <p>
 * 1.将以上对应关系的数据存储到map集合中，key：表示站编号，value：表示站名，并遍历打印(可以不按顺序打印)：
 * <p>
 * 2）.计算地铁票价规则：
 * 总行程 3站内（包含3站）收费3元，
 * 3站以上但不超过5站（包含5站）的收费4元，
 * 5站以上的，在4元的基础上，每多1站增加2元，
 * 10元封顶；
 * <p>
 * 3）.打印格式（需要对键盘录入的上车站和到达站进行判断，如果没有该站，提示重新输入，直到站名存在为止）：
 */
public class busStop {
    private static final Map<Integer, String> map = new HashMap<>();

    public busStop() {
        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, "冥王星");
    }

    public static void main(String[] args) {
        //第一题
        busStop busStop = new busStop();
        System.out.println("🚌 公交车站牌 🚌");
        Set<Map.Entry<Integer, String>> entry = map.entrySet();
        for (Map.Entry<Integer, String> map : entry) {
            System.out.println(map.getKey() + "=" + map.getValue());
        }

        //第三题
        int upNum = 0;
        int downNum = 0;
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入上车的车站：");
        String upStation = sc.nextLine();
        boolean flagUp = true;
        while (flagUp) {
            Iterator it = entry.iterator();
            while (it.hasNext()) {
                Map.Entry<Integer, String> mapEntry = (Map.Entry<Integer, String>) it.next();
                if (mapEntry.getValue().equals(upStation)) {
                    upNum = mapEntry.getKey();
                    flagUp = false;
                }
            }
            if (flagUp) {
                System.out.println("请重新输入：");
                upStation = sc.nextLine();
            }
        }
        System.out.print("请输入下车的车站：");
        String downStation = sc.nextLine();
        boolean flagDown = true;
        while (flagDown) {
            Iterator it = entry.iterator();
            while (it.hasNext()) {
                Map.Entry<Integer, String> mapEntry = (Map.Entry<Integer, String>) it.next();
                if (mapEntry.getValue().equals(downStation)) {
                    downNum = mapEntry.getKey();
                    flagDown = false;
                }
            }
            if (flagDown) {
                System.out.println("请重新输入：");
                downStation = sc.nextLine();
            }
        }

        //第二题
        if (Math.abs(downNum - upNum) <= 3) {
            System.out.println("从" + upStation + "到" + downStation + "要经历" + Math.abs(downNum - upNum) + "站，累计" + "收费" + 3 + "元，大概需要用时" + 2 * Math.abs(downNum - upNum) + "分钟。");
        } else if (Math.abs(downNum - upNum) > 3 && Math.abs(downNum - upNum) <= 5) {
            System.out.println("从" + upStation + "到" + downStation + "要经历" + Math.abs(downNum - upNum) + "站，累计" + "收费" + 4 + "元，大概需要用时" + 2 * Math.abs(downNum - upNum) + "分钟。");
        } else if (Math.abs(downNum - upNum) > 5) {
            int prize = (Math.abs(downNum - upNum) - 5) * 2 + 4;
            if (prize >= 10) {
                prize = 10;
            }
            System.out.println("从" + upStation + "到" + downStation + "要经历" + Math.abs(downNum - upNum) + "站，累计" + "收费" + prize + "元，大概需要用时" + 2 * Math.abs(downNum - upNum) + "分钟。");
        }
    }
}