Java程序设计实验——实验6

Spraing※boy

已于 2022-11-30 16:56:51 修改

阅读量1.6k

点赞数

分类专栏： java实验文章标签： java 开发语言服务器

于 2022-11-29 16:18:26 首次发布

本文链接：https://blog.csdn.net/D1379951481/article/details/128099788

版权

java实验专栏收录该内容

6 篇文章 1 订阅

订阅专栏

Spraing※boy在本次实验中，加入了实验中可能遇到的知识点的总结提示和相关知识点的学习链接，个人觉得这次实验在java中的应用还是非常广泛的，在项目的开发中会经常用到，希望各位友友们能通过这篇博客真正学到一些东西❀❀。

附上：java学习笔记

1、将下列数据：“hello”、123、6.9、“hello”、“”、“Hello”、StringBuffer s=new StringBuffer(“hello”)中的s，添加到一个ArrayList对象中。

• 将ArrayList中的所有元素打印输出。

• 查找元素“hello”。

• 删除指定的元素“hello”。

• 将元素123替换为1000。

• 重点：使用迭代器对集合元素进行输出

• 添加元素：list.add() 查找元素：list.get() .equals() 删除元素：list.remove()

• 替换元素：

注意：这里不能用list.replaceAll()方法，该方法的两个传入参数必须为String类型,实验中替换对象为整型数据

public class S6_1 {
    public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<>();
        list.add("hello");
        list.add(123);
        list.add(6.9);
        list.add("hello");
        StringBuffer s = new StringBuffer("hello");
        list.add(s);
        //重点：使用迭代器对集合元素进行输出
        Iterator it = list.iterator();
        while (it.hasNext()) {
            System.out.println(it.next() + " ");
        }
        //查找元素“hello”
        System.out.println("元素hello出现的位置有：");
        for (int i = 0; i < list.size(); ++i) {
            if (list.get(i).equals("hello")) {
                System.out.print(i + " ");
            }
        }
        //删除指定元素
        list.remove("hello");
        //将元素123替换为1000
        //注意：这里不能用list.replaceAll()方法，该方法的两个传入参数必须为String类型
        for (int i = 0; i < list.size(); ++i) {
            if (list.get(i).equals(123)) {
                list.set(i, 1000);
            }
        }
    }
}

2、使用ArrayList集合，向集合中添加10个整数，并使用Iterator遍历该集合，并查找键盘输入的元素。提示：

• 使用add()方法将元素添加到ArrayList集合中。

• 调用集合的iterator()方法获得Iterator对象，并调用Iterator的hasNext()和next()方法，迭代出集合中的所有元素，完成查找功能，并将重复的元素删除。

• 难点：去除重复元素

在使用迭代器遍历集合元素的时候，添加计数器来标记元素是否重复，

利用标记和list.remove()去除重复的元素

public class S6_2 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int num;
        ArrayList<Integer> list = new ArrayList<>();
        System.out.println("请输入十个整数添加到集合中");
        //使用add方法添加元素
        for (int i = 0; i < 10; ++i){
            num = in.nextInt();
            list.add(num);
        }
        //查找元素
        System.out.println("请输入你要查找的元素：");
        num = in.nextInt();
        for (int i = 0; i < list.size(); ++i){
            if (list.get(i).equals(num)){
                System.out.println("该元素的位置在："+i);
            }
        }
        //去除重复元素
        Iterator<Integer> iterator = list.iterator();
        int count = 0; //添加计数器用来标记是否有重复元素出现
        while (iterator.hasNext()){
            int num1 =  iterator.next();
            for (int i = 0; i < list.size(); ++i){
                if (num1 == list.get(i)){
                    count++;
                }
            }
            if (count > 1){
                iterator.remove();
            }
            count = 0;
        }
        System.out.println("去重之后的集合为："+list);
    }
}

3、分别利用Arraylist和Set随机生成十个不重复的随机整数，随机整数范围为350到450。

• Random类生成一定范围的随机数: random.nextInt(max - min) + min;

• 判断集合中是否存在某元素：list.contains() 返回值类型为Boolean

public class S6_3 {
    public static void main(String[] args) {
        //用ArraryList随机生成十个不重复的随机数，List接口的一个实现类
        Random random = new Random();
        ArrayList<Integer> list = new ArrayList<>();
        int count = 0;
        int num;
        while (count < 10) {
            //生成一定范围的随机数：random.nextInt(max-min)+min;
            num = random.nextInt(101)+350;
            if (!list.contains(num)){ //判断集合中是否存在该元素
                list.add(num);
                count++;
            }
        }
        System.out.println(list);
        //使用Set集合，继承了Collection集合
        Set<Integer> set = new HashSet<>();
        int cnt = 0;
        while(cnt < 10) {
            num = random.nextInt(101)+350;
            if (!set.contains(num)){
                set.add(num);
            }
            cnt++;
        }
        System.out.println(set);
    }
}

