Java进阶 -- Set集合

最新推荐文章于 2022-03-07 16:20:26 发布
最新推荐文章于 2022-03-07 16:20:26 发布
阅读量211 收藏
点赞数
分类专栏： Java进阶 文章标签： 可变参数 Map集合 Collections集合工具类 HashMap集合 斗地主案例
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38088097/article/details/99285541
版权

可变参数

  • 概念：方法参数列表中的参数个数不确定，就表示可变参数。
  • 可变参数的本质：数组。
  • 注意事项：方法的参数列表中只能有一个可变参数，并且可变参数只能在参数列表的末尾。
  • 语法格式: (数据类型…变量名)
public class ParameterDemo {
        public static void main(String[] args) {
            add(10,20,30,40); //允许

            int[] arr={10,20,30,40};
            add(arr);//允许

            Integer[] arr2={10,20,30,40};
            //add(arr2); //报错，int[]和Integer[]不能相互转换
        }
        public static int add(int... nums){
            int sum=0;
            for (int num : nums) {
                sum+=num;
            }
            return sum;
        }
    }
  • 可变参数的使用
/*
    集合和数组之间的相互转换
    数组--->集合 Arrays
    static <T> List<T> asList​(T... a):返回由指定数组支持的固定大小的列表。

    集合--->数组 Collection
    Object[] toArray​():返回一个包含此集合中所有元素的数组。
    <T> T[]	toArray​(T[] a):返回一个包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。
*/
 public class ArgsDemo2 {
     public static void main(String[] args) {
         //数组--->集合
         Integer[] arr={10,20,30,40,50};
         List<Integer> list = Arrays.asList(arr);
         System.out.println(list);

         //集合--->数组
         List<String> lts=List.of("hello","world","java");
         //方式1：Object[]	 toArray​()	:返回一个包含此集合中所有元素的数组
         Object[] arrs1 = lts.toArray();
         System.out.println(Arrays.toString(arrs1));

         //方式2： <T> T[] toArray​(T[] a)：需要传递一个数组对象，集合中数据是什么类型就创建一个该类型的空数组传进去
         /*String[] arrs2=new String[lts.size()];
         lts.toArray(arrs2);*/
         //简化写法
         String[] arrs2 = lts.toArray(new String[lts.size()]);
         System.out.println(Arrays.toString(arrs2));
     }
 }

Map集合

map集合是一个双列集合，每次存储一对值，分为key-value。

  • 特点：key相同，value会被替换。也就是说key是唯一的。

  • map集合的使用，常用方法：

    1. 增/添加/改
      V put​(K key, V value):添加获取替换值，如果添加的key不存在，那么返回值就是null。如果key存在，那么新的value会替换原来的value值，返回值是被替换的值。

    2. 删/移除
      V remove(K key):根据key移除一对元素。返回值就是对应的value值

    3. 查/获取
      V get(K key):根据key获取value。
      K keySet()：获取所有的key
      Map.Entry<K,V> entrySet():获取所有的键值对对象

    4. 遍历：
      方式1：键找值的方式，实现思路：
      1 获取所有的key
      2 遍历所有的key
      3 在遍历过程中根据key获取对应的value值，打印结果
      方式2：键值对的方式，实现思路：
      Map.Entry<K,V> : Entry是Map的一个内部接口（看成是内部类结构）。Entry也有泛型，泛型和Map集合的泛型一样。
      Entry的作用：在我们调用Map集合的put方法存值的时候，其实内部会创建一个Entry实现类对象，将我们存进去的值封装到Entry实现类对象中。
      简单说：Map集合的内部会将每一对值封装成一个个Entry对象，Entry对象也叫做键值对对象。

      1 获取所有的键值对对象：Map.Entry<K,V> entrySet();
      2 遍历所有的键值对对象，获取每一个键值对对象
      3 调用键值对对象的getKey()和getValue()方法获取键和值，打印结果。

  • Map集合key唯一的条件：
    key表示的对象要重写hashCode()和equals()方法。

package com.jxufe_ldl.class01;

public class Student {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

