经典题目整理

1. 输入两个正整数，求其最大公约数与最小公倍数

public class Test01{
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("请输入两个正整数m和n:");
        int m=in.nextInt();
        int n=in.nextInt();
        int r = m%n;
        int a=m;
        int b=n;
        while(r>0){
            a=b;
            b=r;
            r=a%b;
        }
        System.out.println(b+"是最大公约数");
        System.out.println(m*n/b+"是最小公倍数");
}

2. 计算12个小时之内，时针、分针、秒针的重合次数

//这道题中，秒针走60格，分针走1格；分针走60格，时针走1格；时针走一圈也走60格
public class Test02{
    public static void main(String[] args) {
        int second=0;//秒针的开始值
        int minute=0;//分针的开始值
        int hour=0;//时针的开始值
        int count=0;//次数
        while(true){
            second++;//秒针走一次
            if(second==60){//秒针走60次
                minute++;//分针走一次
                second=0;//同时秒针置零
            }
            if(minute==60){//分针走了60次
                hour++;//时针走一次
                minute=0;//分支置零
            }
            if(hour==60){//如果走了12小时
                hour=0;
            }
            if(second==minute&&second==hour){//如果三针重合
                count++;
                if(second==0)
                    break;//如果走了十二小时，结束循环
            }
        }
        System.out.println(count);
    }
}

3. 判断输出结果

class A{
    public String show(D obj){ //D obj = new D();
        return ("A and D"); 

    }
    public String show(A obj){ //A obj = new D();

        return ("A abd A");
    }
}

class B extends A{
    public String show(B obj){

        return ("B and B");
    }
    public String show(A obj){
        
        return ("B and A");
    }

}

class C extends B{ }

class D extends B{ }

问题：以下输出结果是什么？
A a1 = new A();
A a2 = new B();
B b = new B();
C c = new C();
D d = new D();
System.out.println(a1.show(b)); ① A abd A
System.out.println(a1.show(c)); ② A abd A
System.out.println(a1.show(d)); ③ A and D
System.out.println(a2.show(b)); ④ B and A
System.out.println(a2.show(c)); ⑤ B and A
System.out.println(a2.show(d)); ⑥ A and D
System.out.println(b.show(b));  ⑦ B and B
System.out.println(b.show(c));  ⑧ B and B
System.out.println(b.show(d));  ⑨ A and D

第一个输出A abd A是因为a1是A类的一个对象的引用，b是B类的一个对象的引用，根据多态，b向上转型，调用的是show(A obj)，所以输出结果是A abd A。

第二个输出A abd A是因为a1是A类的一个对象的引用，c是C类的一个对象的引用，根据多态，c向上转型，调用的是show(A obj)，所以输出结果是A abd A。

第三个输出A and D是因为a1是A类的引用，d是D类的一个对象的引用，此时show(D obj)的形参也是D类的对象，无需向上转型，直接调用这个方法，所以输出结果是A and D。

第四个输出B and A 是因为a2是一个A类的引用，指向的是一个B类的对象，在A类与B类的关系中，能够调用什么方法看A，同时B类中重写了show(A obj)方法，所以此时可以访问两个方法show(D obj)与show(A obj)，b是一个B类的一个对象的引用，向上转型，调用的是B类中的show(A obj)方法，所以输出的结果是B and A。

第五个输出B and A 是因为c是一个C类的一个对象的引用，向上转型，调用的是B类中的show(A obj)方法，所以输出的结果是B and A。

第六个输出A and D 是因为d是D类的一个对象的引用，此时show(D obj)的形参也是D类的对象，无需向上转型，直接调用这个方法，所以输出结果是A and D。

第七个输出B and B是因为b是B类的一个对象的引用，此时不产生多态，B类中自然可以使用show(A obj)与show(B obj) show(D obj)三个方法，所以调用的是后者，返回的是B and B。

第七个输出B and B是因为c是C类的一个对象的引用，B类中自然可以使用show(A obj)与show(B obj) show(D obj)三个方法，c向上转型最近的是B，所以返回B and B。

第七个输出A and D是因为d是D类的一个对象的引用，B类中自然可以使用show(A obj)与show(B obj) show(D obj)三个方法，d无须转型直接调用show(D obj)，所以返回的是A and D.

