⚔疯狂输出⚔ collection中的Set方法

最新推荐文章于 2024-10-01 13:37:56 发布

福炁AisinGioro

最新推荐文章于 2024-10-01 13:37:56 发布

阅读量193

点赞数

文章标签： string c语言对象

本文链接：https://blog.csdn.net/qq_36390044/article/details/78860487

版权

Set集合的特点无序无下标无重复元素

创建一个HashSet 保存两个A 两个B 两个C
这三个值是怎么存的怎么取出来

public  static void main(String[]agrs){
//使用HashSet声明4一个对象
HashSet<String> hashSet = new HashSet()<>;
hashSet.add("A");
hashSet.add("A");
hashSet.add("B");
hashSet.add("B");
hashSet.add("C");
hashSet.add("C");

//使用增强for循环遍历数组
for(String sting : hashSet){
System.outprintln(String);
}
}

创建一个HastSet 保存这六个元素并且给这个集合遍历
比较两个元素的哈希值，如何两个元素Hash值相同的话
系统会默认帮我们调用equals方法去比较两个元素是否一样
如果一样就不存储删掉重复的相同的那个元素（这里会调用equals方法判断是不是相同的元素）
如果一样就存储保存到Set集合当中（Hash不同的时候系统会认为他是两个不同的元素就不会调用equals方法）

所以要注意了：在保存的时候先看Hash值如果Hash值相同就不会调用equals方法了

如果要是想减少调用equals方法那就要重写 HashCode（）方法和equals方法
下面我们换个题目来重写一下
题目：创建一个HashSet 保存五个人的名字年龄并遍历，认为年龄和姓名就是同一个人去掉重复的。
//先写一个人的类出来里面有名字年龄

public Person{
private String name；
pricate int age；
//无参的构造方法
public void Person（）{
}
//有参的构造方法
public int Person（String name，int age）{
 this.name= name；
 this.age = age；
}
set/get方法
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;
}
toString方法
public String toString() {
    return "Person [name=" + name + ", age=" + age + "]";

}
//下面我们就要重写HashCode方法
public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + age;
    result = prime * result + ((name == null) ? 0 : name.hashCode());
    return result;
}
    //写这么复杂就是为了让hashCode减少重复
    //少调用equals方法 提高了存储的效率。
    //为什么使用31
    //1.31是个质数  能被1和本身整数  减少公约数
    //2.31这个数  不大也不小 
下面我们重写equals方法
public boolean equals(Object obj) {
    //防御式判断   健壮性判断
    if (this == obj)  //两个对象的地址
        return true;  //说明是一个对象
    if (obj == null)  //有一个对象是空的
        return false; //两个对象不相同
    //判断两个对象是不是用同一个类  创建出来的
    if (getClass() != obj.getClass())
        return false;  //认为不是一个对象
    Person other = (Person) obj; //向下转型
    if (age != other.age)  //判断年龄  不同
        return false;
    if (name == null) {  //判断名字是否为空 
        if (other.name != null) //一个为空  一个不为空  说明不是一个对象
            return false;
    } else if (!name.equals(other.name))
        return false;  //名字不同则不是一个对象
    return true;   //前面都没走就说 和这个两个对象是两个相同的对象
}

public  static  void main(String[]agrs){
HashSet<Person> hashSet = new HashSet()<>;
hashSet.add(new Person("小明"，19));
hashSet.add(new Person("小王"，19));
hashSet.add(new Person("小张"，19));
hashSet.add(new Person("小红"，19));
hashSet.add(new Person("小紫"，19));
//使用增强for循环遍历
for(Person person:hashSet){

}
System.out.println(hashSet);
}

上面是hashSet方法的是如何存取元素的、以及hashSet的作用
下面我们来看下
LinkedHashSet 特点：通过它排序出来的元素是有序的
下面我们写一个简单的小程序
创建一个HashSet 保存两个A 两个B 两个C
看他是如何存取的
他继承HashSet所有的方法

public static  void mian (String[]agrs){
LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add("A");
linkedHashSet.add("A");
linkedHashSet.add("B");
linkedHashSet.add("B");
linkedHashSet.add("C");
linkedHashSet.add("C");
System.out.println(linkedHashSet);
}

我们写几个练习来巩固一下今天所学习的知识
题目1.编写一个程序获取10个1-20的随机数，要求不能重复

//思路
//去重-->往Set集合上琢磨
//去创建一个Set集合
//随机10个数
//把10个数  添加到集合中 integer  character
//当集合长度<10添加>=10 就不添加
LinkedHashSet<>linkedHashSet  = new LinkedHashSet<>();
for(i= 0;i<11;i++){
int num =(int)(Math.random()*(20-1+1)+1)
}
linkedHashSet.add(num)//自动装箱
System.out.println(n)；

