Java进阶-Java学习路线课程第二课：Java集合框架-HashSet的使用及去重原理

最新推荐文章于 2022-08-18 09:43:03 发布
置顶 最新推荐文章于 2022-08-18 09:43:03 发布
阅读量3.7k 收藏 39
点赞数 28
分类专栏： java学习路线 collection集合框架 HashCode的使用 文章标签： equals方法和hashCode方法的使用 equals的使用 hashCode方法的使用 Set去重 HashSet去重
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/atgfg/article/details/102774785
版权

本博客地址 | GitHub | 更多资源免费下载

        小伙伴们，大家早上好！今天我给大家带来Java集合框架Collection之Set集合讲解，今天主要讲解Set集合接口下的实现类HashSet集合，今天的讲解重要，请大家仔细看噢！

Java集合框架-HashSet的使用及去重原理

     前面我们已经学过了List集合（不熟悉List集合的小伙伴点击：Java进阶-Java学习路线课程第一课：Java集合框架-ArrayList和LinkedList的使用），相信大家对List集合有所了解了吧！List集合是有索引，有序和不唯一，那Set集合有什么特征呢？当然有它的特征，没有索引，无序和唯一。下面我们来一一讲讲，当然，重点会讲一下HashSet去重。

文章目录

1、首先，还是让大家看看一个简洁的Java集合框架结构体系图：
2、看看这些接口和类有什么特征。
  • Collection(接口)

特征（单列集合）：　不唯一，无序

  • List（子接口）

特征（单列集合）：　不唯一，有序

  • Set（子接口）

特征（单列集合）：　唯一，无序

  • Map（接口）

特征（双列集合）：　键值对

key --->value  map.put("userName",uName);
key是拿的Set的特性，而value是拿的Collection的特性。
  • HashSet

特征：底层由哈希表（实际上是一个 HashMap 实例）支持。它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用 null 元素。无索引，唯一，无序。最大的优势就是去重。

3、先给大家演示一下HashSet去重代码，能做到去重吗？代码如下：
News.java  实例类
package com.javaxyz.entity;

/**
 * @ClassName：News.java
 * @Description：新闻实例类
 * @Author：DongGaoYun
 * @AuthorEnglishName：Andy
 * @URL：www.javaxyz.com 或 www.gyun.org
 * @Email：DongGaoYun@qq.com
 * @QQ：1050968899
 * @WeiXin：QingYunJiao
 * @WeiXinGongZhongHao: JavaForum
 * @Date：2019-10-22 下午2:23:38
 * @Version：1.0 完成以下基本代码： 　1.属性 　2.get和set方法　 　3.构造方法 　4.toString
 * 说明
 　　1.这个新闻实例类没有重写equals和hashCode方法
 　　2.没有用泛型，后面章节会介绍 　
 */
public class News {
	//属性
	private int id;
	private String title;//标题
	private String author;//作者

	/**
	 * @return the id
	 */
	public int getId() {
		return id;
	}

	/**
	 * @param id
	 *            the id to set
	 */
	public void setId(int id) {
		this.id = id;
	}

	/**
	 * @return the title
	 */
	public String getTitle() {
		return title;
	}

	/**
	 * @param title
	 *            the title to set
	 */
	public void setTitle(String title) {
		this.title = title;
	}

	/**
	 * @return the author
	 */
	public String getAuthor() {
		return author;
	}

	/**
	 * @param author
	 *            the author to set
	 */
	public void setAuthor(String author) {
		this.author = author;
	}

	// toString
	@Override
	public String toString() {
		return "News [id=" + id + "," + " title=" + title + "," + " author="
				+ author + "]\n";
	}

	/**
	 * 无参构造方法
	 */
	public News() {
	}

	/**
	 * 有参构造方法
	 * @param id
	 * @param title
	 * @param author
	 */
	public News(int id, String title, String author) {
		super();
		this.id = id;
		this.title = title;
		this.author = author;
	}

}
4、测试代码：
package com.javaxyz.test;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import org.junit.Test;

import com.javaxyz.equals.News;