4.选择对静态描述错误的选项

A.静态成员方法也称之为类方法 B.被静态修饰的成员存在的堆内存中C.静态在内存中只有一份 D.非静态优先于静态

这题选B、D是因为被静态修饰的成员不是存在于堆内存中而是存在静态方法区，同时静态优先于非静态，在类加载的时候就执行了。

5.一档选秀节目, 设计了一个平台供参与者展示才艺, 不同的参与者有不同的才艺. 使用多态编程模拟

package com.huwenlong.day10;

public class Platform {
    public void show(Participant p){
        p.show();
    }
}


package com.huwenlong.day10;

public interface Participant {
    void show();
}

package com.huwenlong.day10;

public class SingParticipant implements Participant {
    public void show() {
        System.out.println("我是一名歌唱家，我会唱歌");
    }
}

package com.huwenlong.day10;

public class DanceParticipant implements   Participant {
    @Override
    public void show() {
        System.out.println("我是一名舞蹈演员，我会跳舞");
    }
}

package com.huwenlong.day10;

public class Test01 {
    public static void main(String[] args) {
        Platform p = new Platform();
        Participant p1 = new SingParticipant();
        Participant p2 = new DanceParticipant();
        p.show(p1);
        p.show(p2);

    }
}

本题使用了模板模型，定义了一个接口，让实现类中的方法与接口中的抽象方法保持一致，然后利用了对象的多态，向上转型为接口，由此实现不同的功能

6.判断定义为String类型的s2和s3是否相等?

• String s1 = "ab";

• String s2 = "abc";

• String s3 = s1 + "c";

• System.out.println(s3 == s2);

• System.out.println(s3.equals(s2));

第一个打印的结果是false，第二个打印的结果是true。因为Java在将字符串常量与字符串变量进行拼接的时候会生成StringBuffer对象，然后返回的结果是一个对象（new String()），这个对象存储在堆区，对象中的值存储的是字符串常量在常量池中的地址。所以s3存储的是这个对象在堆区的地址，而==运算符比较的是地址值，s2直接存储的是字符串在常量池中的地址。而equals比较的是内容，所以返回的是true

7.需求：统计大串中小串出现的次数

• 大串: Adcddkiqooqkdddleef
• 小串: dd

package com.huwenlong.day12;

public class Test04 {
    public static void main(String[] args) {
        String bigStr = "Adcddkiqooqkdddleef";
        String smallStr = "dd";
        int count = 0;
        int start =0;//用start保存找到的第一个下标
        while(true){
            start = bigStr.indexOf(smallStr,start);
            if(start == -1){//如果没找到返回-1，退出循环
                break;
            }
//否则，继续循环，并将count++，从找到的字符串之后开始循环
            count++;
            start += smallStr.length();
        }
        System.out.println("匹配的次数是："+count);
    }
}

8.需求: 去除一个字符串中相邻重复字符

• 举例: abbddAffeeEddcccwceaa
• 输出结果: abdAfeEdcwcea

package com.huwenlong.day12;

public class Test06 {
    public static void main(String[] args) {
        String str = "abbddAffeeEddcccwceaa";
        String result = "";
        for (int i = 0; i < str.length(); i++) {
            char ch = str.charAt(i);
            String chs = String.valueOf(ch);
            if(!result.endsWith(chs)){
                result = result.concat(chs);
            }
        }
        System.out.println(result);
    }
}

9.

• 需求: 创建一个int型数组,从键盘录入数据,使用next()方法获取数据,存入数组中, 遍历数组
• 注意: 对异常进行处理,循环录入, 直到输入"结束",终止程序,遍历数组

分析：由于不知道到底要存放多少元素，所以对于创建的数组如果存满了就要扩容，同时next只能返回字符串类型，需要将字符串转换为Int，需要捕获异常。

package com.huwenlong.day13;
import java.util.Arrays;
import java.util.Scanner;
public class Test01 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] arr = new int[5];
        int index = 0;
        System.out.println("请输入整数，输入‘结束’代表输入结束：");
        while(true){
            String str = sc.next();
            if ("结束".equals(str))
                break;
            try{
                int num = Integer.parseInt(str);
                if(index==arr.length) {
                    arr = Arrays.copyOf(arr,arr.length<<1);
                }
                arr[index++] = num;
            }catch (Exception e){
                System.out.println("输入有误，请重新输入：");
                }
            }
        for (int i = 0; i < index; i++) {
            System.out.print(arr[i]+" ");
            }
        }

}

