1.Java很多技术底层通过Map来实现的。
2.HashMap:按Key-value方式存值，Key无序的,唯一单一对象，底层采用数组+链表(哈希表)结构存值
注意:hashMap的key的泛型数据类型一定要重写hashCode()和equals()
Key唯一性:通过重写hashCode()和equals()实现的
根据key调用hashCode()经过计算得到hash码，根据hash码和数组的长度计算出该key存储的位置index，如果index索引位置上没有值，将当前key-value键值对存在当前位置index上；如果位置index已经存在了键值对（节点），则用key调用equals()与index位置上原本的key进行比较，如果key相同，则当前key-value（新增的键值对）中的key不存value覆盖；如果key不相同，则将key-value键值对（新增的）接着存入到index的后面。
public class Student {
public String sanme;
public Integer sage;
public Student() {
// TODO Auto-generated constructor stub
}
public Student(String sanme, Integer sage) {
super();
this.sanme = sanme;
this.sage = sage;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((sage == null) ? 0 : sage.hashCode());
result = prime * result + ((sanme == null) ? 0 : sanme.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (sage == null) {
if (other.sage != null)
return false;
} else if (!sage.equals(other.sage))
return false;
if (sanme == null) {
if (other.sanme != null)
return false;
} else if (!sanme.equals(other.sanme))
return false;
return true;
}
}
public static void main(String[] args) {
//创建集合对象
HashMap<Student, String> hmap1=new HashMap<>();
//向集合中添加元素
hmap1.put(new Student("kk3",11), "aa");
hmap1.put(new Student("kk1",44), "ee");
hmap1.put(new Student("kk4",22), "bb");
hmap1.put(new Student("kk6",33), "ff");
hmap1.put(new Student("kk3",11), "kk");
/*遍历集合*/
//将Key-value看作一个整体,将map转换为set集合
Set<Entry<Student, String>> set1=hmap1.entrySet();
//获得跌代器对象
Iterator<Entry<Student, String>> it1=set1.iterator();
//判断跌代器对象后面是否有元素可跌代
while (it1.hasNext()) {
//获得每个跌代的元素
Entry<Student, String> e=it1.next();
System.out.println("键姓名属性为:"+e.getKey().sanme+",键年龄属性为:"+e.getKey().sage+",值为:"+e.getValue());
}
System.out.println("---------------------------------");
//删除集合中元素对象
hmap1.remove(new Student("kk6",33));
/*遍历集合*/
//获得map集合中所有Key的集合
Set<Student> set2=hmap1.keySet();
//遍历Key集合
//获得跌代器对象
Iterator<Student> it2=set2.iterator();
//判断跌代器对象后面是否有元素可跌代
while (it2.hasNext()) {
//获得每个跌代的元素
Student k=it2.next();
System.out.println("键姓名属性为:"+k.sanme+",键年龄属性为:"+k.sage+",值为:"+hmap1.get(k));
}
}
3.匿名内部类:当一个类的方法中完整包含另一个类,这个类没有名字就叫匿名内部类
3.1:适用场景:当一个类一生只有一个对象,就可以用匿名内部类
3.2:一个Java类(普通类或内部类)对应一个.class字节码文件
/**
* 自我介绍的接口
*/
public interface MySelf {
/**
* 自我介绍的方法
*/
public void showMyself();
}
public static void main(String[] args) {
// //创建对象
// Student stu1=new Student();
// //用对象调用方法
// stu1.showMyself();
/*第一种:创建匿名内部类的对象,调用方法*/
//创建匿名内部类的一个对象,大括号就是匿名内部类,
//new MySelf()用父接口或父抽象类作为数据类型,创建匿名内部类对象
MySelf teacher= new MySelf() {
@Override
public void showMyself() {
System.out.println("大家好,我叫渣渣辉");
}
};
//用匿名内部类的对象调用方法
teacher.showMyself();
/*第二种:创建匿名内部类的对象的同时调用方法*/
new MySelf() {
@Override
public void showMyself() {
System.out.println("大家好,我叫蔡徐坤1");
}
}.showMyself();
}
4.TreeMap:按Key-value对方式存值,key无序可排序的唯一的单一对象.底层采用红黑二叉车树存值
注意:TreeMap一定要用排序器,重写排序方法
Key的可排序性:通过排序器的排序方法来排序,返回负数(-1)排在前面,返回正数(1)排在后面；
Key的唯一性:去重是通过排序器的排序方法返回0,Key重复不存,Value覆盖
将key-value键值对中的key拿出调用排序器的排序方法，与根节点相比较，如果当前是一棵空树（即没有根节点），将当前的键值对作为根节点；继续将下一对key-value键值对中的key拿出来调用排序器的排序方法与根节点开始依次向下的节点相比较，直到找到该key-value键值对所应该存放的位置为止，比较结果返回负数（-1）排在当前节点的左子节点，返回正数（1）排在当前节点的右子节点，若是返回0则说明是相同的节点，key不存（还是原来的key）value覆盖（新key-value中value）。
public static void main(String[] args) {
//创建集合对象,默认Key用自然排序器,Key的泛型类型要实现自然排序器接口,重写排序方法
TreeMap<Student3, String> tmap1=new TreeMap(new Comparator<Student3>() {
/**
* 重写排序器的排序方法
* @param o1代表当前要添加对象
* @param o2每个要比较的对象,从根节点开始比较
* 排序规则:按姓名升序,姓名相同按年龄升序排序
*/
@Override
public int compare(Student3 o1, Student3 o2) {
if (o1.sanme.compareTo(o2.sanme)!=0) {
return o1.sanme.compareTo(o2.sanme);
}else {//姓名相同按年龄升序排序
return o1.sage.compareTo(o2.sage);
}
}
});
//向集合中添加元素
tmap1.put(new Student3("aa", 22), "aa1");
tmap1.put(new Student3("aa", 66), "ff1");
tmap1.put(new Student3("dd", 44), "dd1");
tmap1.put(new Student3("kk", 88), "kk1");
tmap1.put(new Student3("aa", 22), "uu1");
/*第一种:遍历Map集合*/
//将Key-value看作一数据整体,将map集合转换为set集合
Set<Entry<Student3, String>> set1=tmap1.entrySet();
//获得集合的跌代器对象
Iterator<Entry<Student3, String>> it1=set1.iterator();
//判断跌代器对象后面是否有元素可跌代
while (it1.hasNext()) {
//获得跌代器对象
Entry<Student3, String> e1=it1.next();
System.out.println("Key的姓名属性为:"+e1.getKey().sanme+",Key的年龄属性为:"+e1.getKey().sage+",值为:"+e1.getValue());
}
System.out.println("--------------------------");
//删除集合中元素
tmap1.remove(new Student3("aa", 22));
/*第二种:遍历Map集合*/
//获得map集合中所有的Key
Set<Student3> set2=tmap1.keySet();
//获得集合的跌代器对象
Iterator<Student3> it2=set2.iterator();
//判断跌代器对象后面是否有元素可跌代
while (it2.hasNext()) {
//获得跌代器对象
Student3 k=it2.next();
System.out.println("Key的姓名属性为:"+k.sanme+",Key的年龄属性为:"+k.sage+",值为:"+tmap1.get(k));
}
}
5.排序器:
5.1:自然排序器
/**
* 学生类,实现自然排序器接口
*/
public class Student2 implements Comparable<Student2>{
public String sanme;
public Integer sage;
public Student2() {
// TODO Auto-generated constructor stub
}
public Student2(String sanme, Integer sage) {
super();
this.sanme = sanme;
this.sage = sage;
}
/**
* 重写排序器的排序方法
* @param o 每个要比较的节点对象,从根节点开始
* 排序规则:先按姓名升序排序,姓名相同再按年龄降序
*/
@Override
public int compareTo(Student2 o) {
if (this.sanme.compareTo(o.sanme)!=0) {
return this.sanme.compareTo(o.sanme);
}else {//姓名相同再按年龄降序
return -this.sage.compareTo(o.sage);
}
}
}
public static void main(String[] args) {
//创建集合对象,默认Key用自然排序器,Key的泛型类型要实现自然排序器接口,重写排序方法
TreeMap<Student2, String> tmap1=new TreeMap();
//向集合中添加元素
tmap1.put(new Student2("aa", 22), "aa1");
tmap1.put(new Student2("aa", 66), "ff1");
tmap1.put(new Student2("dd", 44), "dd1");
tmap1.put(new Student2("kk", 88), "kk1");
tmap1.put(new Student2("aa", 22), "uu1");
/*第一种:遍历Map集合*/
//将Key-value看作一数据整体,将map集合转换为set集合
Set<Entry<Student2, String>> set1=tmap1.entrySet();
//获得集合的跌代器对象
Iterator<Entry<Student2, String>> it1=set1.iterator();
//判断跌代器对象后面是否有元素可跌代
while (it1.hasNext()) {
//获得跌代器对象
Entry<Student2, String> e1=it1.next();
System.out.println("Key的姓名属性为:"+e1.getKey().sanme+",Key的年龄属性为:"+e1.getKey().sage+",值为:"+e1.getValue());
}
System.out.println("--------------------------");
//删除集合中元素
tmap1.remove(new Student2("aa", 22));
/*第二种:遍历Map集合*/
//获得map集合中所有的Key
Set<Student2> set2=tmap1.keySet();
//获得集合的跌代器对象
Iterator<Student2> it2=set2.iterator();
//判断跌代器对象后面是否有元素可跌代
while (it2.hasNext()) {
//获得跌代器对象
Student2 k=it2.next();
System.out.println("Key的姓名属性为:"+k.sanme+",Key的年龄属性为:"+k.sage+",值为:"+tmap1.get(k));
}
}
5.2:自定义排序器
/**
* 自定义排序器类
*/
public class MyComparator3 implements Comparator<Student3>{
/**
* 重写排序器的排序方法
* @param o1代表当前要添加对象
* @param o2每个要比较的对象,从根节点开始比较
* 排序规则:按姓名升序,姓名相同按年龄升序排序
*/
@Override
public int compare(Student3 o1, Student3 o2) {
if (o1.sanme.compareTo(o2.sanme)!=0) {
return o1.sanme.compareTo(o2.sanme);
}else {//姓名相同按年龄升序排序
return o1.sage.compareTo(o2.sage);
}
}
}
public static void main(String[] args) {
//创建自定义排序器的对象
MyComparator3 mc=new MyComparator3();
//创建集合对象,默认Key用自然排序器,Key的泛型类型要实现自然排序器接口,重写排序方法
TreeMap<Student3, String> tmap1=new TreeMap(mc);
//向集合中添加元素
tmap1.put(new Student3("aa", 22), "aa1");
tmap1.put(new Student3("aa", 66), "ff1");
tmap1.put(new Student3("dd", 44), "dd1");
tmap1.put(new Student3("kk", 88), "kk1");
tmap1.put(new Student3("aa", 22), "uu1");
/*第一种:遍历Map集合*/
//将Key-value看作一数据整体,将map集合转换为set集合
Set<Entry<Student3, String>> set1=tmap1.entrySet();
//获得集合的跌代器对象
Iterator<Entry<Student3, String>> it1=set1.iterator();
//判断跌代器对象后面是否有元素可跌代
while (it1.hasNext()) {
//获得跌代器对象
Entry<Student3, String> e1=it1.next();
System.out.println("Key的姓名属性为:"+e1.getKey().sanme+",Key的年龄属性为:"+e1.getKey().sage+",值为:"+e1.getValue());
}
System.out.println("--------------------------");
//删除集合中元素
tmap1.remove(new Student3("aa", 22));
/*第二种:遍历Map集合*/
//获得map集合中所有的Key
Set<Student3> set2=tmap1.keySet();
//获得集合的跌代器对象
Iterator<Student3> it2=set2.iterator();
//判断跌代器对象后面是否有元素可跌代
while (it2.hasNext()) {
//获得跌代器对象
Student3 k=it2.next();
System.out.println("Key的姓名属性为:"+k.sanme+",Key的年龄属性为:"+k.sage+",值为:"+tmap1.get(k));
}
}
5.3:匿名自定义排序器
public static void main(String[] args) {
//创建集合对象,默认Key用自然排序器,Key的泛型类型要实现自然排序器接口,重写排序方法
TreeMap<Student3, String> tmap1=new TreeMap(new Comparator<Student3>() {
/**
* 重写排序器的排序方法
* @param o1代表当前要添加对象
* @param o2每个要比较的对象,从根节点开始比较
* 排序规则:按姓名升序,姓名相同按年龄升序排序
*/
@Override
public int compare(Student3 o1, Student3 o2) {
if (o1.sanme.compareTo(o2.sanme)!=0) {
return o1.sanme.compareTo(o2.sanme);
}else {//姓名相同按年龄升序排序
return o1.sage.compareTo(o2.sage);
}
}
});
//向集合中添加元素
tmap1.put(new Student3("aa", 22), "aa1");
tmap1.put(new Student3("aa", 66), "ff1");
tmap1.put(new Student3("dd", 44), "dd1");
tmap1.put(new Student3("kk", 88), "kk1");
tmap1.put(new Student3("aa", 22), "uu1");
/*第一种:遍历Map集合*/
//将Key-value看作一数据整体,将map集合转换为set集合
Set<Entry<Student3, String>> set1=tmap1.entrySet();
//获得集合的跌代器对象
Iterator<Entry<Student3, String>> it1=set1.iterator();
//判断跌代器对象后面是否有元素可跌代
while (it1.hasNext()) {
//获得跌代器对象
Entry<Student3, String> e1=it1.next();
System.out.println("Key的姓名属性为:"+e1.getKey().sanme+",Key的年龄属性为:"+e1.getKey().sage+",值为:"+e1.getValue());
}
System.out.println("--------------------------");
//删除集合中元素
tmap1.remove(new Student3("aa", 22));
/*第二种:遍历Map集合*/
//获得map集合中所有的Key
Set<Student3> set2=tmap1.keySet();
//获得集合的跌代器对象
Iterator<Student3> it2=set2.iterator();
//判断跌代器对象后面是否有元素可跌代
while (it2.hasNext()) {
//获得跌代器对象
Student3 k=it2.next();
System.out.println("Key的姓名属性为:"+k.sanme+",Key的年龄属性为:"+k.sage+",值为:"+tmap1.get(k));
}
}
99
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