4、集合中不容许有重复的对象，对于多个重复对象只能添加一次。例如在HashSet集合中添加三个Person对象，把姓名相同的人当做同一个人，虽然可以添加多次但集合里只保留一个，但是这对类的设计是有要求的，假设Person类中只包含name和age属性，则需要重写hashCode()方法和equals()方法，如果两个对象的name相同，则hashCode()方法的返回值相同，equals（）方法返回true。

重写hashCode()和equals()方法：

让hashCode()方法只要是对象属性值相同，返回值就相同

让equals()方法只要是两个对象的属性值相同结果就为true
这样就可以实现两个属性值相同的对象会被当作同一个对象，只存储到一个中

public class S6_4 {
    public static void main(String[] args) {
        HashSet hashSet = new HashSet<>();
        Person p1 = new Person("spraing",19);
        Person p2 = new Person("凌霄郭",20);
        Person p3 = new Person("凌霄郭",19);
        Person p4 = new Person("obession",20);
        Person p5 = new Person("游标卡尺",19);
        hashSet.add(p1);
        hashSet.add(p2);
        hashSet.add(p3);
        hashSet.add(p4);
        hashSet.add(p5);
        System.out.println(hashSet);
    }
}

//让hashCode()方法只要是对象属性值相同，返回值就相同
//让equals()方法只要是两个对象的属性值相同结果就为true
//这样就可以实现两个属性值相同的对象会被当作同一个对象，只存储到一个中

class Person{
    public String name;
    public int age;

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int hashCode() {
        return name.hashCode();
    }

    @Override
    public boolean equals(Object obj) {
        //判断传进去的obj对象是否与当前对象相同
        if (this == obj) return true;
        //若传进去的对象为null肯定不相等
        if (obj == null) return false;
        //将obj对象转型为Person类
        Person other = (Person) obj;
        //判断名字是否相等
        return other.name.equals(this.name);
    }
}

5、编写程序将一组学生对象的姓名和成绩存入到一个树集（TreeSet）中，完成以下要求：

• 使得按照成绩自动降序排列，并输出排序的结果。

自然排序和定制排序

• 自然排序：（实现Comparable接口，并重写compareTo()方法）

向TreeSet集合中存储的元素所在类必须实现Comparable接口，并重写compareTo()方法
然后TreeSet集合就会对该类型元素使用compareTo()方法进行比较，并默认升序排列

• 定制排序：（实现Comparator接口）

自定义一个比较器来对元素进行定制排序

public class S6_5 {
    public static void main(String[] args) {
        /*
            1.自然排序：
            向TreeSet集合中存储的元素所在类必须实现Comparable接口，并重写compareTo()方法
            然后TreeSet集合就会对该类型元素使用compareTo()方法进行比较，并默认升序排列
            2.定制排序：
            自定义一个比较器来对元素进行定制排序
        */
        //自然排序
        TreeSet treeSet = new TreeSet<>();
        Stu s1 = new Stu("spraing", 100);
        Stu s2 = new Stu("obession", 103);
        Stu s3 = new Stu("凌霄郭",110);
        Stu s4 = new Stu("游标卡尺",105);
        treeSet.add(s1);
        treeSet.add(s2);
        treeSet.add(s3);
        treeSet.add(s4);
        System.out.println(treeSet);
        //定制比较器
        TreeSet treeSet1 = new TreeSet<>(new GradeComparator());
        treeSet1.add(s1);
        treeSet1.add(s2);
        treeSet1.add(s3);
        treeSet1.add(s4);
        System.out.println(treeSet1);
    }
}

//实现Comparable接口，并重写compareTo()方法
class Stu implements Comparable {
    public String name;
    public int grade;

    public Stu(String name, int grade) {
        this.name = name;
        this.grade = grade;
    }

    @Override
    public String toString() {
        return "stu{" +
                "name='" + name + '\'' +
                ", grade=" + grade +
                '}';
    }

    @Override
    public int compareTo(Object o) {
        Stu s = (Stu) o;
        //定义比较方法
        //如果需要交换，则返回1,不需要交换则返回-1
        if (this.grade < s.grade){
            return 1;
        }
        return -1;
    }
}
//定制比较器
class GradeComparator implements Comparator {
    @Override
    public int compare(Object o1, Object o2) {
        Stu s1 = (Stu) o1;
        Stu s2 = (Stu) o2;
        //如果两个对象需要交换，返回1，如果不需要交换，返回-1
       if (((Stu) o1).grade < ((Stu) o2).grade){
           return 1;
       }
       return -1;
    }
}