10.

• 需求: 有一个字符串, 给字符串中所有字符 '我' 添加上引号
• 示例: 我与父亲不想见已二年余了, 我最不能忘记的是他的背影
• 结果: "我"与父亲不想见已二年余了, "我"最不能忘记的是他的背影

package com.huwenlong.day13;
//使用indexOf找到指定的字符串“我”，然后再构造StringBuilder对象插入引号
public class Test03 {
    public static void main(String[] args) {
        String str = "我与父亲不想见已二年余了, 我最不能忘记的是他的背影";
        String ch = "我";
        StringBuilder sb = new StringBuilder(str);
        int index = 0;
        while((index = sb.indexOf(ch,index))!=-1){
            sb.insert(index,"\"");
            index+=ch.length()+1;//index后移
            sb.insert(index,"\"");
        }
        System.out.println(sb);
    }
}

11.

需求: 创建一个Student类,定义name和age属性, 创建几个对象存入集合中(有重复属性的对象),创建方法去除集合中的重复元素
分析：一种思路是双重循环删除其中的重复元素，另一种思路是创建一个新的ArrayList使用contains方法比较，如果不存在则add，如果存在就不做任何操作，不过这样的话就必须重写Student类中的equals和toString方法，才能比较两个对象的内容是否相同，否则默认比较的是对象的地址。

package com.huwenlong.day13;
import java.util.ArrayList;
public class Test08 {
    public static void main(String[] args) {
        ArrayList<Student> arrayList = new ArrayList<>();
        arrayList.add(new Student("小红",19));
        arrayList.add(new Student("小强",20));
        arrayList.add(new Student("小刚",18));
        arrayList.add(new Student("小张",21));
        arrayList.add(new Student("小红",19));
        ArrayList<Student> newArray = new ArrayList<>();
        for (int i = 0; i < arrayList.size(); i++) {
            Student stu = arrayList.get(i);
            if(!newArray.contains(stu)){
                newArray.add(stu);
            }
        }
        System.out.println(newArray);
    }
}

package com.huwenlong.day14;

import java.util.Objects;

public class Student implements Comparable<Student>{
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("Student{");
        sb.append("name='").append(name).append('\'');
        sb.append(", age=").append(age);
        sb.append('}');
        return sb.toString();
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public int compareTo(Student o) {
        return age - o.age;
    }
}

12.

需求: 现在有16只球队, 科特迪瓦，阿根廷，澳大利亚，塞尔维亚，荷兰，尼日利亚、日本，美国，中国，新西 兰，巴西，比利时，韩国，喀麦隆，洪都拉斯，意大利. 将这16只球队存入到集合中,然后随机分成4组存入到4个集合中.遍历打印集合
分析：有16支球队，可以先用字符串切割将其拆分为字符串数组，然后存入集合中，可以生成三个集合，代表三个分组，从原集合中不断移除字符串，轮流放入三个分组中，最后原集合只剩下四个字符串。不过移除字符串的过程中需要随机选择下标

package com.qianfeng.homwork;

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

public class TestDemo7 {

    public static void main(String[] args) {
        String str = "科特迪瓦，阿根廷，澳大利亚，塞尔维亚，荷兰，尼日利亚，日本，美国，中国，新西兰，巴西，比利时，韩国，喀麦隆，洪都拉斯，意大利";

        ArrayList<String> list = new ArrayList<>();
        //切割字符串,存入到集合中
        String[] strs = str.split("，");
        for (int i = 0; i < strs.length; i++) {
            String s = strs[i];
            list.add(s);
        }
        System.out.println(list.size());

        Random random = new Random();

        ArrayList<String> one = new ArrayList();
        ArrayList<String> two = new ArrayList();
        ArrayList<String> three = new ArrayList();
        //定义变量,用来记录第几次随机抽取
        int num = 0;
        while (list.size()>4){
            //将集合中元素的个数当成限制条件生成随机数, 这样的话, 就不会出现超出集合角标的随机数
            int index = random.nextInt(list.size());
            String s = list.remove(index);//没次将当前元素移除原集合
            if(num%3==0){
                one.add(s);
            }else if(num%3==1){
                two.add(s);
            }else if(num%3==2){
                three.add(s);
            }
            num++;
        }

        System.out.println(one);
        System.out.println(two);
        System.out.println(three);
        System.out.println(list);

    }


}

