2020/4/1学习笔记day31

原创 于 2020-04-01 15:54:32 发布 · 146 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入探讨了Java中SortedSet接口的实现类TreeSet，如何通过Comparable和Comparator接口实现对象的排序，以及Map接口的常用实现类如HashMap的使用方法。此外，还介绍了遍历Map的多种方式和Collections工具类的功能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

java-day31

文章目录

SortedSet接口有一个实现类：TreeSet

通过Comparable接口实现比较

在java中，实现了Comparable接口的类的对象，是可以比较大小的，通过调用接口中的方法compareTo方法就可以比较俩个对象的大小。在compareTo方法中， 可以按照自己定义的规则来比较俩个对象的大小。

例子：

重写Student里面的compareTo方法使其按照年龄排序（从小到大）

//重写compareTo方法
//s1.compareTo(s2)
public int compareTo(Object obj){
    //this:s1  obj:s2
    //s1 < s2  return <0
    //s1 > s2  return >1
    //s2 = s2  return 0

    Student stu =(Student) obj;
    return this.age - stu.age;
}

在这里插入图片描述

重写Student里面的compareTo方法使其按照年龄排序（从大到小）

//重写compareTo方法
//s1.compareTo(s2)
public int compareTo(Object obj){
    //this:s1  obj:s2
    //s1 < s2  return <0
    //s1 > s2  return >1
    //s2 = s2  return 0

    Student stu =(Student) obj;
    return -(this.age - stu.age);
}

在这里插入图片描述
重写Student里面的compareTo方法使其按照id排序(从小到大)

//重写compareTo方法
//s1.compareTo(s2)
public int compareTo(Object obj){
    //this:s1  obj:s2
    //s1 < s2  return <0
    //s1 > s2  return >1
    //s2 = s2  return 0

    Student stu =(Student) obj;
    return (int)(this.id - stu.id);
}

在这里插入图片描述

重写Student里面的compareTo方法使其按照id排序(从大到小)

//重写compareTo方法
//s1.compareTo(s2)
public int compareTo(Object obj){
    //this:s1  obj:s2
    //s1 < s2  return <0
    //s1 > s2  return >1
    //s2 = s2  return 0

    Student stu =(Student) obj;
    return -(int)(this.id - stu.id);
}

在这里插入图片描述

注意：

在比较大小的时候我们是在computerTo调用者对象的角度来看比较大小的问题

//站在s1的角度来看大小问题
//s1.compareTo(s2)
public int compareTo(Object obj){
	// this obj
}

通过比较器Comparator实现比较

一个类实现了Comparable接口之后就可以进行对象的大小比较了TreeSet的构造器中还可以传一个比较器Comparator,这个比较器也可以比较对象之间的大小，即使对象没有实现Comparable接口也是可以比较大小的。

TreeSet中的构造器:
public TreeSet( Comparator comparator )

如果集合中的对象实现了Comparable，同时TreeSet中有设置了比较器Comparator,俩者都存在的情况下，比较器的优先级更高。

public void test4(){
    Set set1 =null;

    Comparator c = new Comparator(){
        public int compare(Object o1,Object o2){
            Integer a1 = (Integer) o1;
            Integer a2 = (Integer) o2;
            return -a1.compareTo(a2);
        }
    };
    set1 = new TreeSet(c);
    set1.add(1);
    set1.add(2);
    set1.add(6);
    set1.add(4);
    set1.add(5);java
    this.showCollection(set1);
}

在这里插入图片描述

自定义排序顺序

给定一个随机数，当这个随机数大于5的时候进行从小到大排序，否则进行从大到小排序

public void test4(){
    Set set1 =null;
    Comparator c = null;
    int x = (int)(Math.random()*10);
    System.out.println("x="+x);

    if(x >= 5){
        System.out.println("从小到大");

        c = new Comparator(){
            public int compare(Object o1,Object o2){
                Integer a1 = (Integer) o1;
                Integer a2 = (Integer) o2;
                return a1.compareTo(a2);
            }
        };
    }
    else{
        System.out.println("从大到小");

        c = new Comparator(){
            public int compare(Object o1,Object o2){
                Integer a1 = (Integer) o1;
                Integer a2 = (Integer) o2;
                return -a1.compareTo(a2);
            }
        };
    }

    set1 = new TreeSet(c);
    set1.add(1);
    set1.add(2);
    set1.add(16);
    set1.add(26);
    set1.add(36);
    set1.add(46);
    set1.add(64);
    set1.add(4);
    set1.add(3);
    set1.add(0);
    set1.add(5);
    this.showCollection(set1);
}

