一. 集合框架Set（HashSet哈希表存储、重复元素存储底层探究）
set集合里元素的特点
- 元素不可以重复
- 元素存放和取出的顺序不一定一致
- 不能存放重复元素 字符串、八大基本数据类型
代码演示：
package com.xhh.set;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import com.sun.org.apache.bcel.internal.generic.NEW;
/**
* 1.set集合不能存放重复元素的问题 2.Hashset哈希表存储，重复元素储存底层探究
* 不能存放重复元素 字符串、八大基本数据类型
* set集合中的元素是无序的
* 2、HashSet哈希表存储、重复元素存储底层探究
* list.contains 底层调用了equals方法
* set.add 底层调用了hashCode/equals
* @author linyaodong
*
*/
public class SetDemo {
public static void main(String[] args) {
// List list=new ArrayList<>();
Set set=new HashSet<>();
set.add(new Person("a", 11, 500));
set.add(new Person("b", 23, 1500));
set.add(new Person("c", 33, 6000));
set.add(new Person("d", 44, 4000));
set.add(new Person("e", 55, 300));
set.add(new Person("a", 11, 500));
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();
}
}
运行结果如下：
这就证明了，元素不可重复，并取出来的元素排序不一致
HashSet哈希表存储：
底层数据结构——哈希表
HashSet存入重复元素（以人为例）同姓名同年龄视为同一个人 ，重复元素
HashSet是如何保证元素唯一性的呢？
是通过元素的两个方法：hashCode与equals方法来完成；
如果hashCode值相同，才会判断equals是否为true；
如果hashCode值不同，那么不会调用equals。
注意：对于判断元素是否存在，以及删除等操作，依赖的方法同样是hashCode、equals方法。
附上代码：
package com.xhh.set;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import com.sun.org.apache.bcel.internal.generic.NEW;
/**
* 1.set集合不能存放重复元素的问题 2.Hashset哈希表存储，重复元素储存底层探究
* 不能存放重复元素 字符串、八大基本数据类型
* set集合中的元素是无序的
* 2、HashSet哈希表存储、重复元素存储底层探究
* list.contains 底层调用了equals方法
* set.add 底层调用了hashCode/equals
* @author linyaodong
*
*/
public class SetDemo {
public static void main(String[] args) {
// List list=new ArrayList<>();
Set set=new HashSet<>();
// set.add("a");
// set.add("b");
// set.add("c");
// set.add("d");
// set.add("e");
// set.add("a");
set.add(new Person("a", 11, 500));
set.add(new Person("b", 23, 1500));
set.add(new Person("c", 33, 6000));
set.add(new Person("d", 44, 4000));
set.add(new Person("e", 55, 300));
set.add(new Person("a", 11, 500));
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;
}
@Override
public boolean equals(Object obj) {
if(obj instanceof Person) {
Person p=(Person) obj;
return this.name.equals(p.name) && this.age==p.age;
}
return super.equals(obj);
}
}
运行结果：
List与Set判断重复对象的区别？
List只依赖于equals方法
Set依赖于hashCode、equals方法
二. 集合框架TreeSet（自然排序、数据结构二叉树、比较器排序）
1.自然排序
TreeSet可以对set集合中元素进行排序，String实现了Comparable接口，可以直接进 行排序，引用数据类型想要排序，必须实现Comparable接口。
代码演示：
package com.xhh.set;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class TerrSetDemo {
public static void main(String[] args) {
TreeSet set=new TreeSet<>();
set.add(12);
set.add(18);
set.add(14);
set.add(15);
set.add(10);
System.out.println(set);
}
运行结果：
我们存放的是乱序的，取出来的时候进行了排序
引用数据类型想要排序，必须实现Comparable接口，否则会出现错（java.lang.ClassCastException: com.javaxl.Peroon cannot be cast to java.lang.Comparable），
代码演示：
package com.xhh.set;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class TerrSetDemo {
public static void main(String[] args) {
TreeSet<Object> set=new TreeSet<>();
set.add(new Person("a", 11, 500));
set.add(new Person("b", 44, 1500));
set.add(new Person("c", 33, 6000));
set.add(new Person("d", 64, 4000));
set.add(new Person("e", 55, 300));
System.out.println(set);
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;
}
/**
* 实现Comparable接口就是让其具备比较性
* 例如：前后的年龄进行比较
*/
@Override
public boolean equals(Object obj) {
Person p=(Person) obj;
return this.name.equals(p.name) && this.age==p.age;
}
}
运行结果：
现在实现Comparable接口
package com.xhh.set;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class TerrSetDemo {
public static void main(String[] args) {
TreeSet<Object> set=new TreeSet<>();
// set.add("abc");
// set.add("bc");
// set.add("dea");
// set.add("de");
// set.add("def");
// TreeSet<Person> set=new TreeSet<>(new personAgeMoneyComp());
// TreeSet<Person> set=new TreeSet<>(new personMoneyAgeComp());
set.add(new Person("a", 11, 500));
set.add(new Person("b", 44, 1500));
set.add(new Person("c", 33, 6000));
set.add(new Person("d", 64, 4000));
set.add(new Person("e", 55, 300));
// 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 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) {
Person p=(Person) obj;
return this.name.equals(p.name) && this.age==p.age;
}
/**
* 实现Comparable接口就是让其具备比较性
* 例如：前后的年龄进行比较
*/
@Override
public int compareTo(Person o) {
int num=o.money-this.money;
if(num==0) {
return o.age-this.age;
}
return num;
}
}
运行结果：
注意：排序时，当主要条件相同时，一定要判断次要条件。
2.TreeSet数据结构（二叉树）
可以对set集合进行排序，底层数据结构是二叉树；
保证元素唯一性的依据是，compareTo方法return 0
Comparable接口的用途?
使添加的元素自身具备排序规则
比较器comparator接口作用
使得容器具有比较性
3.TreeSet比较器排序
当元素自身不具备比较性时，或者具备的比较性不是所需要的时候
这时需要让集合自身具备比较性，在集合初始化时，就有了比较方式；
代码演示：
package com.xhh.set;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class TerrSetDemo {
public static void main(String[] args) {
// TreeSet<Object> set=new TreeSet<>();
// set.add("abc");
// set.add("bc");
// set.add("dea");
// set.add("de");
// set.add("def");
TreeSet<Person> set=new TreeSet<>(new personMoneyAgeComp());
set.add(new Person("a", 11, 500));
set.add(new Person("b", 44, 1500));
set.add(new Person("c", 33, 6000));
set.add(new Person("d", 64, 4000));
set.add(new Person("e", 55, 300));
// System.out.println(set);
Iterator it=set.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}
/**
* 比较器排序 钱多，年轻
* @author linyaodong
*
*/
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() {
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) {
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;
}
}
运行结果
可以看到 主要条件钱多的在前面 而当钱相等时 年龄小的在前面
注：因为当两种排序都存在时，比较器排序优先级更高，所以当两种方法都存在时，比较器定义的排序方法会覆盖上一个方法的排序方法，以比较器定义的排序方法为准。
三. 泛型
好处/为什么出现
- 在Jdk1.5以后出现的新特性，用于解决安全问题，是一个安全机制
- 1.不使用泛型的情况下，会将未知的错误表现在运行时期：
错误代码演示
package com.xhh.set;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class FanXingDemo {
public static void main(String[] args) {
List c=new ArrayList();
c.add(22);
c.add(23);
c.add(26);
c.add(28);
c.add(31);
c.add("错误");
Iterator it=c.iterator();
while(it.hasNext()) {
Object obj=it.next();
int num=(int) obj;
if(num%2==0) {
System.out.println(num);
}
}
}
}
什么在编译期并没有报错，但是在运行后却会报错
运行结果：
咱们加上泛型后（如图）
可以看出，将运行时出现的异常ClassCastException，转移到了编译时期，方便于程序员解决问题，让运行时期问题减少，更加安全；
2.提高了代码健壮性
3、什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候，
需要定义泛型来完成扩展，将运行时的异常转移到编译时期
4、泛型方法
泛型类定义的泛型，在整个类中有效，如果被方法调用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
泛型限定
泛型上下限的理解
注：？ 通配符
上限
<? extend T>
collection<? extend T> colle 用来接收对象，这里接收的对象是未知对象。
理解：只要是T或者T的子类，，就可以接收
就可以使用这个方法，如：T是Person,那么他的子类Student\Worker都可以使用这个方法
？是待定类型，T是已知类型
下限
取出，用下限
<? super T>
理解，只要是T或者T的父类，就可以取出
取集合的类型，用集合的父类型接收，保证所有元素全能接收到。
比如我们给Person写一个比较器
我们用comparator<? super T> comp接收对象（接收的对象是已经写好的比较器）
如果接收的对象是Student ，那么只要我们有Student或者Student父类的比较器，我们就可以取出里面的方法来使用
这样就能保证我们对Person写了比较器，对Person以及Person的子类同样适用
？是已知类型，T是待定类型，T就是我们就是我们将要传入的对象，一般为已知类型的子类
扫一扫
301
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