/**
 * @ClassName：HashSetDemo.java
 * @Description：Set的运用 
 * @Author：DongGaoYun
 * @AuthorEnglishName：Andy
 * @URL：www.javaxyz.com 或 www.gyun.org
 * @Email：DongGaoYun@qq.com
 * @QQ：1050968899
 * @WeiXin：QingYunJiao
 * @WeiXinGongZhongHao: JavaForum
 * @Date：2019-10-25 
 * @Version：1.0 HashSet　优势:　去重 特有功能：
 * 
 */
public class HashSetDemo1 {
	// 需求：
	// 增加新闻元素
	// 获取新闻总数
	// 操作HashSet容器，移除元素
	// 判断是否包含此元素
	// 打印输出四种方式
	
    //忽略警告
	@SuppressWarnings("all")
	// public static void main(String[] args) {
	@Test
	public void testSet() {

		// 创建对象
		// 创建多态的形式，要注意的点：只能调用父类与子类重写的方法，子类特有方法无法调用
		Set list = new HashSet();// 多态的形式。//1.父子关系　2.重写方法　3.父类的引用指向子类对象

		News news1 = new News(1, "张卓1", "green1");
		News news2 = new News(2, "张卓2", "green2");
		News news11 = new News(2, "张卓2", "green2");
		News news3 = new News(3, "张卓3", "green3");
		News news4 = new News(4, "张卓4", "green4");
		News news5 = new News(5, "张卓5", "green5");
		News news6 = new News(6, "张卓6", "green6");
		News news7 = new News(7, "张卓7", "green7");
		News news8 = new News(8, "张卓8", "green8");
		// 插入数据
		list.add(news1);
		list.add(news2);
		list.add(news3);
		// 注意set是无序的，没有索引，所以报错
		// list.add(1,news4);
		// 插入数据
		list.add(news6);
		list.add(news11);
		// 总条数
		System.out.println(list.size());

		// 操作HashSet容器，移除元素
		/*
		 * list.remove(0); list.remove(news1);
		 */
		// 判断是否包含此元素
		System.out.println(list.contains(news7));
		// list
		System.out.println("-------第一种打印输出方法---start----");
		System.out.print(list);
		System.out.println("-------第一种打印输出方法---end----");
		System.out.println();
		//System.out.println("-------第二种打印输出方法-普通for--start----");
		// 普通for不能用

		/*
		 * for (int i = 0; i < list.size(); i++) { News newss = (News)
		 * list.get(i); System.out.println("News [id=" + newss.getId() + "," +
		 * " title=" + newss.getTitle() + "," + " author=" + newss.getAuthor() +
		 * "]"); }
		 */

		//System.out.println("-------第二种打印输出方法---end----");
		System.out.println();
		System.out.println("-------第二种打印输出方法-增强for--start----");
		for (Object object : list) {
			News newss = (News) object;
			System.out.println("News [id=" + newss.getId() + "," + " title="
					+ newss.getTitle() + "," + " author=" + newss.getAuthor()
					+ "]");
		}
		System.out.println("-------第二种打印输出方法---end----");
		System.out.println();
		System.out.println("-------第三种打印输出方法-转换成数组--start----");
		/**
		 * toArray Object[] toArray() 返回包含此 collection 中所有元素的数组。如果 collection
		 * 对其迭代器返回的元素顺序做出了某些保证，那么此方法必须以相同的顺序返回这些元素。 返回的数组将是“安全的”，因为此 collection
		 * 并不维护对返回数组的任何引用。（换句话说，即使 collection
		 * 受到数组的支持，此方法也必须分配一个新的数组）。因此，调用者可以随意修改返回的数组。
		 * 
		 * 此方法充当了基于数组的 API 与基于 collection 的 API 之间的桥梁。
		 * 
		 * 返回： 包含此 collection 中所有元素的数组
		 */

		Object[] obj = list.toArray();
		for (Object object : obj) {
			News newss = (News) object;
			System.out.println("News [id=" + newss.getId() + "," + " title="
					+ newss.getTitle() + "," + " author=" + newss.getAuthor()
					+ "]");
		}

		System.out.println("-------第三种打印输出方法---end----");
		System.out.println();
		System.out.println("-------第四种打印输出方法-迭代方式--start----");
		/**
		 * iterator Iterator<E> iterator()
		 * 
		 * boolean hasNext() 如果仍有元素可以迭代，则返回 true。
		 * 
		 * E next() 返回迭代的下一个元素。
		 * 
		 * void remove() 从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。
		 */
		Iterator it = list.iterator();
		while (it.hasNext()) {
			News newss = (News) it.next();
			System.out.println("News [id=" + newss.getId() + "," + " title="
					+ newss.getTitle() + "," + " author=" + newss.getAuthor()
					+ "]");
		}
		System.out.println("-------第四种打印输出方法---end----");
	}
}
5、输出结果：
5
false
-------第一种打印输出方法---start----
[News [id=1, title=张卓1, author=green1]
, News [id=2, title=张卓2, author=green2]
, News [id=3, title=张卓3, author=green3]
, News [id=2, title=张卓2, author=green2]
, News [id=6, title=张卓6, author=green6]
]-------第一种打印输出方法---end----


