集合的笼统介绍之set（无序）

collection下的另一个集合接口set

它的hashset集合特点：①无序②无下标③不可存储重复

如何判断存储元素是重复HashSet集合，采用哈希表结构存储数据，保证元素唯一性的方式依赖于：hashCode()与equals()方法。

set最重要的一点就是哈希表，也就是hashset的存储数据结构(哈希表)

除此之外，它的创建对象，常用方法，遍历和collection几乎一致，一个案例表明一下。但我们需要注意，它是没有下标的，所以做不到list集合那样怎么存怎么取，唯一能够判断的也就是哈希值了。

    public static void main(String[] args) {
        //创建hashset对象。string类型的继承set接口的hashset集合，进行存储
        Set<String> set=new HashSet<String>();
        //给hastset添加自定义对象
        set.add("abc");
        set.add("bcd");
        set.add("abc");
        //遍历
        for(String s:set){
            System.out.println(s);
        }
    }

这里应证了，set集合不能存储重复元素，顺序随心情而定。

 

它默认的长度是16，哈希值是0.75，也就是说，当一次new16个长度集合，我们在存储到12时就需要再创建一个新的。

但是为什么能通过hashcode直接判断元素重复呢，也就是哈希表是个啥东西呢？

概念上来讲

package com.oracle.demo5;

public class Demo02 {
    public static void main(String[] args) {
        //调取hashcod方法来写哈希值。哈希值是整形
        int s1="abc".hashCode();
        int s2="abc".hashCode();
        int s3="bcd".hashCode();
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        //当我们向hashset存元素时，add方法先去调用集合存储的类型的类中的hashcode方法元素的哈希值
        //计算完哈希值，去容器中寻找是否有哈希值，
        //如果没有直接将改元素存入集合，如果有，则调用该类型的equals方法比较内容，如果内容不同，将该元素存入集合。
        //如果相同，则不存储该元素
    }

}

得出数字发现96354是一样的，所以去掉。

 它是如何判断的呢？

这里面有一个点就是如果哈希值一样，但是内容不同，通过equals方法比较不同后会仍然存入集合。如zzz

底层算法的流程，底层重写了hashcode方法，并将传进来的元素进行计算，得出数值。

以上是存储的集合中已经有的类，那么我们存储自定义类的时候，根据当时我们得知，自定义类系统是不给重写equals方法的，这里hashcode方法也不重写。

package com.oracle.demo5;

public class Person {
    private String name;
    private int age;
    
    
    public Person() {
        super();
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = 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;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    //重写hashcode
    /*public int hashCode(){
        //return super.hashCode();
        return name.hashCode()+age;
    }*/
//重写hashcode
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age*31;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    //重写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;
    }
}

测试类：

package com.oracle.demo5;
//自定义类，需要重写equals方法和hashcode方法
import java.util.HashSet;
import java.util.Set;

public class Demo03 {
    public static void main(String[] args) {
        Set<Person> set=new HashSet<Person>();
        //自定义类并没有重写hashcode和equals方法，需要我们自己重写
        set.add(new Person("司南",18));
        set.add(new Person("周戎",19));
        set.add(new Person("司南",18));
        //遍历
        for(Person s:set){
            System.out.println(s);
        }
    }
}

linkedlist  保证有序，唯一的不同

package com.oracle.demo5;
//LinkedHashSet与父类相比，只多了一个顺序是正常的
import java.util.LinkedHashSet;

public class Demo04 {
    public static void main(String[] args) {
        //创建int类型的LinkedHashSet集合
        LinkedHashSet<Integer> set=new LinkedHashSet<Integer>();
        set.add(1);
        set.add(2);
        //遍历
        for(Integer s:set){
            System.out.println(s);
        }
    }
}
输出顺序
1
2
顺序正常

 ASCII码

ASCII值	控制字符	ASCII值	控制字符	ASCII值	控制字符	ASCII值	控制字符
0	NUT	32	(space)	64	@	96	、
1	SOH	33	!	65	A	97	a
2	STX	34	"	66	B	98	b
3	ETX	35	#	67	C	99	c
4	EOT	36	$	68	D	100	d
5	ENQ	37	%	69	E	101	e
6	ACK	38	&	70	F	102	f
7	BEL	39	,	71	G	103	g
8	BS	40	(	72	H	104	h
9	HT	41	)	73	I	105	i
10	LF	42	*	74	J	106	j
11	VT	43	+	75	K	107	k
12	FF	44	,	76	L	108	l
13	CR	45	-	77	M	109	m
14	SO	46	.	78	N	110	n
15	SI	47	/	79	O	111	o
16	DLE	48	0	80	P	112	p
17	DCI	49	1	81	Q	113	q
18	DC2	50	2	82	R	114	r
19	DC3	51	3	83	S	115	s
20	DC4	52	4	84	T	116	t
21	NAK	53	5	85	U	117	u
22	SYN	54	6	86	V	118	v
23	TB	55	7	87	W	119	w
24	CAN	56	8	88	X	120	x
25	EM	57	9	89	Y	121	y
26	SUB	58	:	90	Z	122	z
27	ESC	59	;	91	[	123	{
28	FS	60	<	92	/	124	|
29	GS	61	=	93	]	125	}
30	RS	62	>	94	^	126	`
31	US	63	?	95	_	127	DEL

转载于:https://www.cnblogs.com/a199706/p/11361840.html