    public Student() {
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
}


package com.jxufe_ldl.class01;

import com.jxufe_ldl.selfstudy.class02.Studen;

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

public class HashMapDemo02 {
    public static void main(String[] args) {
        // 创建集合
        Map<Student, String> hm = new HashMap<Student, String>();

        // 创建学生对象
        Student s1 = new Student("林青霞", 30);
        Student s2 = new Student("张曼玉", 35);
        Student s3 = new Student("王祖贤", 33);
        Student s4 = new Student("王祖贤", 33);

        hm.put(s1, "西安");
        hm.put(s2, "武汉");
        hm.put(s3, "郑州");
        hm.put(s4, "北京");

        Set<Student> keySet = hm.keySet();
        for (Student key : keySet) {
            String value = hm.get(key);
            System.out.println(key.getName() + "," + key.getAge() + "," + value);
        }

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

        Set<Map.Entry<Student, String>> entries = hm.entrySet();
        for (Map.Entry<Student, String> me : entries) {
            Student key = me.getKey();
            String value = me.getValue();
            System.out.println(key.getName() + "," + key.getAge() + "," + value);
        }
    }
}

Collections集合工具类

  1. Collection和Collections的区别？
    Collection是单列集合的顶层接口，Collections是操作集合的工具类。
  2. Collections的常用方法：
    static void shuffle​(List<?> list)：随机打乱集合中元素的顺序。
    static <T extends Comparable<? super T>> void sort​(List<T> list)：对list集合中的元素进行自然排序，list集合中的元素必须要实现Comparable接口
    static <T> void sort​(List<T> list, Comparator<? super T> c)：对list集合中的元素使用Comparator比较器进行排序
package com.jxufe_ldl.class03;

public class Student {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

    public Student() {
    }

}

package com.jxufe_ldl.class03;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class ArrayListSortDemo {
    public static void main(String[] args) {
        // 创建ArrayList集合duixiang
        ArrayList<Student> al = new ArrayList<>();

        // 创建学生对象
        Student s1 = new Student("wangzuxian", 43);
        Student s2 = new Student("linqingxia", 38);
        Student s3 = new Student("liuyan", 42);
        Student s4 = new Student("fengqingyang", 38);

        // 向集合中添加元素
        al.add(s1);
        al.add(s2);
        al.add(s3);
        al.add(s4);

        // 调用sort方法
        Collections.sort(al, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int num = o1.getAge() - o2.getAge();
                int num2 = num == 0 ? o1.getName().compareTo(o2.getName()) : num;
                return num2;
            }
        });

        for (Student stu : al) {
            System.out.println(stu.getName() + "," + stu.getAge());
        }
    }
}

斗地主案例

  • 基础版思路分析
    1. 准备牌：
      1、定义一个List集合作为牌盒
      2、定义两个数组，存储花色和牌号
      3、遍历数组，将花色和牌号进行组合，将组合好的牌存的牌盒list集合中
    2. 洗牌：
      Collections.shuffle(牌盒集合)
    3. 发牌
      1、定义三个List集合表示三个玩家和一个集合表示底牌
      2、遍历牌盒的list集合，共有54张牌在list集合中
      3、如果索引大于50，那么就发给底牌集合
      4、将索引对3取余，如果余数是0，那么就发给玩家1；如果余数是1，就发给玩家2；如果余数是2，就发给玩家3
			if(i>50){
			 //发给底牌
			     }else if(i%3==0){
			       //发给玩家1
			     }else if(I%3==1){
			       //发给玩家2
			     } else if(I%3==2){
			       //发给玩家3
			     }
  1. 看牌：打印玩家姓名和玩家集合对象
package com.jxufe_ldl.test04;

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

public class PokerDemo01 {
    public static void main(String[] args) {
        // 创建一个ArrayList集合，用来存储牌
        List<String> poker = new ArrayList<String>();

        // 创建两个数组，分别存储牌色和牌号
        String[] colors = {"♥", "♠", "♦", "♣"};
        String[] numbers = {"3","4","5","6","7","8","9","10","J","Q","K","2"};

        // 把牌色和牌号组合起来，存到集合中
        poker.add("大王");
        poker.add("小王");

        for (String color : colors) {
            for (String number : numbers) {
                poker.add(color+number);
            }
        }

        // 洗牌
        Collections.shuffle(poker);

        // 发牌
        // 定义4个ArrayList集合，用来存储3个玩家的牌鸡儿底牌
        List<String> player1 = new ArrayList<String>();
        List<String> player2 = new ArrayList<String>();
        List<String> player3 = new ArrayList<String>();
        List<String> dipai = new ArrayList<String>();

        for (int i = 0; i < poker.size(); i++) {
            if (i>= poker.size()-3) {
                dipai.add(poker.get(i));
            } else if (i%3 == 0) {
                player1.add(poker.get(i));
            } else if (i%3 == 1) {
                player2.add(poker.get(i));
            } else if (i%3 == 2) {
                player3.add(poker.get(i));
            }
        }

        // 看牌
        System.out.println("玩家1：" + player1);
        System.out.println("玩家2：" + player2);
        System.out.println("玩家3：" + player3);
        System.out.println("底牌：" + dipai);
        System.out.println(poker);
    }
}