-------第二种打印输出方法-增强for--start----
News [id=1, title=张卓1, author=green1]
News [id=2, title=张卓2, author=green2]
News [id=3, title=张卓3, author=green3]
News [id=2, title=张卓2, author=green2]
News [id=6, title=张卓6, author=green6]
-------第二种打印输出方法---end----

-------第三种打印输出方法-转换成数组--start----
News [id=1, title=张卓1, author=green1]
News [id=2, title=张卓2, author=green2]
News [id=3, title=张卓3, author=green3]
News [id=2, title=张卓2, author=green2]
News [id=6, title=张卓6, author=green6]
-------第三种打印输出方法---end----

-------第四种打印输出方法-迭代方式--start----
News [id=1, title=张卓1, author=green1]
News [id=2, title=张卓2, author=green2]
News [id=3, title=张卓3, author=green3]
News [id=2, title=张卓2, author=green2]
News [id=6, title=张卓6, author=green6]
-------第四种打印输出方法---end----
6、从上面的打印中可以看出：
  • Set的输出是无序的；
  • Set虽然说具有去重的功能，但是自定义对象增加到Set集合或HashSet集合中，还是有重复的对象，怎么办呢？有什么玄机呢？为什么没有去重呢？我们还是看看java的系统类String，我们在String类中把相同的对象增加进去会去重吗？我们来试试。具体代码如下：
public class HashSetDemo2_String {
	// 需求：
	// 增加新闻元素
	// 获取新闻总数
	// String类，如果在HashSet容器增加元素，如果增加的元素是相同的，就会去重。

	@SuppressWarnings("all")
	// public static void main(String[] args) {
	@Test
	public void testSet() {

		// 创建对象
		// 创建多态的形式，要注意的点：只能调用父类与子类重写的方法，子类特有方法无法调用
		// Set list=new HashSet();//多态的形式。//1.父子关系　2.重写方法　3.父类的引用指向子类对象

		HashSet list = new HashSet();
		String s1 = new String("abc");
		String s2 = new String("abc");
        String s3 = new String("abc");
		// 增加元素
		list.add(s1);
        // 注意：当向set集合中存储相同元素时，add(obj)方法返回的是false.
		list.add(s2);
        list.add(s3);
		// 获取元素总数
		System.out.println(list.size());
		System.out.println();
		//打印输出
		System.out.println(list);
	}
}
7、输出结果：
1

[abc]
8、很显然，java系统类在向Set或HashSet集合里增加元素时，已经完美的去重了。那我们就看看String类里重写了哪些方法，我们来借鉴一下！惊奇的发现了String重写Object超类中的两个方法：一个是equals方法（前面介绍过：Java入门-Java学习路线扩展课程：equals的使用），另一个是hashCode方法。源码如下：
  • 重写equals方法
public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String) anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}
  • 重写hashCode方法