在这里插入图片描述

先排偶数（从大到小），再排奇数（从小到大）

public void test5(){
    Set set1 =null;
    Comparator c = new Comparator(){
        public int compare(Object o1,Object o2){
            int a1 = ((Integer) o1).intValue();
            int a2 = (Integer) o2;//自动拆箱

            //a1是偶数 a2是偶数
            if(a1%2==0 && a2%2==0){
                return -(a1-a2);//都是偶数，从大到小拍
            }
            //a1是偶数 a2是奇数
            else if(a1%2==0 && a2%2!=0){
                return -1;//偶数一定是小的，排在前面
            }
            //a1是奇数 a2是奇数
            else if(a1%2!=0 && a2%2!=0){
                return a1-a2;//都是奇数默认顺序排（从小到大）
            }
            //a1是奇数 a2是偶数
            else if(a1%2!=0 && a2%2==0){
                return 1;//奇数一定是大的，排在后面
            }
            else return 0;
        }
    };

    set1 = new TreeSet(c);
    set1.add(1);
    set1.add(2);
    set1.add(3);
    set1.add(4);
    set1.add(5);
    set1.add(6);
    set1.add(7);
    set1.add(8);
    set1.add(9);
    set1.add(10);
    this.showCollection(set1);
}

在这里插入图片描述

Map接口常用的实现类：

HashMap、TreeMap、HashTable
在这里插入图片描述

HashMap的声明

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
    	//...
    }

Map接口中定义的方法：

void 	clear() 
		从该Map中删除所有的映射（可选操作）。  
		
boolean containsKey(Object key) 
		如果此映射包含指定键的映射，则返回 true 。  
		
boolean containsValue(Object value) 
		如果此Map将一个或多个键映射到指定的值，则返回 true 。  
  
boolean equals(Object o) 
		将指定的对象与此映射进行比较以获得相等性。 
		
V 		get(Object key) 
		返回到指定键所映射的值，或 null如果此映射包含该键的映射。
		
int 	size() 
		返回此Map中键值映射的数量。  
		
int 	hashCode() 
		返回此Map的哈希码值。  
		
boolean isEmpty() 
		如果此Map不包含键值映射，则返回 true 。 
        
Set<K>	keySet() 
		返回此Map中包含的键的Set视图。
		
V 		put(K key, V value) 
		将指定的值与该映射中的指定键相关联（可选操作）。
		
Collection<V> 		values() 
					返回此Map中包含的值的Collection视图。
					
Set<Map.Entry<K,V>> entrySet() 
					返回此Map中包含的映射的Set视图。
					
void 				putAll(Map<? extends K,? extends V> m) 
					将指定Map的所有映射复制到此映射（可选操作）。
					
V 					remove(Object key) 
					如果存在（从可选的操作），从该Map中删除一个键的映射。
封装遍历Map的Key的方法
private void showMapKey(Map map){
    Set set = map.keySet();
    Iterator it = set.iterator();
    System.out.println("\n 遍历Map中的key开始");

    while(it.hasNext()){
        Object key = it.next();
        System.out.println("\tkey = "+key);	
    }
    System.out.println(" 遍历Map中的key结束");
}

在这里插入图片描述

封装遍历Map的Value的方法
private void showMapValue(Map map){
    Collection c = map.values();
    Iterator it = c.iterator();
    System.out.println("\n 遍历Map中的key开始");

    while(it.hasNext()){
        Object value = it.next();
        System.out.println("\tvalue = "+value);	
    }
    System.out.println(" 遍历Map中的key结束");
}

在这里插入图片描述

