集合框架--set集合

集合框架

Set

1.set集合不能存放重复元素

• set集合中的元素是无序的

2.HashSet哈希表存储、重复元素存储底层探究

• list.contains:底层调用了equals方法
• set.add：底层调用了hashCode/equals

代码片

package com.lrc;

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

/**
 * 1.set集合不能存放重复元素
 * set集合中的元素是无序的
 * 2.HashSet哈希表存储、重复元素存储底层探究
 * list.contains:底层调用了equals方法
 * set.add：底层调用了hashCode/equals
 */

public class SetDemo {
	public static void main(String[] args) {
		//List l=new ArrayList<>();
		Set s=new HashSet<>();
		s.add(new Person("haohao",12,1200));
		s.add(new Person("shishi",17,1100));
		s.add(new Person("yanyan",14,2200));
		s.add(new Person("wanwan",23,3200));
		s.add(new Person("shishi",17,1100));
		System.out.println(s.size());
		Iterator it=s.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}
}

class Person{
	private String name;
	private int age;
	private int money;
	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;
	}
	public int getMoney() {
		return money;
	}
	public void setMoney(int money) {
		this.money = money;
	}
	public Person(String name, int age, int money) {
		super();
		this.name = name;
		this.age = age;
		this.money = money;
	}
	public Person() {
		super();
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", money=" + money + "]";
	}
	
	@Override
	public int hashCode() {
		System.out.println("hashcCode-----"+this.name);
		//每次返回的hashCode值不一样
		int co=this.name.hashCode()+this.age;
		System.out.println(co);
		return co;
	}
	
	@Override
	public boolean equals(Object obj) {
		Person p=(Person) obj;
		return this.name.equals(p.name) && this.age==p.age ;
	}
	
}

代码效果展示如下

@Override
	public int hashCode() {
		System.out.println("hashcCode-----");
		//每次返回的hashCode值不一样
		return super.hashCode();
	}
	
	@Override
	public boolean equals(Object obj) {
		System.out.println("equals----");
		return super.equals(obj);
	}

	因为每次返回的hashCode值不一样

@Override
	public int hashCode() {
		System.out.println("hashcCode-----");
		//每次返回的hashCode值不一样
		int co=super.hashCode();
		System.out.println(co);
		return 666;
	}

@Override
	public int hashCode() {
		System.out.println("hashcCode-----"+this.name);
		//每次返回的hashCode值不一样
		int co=this.name.hashCode()+this.age;
		System.out.println(co);
		return co;
	}

@Override
	public int hashCode() {
		System.out.println("hashcCode-----"+this.name);
		//每次返回的hashCode值不一样
		int co=this.name.hashCode()+this.age;
		System.out.println(co);
		return co;
	}
	
	@Override
	public boolean equals(Object obj) {
		Person p=(Person) obj;
		return this.name.equals(p.name) && this.age==p.age ;
	}

TreeSet

1、TreeSet自然排序
TreeSet可以对set集合中元素进行排序
2、TreeSet数据结构（二叉树）
可以对set集合进行排序，底层数据结构是二叉树；

代码片

package com.lrc;

import java.util.Iterator;
import java.util.TreeSet;

/**
 * 集合框架TreeSet（自然排序、数据结构二叉树、比较器排序）
 * treeSet容器是根据二叉树的排序规则对容器中的元素进行排序
 * 自然排序（元素自身具有比较性）
 */

public class TreeSetDemo {
	public static void main(String[] args) {
		TreeSet<Object> se=new TreeSet<>();
		se.add(new Person("haohao",12,1200));
		se.add(new Person("shishi",17,1100));
		se.add(new Person("yanyan",14,2200));
		se.add(new Person("wanwan",23,3200));
		se.add(new Person("shisi",13,1100));
		//System.out.println(se);
		Iterator it=se.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}
}

class Person implements Comparable<Person>{
	private String name;
	private int age;
	private int money;
	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;
	}
	public int getMoney() {
		return money;
	}
	public void setMoney(int money) {
		this.money = money;
	}
	public Person(String name, int age, int money) {
		super();
		this.name = name;
		this.age = age;
		this.money = money;
	}
	public Person() {
		super();
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", money=" + money + "]";
	}
	
	@Override
	public int hashCode() {
		System.out.println("hashcCode-----"+this.name);
		//每次返回的hashCode值不一样
		int co=this.name.hashCode()+this.age;
		System.out.println(co);
		return co;
	}
	
	@Override
	public boolean equals(Object obj) {
		Person p=(Person) obj;
		return this.name.equals(p.name) && this.age==p.age ;
	}
	/*
	 *让元素具备比较性
	 *注意：在做自然排序方法重写的时候，一定先判断主要条件，还要判断次要条件
	 */
	@Override
	public int compareTo(Person o) {
		int num=o.money-this.money;
		if(num==0) {
			return o.age-this.age;
		}
		return num;
	}
	
}

