Java集合框架-3.Set

最新推荐文章于 2022-12-01 00:25:51 发布

董铠

最新推荐文章于 2022-12-01 00:25:51 发布

阅读量84

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/weixin_43203731/article/details/104995369

版权

Java 专栏收录该内容

48 篇文章 0 订阅

订阅专栏

List：有索引，有序（存和取一致），可以重复

Set：无索引，无序（存和取不一致），不可以重复

	public static void demo1() {
		HashSet<String> hs = new HashSet<String>();
		boolean b1 = hs.add("a");
		hs.add("b");
		hs.add("c");                   //存和取是没有顺序的
		boolean b2 = hs.add("a");      //当存储不成功的时候返回false,不可以重复
		
		System.out.println(b1);        //ture
		System.out.println(b2);        //false
		System.out.println(hs);
	}

public static void demo2() {
	HashSet<Person> hs = new HashSet<>();
	hs.add(new Person("张三",23));
	hs.add(new Person("张三",23));
	hs.add(new Person("李四",24));
	hs.add(new Person("李四",24));
	hs.add(new Person("王五",25));
	hs.add(new Person("王五",25));
	
	System.out.println(hs);         
	//输出不是唯一的，重复的都能输出（地址值是不同的），重写equals()方法也还是不行，再重写hashCode()就可以
}

//在Person类中重写
	@Override
	public boolean equals(Object obj) {
		Person p =(Person)obj;
		return this.name.equals(p.name) && this.age == p.age;
	}
	@Override
	public int hashCode() {
		// TODO Auto-generated method stub
		return 1;                     
		//直接让每一个对象的hashCode的值相同，hashCode值相同才调用equals()方法，所以就会清除相同的
	}


//以上重写方法是不恰当的，默认重写（Alt+Shift+s_h）
	@Override
	public boolean equals(Object obj) {
		if (this == obj)                //调用的对象和传入的对象是同一个对象
			return true;                //直接返回true
		if (obj == null)                //传入的对象为null
			return false;               //返回false
		if (getClass() != obj.getClass())  //调用对象字节码对象和传入对象对应的字节码对象不是同一个对象（两个类）
			return false;                //返回false
		Person other = (Person) obj;    //向下转型
		if (age != other.age)           //如果调用对象的age!=传入对象的age
			return false;               //返回false
		if (name == null) {             //如果调用对象属性为null
			if (other.name != null)     //而传入的对象属性不为null
				return false;           //返回false
		} else if (!name.equals(other.name))   //如果调用对象的name和传入对象的name不是同一个name
			return false;               //返回false
		return true;                    //最后返回true
	}
	@Override
	public int hashCode() {            //要让hashCode()每次都不同就不用调用equals()方法
		final int prime = 31;          //31是一个质数（只能和1和本身整除），31不大也不小，31是2^5-1好计算
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

Hashset保证元素唯一性原理：

哈希算法提高了去除重复的效率，只有hashCode()不同的时候才会调用equals()方法。如果没有hashCode()值相同的直接存入集合，equals（）方法返回值为false的存入集合

hashCode():属性相同的对象返回值必须相同，属性不同的对象返回值尽量不同。

equals():属性相同返回true,属性不同返回false,返回false存储

LinkedHashSet继承了HashSet，可以保证存储和提取顺序（和HashSet不同，因为底层是链表）

package day17;

import java.util.HashSet;
import java.util.Random;

public class Dk8Random {

	//获取10个1~20的随机数，要求随机数不能重复
	public static void main(String[] args) {
		HashSet<Integer> hs = new HashSet<Integer>();      
		//Integer重写了hashCode()和equals()方法就不会重复
		Random r = new Random();
		
		while (hs.size() < 10) {
			hs.add(r.nextInt(20) + 1);         //生成1~20的随机数
		}
		//可以用增强for循环和迭代器遍历
		System.out.println(hs);

	}

}
//输出
[17, 18, 19, 6, 7, 8, 9, 12, 13, 14]

package day17;

import java.util.LinkedHashSet;
import java.util.Scanner;

public class Dk9Filter {
	//使用Scanner录入一行输入，去掉重复字符
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		System.out.println("请输入字符串：");
		String line = input.nextLine();      //一行输入
		char[] arr = line.toCharArray();    //将字符串转成字符数组，char的包装类Character
		LinkedHashSet<Character> hs = new LinkedHashSet<>();
		//创建hashset集合对象
		for (char c : arr) {              //遍历字符数组，将字符添加到集合
			hs.add(c);                    //自动装箱
		}
		for (Character ch : hs) {         //遍历集合,自动拆箱
			System.out.println(ch);
		}
	}

}
//输出
请输入字符串：
aaabbbccc
a
b
c

package day17;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;

public class Dk91getSingle {

	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<>();
		list.add("a");
		list.add("d");
		list.add("f");
		list.add("c");
		list.add("b");
		list.add("a");
		list.add("a");
		list.add("c");
		list.add("e");
		list.add("b");
		getSingle(list);
		System.out.println(list);

	}
	//将集合中重复的元素去掉
	public static void getSingle(List<String> list) {
		LinkedHashSet<String> lhs = new LinkedHashSet<String>();
		lhs.addAll(list);             //将list中所有元素添加到lhs
		list.clear();                 //清空原集合
		list.addAll(lhs);             //将新的前加到list中
	}
}
//输出
[a, d, f, c, b, e]

