Set(HashSet、TreeSet)、泛型

最新推荐文章于 2022-03-11 21:24:39 发布
最新推荐文章于 2022-03-11 21:24:39 发布
阅读量349 收藏
点赞数 1
分类专栏： java基础 文章标签： java 语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a626361893/article/details/50539173
版权


一、set

Set:元素不可以重复，是无序。
Set接口中的方法和Collection一致。
      |--HashSet：内部数据结构是哈希表，是不同步的。
      |--TreeSet：可以对Set集合中的元素进行排序，是不同步的。

HashSet

       1.HashSet保证元素唯一性的方式 
                 HashSet通过元素的两个方法：hashCode()和equals来完成，如果元素的hashCode值相同，才会判断equals是否为true，如果元素的hashCode值不同，不会调用equals；

       2.存入到HashSet集合中的自定义对象，一般要复写hashCode和equals方法，这两个方法是集合底层自动调用的；


示例：


import java.util.*;

/*
	往hashSet集合中存入自定对象
	姓名和年龄相同为同一个人，重复元素。
*/
class HashSetTest 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		HashSet hs =  new HashSet();
		hs.add(new Person("a1",11));
		hs.add(new Person("a2",12));
		hs.add(new Person("a2",12));
		hs.add(new Person("a3",13));

		sop("a1:"+hs.contains(new Person("a2",12)));

		Iterator it = hs.iterator();
		while(it.hasNext())
		{
			Person p = (Person)it.next();
			sop(p.getName()+"::"+p.getAge());
		}

	}
}

class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	public int hashCode()
	{
		System.out.println(this.name+"....hashCode");
		return name.hashCode()+age*39;
	}
	public boolean equals(Object obj)
	{
		
		if(!(obj instanceof Person))
		{
			return false;
		}
		Person p = (Person)obj;
		System.out.println(this.name+"...."+p.name);
		return this.name.equals(p.name) && this.age ==p.age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}



哈希表确定元素是否相同
    

    1. 判断的是两个元素的哈希值是否相同。
       如果相同，再判断两个对象的内容是否相同。
    2. 判断哈希值相同，其实判断的是对象的HashCode方法。判断内容相同，用的是equals方法。

P.S.
    如果哈希值不同，不需要判断equals。


TreeSet

            1.TreeSet可以对set集合中的元素排序，底层数据结构是二叉树；

      2.TreeSet判断元素唯一性的方式：就是根据比较方法的返回结果是否是0，是0，就是相同元素，不存。


示例：


class  TreeSetDemo
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
			TreeSet ts = new TreeSet();

			ts.add(new Student("lisi02",22));
			ts.add(new Student("lisi007",20));
			ts.add(new Student("lisi09",19));
			ts.add(new Student("lisi01",19));

			Iterator it = ts.iterator();
			while(it.hasNext())
			{
				Student stu = (Student)it.next();
				sop(stu.getName()+"......"+stu.getAge());
			}

	}
}