通过Map的子接口Entry遍历键值对
//Map中的键值对
//Entry是map的一个内部接口
private void showMapEntry(Map map){
    Set set = map.entrySet();
    Iterator it = set.iterator();
    System.out.println("\n 遍历Map中的entry开始");
    while(it.hasNext()){
        Object obj = it.next();
        Entry entry = (Entry) obj;
        Object key = entry.getKey();
        Object value = entry.getValue();
        System.out.println("\tkey="+key+",value="+value);
    }
    System.out.println(" 遍历Map中的entry结束");
}

在这里插入图片描述

通过先得到Map的key，再拿到value遍历键值对
private void showMapKeyAndValue(Map map){
    Set set = map.keySet();
    Iterator it = set.iterator();
    System.out.println("\n 遍历Map中的key和value开始");

    while(it.hasNext()){
        Object key = it.next();
        Object value = map.get(key);
        System.out.println("\tkey="+key+",value="+value);
    }
    System.out.println(" 遍历Map中的key和value结束");
}

在这里插入图片描述

将类对象数据存入Map并调用
public void test2(){
    Map map =null;
    map = new HashMap();
    Student s1 = new Student(1L,"zzb1",21);
    Student s2 = new Student(2L,"zzb2",22);
    Student s3 = new Student(3L,"zzb3",24);
    Student s4 = new Student(4L,"zzb4",20);
    Student s5 = new Student(5L,"zzb5",25);

    map.put(s1.getId(),s1);
    map.put(s2.getId(),s2);
    map.put(s3.getId(),s3);
    map.put(s4.getId(),s4);
    map.put(s5.getId(),s5);

    System.out.println(map.get(1L));
    System.out.println(map.get(2L));
    System.out.println(map.get(3L));
    System.out.println(map.get(4L));
}

在这里插入图片描述

Collections

Collections是操作集合对象的工具类，之前用的另一个工具类是Arrays。

注意，Collection和Collections的区别：前者是接口，后者是工具类

测试fill、max、min
	//fill方法使用给的值，把集合中原有的数据替换掉
	public void test1(){
		List list = new ArrayList();
		
		list.add(1);
		list.add(2);
		list.add(3);

		Collections.fill(list,"hello");

		this.showCollection(list);

	}
	
	//max方法 获取集合中排序后的最大值
	//min方法 获取集合中排序后的最小值
	public void test2(){
		List list = new ArrayList();
		
		list.add(10);
		list.add(17);
		list.add(51);
		list.add(12);
		list.add(31);

		Object obj = Collections.max(list);

		System.out.println(obj);
	}
测试reverse方法
//reverse方法 反转集合的元素的排列顺序
public void test3(){
    List list = new ArrayList();

    list.add(10);
    list.add(17);
    list.add(51);
    list.add(12);
    list.add(31);

    Collections.reverse(list);
    this.showCollection(list);

}

//sort 方法可以给list集合进行排序
public void test4(){
    List list = new ArrayList();

    list.add(10);
    list.add(17);
    list.add(51);
    list.add(12);
    list.add(31);

    //可以使用自然排序，要求list的元素实现comparable接口
    //Collections.sort(list);

    //同时也可以选择使用比较器来进行排序
    Collections.sort(list,new Comparator(){
        public int compare(Object o1,Object o2){
            int a1 = (Integer)o1;
            int a2 = (Integer)o2;

            return -(a1-a2);
        }
    });
    this.showCollection(list);
}
测试swap、shuffle方法
//swap方法 指定集合俩个下标的值进行交互
public void test5(){
    List list = new ArrayList();

    list.add(10);
    list.add(17);
    list.add(51);
    list.add(12);
    list.add(31);

    Collections.swap(list,1,3);

    this.showCollection(list);

}

//shuffle方法 随机打乱集合中的元素
public void test6(){
    List list = new ArrayList();

    list.add(10);
    list.add(17);
    list.add(51);
    list.add(12);
    list.add(31);

    Collections.shuffle(list);

    this.showCollection(list);

}

//  这些方法可以把一个非线程安全的集合变为一个线程安全的集合
// 	synchronizedSet
//  synchronizedMap
//  synchronizedList
//  synchronizedCollection
private void showCollection(Collection c){
    Iterator it = c.iterator();
    System.out.println(" 遍历集合元素开始");
    while(it.hasNext()){
        Object obj = it.next();
        System.out.println("\t"+obj);
    }
    System.out.println(" 遍历集合元素结束");
}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值