集合框架set集合框架(HashSet哈希表存储、重复元素存储底层探究)
set集合不能存放重复元素
字符串、八大基本数据类型 set集合中的元素是无序的
代码如下:
package com.denghaijian.set;
import java.util.HashSet;
import java.util.Set;
public class SetDemo {
public static void main(String[]{
Set set=new HashSet<>();
set.add("a1");
set.add("c3");
set.add("b2");
set.add("d4");
set.add("a1");
System.out.println(set.size());
}
}
运行结果:
运行结果为:4
可以看出set集合里面可以去重复元素
但是set集合里去重复限制于字符串和八大基本数据类型
代码如下:
package com.denghaijian.set;
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
* @author 10237
*
*/
public class SetDemo {
public static void main(String[] args) {
// List list=new ArrayList<>();
Set set=new HashSet<>();
set.add(new person("a1",18,1500));
set.add(new person("c3",23,500));
set.add(new person("b2",19,1200));
set.add(new person("d4",22,2500));
set.add(new person("a1",18,1500));
System.out.println(set.size());//打印数量
Iterator it= set.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;
}
@Override
public String toString() {
return "person [name=" + name + ", age=" + age + ", money=" + money + "]";
}
public person(String name, int age, int money) {
super();
this.name = name;
this.age = age;
this.money = money;
}
public person() {
}
}
打印结果:
set集合是无序的
set集合去重复只能对于字符串和八大基本数据类型
HashSet哈希表存储,重复元素存储底层探究
代码如下:
package com.denghaijian.set;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
public class SetDemo {
public static void main(String[] args) {
// List list=new ArrayList<>();
Set set=new HashSet<>();
set.add(new person("a1",18,1500));
set.add(new person("c3",23,500));
set.add(new person("b2",19,1200));
set.add(new person("d4",22,2500));
set.add(new person("a1",18,1500));
System.out.println(set.size());
Iterator it= set.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;
}
@Override
public String toString() {
return "person [name=" + name + ", age=" + age + ", money=" + money + "]";
}
public person(String name, int age, int money) {
super();
this.name = name;
this.age = age;
this.money = money;
}
public person() {}
@Override
public int hashCode() {
System.out.println("hashCode----"+this.name);
int code= this.name.hashCode()+this.age;
System.out.println(code);
return this.name.hashCode()+this.age;
}
@Override
public boolean equals(Object obj) {
person p=(person) obj;
return this.name.equals(p.name) &&this.age==p.age;
}
}
运行结果:
集合框架TreeSet(自然排序,数据结构二叉树,比较器排序)
代码如下:
TreeSet set=new TreeSet<>();
set.add(25);
set.add(55);
set.add(31);
set.add(28);
System.out.println(set);
运行结果:
数据结构二叉树和比较器排序
- teeSet容器是根据二叉树的排序规则堆容器中的元素进行排序的 自然排序(元素自身具有比较性)
数据结构二叉树
代码如下:
package com.denghaijian.set;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
/**
* 2.集合框架TreeSet(自然排序,数据结构二叉树,比较器排序)
* treeSet容器是根据二叉树的排序规则堆容器中的元素进行排序的 自然排序(元素自身具有比较性)
* java.lang.ClassCastException:
* com.denghaijian.set.person cannot be cast to java.lang.Comparable
*
* a.自然排序
* b.比较器排序
*
* @author 10237
*
*/
public class TreeSetTest {
public static void main(String[] args) {
TreeSet<person> set=new TreeSet<>(new personMoneyAgeComp());
set.add(new person("a1",18,8500));
set.add(new person("c3",23,500));
set.add(new person("f5",23,1000));
set.add(new person("b2",19,1200));
set.add(new person("d4",22,2500));
set.add(new person("a11",88,8500));
// System.out.println(set);
Iterator it= set.iterator();
while(it.hasNext()) {
System.out.println(it.next()); }
}
}
//定义Person类
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;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", 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 int hashCode() {
System.out.println("hashCode---------"+this.name);
int code=this.name.hashCode()+this.age;
System.out.println(code);
return code;
}
@Override
public boolean equals(Object obj) {
System.out.println("equals---");
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.denghaijian.set;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
/**
* 2.集合框架TreeSet(自然排序,数据结构二叉树,比较器排序)
* treeSet容器是根据二叉树的排序规则堆容器中的元素进行排序的 自然排序(元素自身具有比较性)
* java.lang.ClassCastException:
* com.denghaijian.set.person cannot be cast to java.lang.Comparable
*
* a.自然排序
* b.比较器排序
*
* @author 10237
*
*/
public class TreeSetDemo {
public static void main(String[] args) {
// TreeSet<Object> set=new TreeSet<>();
// TreeSet<person> set=new TreeSet<>(new personAgeMoneyComp());
TreeSet<person> set=new TreeSet<>(new personMoneyAgeComp());
set.add(new person("a1",18,8500));
set.add(new person("c3",23,500));
set.add(new person("f5",23,1000));
set.add(new person("b2",19,1200));
set.add(new person("d4",22,2500));
set.add(new person("a11",88,8500));
// System.out.println(set);
Iterator it= set.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}
/**
* 按age排序并且money值大
* @author 10237
*
*/
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;
}
}
/**
* 按money值排序,并且age值小
* @author 10237
*
*/
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;
}
@Override
public String toString() {
return "person [name=" + name + ", age=" + age + ", money=" + money + "]";
}
public person(String name, int age, int money) {
super();
this.name = name;
this.age = age;
this.money = money;
}
public person() {}
@Override
public int hashCode() {
System.out.println("hashCode----"+this.name);
int code= this.name.hashCode()+this.age;
System.out.println(code);
return this.name.hashCode()+this.age;
}
@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.denghaijian.set;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* 泛型 有什么好处,为什么出现
* 不使用泛型的情况下,会将未知的错误表现在运行时期
* 如果说用代码去处理了,这俄格可能发现的错误,那么运行时期的错误就不会暴露出来
*
*
* 1.将运行时期的异常转换成编译期的错误,让程序员更早的发现,从而解决代码的隐患
* 2.提高了代码的健壮性
* 泛型类 泛型接口 泛型方法
* 对于编码而言有什么更深层次的好处?
*
*
* @author 10237
*
*/
public class FanXingDemo {
public static void main(String[] args) {
List<Integer> l = new ArrayList<>();
l.add(18);
l.add(21);
l.add(26);
l.add(28);
l.add(33);
// l.add("s");
Iterator it = l.iterator();
while (it.hasNext()) {
Object obj = it.next();
int num = (int) obj;
if (num % 2 == 0) {
System.out.println(num);
}
}
}
}
/*
* 购物车项目
* 订单模块,用户模块、商品模块
* Class OrderDao{
* public List<Order> list(Order order){
*
* }
*
* public int add(Order order){}
* public int edit(Order order){}
* public int del(Order order){}
*
* }
*
* Class UserDao{
* public List<User> list(User User){}
* public int add(User User){}
* public int edit(User User){}
* public int del(User User){}
*
* }
*
* Class ProductDao{
*
* }
*
* --------不使用泛型的情况-----------------
* --------使用泛型的情况-----------------
* Class BaseDao<T>{
* public List<T> list(T t){}
* public int add(T t){}
* public int edit(T t){}
* public int del(T t){}
* }
*
* Class OrderDao extends BaseDao<Order>{}
* Class UserDao extends BaseDao<User>{}
* Class ProductDao extends BaseDao<Product>{}
*/