class Student implements Comparable //该接口强制让学生具备比较性。
{
	private String name;
	private int age;
	Student(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	public int compareTo(Object obj)
	{
		if(!(obj instanceof Student))
			throw new RuntimeException("不是学生对象");
		Student s = (Student)obj;

		System.out.println(this.name+"..compareto...."+s.name);
		if(this.age>s.age)
			return 1;
		if(this.age ==s.age)
			return this.name.compareTo(s.name);
		return -1;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}

TreeSet排序的第一种方式：

让元素自身具备比较性。
元素需要实现Comparable接口，覆盖compareTo方法、这种方式也称为元素的自然顺序，或者叫做默认顺序。

TreeSet的第二种排序方式：
当元素自身不具备比较性时，或者具备的比较性不是所需要时。
这时就需要让集合自身具备比较性。
在集合初始化时，就有了比较方式。

PS:

          当元素自身不具备比较性，或者具备的比较性不是所需要的。
          这时需要让容器自身具备比较性。
          定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
          当两种排序都存在时，以比较器为主。
          定义一个类，实现Comparator接口，覆盖compare方法。


示例：

import java.util.*;

class TreeSetDemo2
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
			TreeSet ts = new TreeSet(new MyCompare());

			ts.add(new Student("lisi02",22));
			ts.add(new Student("lisi007",20));
			ts.add(new Student("lisi09",19));
			ts.add(new Student("lisi01",18));
			ts.add(new Student("lisi01",20));

			Iterator it = ts.iterator();
			while(it.hasNext())
			{
				Student stu = (Student)it.next();
				sop(stu.getName()+"......"+stu.getAge());
			}

	}
}
class Student implements Comparable //该接口强制让学生具备比较性。
{
	private String name;
	private int age;
	Student(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	public int compareTo(Object obj)
	{
		if(!(obj instanceof Student))
			throw new RuntimeException("不是学生对象");
		Student s = (Student)obj;

		//System.out.println(this.name+"..compareto...."+s.name);
		if(this.age>s.age)
			return 1;
		if(this.age ==s.age)
			return this.name.compareTo(s.name);
		return -1;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}
class MyCompare implements Comparator
{
	public int compare(Object o1,Object o2)
	{
		Student s1 = (Student)o1;
		Student s2 = (Student)o2;
		int num =  s1.getName().compareTo(s2.getName());

		if(num == 0)
		{
			if(s1.getAge()>s2.getAge())
				return 1;
			if(s1.getAge() == s2.getAge())
				return 0;
			
		}
		return -1;
	}
}


二、泛型

JDK1.5版本以后出现新特性。用于解决安全问题，是一个安全机制。


好处
      1.将运行时期出现的问题ClassCastException,转移到了编译时期。
         方便于程序员解决问题，让运行事情问题减少,安全，
      2.避免了强制转换麻烦。

泛型格式：通过<>来定义要操作的引用数据类型。

在使用java提供的对象时，什么时候写泛型呢？
        通常在集合框架中很常见。

        只要见到<>,就要定义泛型。
        其实<>就是用来接收类型的。
        当使用集合时，将集合中要存储的数据类型作为参数传递传递到<>即可。

示例：

import java.util.*;
class  GenericDemo
{
	public static void main(String[] args) 
	{
		
		ArrayList<String> a1 = new ArrayList<String>();

		a1.add("abc01");
		a1.add("abc01ss");
		a1.add("abc01dsfds");
		
		//a1.add(4);//a1.add(new Integer(4));

		Iterator<String> it  = a1.iterator();

		while(it.hasNext())
		{
			String s = it.next();

			System.out.println(s+":"+s.length());
		}
	}
}

泛型类


        1.类中要操作的引用数据类型不确定的时候，早起定义Object来完成扩展，现在定义泛型来完成扩展，例：

class Util<QQ>
{
    private QQ q;
    public void setObject(QQ q)
    {
        this.q=q;
    }
    public QQ getObject()
    {
        return q;
    }
}

        2.泛型类定义的泛型，在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了； 为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上，例：

class Demo<T>
{
    public void show(T t)
    {
        System.out.println("show:"+t);
    }
    public <Q> void print()
    {
        System.out.println("print:"+q);
    }
}

       3.特殊之处：
                  静态方法不可以访问类上定义的泛型。
                  如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。 

class Demo<T>
{
    public  void show(T t)
    {
        System.out.println("show:"+t);
    }
    public <Q> void print(Q q)
    {
        System.out.println("print:"+q);
    }
    public  static <W> void method(W t)
    {
        System.out.println("method:"+t);
    }
}
class GenericDemo4 
{
    public static void main(String[] args) 
    {
        Demo <String> d = new Demo<String>();
        d.show("haha");
        //d.show(4);
        d.print(5);
        d.print("hehe");
        Demo.method("hahahahha");
        /*
        Demo d = new Demo();
        d.show("haha");
        d.show(new Integer(4));
        d.print("heihei");
        Demo<Integer> d = new Demo<Integer>();
        d.show(new Integer(4));
        d.print("hah");
        Demo<String> d1 = new Demo<String>();
        d1.print("haha");
        d1.show(5);
        */
    }
}

        4.泛型定义在接口上

示例:

interface Inter<T>
{
	void show(T t);
} 

/*class InterImpl implements Inter<String>
{
	public void show(String t)
	{
		System.out.println("show:"+t);
	}
}
*/
class InterImpl<T> implements Inter<T>
{
	public void show(T t)
	{
		System.out.println("show:"+t);
	}
}
class  GenericDemo5
{
	public static void main(String[] args) 
	{
		InterImpl<Integer> i = new InterImpl<Integer>();
		i.show(4);
	}
}

         5.泛型的限定

                    泛型的限定：
                             ？ extends E：可以接收E类型或者E的子类型。上限。
                             ？ super E: 可以接收E类型或者E的父类型。

示例：

class  GenericDemo6
{
	public static void main(String[] args) 
	{
		/*
		ArrayList<String> a1 = new ArrayList<String>();

		a1.add("abc1");
		a1.add("abc2");
		a1.add("abc3");
		a1.add("abc4");

		ArrayList<Integer> a11 = new ArrayList<Integer>();
		a11.add(4);
		a11.add(7);
		a11.add(6);
		a11.add(8);
		
		printColl(a11);	
		printColl(a1);
		*/
		ArrayList<Person> a1  = new ArrayList<Person>();
		a1.add(new Person("abc1"));
		a1.add(new Person("abc2"));
		a1.add(new Person("abc3"));
		printColl(a1);

		ArrayList<Student> a11  = new ArrayList<Student>();
		a11.add(new Student("abc11"));
		a11.add(new Student("abc22"));
		a11.add(new Student("abc33"));
		printColl(a11);//ArrayList<String>a1 = new ArrayList<Person>();error

	}
	public static void printColl(ArrayList<? extends Person> a1)
	{
		Iterator<? extends Person> it = a1.iterator();//<?>占位符 ，不明确时
		while(it.hasNext())
		{
			System.out.println(it.next().getName());
		}
	}
	/*
	public static void printColl(ArrayList<?> a1)//ArrayList<String> a1 = new ArrayList<Integer>();error
	{
		Iterator<?> it = a1.iterator();//<?>占位符 ，不明确时
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}*/
}

class Person
{
	private String name;
	Person(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
}
class Student extends Person
{
	Student(String name)
	{
		super(name);
	}
}

class Student implements Comparable<Student>//<? super E>
{
	public int compareTo(Person s)
	{
		this.getName()	

	}
}

class Comp implements Comparator<Person>
{
	public int compare(Person s1, Person s2)
	{
		return s1.getName().compareTo(s2.getName());
	}
}


Done_boy
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HashSet<E>泛型类
chindroid
07-12 9546
HashSet泛型类在数据组织上类似于数学上的集合，可以进行“交”、“并”、“差”等运算。 1、HashSet对象 HashSet泛型类创建的对象称为集合，如： HashSet set = HashSet; 那么set就是一个可以存储 string 类型数据的集合，set 可以调用 add(String s) 方法将 string 类型的数据添加到集合中。添加到集合中的数据称为集合的元
java基础之-HashSet
m0_53224107的博客
05-19 1565
一、HashSet底层基础数据 HashSet的底层是基于的HashMap去实现的这个似乎没有什么可说的这个直接看HashSet的源码 public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable, java.io.Serializable { static final long serialVersionUID = -5024744406713321676L
java中的几种泛型类——HashSet、HashMap、TreeSet、TreeMap，遍历map，排序，HashTable比较
木羊的专栏
05-08 2766
HashSet HashSet泛型类在数据组织上类似于数学上的集合，可以进行“交”、“并”、“差”等运算。 HashSet泛型类创建的对象称为集合，如：     HashSet set =  HashSet();     那么set就是一个可以存储string类型数据的集合，set可以调用add(String s)方法将string类型的数据添加到集合中。添加到集合中的数据称为
TreeSet关于泛型的使用
雨安的BLOG
05-31 522
随机数组就是在指定长度的数组中用随机数字为每个元素赋值， 这常用于需要不确定数值的环境，如拼图游戏需要随机数来打乱图片的排序。 可是随机数的重复问题也同时存在。请运用TreeSet集合实现不重复的随机数的数列， 并完成元素的排序，然后输出数组。 /* 泛型关于TreeSet的应用 */ import java.util.*; public class Main { public stati...
集合与泛型：Java中Hashset方法总结
qq_45039784的博客
08-09 430
Set常用方法 1.add(Object obj)：向Set集合中添加元素，添加成功返回true，否则返回false 2. size() ：返回Set集合中的元素个数 3.remove(Object obj) ： 删除Set集合中的元素，删除成功返回true，否则返回false。 4.isEmpty() ：如果Set不包含元素，则返回 true ，否则返回false clear() ：...
实验七：Java集合与泛型
07-14
本次实验掌握了集合的概念、体系结构、分类及使用场景，了解了Set接口及主要实现类（HashSet、TreeSet）,了解了解List接口及主要实现类（ArrayList、LinkedList、Vector），掌握ArrayList的使用及其与Vector的区别，...
javaee笔试题-JavaExercise:Java学习的代码，包括设计模式、se、ee以及相关测试代码
06-03
HashSet TreeSet Map HashMap 泛型 Iterator 线程 反射 虚拟机 Java8 新特性 Java EE 源码 JUnit SpringSide Jive 论坛 框架 J2EE Development without EJB SpringMVC 视频 看透SpringMVC Spring Mybatis 计算机网络...
Java 基础核心总结 +经典算法大全.rar
11-08
ArrayList Vector LinkedList 类Stack HashSet TreeSet LinkedHashSet 类 PriorityQueue HashMap TreeMap 类 LinkedHashMap 类 Hashtable 类IdentityHashMap 类WeakHashMap 类 Collections 类集合实现类特征图 泛形 ...
实验05 Java集合.doc
06-27
2）了解Set接口及主要实现类（HashSet、TreeSet） 3）了解List接口及主要实现类（ArrayList、LinkedList、Vector） 4）了解Map接口及主要实现类（HashMap、TreeMap、HashTable） 二、实验内容及步骤 1、编写程序...
java8源码-JavaRobot:Java学习笔记，JavaLearningNote
06-04
泛型 Java NIO Buffer Channel Selector Java 8 Features 源码解读 String源码系列 List源码系列 ArrayList LinkedList CopyOnWriteArrayList Vector Map源码系列 HashMap LinkedHashMap ConcurrentHashMap TreeMap ...
HashSet,TreeSet,泛型
myloveprogrmming的博客
10-23 191
[1]HashSet import java.util.*; /* * Set:无序不可重复 * HashSet:线程不安全的，底层是哈希表 * TreeSet:线程不安全的，底层是二叉树 * * * HashSet:如何去重 * 原理:是在添加元素时，add()方法调用元素的hashCode()和equals方法实现去重，首先分别调用元素所属类的hashCode(...
HashSet、TreeSet和泛型的一些运用
阳某的博客
05-21 472
文章目录HashSetTreeSet泛型 HashSet HashSet的特点：数据结构是哈希表、元素是无序（存入和取出的顺序不一定一致），字符串元素不可以重复； 探究HashSet判断元素重复问题 原理：利用HashSet调用add方法的同时底层会自动调用HashCode()和equals()方法,重写两个方法,HashCode()比较的是内存地址，equals()比较的是元素内容 class ...
java创建TreeSet泛型集合_Java-（泛型，集合-Set,HashMap,异常处理）
weixin_39882317的博客
03-01 303
心得体会有时候上课认真听讲效率胜过课后自己花费大量时间再去学习，上课边听边有意识的整理笔记胜过课后去整理自己杂乱的笔记要来的轻松。如果自己在课上写代码的时候有意识的将代码模块化，课后再去整理就会轻松很多。一个好习惯的养成是长久的坚持。今日知识点1.泛型2.集合-Set(hashSet)3.TreeSet进行排序的两种办法4.HashMap的方法5.键值对的两种遍历方式6.异常处理具体操作1.泛型1...
HashSet、TreeSet及泛型
yangruijing1990的专栏
03-06 374
Set：无序（存入和取出的顺序不一定一致），不能重复，Set集合的功能和Collection是一致的 1、常见的子类： HashSet：底层数据结构是哈希表       HashSet是通过元素的两个方法，hashCode和equals来完    成，如果元素的HashCode值相同，才会判断equals是否为 true，如果元素的hashCode值不同，不会调用equals。 注意：对于
Java中集合的泛型(详解)
热门推荐
SuPrEeMm的博客
01-22 1万+
首先创建3个类 1个 Person类 1个Student类 1个Worker类 Person类中 写两个变量 姓名 年龄 写出构造方法 set/get方法 重写toString方法 Student类继承Person类 写出构造方法 Worker类先声明都不写 泛型: 表示集合中 保存的数据的类型 用集合来保存字符串 要写泛型
【Java】Set集合之HashSet
weixin_53972936的博客
03-11 3444
​ HashSet是Set接口的典型实现，大多数时候使用Set集合时就是使用这个实现类。HashSet按Hash算法来存储集合中的元素，因此具有很好的存取和查找性能。底层数据结构是哈希表。 ​
TreeSet＜E＞ 泛型类
静Yu的博客
01-26 387
TreeSet泛型类 1.TreeSet泛型类在java.util包中 2.TreeSet泛型类创建的对象称为树集 创建TreeSet泛型类对象 假设已经声明了学生类Student，可以创建学生树集 TreeSet tree=new TreeSet (); • tree可以存储Student对象的集合。 • tree可以调用 add(Student s) 将Student对象添加到树集中。 • TreeSet泛型类的其他常用方法，请自行 查阅Java API 以下源代码可以创建字符串树集，并且按照字典序升序
Set集合：HashSet、TreeSet、泛型
Tang Hui
07-25 1514
Set集合接口 Set集合的功能及函数和Collection是一致的 常见的子类: HashSet : 底层数据结构是Hash表，线程是非同步的。保证元素唯一性的原理：判断元素的hashcode值是否相同，如果相同，还会继续判断元素的equals方法是否为真。 TreeSet：可以对Set集合中的元素进行排序。实现Comparable接口后，对象才具有比较性
java set泛型_Java中的Set集合，泛型，可变参数
最新发布
05-26
Java中的Set集合是一种不允许重复元素的集合，常用的实现类有HashSet、TreeSet和LinkedHashSet等。其中，HashSet底层是由HashMap实现的，TreeSet底层是由TreeMap实现的，LinkedHashSet则是在HashSet基础上加入链表实现的。在使用Set集合时，我们可以通过泛型来指定集合中元素的类型，例如： ``` Set<String> set = new HashSet<>(); ``` 这样，我们就指定了这个Set集合中存储的元素类型为String类型。在添加元素时，如果添加的元素类型不符合泛型指定的类型，则会编译错误。 同时，Java中的Set集合也支持可变参数，我们可以使用以下方式来添加多个元素： ``` set.addAll("a", "b", "c"); ``` 这样就可以将a、b、c三个元素添加到set集合中。 需要注意的是，由于Set集合不允许重复元素，因此添加重复元素时会被忽略。另外，Set集合中的元素是无序的，因此无法通过下标来获取元素。如果需要按照一定顺序获取元素，则应该使用TreeSet，它可以根据元素的自然顺序或指定的比较器顺序进行排序。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值