13.需求: 创建一个Student类, 定义 姓名,年龄,班级,成绩 属性, 然后创建多个对象存入集合中, 求出所有学生的平均年龄和每个班级的平均成绩

• Student类的属性如下所示

    private String name;
    private int age;
    private  int score;
    private String ClassNum;

分析：这道题中所有学生的平均年龄比较好求，由于我们事先不知道有多少学生以及多少班级，所以这道题求每个班级的平均成绩的需要使用集合的嵌套。

package com.qianfeng.homwork;

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

public class TestDemo8 {

    public static void main(String[] args) {

        ArrayList<Person> list = new ArrayList<>();

        list.add(new Person("小明",19,99,"一班"));
        list.add(new Person("小红",18,100,"一班"));
        list.add(new Person("小张",20,85,"二班"));
        list.add(new Person("小李",16,76,"三班"));
        list.add(new Person("小刚",22,93,"三班"));
        list.add(new Person("小赵",7,42,"一班"));
        list.add(new Person("小王",28,89,"二班"));


        int age = 0;

        for (int i = 0; i < list.size(); i++) {
            age += list.get(i).getAge();
        }
        System.out.println("所有学员的平均年龄是:"+(age/list.size()));


        //想要计算每个班级的平均成绩, 那么先要给所有的学员分班
        List<List<Person>> school = new ArrayList();
        //遍历所有的学员
        w:for (int i = 0; i < list.size(); i++) {
            Person p = list.get(i); //获取到当前学员
            //遍历学校, 获取每个班级
            for (int j = 0; j <school.size() ; j++) {
                //获取每个班级
                List<Person> classRoom = school.get(j);
                //将当前班级中的第一个学员的班级和刚刚遍历出的哪个学员的班级相比较
                //如果比较成功,就说明,新学员就是这个班级的人,加入即可
                if(classRoom.get(0).getClassNum().equals(p.getClassNum())){
                    classRoom.add(p);
                    continue w; //一旦当前学员加入到班级中, 外循环继续下一次
                }
            }
            //如果代码能执行到这里, 说明,这个学生没有在学校中找到对应的班级,
            //我们自己造一个班级, 将学生加进去,然后将班级加到学校中去
            ArrayList<Person> classRoom = new ArrayList<>();
            classRoom.add(p);
            school.add(classRoom);
        }

        for (int i = 0; i < school.size(); i++) {
            int sum  = 0;
            List<Person> classRoom = school.get(i);
            for (int j = 0; j < classRoom.size(); j++) {
                sum+= classRoom.get(j).getScore();
            }
            System.out.println(classRoom.get(0).getClassNum()+"的平均成绩是"+(sum/classRoom.size()));

        }


    }


}

14.产生10个随机的字符串, 要求不能重复(字符串中的字符取值在 'a' 到 'z' , 'A' 到 'Z' ,'0' 到 '9'),字符串的长度1-20

package com.huwenlong.day14;

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

public class TestDemo04 {
    public static void main(String[] args) {
        //创建一个字符数组存储数据源
        char[] chs = new char[62];
        int index = 0;
        //char类型实际上还是整型，所以可以进行遍历，自增运算
        for (char i = 'a'; i <= 'z' ; i++) {
            chs[index++] = i;
        }
        for (char i = 'A'; i <= 'Z' ; i++) {
            chs[index++] = i;
        }
        for (char i = '0'; i <= '9' ; i++) {
            chs[index++] = i;
        }
        Random random = new Random();//用于生成随机数
        HashSet<String> set = new HashSet<>();
        while (set.size()<10){//如果不够十个字符串，继续循环
            int length = random.nextInt(20)+1;//长度随机生成1-20
            StringBuilder sb = new StringBuilder();//用于字符串拼接
            for (int i = 0; i < length; i++) {
                index = random.nextInt(chs.length);//生成随机下标
                sb.append(chs[index]);//将字符数组对应下标的元素存入
            }
            String str = sb.toString();//将StringBuffer转换为String
            set.add(str);//加入HashSet中
        }
        System.out.println(set);
    }
}

