1.集合框架set集合框架Set(HashSet哈希表存储、重复元素存储底层探究)
Set存储的元素是无序的,不可重复
无序性不等于随机性 添加set所在类必须重写equls和hashCode方法 。
保证Set的不可重复。Set元素中的存储采用了哈希算法。
// * 1.set集合不能存放重复元素的问题 2、HashSet哈希表存储、重复元素存储底层探究
* 不能存放重复元素 字符串、八大基本数据类型
* set集合的元素是无序的
public class setDemo {
public static void main(String[] args) {
Set set=new HashSet<>();
set.add( "wanting");
set.add("zhuangyuan");
set.add("runchen");
set.add("xiang");
set.add("wanting");
System.out.println(set.size());
}
}
-
由此论证Set集合不能存放重复元素
-
2、Hash哈希存储、重复元素存储底层探
-
list.contains 底层调用eqluals方法
-
sat.add 底层调用了hashCode/equals
```javascript
public class setDemo {
public static void main(String[] args) {
Set set=new HashSet<>();
set.add(new Person("wanting",18,1500));
set.add(new Person("zhuangyuan",18,500));
set.add(new Person("runchen",18,1200));
set.add(new Person("xiang",22,2500));
set.add(new Person("wanting",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() {
super();
}
@Override
public int hashCode() {
// System.out.println("hashCode-----------"+this.name);
int code= this.name.hashCode()+this.age;
// System.out.println(code);
return code;
}
- set集合中的元素是无序的(存入和取出的顺序不一定一致)
- 说明set重复只限于只限对于字符串、八大基本数据类型
但equls与hashCodo同时运行
@Override
public int hashCode() {
System.out.println("hashCode-----------"+this.name);
// int code= this.name.hashCode()+this.age;
// System.out.println(code);
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("hashCode-----------");
int code= this.name.hashCode()+this.age;
System.out.println(code);
return code;
}
- 可以得出结论:hashCodo与equals方法来完成;如果hashCode值相同,才会判断equals是否为true;如果hashCode值不同,那么不会调用equals。
2、集合框架TreeSet(自然排序、数据结构二叉树、比较器排序)
/**
* 2、集合框架TreeSet(自然排序、数据结构二叉树、比较器排序)
* java.lang.ClassCastException:
* com.zking.set.Person connot be cast to java.lang.Comparable
* @author 96345
*
*/
package com.zking.list;
import java.util.TreeSet;
public class TreeSetDemo {
public static void main(String[] args) {
TreeSet set= new TreeSet();
set.add(26);
set.add(25);
set.add(28);
set.add(21);
set.add(31);
System.out.println(set);
}
}
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() {
super();
}
}
- 1.treeSet容器是根本二叉树的排序规则对容器中元素进行排序的 自然排序(元素自身具有比较性)
2.1自然排序
public class TreeSetDemo {
public static void main(String[] args) {
TreeSet set= new TreeSet();
set.add("ab");
set.add("cd");
set.add("ef");
System.out.println(set);
}
}
}
运行结果:
package com.zking.list;
import java.util.Iterator;
import java.util.TreeSet;
/**
* 2、集合框架TreeSet(自然排序、数据结构二叉树、比较器排序)
* 1.treeSet容器是根本二叉树的排序规则对容器中元素进行排序的 自然排序(元素自身具有比较性)
* java.lang.ClassCastException:
* com.zking.set.Person connot be cast to java.lang.Comparable
* @author 96345
*
*/
public class TreeSetDemo {
public static void main(String[] args) {
TreeSet set= new TreeSet();
set.add(new Person("wanting",18,1500));
set.add(new Person("zhuangyuan",23,500));
set.add(new Person("runchen",19,1200));
set.add(new Person("xiang",22,2500));
set.add(new Person("wantings",88,1500));
// System.out.println(set);
Iterator it=set.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
/**
* 年少有为
* @author 96345
*
*/
class Personns implements Comparable<Person>{
public int compare(Person o1, Person o2) {
int num=o1.getAge()-o2.getAge();//年轻
if(num==0) {
return o2.getMoney()-o1.getMoney();//有为钱多
}
return num;
}
@Override
public int compareTo(Person o) {
// TODO Auto-generated method stub
return 0;
}
}
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() {
super();
}
@Override
public int hashCode() {
System.out.println("hashCode----"+this.name);
int code=this.name.hashCode()+this.age;//算一个name和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.age;
// if (num==0) {
// return o.age-this.age;
// }
// return num;
// }
}
我们存放的是乱序的,取出来的时候进行了排序
引用数据类型想要排序,必须实现Comparable接口,否则会出现错(java.lang.ClassCastException: com.javaxl.Peroon cannot be cast to java.lang.Comparable)
2.2、TreeSet数据结构(二叉树)
可以对set集合进行排序,底层数据结构是二叉树;
保证元素唯一性的依据是,compareTo方法return 0
所以
注意:TreeSet排序的第一种方式,让元素自身具有比较性;
元素需要实现Comparable接口,覆盖compareTo方法;
这种方式也被称为元素的自然顺序,或者叫做默认顺序。
package com.zking.list;
import java.util.Iterator;
import java.util.TreeSet;
/**
* 2、集合框架TreeSet(自然排序、数据结构二叉树、比较器排序)
* 1.treeSet容器是根本二叉树的排序规则对容器中元素进行排序的 自然排序(元素自身具有比较性)
* java.lang.ClassCastException:
* com.zking.set.Person connot be cast to java.lang.Comparable
* @author 96345
*
*/
public class TreeSetDemo {
public static void main(String[] args) {
TreeSet set= new TreeSet();
set.add(new Person("wanting",18,1500));
set.add(new Person("zhuangyuan",23,500));
set.add(new Person("runchen",19,1200));
set.add(new Person("xiang",22,2500));
set.add(new Person("wantings",88,1500));
System.out.println(set);
Iterator it=set.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;
}
@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 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.age;
if (num==0) {
return o.age-this.age;
}
return num;
}
}
比较器排序(用于应对某些代码频繁修改所带来不便情况)
通过实现Comparator来完成(调用不同的方法来完成)不需要每次都修改代码,也可以实现方法回滚
TreeSet比较器排序
TreeSet排序的第二种方式
当元素自身不具备比较性时,或者具备的比较性不是所需要的;
注意:这时需要让集合自身具备比较性
在集合初始化时,就有了比较方式;
定义一个类,实现comparator接口,实现compare方法
当两种排序都存在时,比较器排序优先级更高
找集合中年少有为的男人
package com.zking.list;
mport java.util.Iterator;
import java.util.TreeSet;
/**
* 2、集合框架TreeSet(自然排序、数据结构二叉树、比较器排序)
* 1.treeSet容器是根本二叉树的排序规则对容器中元素进行排序的 自然排序(元素自身具有比较性)
* java.lang.ClassCastException:
* com.zking.set.Person connot be cast to java.lang.Comparable
* @author 96345
*
*/
public class TreeSetDemo {
public static void main(String[] args) {
TreeSet set= new TreeSet();
set.add(new Person("wanting",18,1500));
set.add(new Person("zhuangyuan",23,500));
set.add(new Person("runchen",19,1200));
set.add(new Person("xiang",22,2500));
set.add(new Person("wantings",88,1500));
// System.out.println(set);
Iterator it=set.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
/**
* 年少有为
* @author 96345
*
*/
class Personns implements Comparable<Person>{
public int compare(Person o1, Person o2) {
int num=o1.getAge()-o2.getAge();//年轻
if(num==0) {
return o2.getMoney()-o1.getMoney();//有为钱多
}
return num;
}
@Override
public int compareTo(Person o) {
// TODO Auto-generated method stub
return 0;
}
}
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;//算一个name和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 compare(Person o1, Person o2) {
int num=o2.getMoney()-o1.getMoney();
if(num==0) {
return o1.getAge()-o2.getAge();
}
return num;
}
}
泛 型
- 好处/为什么出现?
-
不使用泛型的情况下,会将未知的错误表现在运行时期
-
如果说用代码去处理了,这个可能发现的错误,那么运行时期的错误就不会暴露处理
- 1、讲运行期的异常转换成编译期的错误,让程序员更早的发现,从而解决代码隐患
- 2、提高了代码健壮性
- 泛型类
- 泛型接口
- 泛型方法
public class FanXinDemo {
public static void main(String[] args) {
List<Integer> c=new ArrayList();
c.add(22);
c.add(23);
c.add(26);
c.add(28);
c.add(55);
//c.add("s")
//ctrl+shift+o 快速导包
Iterator it=c.iterator();
while (it.hasNext()) {
Object obj=it.next();
int num=(int) obj;
if (num % 2==0) {
System.out.println(num);
}
}
}
}
/**javascript
* 购物车项目
* 订单模块,用户模块、商品模块
* 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<Order> list(Order order){
* public int add(User User){}
* public int edit(User User){}
* public int del(User User){}
* }
*
* Class ProductDao{
* public List<Order> list(Order order){
* public int add(User User){}
* public int edit(User User){}
* public int del(User User){}
* }
*
* }
* -----不使用泛型的情况-----------
* -----使用泛型的情况-----------
* Class ProductDao{
* 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 OrderDao extends BaseDao<order>{}
* Class OrderDao extends BaseDao<order>{}
* */