Java中集合相关使用练习

sugarJava

已于 2023-02-23 09:08:04 修改

阅读量265

点赞数

分类专栏： JavaEE 文章标签： java Powered by 金山文档

于 2023-02-22 18:21:23 首次发布

本文链接：https://blog.csdn.net/2201_75452232/article/details/129167916

版权

JavaEE 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

使用Set的特性去重复元素

题目描述

从键盘上输入一行字符串，要求去重复字符

需要使用Scanner类

输入的是一行字符串，需要转换成字符数组

创建HashSet集合对象（利用HashSet无法储存相同元素的特性达到去除重复字符的目的）

字符数组遍历元素，并添加进入HashSet集合

遍历集合元素

代码案例

public class Test01 {
public static void main(String[] args) {

    //1.创建扫描器
    Scanner scanner=new Scanner(System.in);
    System.out.println("请输入一个字符串：");
    String line=scanner.nextLine();

    //2.字符串转换程字符数组
    char[] charArray=line.toCharArray();

    //3字符数组转成集合对象，创建HashSet
    HashSet<Character> hashSet=new HashSet<>();

    //4遍历数组依次添加进集合
    for (int i = 0; i <charArray.length ; i++) {
        hashSet.add(charArray[i]);
    }
    for (Character character : hashSet) {
        System.out.println(character);
    }
 }
}

结果

生成10个不重复随机数

题目描述

生成10个1到20之间的不重复的随机数

需要生成随机数,那么需要引用Random类;

需要存储10个不能重复的数字,需要Hashmap集合

判断,当hashSet的Size小于10就往集合里存储随机数,等于限制存储元素的个数

通过Random的nextInt()方法获取随机数并加入到HashSet里

遍历HashSet,打印出10个随机数

代码案例

public static void main(String[] args) {
    //1.创建Random类实例
    Random random=new Random();
    //2.创建HashSet
    HashSet<Integer>hashSet=new HashSet<>();
    //3.判断并添加元素
    while (hashSet.size()<10) {
        //4.通过random中随机方法nextInt()获取1到20范围内随机数
        hashSet.add(random.nextInt(20)+1);//随机数是从0开始生成的,
    }
    //5.遍历hashset
    System.out.println("生成随机数如下：");
    for (Integer i : hashSet) {
        System.out.print(i+" ");
    }
 }
}

结果

使用顺序列表ArrayList

题目描述

假设顺序列表ArrayList中存储的元素是整型数字1~5，遍历每个元素，将每个元素顺序输出。（list集合遍历方法总结）

代码案例

public class Test03 {
    public static void main(String[] args) {
        List<Integer> list=new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        Iterator<Integer>iterator=list.iterator();//声明迭代器对象
        //迭代遍历
        while (iterator.hasNext()){
             System.out.print(iterator.next()+"\t");
        }
    //for循环遍历
        for (int i = 0; i <list.size() ; i++) {
            System.out.println(list.get(i));
        }

     //增强for循环
     for(Integer integer:list){
         System.out.println(integer);
     }
    }
}

结果

使用List的compareTo排序

题目描述

在一个列表中存储元素:apple, grape,banana,pear

返回集合中的最大和最小的元素

将集合进行排序,并将排序后的结果打印

代码案例

public class Tsst04 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("apple");
        list.add("grape");
        list.add("banana");
        list.add("pear");
        for(int j = 0;j<list.size()-1;j++){//冒泡排序
            for(int i = 0;i<list.size()-1-j;i++){
                if(list.get(i).compareTo(list.get(i+1))>0){
                    String temp = list.get(i);
                    list.set(i, list.get(i+1));
                    list.set(i+1, temp);
                }
            }
        }

        System.out.print("排序后的顺序：");  //
        for(int i = 0;i<list.size();i++){
            System.out.print(list.get(i)+" ");
        }
        System.out.println();
        System.out.println("集合中最大的元素是"+list.get(0));
        System.out.println("集合中最小的元素是"+list.get(3));
    }
}

结果

使用set获取不重复字符

题目描述

编写程序，获取命令行参数中字符串列表

输出其中重复的字符,不重复的字符以及消除重复以后的字符列表

