集合框架
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);
}
}
}
}
}
代码效果展示如下