加强版思路分析：

  1. 准备牌
    1、定一个Map集合最为牌盒
    2、定义两个数组，存储花色和牌号
    3、定义一个牌的序号起始值为0，每存一张牌，序号就++；
    4、遍历数组，将花色和牌号进行组合，将组合好的牌存的牌盒map集合中
  2. 洗牌
    1.获取Map集合的所有key
    Set keys=poker.keySet();
    2.将set集合转换成list，使用list的构造方法即可
    3.打乱顺序
    Collections.shuffle(list)
  3. 发牌
    1、定义三个TreeSet集合表示三个玩家和一个集合表示底牌
    2、遍历装有序号的list集合，共有54个序号在list集合中
    3、如果索引大于50，那么就发给底牌集合
    4、将索引对3取余，如果余数是0，那么就发给玩家1；如果余数是1，就发给玩家2；如果余数是2，就发给玩家3
		if(i>50){
               //发给底牌
            }else if(i%3==0){
              //发给玩家1
            }else if(I%3==1){
              //发给玩家2
            } else if(I%3==2){
              //发给玩家3
            }
  1. 看牌
    定义一个方法：遍历玩家的TreeSet集合，根据序号从Map集合中获取对应的牌，打印到控制台
package com.jxufe_ldl.test04;

import java.util.*;

public class PokerDemo03 {
    public static void main(String[] args) {
        // 用HashMap定义一个牌盒
        HashMap<Integer, String> poker = new HashMap<>();

        // 定义2个数组，分别装牌色和牌号
        String[] colors = {"♥", "♠", "♦", "♣"};
        String[] numbers = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};

        int index = 0;

        // 装牌
        for (String number : numbers) {
            for (String color : colors) {
                poker.put(index++, color+number);
            }
        }
        poker.put(index++, "小王");
        poker.put(index++, "大王");

//        System.out.println(poker);
        // 把编号保存到ArrayList集合中，把Set集合转换为List集合，只需要把Set对象放到List构造方法中就可以了
        Set<Integer> keySet = poker.keySet();
        ArrayList<Integer> al = new ArrayList<>(keySet);

//        System.out.println(al);
        // 定义3个玩家和1个底牌
        TreeSet<Integer> player1 = new TreeSet<>();
        TreeSet<Integer> player2 = new TreeSet<>();
        TreeSet<Integer> player3 = new TreeSet<>();
        TreeSet<Integer> dipai = new TreeSet<>();

        // 洗牌
        Collections.shuffle(al);

        // 发牌
        for (int i = 0; i < al.size(); i++) {
            Integer poker1 = al.get(i);
            if (i >= al.size() - 3) {
                dipai.add(poker1);
            } else if (i%3 == 0) {
                player1.add(poker1);
            }else if (i%3 == 1) {
                player2.add(poker1);
            }else if (i%3 == 2) {
                player3.add(poker1);
            }
        }