6、编写一个程序，读取个数不定的整数，然后查找其中出现频率最高的数字。要求通过键盘输入数据，当输入为0时，表示结束输入。如：如果输入的数据是2 3 40 3 54 -3 3 3 2 0，那么数字3的出现频率是最高的。如果出现频率最高的数字不是一个而是多个，则应该将它们全部输出。例如当数据是9 30 3 9 3 2 4时，3和9都出现了两次，3和9都应该输出。

提示：可以利用集合的元素不能重复这一特性。

• HashMap集合是Map接口的一个实现类，它存储的每一个元素都是键值对<Key, Value>，键和值均可以是任意类型。我们这里把数字存储到key中，value用来存储对应的频率

• foreach循环遍历HashMap()中的key和value
由于Map中存放的元素均为键值对，故每一个键值对必然存在一个映射关系。Map中采用 Entry内部类来表示一个映射项，映射项包含Key和Value (我们总说键值对键值对, 每一个键值对也就是一个Entry), Map.Entry里面包含getKey()和getValue()方法
该方法适合容量大的时候使用(推荐)

• 更多遍历Map的方法

public class S6_6 {
    public static void main(String[] args) {
        //HashMap集合是Map接口的一个实现类，它存储的每一个元素都是键值对<Key, Value>，键和值均可以是任意类型。
        //我们这里把数字存储到key中，value用来存储对应的频率
        HashMap<Integer, Integer> hashMap = new HashMap<>();
        Scanner in = new Scanner(System.in);
        int num;
        System.out.println("请输入任意数量的数字（0作为停止的标志）:");
        while (true) {
            num = in.nextInt();
            if (num == 0) break;
            if (!hashMap.containsKey(num)) {
                hashMap.put(num, 1);
            } else {
                int value = hashMap.get(num);
                value++;
                hashMap.put(num, value);
            }
        }
        int max = 0;
        //foreach循环遍历HashMap()中的key和value
        //由于Map中存放的元素均为键值对，故每一个键值对必然存在一个映射关系。
        //Map中采用Entry内部类来表示一个映射项，映射项包含Key和Value (我们总说键值对键值对, 每一个键值对也就是一个Entry)
        //Map.Entry里面包含getKey()和getValue()方法
        //该方法适合容量大的时候使用(推荐)
        for (Map.Entry<Integer,Integer> entry: hashMap.entrySet()) {
           if (entry.getValue() > max){
               max = entry.getValue();
           }
        }
        System.out.println("出现频率最大的数字是：");
        for (Map.Entry<Integer,Integer> entry: hashMap.entrySet()) {
            if (entry.getValue() == max){
                System.out.println(entry.getKey());
            }
        }
    }
}

7、选择合适的Map集合保存5个用户的用户名和密码，然后将这些键值对打印出来。

• 利用keySet遍历Map,二次取值(普遍使用)

• 更多遍历Map的方法

public class S6_7 {
    public static void main(String[] args) {
        HashMap<String, String> hashMap = new HashMap<>();
        hashMap.put("spraing","boy");
        hashMap.put("obession","feng");
        hashMap.put("凌霄郭","guo");
        hashMap.put("游标卡尺","shi");
        //遍历Map的方法之一，普遍使用，二次取值
        for(String key: hashMap.keySet()){
            System.out.println("key = "+key+" value = "+hashMap.get(key));
        }
    }
}

8、（选做）统计字符串中每个单词出现的次数，使用HashMap来实现。例如：“Today, We have a class of java, as we known, java is an object oriented programming language, and java is fun! wish you enjoy it!”，统计结果存储成以下形式：

a-->1

an-->1

and-->1

as-->1……

is-->2

提示：使用String.split(("[ \n\t\r.,;:!?()]")方法进行分词。

该实验题目实际上跟上面的实验题目差不多，思路基本一致，用到的知识点也基本一致，对于字符串的分隔也已经给出方法，可以尝试独立完成一下。

public class S6_8 {
    public static void main(String[] args) {
        //使用HashMap<String, Integer>,key用来存储字符串，value用来存储单词出现的次数
        HashMap<String,Integer> hashMap = new HashMap<>();
        String str = "Today, We have a class of java, as we kown, java is an object oriented  programming language,and java is fun! wish you enjoy it!";
        //使用String.split("[ \n\t\r.,;:!?()]")方法进行分词
        String newstr[] = str.split("[ \n\t\r.,;:!?()]");
        for (int i = 0; i < newstr.length; ++i){
            if (!hashMap.containsKey(newstr[i])){
                hashMap.put(newstr[i],1);
            } else {
                int value = hashMap.get(newstr[i]);
                value++;
                hashMap.put(newstr[i], value);
            }
        }
        //遍历获取HashMap中的key和value
        for (Map.Entry<String,Integer> entry: hashMap.entrySet()){
            System.out.println(entry.getKey()+"-->"+entry.getValue());
        }
    }
}