15.在一个集合中存储了无序并且重复的字符串,定义一个方法,让其有序(字典顺序),而且还不能去除重复，使用TreeSet进行排序

分析：这道题如果使用TreeSet进行排序的话由于TreeSet默认会去重，所以要使用第三方比较器。如果两个字符串相同，那么将其放在右边或者左边，不相同比较返回其compareTo的数值：

package com.huwenlong.day14;

import java.util.Comparator;
import java.util.TreeSet;

public class Test05 {
    public static void main(String[] args) {
        TreeSet<String> list = new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2)==0?2:o1.compareTo(o2);
            }
        });
        list.add("abcdef");
        list.add("abcde");
        list.add("abcdefa");
        list.add("poiuy");
        list.add("abcdef");
        list.add("lkjghf");
        list.add("xxzxsd");
        list.add("poiuy");
        for (String s : list) {
            System.out.println(s);
        }
    }

}

15. 需求: 模拟斗地主洗牌发牌,并对已发好的拍进行排序(红桃A,方块A, 黑桃2.......)

package com.huwenlong.day15;

import java.util.*;

public class TestDemo04 {
    public static void main(String[] args) {
        String[] color = {"红桃","黑桃","梅花","方块"};
        String[] num = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
        ArrayList<String> poker = new ArrayList<>();
        Map<String,Integer> map = new HashMap<>();
        int j=0;
        for (String s : num) {
            for (String s1 : color) {
                String str = s1.concat(s);
                poker.add(str);
                map.put(str,j++);
            }
        }
        map.put("小王",j++);
        map.put("大王",j);
        System.out.println(map.size());
        poker.add("小王");
        poker.add("大王");
        System.out.println(poker);
        Random random = new Random();
        //洗牌的一种方法是随意交换牌中的两张牌
        for (int i = 0; i < 100; i++) {
            int index1 = random.nextInt(poker.size());
            int index2 = random.nextInt(poker.size());
            Collections.swap(poker,index1,index2);
        }
        ArrayList<String> player1 = new ArrayList<>();
        ArrayList<String> player2 = new ArrayList<>();
        ArrayList<String> player3 = new ArrayList<>();
        ArrayList<String> left = new ArrayList<>();
        for (int i = 0; i < poker.size(); i++) {
            String str = poker.get(i);
            if(i<poker.size()-3){
                if(i%3==0){
                    player1.add(str);
                }
                else if(i%3==1){
                    player2.add(str);
                }
                else{
                    player3.add(str);
                }
            }
            else left.add(str);
        }
        class MyComparator implements Comparator<String>{

            @Override
            public int compare(String o1, String o2) {
                int num1;
                int num2;
                num1 = map.get(o1);

                num2 = map.get(o2);
                return num1-num2;
            }
        }
        player1.sort(new MyComparator());
        player2.sort(new MyComparator());
        player3.sort(new MyComparator());
        System.out.println(player1);
        System.out.println(player2);
        System.out.println(player3);
        System.out.println(left);
    }
}

16.需求: 创建俩个List集合,添加一些数据，求它们的并集，差集和交集。

分析：list中的addAll、removeAll、retailAll可以对自己和另一个集合进行操作，但是无法去重，所以要结合set使用。

package com.huwenlong.day15;

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

public class Test02 {
    public static void main(String[] args) {
        List<Character> list1 = new ArrayList<>();
        List<Character> list2 = new ArrayList<>();
        list1.add('a');
        list1.add('b');
        list1.add('a');
        list1.add('d');
        list2.add('b');
        list2.add('a');
        list2.add('c');
        List<Character> list3 = new ArrayList<>(list1);//用于保存list1
        list1.addAll(list2);
        System.out.println("并集是"+new TreeSet<>(list1));//用于去重
        list1 = new ArrayList<>(list3);
        list1.retainAll(list2);
        System.out.println("交集是"+new TreeSet<>(list1));
        list1 = new ArrayList<>(list3);
        list1.removeAll(list2);
        list2.removeAll(list3);
        list1.addAll(list2);
        System.out.println("补集是"+new TreeSet<>(list1));
        //System.out.println(list3);
    }
}