1. 首页
  2. 文章中心
  3. Java进阶

Java进阶 -- Set集合

66 阅读 0 评论
我是靠谱客的博主 重要超短裙，最近开发中收集的这篇文章主要介绍Java进阶 -- Set集合，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

可变参数

  • 概念：方法参数列表中的参数个数不确定，就表示可变参数。
  • 可变参数的本质：数组。
  • 注意事项：方法的参数列表中只能有一个可变参数，并且可变参数只能在参数列表的末尾。
  • 语法格式: (数据类型…变量名)
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();
    }
}

最后

以上就是重要超短裙为你收集整理的Java进阶 -- Set集合的全部内容，希望文章能够帮你解决Java进阶 -- Set集合所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(44)

相关文章

集合进阶-----Collection单列：泛型
集合进阶-----Collection单列：泛型
Java进阶-01（集合、迭代器、泛型）                         集合、迭代器、泛型Collection迭代器泛型
Java进阶-01（集合、迭代器、泛型）                         集合、迭代器、泛型Collection迭代器泛型
javaSE--进阶八(泛型,二叉树)
javaSE--进阶八(泛型,二叉树)
JavaSE进阶07：泛型、Set集合、TreeSet、二叉树、红黑树系列文章目录
JavaSE进阶07：泛型、Set集合、TreeSet、二叉树、红黑树系列文章目录
Java进阶 -- Set集合
Java进阶 -- Set集合
回归java9-java进阶-泛型泛型
回归java9-java进阶-泛型泛型
Java进阶--Java中的泛型详解
Java进阶--Java中的泛型详解
Java进阶2（集合+泛型）
Java进阶2（集合+泛型）

评论列表共有 0 条评论

立即
投稿
返回
顶部