public int hashCode() {
    int h = hash;
    if (h == 0 && value.length > 0) {
        char val[] = value;

        for (int i = 0; i < value.length; i++) {
            h = 31 * h + val[i];
        }
        hash = h;
    }
    return h;
}
9、原来如此，String类用属性value值作为底层数据来计算hashCode的，即相同的value就一定会有相同的哈希值。如果value值相同，那么调用equals方法比较也是相等的；反过来不一定成立。它不保证相同的哈希值一定就是相同的对象。
10、在Java中，String类有个别对象的属性值不同，但是哈希值相同，比如字符串"gdejicbegh"与字符串"hgebcijedg"具有相同的哈希值-801038016。代码如下：
		HashSet list = new HashSet();
		String s1 = new String("gdejicbegh");
		String s2 = new String("hgebcijedg");
		System.out.println(s1.hashCode()==s2.hashCode());
		System.out.println(s1.hashCode());
		System.out.println(s2.hashCode());
11、输出结果：
true
-801038016
-801038016
12、结论如下：
  • 如果equals比较后相等，则hashCode一定会相等。　　　更多免费资料请加微信公众号：javaforum
  • 如果hashCode的哈希值相等，equals就不一定相等，注意：它不保证相同的哈希值一定就是相同的对象。
13、小伙伴们是不是有种豁然开朗的感觉？我们来改造一下News.java类，改造代码如下：
package com.javaxyz.equals;

/**
 * @ClassName：News.java
 * @Description：描述信息
 * @Author：DongGaoYun
 * @AuthorEnglishName：Andy
 * @URL：www.javaxyz.com 或 www.gyun.org
 * @Email：DongGaoYun@qq.com
 * @QQ：1050968899
 * @WeiXin：QingYunJiao
 * @WeiXinGongZhongHao: JavaForum
 * @Date：2019-10-22 下午2:23:38
 * @Version：1.0 
 * 完成以下基本代码： 　1.属性 　2.get和set方法　 　3.构造方法 　4.toString
 * 重写Object的两个方法
 * 1.hashCode方法
 * 2.equals方法
 *  Set集合即可去重。
 * 
 */
public class News {
	// 属性
	private int id;
	private String title;// 标题
	private String author;// 作者

	/**
	 * @return the id
	 */
	public int getId() {
		return id;
	}

	/**
	 * @param id
	 *            the id to set
	 */
	public void setId(int id) {
		this.id = id;
	}

	/**
	 * @return the title
	 */
	public String getTitle() {
		return title;
	}

	/**
	 * @param title
	 *            the title to set
	 */
	public void setTitle(String title) {
		this.title = title;
	}

	/**
	 * @return the author
	 */
	public String getAuthor() {
		return author;
	}

	/**
	 * @param author
	 *            the author to set
	 */
	public void setAuthor(String author) {
		this.author = author;
	}

	// toString
	@Override
	public String toString() {
		return "News [id=" + id + "," + " title=" + title + "," + " author="
				+ author + "]\n";
	}

	/**
	 * 无参构造方法
	 */
	public News() {
	}

	/**
	 * 有参构造方法
	 * 
	 * @param id
	 * @param title
	 * @param author
	 */
	public News(int id, String title, String author) {
		super();
		this.id = id;
		this.title = title;
		this.author = author;
	}

	/* 
	 * 为什么把prime变量值初始化为31,有以下几个原因：更多免费资料请加微信公众号：javaforum
	 * 1.31这个数字不大也不太小
	 * 2.31是一个奇数，也是一个质数，即只能被1和本身整除的数。
	 * 3.如果选择偶数，乘2相当于移位运算可能导致溢出，数据会丢失
	 * 4.31有个很好的特性，就是用移位和减法来代替乘法，可以得到更好的性能：31*i==(i<<5)-i。现在的JVM可以自动完成这种优化。	 * 
	 */
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((author == null) ? 0 : author.hashCode());
		result = prime * result + id;
		result = prime * result + ((title == null) ? 0 : title.hashCode());
		System.out.println("执行的hashCode是："+result);
		return result;
	}

	/* 
	 * 在我的博文中已经讲过： Java入门-Java学习路线扩展课程：equals的使用　更多免费资料请加微信公众号：javaforum
	 */
	@Override
	public boolean equals(Object obj) {
		//提升效率　判断传入的对象与本对象是否是同一个对象
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())//比较两个对象的字节码文件是否是同一个字节码
			return false;
		News other = (News) obj;//向下转型
		if (author == null) {
			if (other.author != null)
				return false;
		} else if (!author.equals(other.author))
			return false;
		if (id != other.id)
			return false;
		if (title == null) {
			if (other.title != null)
				return false;
		} else if (!title.equals(other.title))
			return false;
		return true;
	}
}
14、测试代码：
package com.javaxyz.test;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import org.junit.Test;