代码案例

public class Test05 {
    public static void main(String[] args) {
     String string="aaaawbbbqcccxddddd";
        System.out.println("原字符串："+string);

        Set<Character> set1=new HashSet<Character>();//消除重复后的字符
        Set<Character> set2=new HashSet<Character>();//重复的字符
        Set<Character> set3=new HashSet<>();//不重复的字符

        //把字符串转为字符数组
        char[] cs=string.toCharArray();
        for (char c:cs){
            boolean b=set1.add(c);//是否添加成功
            if(!b){
                set2.add(c);//装重复的字符
            }
        }

        //把消除重复后的字符赋给set3
        set3.addAll(set1);
        //把重复后的字符-重复的字符 =不重复的字符，
        set3.removeAll(set2);

        System.out.println("消除重复后的字符：");//set集合的特性：重复的元素只保存一个
        for (Character char1 : set1) {
            System.out.print(char1+"\t");
        }

        System.out.println("\n"+"重复的字符：");
        for (Character char2 : set2) {
            System.out.print(char2+"\t");
        }

        System.out.println("\n"+"不重复的字符：");
        for (Character char3 : set3) {
            System.out.print(char3+"\t");
        }

    }
}

结果

使用map集合特性统计元素数量

题目描述

使用scanner从控制台读取一个字符串,统计字符串中每个字符出现的次数,实现思路map+set+List集合的特性完成

代码案例

public class Test06 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入一组字符串");
        String str=scanner.nextLine();

        Map<Character,Integer>map=new HashMap<Character, Integer>();
        char[] chars=str.toCharArray();
        for (char c:chars){
            if (map.containsKey(c)){
                Integer value=map.get(c);
                value++;
                map.put(c, value);//更新value的值到map中
            }
            else {
                map.put(c, 1);//第一次进入循环体，赋值value为1
            }
        }

        //遍历map
        Set<Character> set=map.keySet();
        for (Character character:set){
            System.out.println(character+"出现了"+map.get(character)+"次");
        }
    }
}

结果

自定义类比较Comparable接口

题目描述

写一个Student类, 包含属性id[1-20), grade[1-6], score[0-100], 所有属性都是随机生成创建一个Set集合, 保存30个对象, 如果两个对象的id是一样的,则不允许添加.使用迭代器遍历集合,打印输出对象的信息, 并找出分数最高的同学和分数最低的同学,最后打印输出最高分和最低分同学信息.

代码案例

public class Test07 {
    public static void main(String[] args) {
        Set<Student>set=new HashSet<Student>();

        for (;set.size()!=30;){ //保存30个对象，省略了i和i++
          int id=(int)(Math.random()*20+1);
          int grade=(int)(Math.random()*6+1);
          double score=(int)(Math.random()*1001/10.0);//向上取整
            set.add(new Student(id,grade,score));
        }

        for (Student student : set) {
            System.out.println(student);
        }
        System.out.println("====================================");
        Student maxScoreStudent=null;
        Student minScoreStudent=null;
        Iterator<Student> iterator=set.iterator();
        while (iterator.hasNext()){
            Student student=iterator.next();
            if(maxScoreStudent==null){
                maxScoreStudent=student;
                minScoreStudent=student;
            }
           if (student.getScore()>maxScoreStudent.getScore()){
               maxScoreStudent=student;
           }else if (student.getScore()<minScoreStudent.getScore())
           {
               minScoreStudent=student;
           }
        }
        System.out.println(maxScoreStudent);
        System.out.println(minScoreStudent);

        Object[] arraySet= set.toArray();
        Arrays.sort(arraySet);//排序
        System.out.println("排序后：");
        for (Object o : arraySet) {
            System.out.println(o);
        }
    }
}

====================================================================
    //Student类
  public class Student implements Comparable<Student> {
  private int id;
  private int grade;
  private double score;

    public Student(int id, int grade, double score) {
        this.id = id;
        this.grade = grade;
        this.score = score;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getGrade() {
        return grade;
    }

    public void setGrade(int grade) {
        this.grade = grade;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", grade=" + grade +
                ", score=" + score +
                '}';
    }

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