TreeSet集合对元素进行排序在输出
在这里插入图片描述

重写compareTo()方法返回0时，只存放第一个（后面的比它大放右边，比它小放左边，但是都是0所以不存放）。
控制台只打印第一个

//类名要先实现Comparable接口
	@Override
	public int compareTo(Person o) {        //将年龄作为主要条件比较
		int num = this.age - o.age;
		return num == 0 ? this.name.compareTo(o.name) : num ;
	}

	@Override
	public int compareTo(Person o) {        //将姓名作为主要条件比较（根据中文的编码表值）
		int num = this.name.compareTo(o.name);
		return num == 0 ? this.age - o.age : num ;
	}
	@Override
	public int compareTo(Person o) {        //将姓名长度作为主要条件比较
		int num = this.name.length()- o.name.length();
		int num2 = num == 0 ? this.name.compareTo(o.name) : num;
		return num2 == 0 ? this.age - o.age : num2;
	}

package day17;

import java.util.Comparator;
import java.util.TreeSet;

public class Dk92TreeSetStr {

	//根据字符串长度比较,用TreeSet第三种构造方法,比较器
	public static void main(String[] args) {
		TreeSet<String> ts = new TreeSet<String>(new CompareByLen());
		ts.add("nba");
		ts.add("wnba");
		ts.add("cba");
		ts.add("baba");
		ts.add("nnnba");
		ts.add("nbaaaaa");
		ts.add("nbbbba");
		ts.add("ba");
		
		System.out.println(ts);
	}

}

class CompareByLen implements Comparator<String>{

	@Override
	public int compare(String s1, String s2) {
		int num = s1.length() - s2.length();
		return num == 0 ? s1.compareTo(s2) : num;  //先比较长度，再比较字典顺序，原理图如下
	}
	
}
//输出
[ba, cba, nba, baba, wnba, nnnba, nbbbba, nbaaaaa]

在这里插入图片描述
TreeSet原理：

自然顺序（Comparable）
1. TreeSet类的add()方法会把存入的对象提升为Comparable类型
2. 调用对象的compareTo()方法和集合中的对象比较
3. 根据compareTo()方法返回的结果存储
比较器顺序（Comparator）
1. 创建TreeSet对象的时候可以制定一个Comparator
2. 如果传入了Comparator的子类对象，那么TreeSet就会按照比较器的顺序排序
3. add()方法会自动调用Comparator接口中的compare()方法排序
两种方式的区别
1. TreeSet构造函数什么都不传，默认按照类中Comparable顺序（没有就报错ClassCastException）
2. TreeSet如果传入Comparator,就优先按照Comparator

package day17;

import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;

public class Dk93TreeSetScanner {

	//从键盘接受一个字符串，对其中所有字符进行排序,保留重复的
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		String str = input.nextLine();
		
		char[] arr = str.toCharArray();
		TreeSet<Character> ts = new TreeSet<Character>(new Comparator<Character>() {  //匿名内部类

			@Override
			public int compare(Character c1, Character c2) {
				int num = c1.compareTo(c2);
				//int num = c1 - c2;            //或者自动拆箱也可以
				return num == 0 ? 1 : num;      //保留重复的
			}
			
		});
		
		for (char c : arr) {
			ts.add(c);
		}
		
		for (Character c : ts) {
			System.out.print(c);
		}
	}

}
//输出
bfdasfaf
aabdfffs

package day17;

import java.util.ArrayList;
import java.util.Iterator;

public class Dk94Remove {

	//for循环、迭代器、for循环增强删除元素
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();
		list.add("a");
		list.add("b");
		list.add("b");
		list.add("c");
		list.add("d");
		list.add("e");
		
		for (int i = 0; i < list.size(); i++) {
			if (list.get(i).equals("b")) {
				list.remove(i--);             //for循环可以删除，但是要i--,如下图所示
			}
		}
		
		Iterator<String> it = list.iterator();
		while (it.hasNext()) {
			String temp = it.next();
			if (temp.equals("b")) {
				list.remove("b");             //不能用集合的删除方法，会报出并发修改异常
				it.remove();               //迭代器的方法可以用，内部做了一个i--的操作
			}
			
		}
		
		for (String s : list) {
			if(s.equals("b")) {
				list.remove("b");         //增强for循环不能删除，适合遍历
			}
		}

	}

}

在这里插入图片描述
当用equals()方法比较常量和变量时，用常量调用equals()方法，括号里写变量

董铠

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java集合框架-3.Set

List：有索引，有序（存和取一致），可以重复Set：无索引，无序（存和取不一致），不可以重复 public static void demo1() { HashSet<String> hs = new HashSet<String>(); boolean b1 = hs.add("a"); hs.add("b"); hs.add("c"); ...
复制链接

扫一扫