import com.javaxyz.equals.News;

/**
 * @ClassName：HashSetDemo.java
 * @Description：Set的运用 
 * @Author：DongGaoYun
 * @AuthorEnglishName：Andy
 * @URL：www.javaxyz.com 或 www.gyun.org
 * @Email：DongGaoYun@qq.com
 * @QQ：1050968899
 * @WeiXin：QingYunJiao
 * @WeiXinGongZhongHao: JavaForum
 * @Date：2019-10-25 
 * @Version：1.0 HashSet　优势:　去重 特有功能：
 * 
 */
public class HashSetDemo1 {
	// 需求：
	// 增加新闻元素
	// 获取新闻总数
	// 操作HashSet容器，移除元素
	// 判断是否包含此元素
	// 打印输出四种方式
	// String类，如果在HashSet容器增加元素，如果增加的元素是相同的，就会去重。

	@SuppressWarnings("all")
	// public static void main(String[] args) {
	@Test
	public void testSet() {

		// 创建对象
		// 创建多态的形式，要注意的点：只能调用父类与子类重写的方法，子类特有方法无法调用
		Set list = new HashSet();// 多态的形式。//1.父子关系　2.重写方法　3.父类的引用指向子类对象
		String s1 = new String("gdejicbegh");
		String s2 = new String("hgebcijedg");
		System.out.println(s1.hashCode()==s2.hashCode());
		System.out.println(s1.hashCode());
		System.out.println(s2.hashCode());
		// list.add(s1);
		// list.add(s2);
		//System.out.println(list.size());
		
		
		
		
		News news1 = new News(1, "张卓1", "green1");
		News news2 = new News(2, "张卓2", "green2");
		News news11 = new News(2, "张卓2", "green2");
		News news3 = new News(3, "张卓3", "green3");
		News news4 = new News(4, "张卓4", "green4");
		News news5 = new News(5, "张卓5", "green5");
		News news6 = new News(6, "张卓6", "green6");
		News news7 = new News(7, "张卓7", "green7");
		News news8 = new News(8, "张卓8", "green8");
		// 插入数据
		list.add(news1);
		list.add(news2);
		list.add(news3);
		// 注意set是无序的，没有索引，所以报错             更多免费资料请加微信公众号：javaforum
		// list.add(1,news4);
		// 插入数据
		list.add(news6);
		//注意:自定义对象重写equals和hashCode方法后，如果是重复元素，这时就会返回false
		System.out.println(list.add(news11));
		// 总条数
		System.out.println(list.size());

		// 操作HashSet容器，移除元素
		/*
		 * list.remove(0); list.remove(news1);
		 */
		// 判断是否包含此元素
		System.out.println(list.contains(news7));
		// list
		System.out.println("-------第一种打印输出方法---start----");
		System.out.print(list);
		System.out.println("-------第一种打印输出方法---end----");
		System.out.println();
		//System.out.println("-------第二种打印输出方法-普通for--start----");
		// 普通for不能用

		/*
		 * for (int i = 0; i < list.size(); i++) { News newss = (News)
		 * list.get(i); System.out.println("News [id=" + newss.getId() + "," +
		 * " title=" + newss.getTitle() + "," + " author=" + newss.getAuthor() +
		 * "]"); }
		 */

		//System.out.println("-------第二种打印输出方法---end----");
		System.out.println();
		System.out.println("-------第二种打印输出方法-增强for--start----");
		for (Object object : list) {
			News newss = (News) object;
			System.out.println("News [id=" + newss.getId() + "," + " title="
					+ newss.getTitle() + "," + " author=" + newss.getAuthor()
					+ "]");
		}
		System.out.println("-------第二种打印输出方法---end----");
		System.out.println();
		System.out.println("-------第三种打印输出方法-转换成数组--start----");
		/**
		 * toArray Object[] toArray() 返回包含此 collection 中所有元素的数组。如果 collection
		 * 对其迭代器返回的元素顺序做出了某些保证，那么此方法必须以相同的顺序返回这些元素。 返回的数组将是“安全的”，因为此 collection
		 * 并不维护对返回数组的任何引用。（换句话说，即使 collection
		 * 受到数组的支持，此方法也必须分配一个新的数组）。因此，调用者可以随意修改返回的数组。
		 * 
		 * 此方法充当了基于数组的 API 与基于 collection 的 API 之间的桥梁。
		 * 
		 * 返回： 包含此 collection 中所有元素的数组                                  更多免费资料请加微信公众号：javaforum
		 */

		Object[] obj = list.toArray();
		for (Object object : obj) {
			News newss = (News) object;
			System.out.println("News [id=" + newss.getId() + "," + " title="
					+ newss.getTitle() + "," + " author=" + newss.getAuthor()
					+ "]");
		}

		System.out.println("-------第三种打印输出方法---end----");
		System.out.println();
		System.out.println("-------第四种打印输出方法-迭代方式--start----");
		/**
		 * iterator Iterator<E> iterator()
		 * 
		 * boolean hasNext() 如果仍有元素可以迭代，则返回 true。
		 * 
		 * E next() 返回迭代的下一个元素。                          更多免费资料请加微信公众号：javaforum
		 * 
		 * void remove() 从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。
		 */
		Iterator it = list.iterator();
		while (it.hasNext()) {
			News newss = (News) it.next();
			System.out.println("News [id=" + newss.getId() + "," + " title="
					+ newss.getTitle() + "," + " author=" + newss.getAuthor()
					+ "]");
		}
		System.out.println("-------第四种打印输出方法---end----");
	}
}
15、输出结果：
true
-801038016
-801038016
false
4
false
-------第一种打印输出方法---start----
[News [id=1, title=张卓1, author=green1]
, News [id=2, title=张卓2, author=green2]
, News [id=6, title=张卓6, author=green6]
, News [id=3, title=张卓3, author=green3]
]-------第一种打印输出方法---end----