//输入一个字符串去掉其中重复的字符，打印出不同的那些字符
//用LinkedHashSet 编写一段程序
//键盘中输入一个字符串
//获取字符串里字符的值
//去掉重复的值
//打印去重后的值

LinkedHashSet<Character>linkedHashSet = new linkedHashSet<>();
Scanner scanner  =  new Scanner(system.in);
String  string = scanner.next.Line();
for(i =0 ;i<string.length;i++){
LinkedHashSet.add（string.CharAt（i））；
}
System.out.println（LinkedHashSet）；

用set方法接收一个字符串然后去重打印去重后的值

//编写Set集合
//把接收过来的字符串  转成 字符数组
//遍历这个字符数组 把每一个字符 存入Set中
//打印set集合
System.out.println("请输入一串字符");
Scanner scanner = new Scanner(System.in);
String string = scanner.nextLine();
char[] charArray = string.toCharArray();
HashSet<Character> set = new HashSet<>();
for (int i = 0; i < charArray.length; i++) {
set.add(charArray[i]);
}
System.out.println(set);

利用set集合去除ArrayList集合中的重复元素(操作原ArrayList)

ArrayList<String> arraylist = new ArrayList<>();
arraylist.add("s");
arraylist.add("a");
arraylist.add("d");
arraylist.add("w");
arraylist.add("t");
//为了保存原来的顺序所以选取LinkedHashSet
LinkedHashSet<> linkedHashSet  = new LinkedHashSet<>();
//把arraylist中所有的元素加载到linkedHashSet中 去掉重复的
linkedHashSet.addALL(arraylist)；
linkedHashSet.clear（）；
linkedHashSet.addAll（linkedHashSet）；
System.out.println（arraylist）；

TreeSet
特点：排序去重
比较器

TreeSet<String>set = new TreeSet<>(new Comparatorimpl()){
        });
        set.add("sd");
        set.add("sdflk");
        set.add("sdqeg");
        set.add("sdsd");
        set.add("sadt");
        set.add("sds");
        set.add("s");
        for (String string : set) {
            System.out.println(string);
        }

比较重写接口中的compare方法

public class Comparatorimpl implements Comparator<String> {
      //主要按照字符串长度比较
     //次要按字符比较
    //比较器相当于TreeSet的存储规则
    @Override
    public int compare(String o1, String o2) {
    int length  = o1.length()-o2.length();
    int num = length == 0 ?o1.compareTo(o2):length;
    //如果字符串长度和字符都相同也需要把字符串都存进去
    //所以返回正数(1) 或 负数 (-1) (不返回0就可以)
        return num ==0 ? 1:num;
    }

}

在一个集合中存储了无序并且重复的字符串,
要求排序,而且还不能去除重复(用比较器)

ArrayList<String> arrayList  = new ArrayList<>();
        arrayList.add("dasd");
        arrayList.add("daadadasd");
        arrayList.add("asdasdasdasdsdasd");
        arrayList.add("daadadjasd");
        arrayList.add("asdasdassdasdasd");
        arrayList.add("daadajjjdasd");
        arrayList.add("adasdasdasdasd");    
        arrayList.add("dadasd");
        arrayList.add("asdaasdasdasdasd");
        TreeSet<String> Set = new TreeSet<>(new Comparatorimpl());
        //把arrayList塞进Set里
        Set.addAll(arrayList);
        //清空arrayList   
        arrayList.clear();
        //再把Set塞进arrayList里面
        arrayList.addAll(Set);
        for (String string : arrayList) {
        System.out.println(string);

比较器

public class Comparatorimpl implements Comparator<String> {
      //主要按照字符串长度比较
     //次要按字符比较
    //比较器相当于TreeSet的存储规则
    @Override
    public int compare(String o1, String o2) {
    int length  = o1.length()-o2.length();
    int num = length == 0 ?o1.compareTo(o2):length;
    //如果字符串长度和字符都相同也需要把字符串都存进去
    //所以返回正数(1) 或 负数 (-1) (不返回0就可以)
        return num ==0 ? 1:num;
    }

}

接收一个字符串，程序对其中所有字符进行排序
要求保留重复的

//从键盘输入一个值
System.out.println（"请输入一个字符串"）；
Scanner  scanner   = new Scanner.（system.in）；
String string = scanner.nextline（）；
//将接收的字符串转化为字符数组

福炁AisinGioro

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