        // 看牌
        lookPoker("刘达亮", player1, poker);
        lookPoker("于曼丽", player2, poker);
        lookPoker("刘小亮", player3, poker);
        lookPoker("底牌", dipai, poker);

    }

    public static void lookPoker(String name, TreeSet<Integer> ts, HashMap<Integer, String> hm) {
        System.out.print(name + "的牌是：");
        for (Integer key : ts) {
            String value = hm.get(key);
            System.out.print(value+" ");
        }
        System.out.println();
    }
}
雨碎江南ldy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
在集合中添加十个1到10的整数求和打乱倒置
qq_58695235的博客
07-15 327
import java.util.ArrayList; import java.util.Random; public class Test { public static void main(String[] args) { //随机十位数 Random r = new Random(); ArrayList<Integer> LIST1 = new ArrayList<>(); //循环十次 for (in
Java—集合排序
wintershii的博客
07-27 5101
Java——集合的排序 &amp;lt;一&amp;gt;接口comparable与接口comparator的比较 1&amp;gt; Comparable Comparable是在集合内部定义方法实现的排序，位于java.util包下。是一个对象本身就已经支持自然比较所需要实现的接口。例如String，Interger自己就实现了Comparable接口，并且重写了compareTo方法，可以完成比较...
java Set方法 toArray(T[] a)
chenli4707的博客
04-25 1849
<T>T[]toArray(T[]a) Returns an array containing all of the elements in this set; the runtime type of the returne...
Java 集合转数组的toArray()和toArray(T[] a)方法通俗易懂
梁同学与Android
09-17 4043
1、ArrayList的toArray 　　ArrayList提供了一个将List转为数组的一个非常方便的方法toArray。toArray有两个重载的方法： 　　（1）list.toArray(); 　　（2）list.toArray(T[]  a); 　　对于第一个重载方法，是将list直接转为Object[] 数组； 　　第二种方法是将list转化为你所需要类型的数组，当...
java 集合的常用操作（排序、查找、打乱顺序）
weixin_30341735的博客
05-02 238
排序： Collections.sort 查找： Collections.binarySearch 任意打乱元素顺序： Collections.shuffle 其他： Collections.addAll Collections.copy Collections.disjoint 比较是否有相同元素 Collections.fill Collections.frequen...
集合乱序方法
smallblood的专栏
12-25 255
这是转的，在别的地方看到的，记录下来~ 　　排序的算法有很多，也有很多公认的方法，冒泡、插排、快排。乱序的算法一直没有什么公认的好方法。自己尝试做了一些，觉得这个方法还比较不错，在这里把东西备份一下，以免以后忘记了，找不到了。如果有朋友有更好的算法，请您赐教。 　　假设现在有一个集合，里面有10个元素，需要做乱序。 　　我的做法是，每次随机产生一个集合索引范围内的随机数，从集合中...
Java集合-Set
喜欢前端的后端 MelodyJerry
01-01 468
2020.12.31 更新 待补充、完善ing…… Set概述 set集合不能存储相同的元素 同时因为其是一个抽象的接口：所以不能直接实例化一个set对象。 Set s = new Set() ：× 该接口主要继承于Collections接口，所以具有Collection的一些常见的方法。 常见用法 Sr.No. Method Description 1 add( ) 向集合中添加元素 2 clear( ) 去掉集合中所有的元素 3 contains( ) 判断集合中是否包含某
7-java进阶-集合1
08-03
本节主要讨论的是Java集合中的高级话题，特别是关于`List`、`Set`接口以及它们的实现类，如`ArrayList`、`LinkedList`、`HashSet`、`HashMap`等。 首先，集合框架的核心是`Collection`接口，它是所有单个数据存储的...
Java进阶--深入理解ArrayList实现原理
01-27
ArrayList是Java集合框架中常用的列表实现之一，它作为动态数组，允许我们在运行时根据需要增加或减少元素。ArrayList继承自AbstractList，并实现了List、RandomAccess、Cloneable和Serializable接口。这意味着...
黑马程序员-Java语言进阶-源码、教程笔记.zip
12-16
day03_List、Set、数据结构、Collections day04_Map，斗地主案例 day05_异常，线程 day06_线程、同步 day07_等待与唤醒案例、线程池、Lambda表达式 day08_File类、递归 day09_字节流、字符流 day10_缓冲流、转换流、...
JavaSE进阶-05-集合.pdf
09-10
JavaSE进阶课程中的集合框架是Java编程中不可或缺的一部分，它提供了一种高效管理大量数据的方式。本课程主要涵盖了以下几个核心知识点： 1. **主要集合概述**：Java集合框架包括了三种主要类型，即List、Set和Map...
Java进阶学习资料.zip
06-21
在Java进阶学习中，你需要掌握以下几个关键的知识点： 1. 高级数据结构与算法：理解并能熟练运用ArrayList、LinkedList、HashMap等集合框架，深入研究Set、Queue、Stack等接口及其实现类。同时，学习并应用高级排序...
Java高级语法02-集合（List、Set、数据结构、Collections）
qq_42768841的博客
05-11 203
Java高级语法02（List、Set、数据结构、Collections） 一、集合与数据结构 1.1常见的数据结构 数据存储的常用结构有：栈、队列、数组、链表和红黑树。 栈（先进后出） 栈：stack,又称堆栈，它是运算受限的线性表，其限制是仅允许在标的一端进行插入和删除操作，不允许在其他任何位置进行添加、查找、删除等操作。 先进后出（即，存进去的元素，要在后它后面的元素依次取出后，才能取出该元素）。例如，子弹压进弹夹。 栈的入口、出口的都是栈的顶端位置。 这里两个名词需要注意： 压栈：就是存元素。即
将一个有序的数组打乱（Java实现）
RSMung的博客
03-07 2881
题目 给定一个有序的数组，将其打乱。 解决办法 解题思路1 生成随机数当作当前要处理的元素的index，依次将它们放入新数组里面。 使用HashMap或者HashSet来保证生成的index的唯一性。 /** * 使用Hash保证index的唯一性 * */ public int[] test1(){ //使用日期做种子生成真随机数 Random random = new Random(new Date().getTime()); int index = Math.abs(
Set的集合操作
实践求真知
01-27 809
一 差集 1 说明 SDIFF key [key ...]   从第一个key的集合中去除其他集合中和自己相交的部分。 SDIFFSTORE destination key [key ...] 将差集保存到destination集合中 2 举例 127.0.0.1:6379> SADD num1 123 456 789 (integer) 3 127.0.0.1:6379> SA
Java练习>ArrayList集合>>斗地主案例（无序排序版本）
越努力，越幸福！
08-02 674
案例介绍： 按照斗地主的规则，完成洗牌发牌的动作。 具体规则： 使用54张牌打乱顺序，三个玩家参与游戏，三者交替摸牌，每人1张牌，最后三张作留底牌 案例分析： 1. 准备洗牌 牌可以设计为一个ArrayList<String>，每个字符串为一张牌。 每张牌由花色数字两部分组成，我们可以使用花色集合与数字集合嵌套迭代完成每张牌的组装。 牌由Co...
OGSM绩效管理培训材料双份资料.pptx
07-12
OGSM绩效管理培训材料双份资料.pptx
CAD机械设计赛项单选题样题.docx
07-12
CAD机械设计赛项单选题样题
100款古风PPT (79).pptx
最新发布
07-12
【ppt素材】工作总结、商业计划书、述职报告、读书分享、家长会、主题班会、端午节、期末、夏至、中国风、卡通、小清新、岗位竞聘、公司介绍、读书分享、安全教育、文明礼仪、儿童故事、绘本、防溺水、夏季安全、科技风、商务、炫酷、企业培训、自我介绍、产品介绍、师德师风、班主任培训、神话故事、巴黎奥运会、世界献血者日、防范非法集资、3D快闪、毛玻璃、人工智能等等各种样式的ppt素材风格。 设计模板、图片素材、PPT模板、视频素材、办公文档、小报模板、表格模板、音效配乐、字体库。 广告设计：海报，易拉宝，展板，宣传单，宣传栏，画册，邀请函，优惠券，贺卡，文化墙，标语，制度，名片，舞台背景，广告牌，证书，明信片，菜单，折页，封面，节目单，门头，美陈，拱门，展架等。 电商设计：主图，直通车，详情页，PC端首页，移动端首页，钻展，优惠券，促销标签，店招，店铺公告等。 图片素材：PNG素材，背景素材，矢量素材，插画，元素，艺术字，UI设计等。 视频素材：AE模板，会声会影，PR模板，视频背景，实拍短片，音效配乐。 办公文档：工作汇报，毕业答辩，企业介绍，总结计划，教学课件，求职简历等PPT/WORD模板。
Java基础和Java进阶
10-16
除了集合和流，多线程也是Java进阶中重要的内容。Java提供了丰富的线程相关的类和接口，可以方便地编写多线程程序。多线程可以充分发挥多核处理器的优势，提高程序的执行效率。在多线程编程中，需要注意线程之间的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值