-------第二种打印输出方法-增强for--start----
News [id=1, title=张卓1, author=green1]
News [id=2, title=张卓2, author=green2]
News [id=6, title=张卓6, author=green6]
News [id=3, title=张卓3, author=green3]
-------第二种打印输出方法---end----

-------第三种打印输出方法-转换成数组--start----
News [id=1, title=张卓1, author=green1]
News [id=2, title=张卓2, author=green2]
News [id=6, title=张卓6, author=green6]
News [id=3, title=张卓3, author=green3]
-------第三种打印输出方法---end----

-------第四种打印输出方法-迭代方式--start----
News [id=1, title=张卓1, author=green1]
News [id=2, title=张卓2, author=green2]
News [id=6, title=张卓6, author=green6]
News [id=3, title=张卓3, author=green3]
-------第四种打印输出方法---end----

16、由此可见，要想将自定义类的对象存入HashSet集合里去重，需要注意以下三点：

  • 自定义类中必须同时重写equals()和hashCode()方法
  • hashCode(): 属性值相同的对象返回值必须相同, 属性值不同的返回值尽量不同(提高效率)
  • equals(): 属性值相同返回true, 属性值不同返回false,返回false的时候存储
17、HashSet去重原理：
17.1、使用HashSet集合调用add()方法存储对象之前，应该注意尽量使重写的hashCode()方法返回的值不同，减少调用equals方法，提升性能；在调用add方法时，系统会先调用对象的hashCode（）方法得到一个哈希值, 然后在HashSet集合中比较是否有哈希值相同的对象
  • 如果没有哈希值相同的对象就会直接存入HashSet集合
  • 如果有哈希值相同的对象, 就和哈希值相同的对象逐个调用equals()方法进行比较,结果为false就直接存入, 为true则不存
       小伙伴们，本章已经结束，你们都懂了吗？我花了四个小时的时间编写，记得关注、点赞、分享和关注微信公众号（javaforum）噢！有疑问或好的建议请与我联系噢！持续更新！敬请关注！