代码效果展示如下

TreeSet比较器排序

当元素自身不具备比较性时，或者具备的比较性不是所需要的；
注意：这时需要让集合自身具备比较性

在集合初始化时，就有了比较方式；

代码片

下面展示一些 内联代码片。

package com.lrc;

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

/**
 * 集合框架TreeSet（自然排序、数据结构二叉树、比较器排序）
 * treeSet容器是根据二叉树的排序规则对容器中的元素进行排序
 * 自然排序（元素自身具有比较性）
 * 比较器排序（应对世纪佳缘活动规则不断更新）
 */

public class TreeSetDemo {
	public static void main(String[] args) {
		//TreeSet<Object> se=new TreeSet<>();
		//TreeSet<Person> se=new TreeSet<>(new PersonAgeMoneyComp());
		TreeSet<Person> se=new TreeSet<>(new PersonMoneyAgeComp());
		se.add(new Person("haohao",12,1200));
		se.add(new Person("shishi",17,1100));
		se.add(new Person("yanyan",14,2200));
		se.add(new Person("wanwan",23,3200));
		se.add(new Person("shisi",13,1100));
		//System.out.println(se);
		Iterator it=se.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}
}
/*
 * age小，money多的规则
 */
class PersonAgeMoneyComp implements Comparator<Person>{
	@Override
	public int compare(Person o1, Person o2) {
		int num=o1.getAge()-o2.getAge();
		if(num==0) {
			return o2.getMoney()-o1.getMoney();
		}
		return num;
	}
}
//钱多，年龄小
class PersonMoneyAgeComp implements Comparator<Person>{
	@Override
	public int compare(Person o1, Person o2) {
		int num=o2.getMoney()-o1.getMoney();
		if(num==0) {
			return o1.getAge()-o2.getAge();
		}
		return num;
	}
}

class Person implements Comparable<Person>{
	private String name;
	private int age;
	private int money;
	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;
	}
	public int getMoney() {
		return money;
	}
	public void setMoney(int money) {
		this.money = money;
	}
	public Person(String name, int age, int money) {
		super();
		this.name = name;
		this.age = age;
		this.money = money;
	}
	public Person() {
		super();
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", money=" + money + "]";
	}
	
	@Override
	public int hashCode() {
		System.out.println("hashcCode-----"+this.name);
		//每次返回的hashCode值不一样
		int co=this.name.hashCode()+this.age;
		System.out.println(co);
		return co;
	}
	
	@Override
	public boolean equals(Object obj) {
		Person p=(Person) obj;
		return this.name.equals(p.name) && this.age==p.age ;
	}
	/*
	 *让元素具备比较性
	 *注意：在做自然排序方法重写的时候，一定先判断主要条件，还要判断次要条件
	 */
	@Override
	public int compareTo(Person o) {
		int num=o.money-this.money;
		if(num==0) {
			return o.age-this.age;
		}
		return num;
	}
	
}

代码效果展示如下

范型

代码片

package com.lrc;

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

/**
 * 范型：
 * 好处/为什么出现
 * 不适用范型的情况下，会将未知的错误表现在运行时期
 * 如果用代码处理了可能发现的错误，那么运行的时期，错误不会暴露出来
 * 好处：
 * 1.将运行期的异常转换成编译期的错误，让程序员更早的发现，从而解决代码隐患
 * 2.提高了代码的健壮性
 * 泛型类
 * 泛型接口
 * 泛型方法 
 */

public class FangDemo {
	public static void main(String[] args) {
		List l=new ArrayList();
		l.add(11);
		l.add(22);
		l.add(33);
		l.add(44);
		l.add(55);
		l.add("a");//可能会报转换错误，需要筛选判断
		Iterator it=l.iterator();
		while(it.hasNext()) {
			Object ob=it.next();
			if(ob instanceof Integer) {
				int n=(int) ob;
				if(n%2==0) {
					System.out.println(n);
				}
			}
			
		}
	}
	
	
}

代码效果展示如下