———— 精　选　文　章 ————
  1. Java入门-Java学习路线课程第一课：初识JAVA
  2. Java入门-Java学习路线课程第二课：变量与数据类型
  3. Java入门-Java学习路线课程第三课：选择结构
  4. Java入门-Java学习路线课程第四课：循环结构
  5. Java入门-Java学习路线课程第五课：一维数组
  6. Java入门-Java学习路线课程第六课：二维数组
  7. Java入门-Java学习路线课程第七课：类和对象
  8. Java入门-Java学习路线课程第八课：方法和方法重载
  9. Java入门-Java学习路线扩展课程：equals的使用
  10. Java入门-Java学习路线课程面试篇：取商　/　和取余(模)　%　符号的使用
  11. Java进阶-Java学习路线课程第一课：Java集合框架-ArrayList和LinkedList的使用
  12. Spring框架-Java学习路线课程第一课：Spring核心
  13. Spring框架-Java学习路线课程：Spring的扩展配置
  14. Springboot框架-Java学习路线课程：Springboot框架的搭建之maven的配置
  15. java学习：在给学生演示用Myeclipse10.7.1工具生成War时，意外报错：SECURITY: INTEGRITY CHECK ERROR
  16. 使用jquery发送Ajax请求的几种异步刷新方式
  17. idea Springboot启动时内嵌tomcat报错- An incompatible version [1.1.33] of the APR based Apache Tomcat Native
  18. 一个简单的SSM框架Demo(登录(包含拦截器)和注销

更多免费资源请关注微信公众号：

青云交
关注
  • 28
    点赞
  • 踩
  • 39
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
通过实例学习Java集合框架HashSet
08-25
主要介绍了通过实例学习Java集合框架HashSet,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java用hashset去重_java基础：去重2（HashSet对象集合）
weixin_32747681的博客
02-24 723
HashSet：底层是哈希表，线程不安全首先要明白HashSet是如何实现去重的：HashSet内部默认对String类型的集合进行去重，它的原理很简单就是通过调用元素内部的hashCode和equals方法实现去重1、首先调用hashCode方法，比较两个的哈希值，如果哈希值不同，直接认为是两个对象，停止比较2、如果哈希值相同，再去调用equals方法，若判断返回true，认为是同一个对象，返回...
java中HashSet去重的方法
qq_42676052的博客
08-16 5865
package day8_15; import java.util.HashSet; import java.util.Set; class Employee{ private int no ; private String name; public Employee() { super(); } public Employee(int no, String name) { s...
Java中HashSet如何进行去重操作呢？
qq_25073223的博客
08-18 1979
Java中HashSet进行去重操作的方法分享
Java中HashSet去重的实现原理
卡多希y的博客
07-08 1419
HashSet作为Set接口的实现类，它的底层还是基于HashMap来创建的。而HashSet拥有两个特点：1、插入元素的顺序和输出元素顺序与HashSet中的位置不一致。2、HashSet可以保证集合中的元素唯一。这篇文章主要针对HashSet的这个特点来详细讲解HashSet是如何在底层进行去重的。那么HashSet是如何去重的呢？当我们在一个HashSet的对象中添加元素时，首先计算该元素的hashCode是否与HashSet中元素的hashCode相同，如果不相同，则直接添加到HashSet之中；如
【Java基础】HashSet去重原理
Elephant_King的博客
01-08 1803
关于HashSet的概念，参考这篇文章 1.Java中HashSet使用散列表实现的，散列表的默认大小为16，加载因子为0.75 在这里的加载因子是代表Hash表中的元素填满的程度，加载因子0.75代表当HashSet中元素达到总容量的75%就要对HashSet进行扩充了 加载因子越大，填满的元素越多，空间率用率越高，但是冲突的机会增加了，查找成本越大，查找时间越长 加载因子越小，填满的元素越少，空间利用率越低，但是冲突的机会减少了，查找成本越小，查找...
java集合-HashSet的使用
最新发布
06-14
HashSet 是 Java 中的一个集合类，它实现了 Set 接口并提供了基于哈希表的无序、不重复元素的集合。具体来说，它是通过哈希表（实际上是一个 HashMap 实例）来存储元素的。 以下是 HashSet 的一些主要特点： 无序...
Java高级程序设计：第7章-集合框架.pptx
05-26
掌握Java集合框架中的三大类集合的特征和适用场合 掌握ArrayList类的使用 掌握HashMap类的使用 了解HashSet类的使用 掌握Collections类的使用 了解集合框架中的其它集合类 集合框架(Collection Framework) java.util...
Java中List集合对象去重及按属性去重的8种方法
09-08
主要介绍了Java中List集合对象去重及按属性去重的8种方法,本文给大家介绍的非常详细，对大家的学习或工作具有一地的参考借鉴价值，需要的朋友可以参考下
java-immutable-collections：Java的高效ImmutablePersistent集合
02-15
Java的不可变集合 概述 Java库的不可变集合（JImmutable Collections）是一组高性能的不可变集合，用于替换或补充标准的java.util集合。 为每个最常用的集合提供功能替换： Java类 JImmutable接口 工厂方法 数组...
HashSet去重
07-27
简述了HashSet去重原理
java中HashSet的去重以及容量扩增原理
weixin_33895604的博客
07-11 378
为什么80%的码农都做不了架构师？>>> ...
Java之HashSet除重原理
一名小白的进阶之路
01-22 2681
HashSet的除重原理：先判断HashCode方法，后判断equals方法，若两者同时返回true则认为对象与集合中对象重复，若HashCode返回false则不再执行equals。 HashCode方法：根据一套特殊的计算方法返回一个整形值，此值被HashSet用来定位对象的存储地址。 equals方法：判断两个对象的内容是否相等。 除重判断流程：HashSet会将新增对象与集合中的每一...
java hashset去重原理
Cris
02-27 4887
Java中的set是一个不包含重复元素的集合，确切地说，是不包含e1.equals(e2)的元素对。Set中允许添加null。Set不能保证集合里元素的顺序。 在往set中添加元素时，如果指定元素不存在，则添加成功。也就是说，如果set中不存在(e==null ? e...
Set 不重复实现原理
热门推荐
小武的专栏
11-26 1万+
Java中的set是一个不包含重复元素的集合，确切地说，是不包含e1.equals(e2)的元素对。Set中允许添加null。Set不能保证集合里元素的顺序。 在往set中添加元素时，如果指定元素不存在，则添加成功。也就是说，如果set中不存在(e==null ? e1==nu
java 利用HashSet去重并保持排序
z446372168的博客
03-29 8139
java 利用HashSet去重并保持排序 @(技能提升)[Java, 排序,ArrayList,HashSet] java 利用HashSet去重并保持排序 1.去重 2.保持排序 1.去重 在java中 对arrayList 去重, 最便利的方式即利用HashSet的不可重复特性,直接去重: List&lt;Result&gt; resultList ...
Java进阶-Java学习路线课程第一课：Java集合框架-ArrayList和LinkedList的使用
atgfg的博客
10-22 4064
本博客地址 | GitHub | 小站坐坐 | 更多资源免费下载         小伙伴们，大家晚上好！今天我给大家带来Java集合框架Collection之List讲解，今天主要讲解List接口下的两个实现类ArrayList和LinkedList，今天的讲解重要，请大家仔细看噢！ Java集合框架-ArrayList和L...
Java入门-Java学习路线扩展课程：equals的使用
atgfg的博客
10-16 2788
本博客地址 | 小站坐坐 | 更多资源免费下载         各位小伙伴，大家晚上好！今天我给大家带来equals的使用，主要从两个方面去讲解：第一种，就是系统提供的类使用equals方法进行比较，另一种就是自定义类使用equals方法进行比较。希望大家喜欢。 JavaSE equals方法的使用 文章目录&nbs...
第1关:学习-Java集合类之Set的HashSet之常用方法的使用
03-27
Java中的Set接口是一种不允许重复元素的集合，其中的元素没有特定的顺序。HashSet是Set接口的一个实现类，使用哈希表来存储元素，具有快速的查找和插入性能。 HashSet的常用方法如下： 1. 添加元素：add(Object ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值