集合之Map家族的TreeMap + Sort +Properties及Collections工具类和总结

最新推荐文章于 2024-04-10 17:32:24 发布
最新推荐文章于 2024-04-10 17:32:24 发布
阅读量242 收藏
点赞数 1
分类专栏： Java基础 文章标签： java 开发语言 学习 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gl280599zl/article/details/127524955
版权

集合之Map家族的TreeMap + Sort +Properties及Collections工具类和总结

一、TreeMap

1.TreeMap的使用

import java.util.Arrays;
import java.util.Collection;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

public class Test01 {

	public static void main(String[] args) {
		
		TreeMap<String, Integer> map = new TreeMap<>();
		
		//添加元素 -- 如果key是第一次添加，则返回null
		Integer put1 = map.put("张飞", 19);
		Integer put2 = map.put("关羽", 20);
		Integer put3 = map.put("刘备", 23);
		Integer put4 = map.put("诸葛亮", 19);
		Integer put5 = map.put("赵云", 22);
		Integer put6 = map.put("马超", 21);
		
		System.out.println("put()的返回值：" + put1);
		System.out.println("put()的返回值：" + put2);
		System.out.println("put()的返回值：" + put3);
		System.out.println("put()的返回值：" + put4);
		System.out.println("put()的返回值：" + put5);
		System.out.println("put()的返回值：" + put6);
		
		//替换元素，返回被替换掉的值
		Integer put = map.put("关羽", 22);
		System.out.println("put()的返回值：" + put);
		
		//替换元素，返回被替换掉的值
		Integer replace = map.replace("关羽",25);
		System.out.println("repace()的返回值：" + replace);
		
		//替换元素，返回是否替换成功的boolean
		boolean bool = map.replace("马超",21,23);
		System.out.println("替换元素，返回是否替换成功的boolean：" + bool);
		
		//清空所有元素
		//map.clear();
		
		System.out.println("判断map中是否有指定的key：" + map.containsKey("刘备"));
		System.out.println("判断map中是否有指定的value：" + map.containsValue(23));
		
		//获取指定key对应的value
		Integer integer = map.get("诸葛亮");
		System.out.println("获取指定key对应的value：" + integer);
		
		//获取指定key对应的value，如果没key，就返回默认值
		Integer orDefault = map.getOrDefault("关羽", 666);
		System.out.println("获取指定key对应的value：" + orDefault);
		
		System.out.println("判断map集合中是否不包含元素：" + map.isEmpty());
		
		//将newMap中所有的元素都添加到map中
		TreeMap<String, Integer> newMap = new TreeMap<>();
		
		newMap.put("aa",10);
		newMap.put("bb",30);
		newMap.put("cc",20);
		map.putAll(newMap);
		
		//如果map中没有该key就添加，如果有就返回对应的value
		Integer putIfAbsent = map.putIfAbsent("ddd", 40);
		System.out.println("如果map中没有该key就添加，如果有就返回对应的value：" + putIfAbsent);
		
		//根据key删除映射关系
		map.remove("赵云");
		//根据key+value删除映射关系
		map.remove("cc", 20);
		
		System.out.println("获取map中映射关系的个数：" + map.size());
		
		//获取map中所有的value，返回集合
		Collection<Integer> values = map.values();
		System.out.println(Arrays.toString(values.toArray()));
		
		System.out.println("---------------");
		
		//遍历方式1 -- keySet()
		//思路：获取map中所有的key，将key存放在set集合中，遍历set集合将key取出，就可以通过map获取key对应的value
		Set<String> keySet = map.keySet();
		for (String key : keySet) {
			Integer value = map.get(key);//传入key获取到对应的value
			System.out.println(key + " -- " + value);
		}
		
		System.out.println("---------------");
		
		//遍历方式2 -- entrySet()
		//entry：表示映射关系（key + value）
		//思路：获取map中所有的映射关系对象，将映射关系对象存放在set集合中，遍历set集合将映射关系对象取出，就可以通过映射关系对象获取到key和value
		Set<Entry<String, Integer>> entrySet = map.entrySet();
		for (Entry<String, Integer> entry : entrySet) {
			String key = entry.getKey();
			Integer value = entry.getValue();
			System.out.println(key + " -- " + value);
		}
	}
}

2.验证TreeMap的特点

特点：针对于Key的自然排序
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

public class Test02 {

	public static void main(String[] args) {
		
		TreeMap<String, Integer>  map = new TreeMap<>();
		
		map.put("c",10);
		map.put("d",40);
		map.put("a",20);
		map.put("b",30);
		map.put("d",50);
		
		Set<Entry<String, Integer>> entrySet = map.entrySet();
		
		for (Entry<String, Integer> entry : entrySet) {
			String key = entry.getKey();
			Integer value = entry.getValue();
			System.out.println(key + "-----" + value);
		}
	}
}

3.内置比较器

import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
public class Test03 {

	public static void main(String[] args) {
		
		TreeMap<Student,String> map = new TreeMap<>();
		
		map.put(new Student("孙尚香", '女', 22, "2211", "001"),"赏月");     
		map.put(new Student("安吉拉", '女', 25, "2211", "002"),"闻香");     
		map.put(new Student("虞姬", '女', 19, "2211", "003"),"听雨");     
		map.put(new Student("妲己", '女', 29, "2211", "004"),"拾花");     
		map.put(new Student("杨贵妃", '女', 21, "2211", "005"),"闻香");    
		map.put(new Student("钟无艳", '女', 20, "2211", "006"),"听雨");    
		map.put(new Student("貂蝉", '女', 19, "2211", "007"),"拾花");    
		map.put(new Student("大桥", '女', 18, "2211", "008"),"赏月");    
		map.put(new Student("伽罗", '女', 21, "2211", "009"),"赏花");    
		map.put(new Student("黄忠", '男', 25, "2211", "010"),"酌酒");     
		map.put(new Student("小乔", '女', 22, "2212", "001"),"赏花");    
		map.put(new Student("阿珂", '女', 24, "2212", "002"),"闻香");    
		map.put(new Student("瑶", '女', 20, "2212", "003"),"上身");   
		map.put(new Student("上官婉儿", '女', 22, "2212", "004"),"酌酒");  
		map.put(new Student("墨瞳茉拉", '女', 22, "2213", "004"),"抚琴"); 
		
		Set<Entry<Student, String>> entrySet = map.entrySet();
		for (Entry<Student, String> entry : entrySet) {
			System.out.println(entry);
		}
	}

public class Student implements Comparable<Student>{
	
	private String name;
	private char sex;
	private int age;
	private String classId;
	private String id;
	
	public Student() {
	}
	
	public Student(String classId, String id) {
		this.classId = classId;
		this.id = id;
	}

	public Student(String name, char sex, int age, String classId, String id) {
		this.name = name;
		this.sex = sex;
		this.age = age;
		this.classId = classId;
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public char getSex() {
		return sex;
	}

	public void setSex(char sex) {
		this.sex = sex;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getClassId() {
		return classId;
	}

	public void setClassId(String classId) {
		this.classId = classId;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}
	
	//判断两个学生是否相同（班级号 + 学号）
	@Override
	public boolean equals(Object obj) {
		if(this == obj){
			return true;
		}
		
		if(obj instanceof Student){
			Student stu = (Student) obj;
			if(classId.equals(stu.classId) && id.equals(stu.id)){
				return true;
			}
		}
		
		return false;
	}

	@Override
	public String toString() {
		return name + "\t" + sex + "\t" + age + "\t" + classId + "\t" + id;
	}

	//排序规则：按照年龄排序
	@Override
	public int compareTo(Student o) {
		//年龄差
		int num = this.age - o.age;
		if(num != 0){
			return num;
		}
		
		if(this == o || this.equals(o)){
			return 0;
		}
		
		return 1;//年龄相同，但是两个学生又不是同一个对象，我们还是返回1
	}
}

4.外置比较器

import java.util.Comparator;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

public class Test04 {

	public static void main(String[] args) {
		
		TreeMap<Student, String> map = new TreeMap<>(new Comparator<Student>() {

			@Override
			public int compare(Student o1, Student o2) {
			if (o1 == o2 || o1.equals(o2)) {
				return 0;
			}
			int len1 = o1.getName().length();
			int len2 = o2.getName().length();
			if (len1 != len2) {
				return len1-len2;
			}
			int age1 = o1.getAge();
			int age2 = o2.getAge();
			if (age1 != age2) {
				return age1-age2;
			}
				return 1;
			}
		});
		map.put(new Student("孙尚香", '女', 22, "2211", "001"),"赏月");     
		map.put(new Student("安吉拉", '女', 25, "2211", "002"),"闻香");     
		map.put(new Student("虞姬", '女', 19, "2211", "003"),"听雨");     
		map.put(new Student("妲己", '女', 29, "2211", "004"),"拾花");     
		map.put(new Student("杨贵妃", '女', 21, "2211", "005"),"闻香");    
		map.put(new Student("钟无艳", '女', 20, "2211", "006"),"听雨");    
		map.put(new Student("貂蝉", '女', 19, "2211", "007"),"拾花");    
		map.put(new Student("大桥", '女', 18, "2211", "008"),"赏月");    
		map.put(new Student("伽罗", '女', 21, "2211", "009"),"赏花");    
		map.put(new Student("黄忠", '男', 25, "2211", "010"),"酌酒");     
		map.put(new Student("小乔", '女', 22, "2212", "001"),"赏花");    
		map.put(new Student("阿珂", '女', 24, "2212", "002"),"闻香");    
		map.put(new Student("瑶", '女', 20, "2212", "003"),"上身");   
		map.put(new Student("上官婉儿", '女', 22, "2212", "004"),"酌酒");  
		map.put(new Student("墨瞳茉拉", '女', 22, "2213", "004"),"抚琴");
		
		Set<Entry<Student,String>> entrySet = map.entrySet();
		for (Entry<Student, String> entry : entrySet) {
			System.out.println(entry);
		}
	}
}

二、Sort

1.ArrayList排序

import java.util.ArrayList;
import java.util.Comparator;

public class Test01 {

	public static void main(String[] args) {
		
		ArrayList<String> list = new ArrayList<>();
		
		list.add("d");
		list.add("a");
		list.add("bc");
		list.add("b");
		list.add("B");
		list.add("bac");
		list.add("e");
		list.add("A");
		list.add("ecz");
		list.add("ea");
		list.add("C");
		list.add("c");
		
		list.sort(new Comparator<String>() {

			@Override
			public int compare(String o1, String o2) {
				return o1.compareTo(o2);
			}
		});
		
		for (String element : list) {
			System.out.println(element);
		}
	}
}

2.HashMap的value排序

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;

public class Test02 {

	public static void main(String[] args) {
		
		HashMap<String, Integer> map = new HashMap<>();
		
		 map.put("大桥",18);
		 map.put("小乔",19);
		 map.put("西施",25);
		 map.put("王昭君",20);
		 map.put("杨贵妃",23);
		 map.put("貂蝉",28);
		 
			//将map所有的映射关系取出 -- entrySet()
		 Set<Entry<String, Integer>> entrySet = map.entrySet();
		 
		//将Set集合转换为ArrayList集合
		 ArrayList<Entry<String, Integer>> list = new ArrayList<>(entrySet);
		 
		 list.sort(new Comparator<Entry<String,Integer>>() {

			@Override
			public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
				
				Integer value1 = o1.getValue();
				Integer value2 = o2.getValue();
				if (value1 == value2) {
					return 1;
				}
				return value1 - value2;
			}
		});
		 for (Entry<String, Integer> entry : list) {
			System.out.println(entry);
		}
	}
}

三、Properties – 配置文件

import java.io.IOException;
import java.util.Properties;

public class Test01 {
	public static void main(String[] args) throws IOException {
		
		//创建配置文件对象
		Properties properties = new Properties();
		
		//将配置文件加载到对象中
		properties.load(Test01.class.getClassLoader().getResourceAsStream("DBConfig.properties"));
		
		//读取配置文件中的数据
		String username = properties.getProperty("username");
		String password = properties.getProperty("password");
		System.out.println(username + " -- " + password);
		
	}
}

username=gl
password=123456

四、Collections – 集合工具类

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;

public class Test01 {

	public static void main(String[] args) {
		
		ArrayList<String> list = new ArrayList<>();
		
		//批量添加
		Collections.addAll(list, "c","a","d","b");
		
		//使用集合中元素的内置比较器进行排序
		Collections.sort(list);
		
		//使用外置置比较器进行排序
		Collections.sort(list, new Comparator<String>() {

			@Override
			public int compare(String o1, String o2) {
				return -o1.compareTo(o2);
			}
		});
		
		//替换
		Collections.fill(list, "abc");
		
		System.out.println(Arrays.toString(list.toArray()));
	}
}

五、总结

1.Collection 与 Map的区别

1.Collection 存单个值，可以获取迭代器进行遍历
2.Map存两个值(Key-Value)，不可以获取迭代器，不能遍历（Map可以间接遍历）

2.ArrayList 与 LinkedList的区别

1.使用上的区别：
LinkedList添加了
队列模式-先进先出（removeFirst（））
栈模式-先进后出（removeLast（））
2.效率上的区别：
1.ArrayList底层数据结构是一维数组
2.LinkedList底层数据结构是双向链表
添加 - 不扩容的情况：ArrayList快
添加 - 扩容的情况：LinkedList快
删除：LinkedList快
查询：ArrayList快
修改：ArrayList快
3.注意：工作中常用ArrayList，因为很多需求都需要使用查询功能，ArrayList查询更快

3.各种集合的应用场景

1.ArrayList：存数据，线程不安全
2.LinkedLinked：队列模式、栈模式，线程不安全
3.Vector：弃用，线程安全
4.Stack：弃用，线程安全
5.HashSet：去重+无序，线程不安全
6.LinkedHashSet：去重+有序，线程不安全
7.TreeSet：排序，线程不安全
8.HashMap：存key+value，key去重，无序，线程不安全
9.LinkedHashMap：存key+value，key去重，有序，线程不安全
10.Hashtable：弃用，存key+value，key去重，无序，线程安全，方法加锁-效率低
11.ConcurrentHashMap：存key+value，key去重，无序，线程安全，局部加锁、CAS-效率高
12.TreeMap：存key+value，针对于Key排序
13.Properties：配置文件
雨霖先森
关注
专栏目录
JAVA＜集合框架＞完结--Map、HashMap、TreeMap、Collections工具类
weixin_42875313的博客
04-10 422
1.集合的概念 2.Collection接口 3.List接口与实现类 4.泛型和工具类 5.Set接口与实现类 6.Map接口与实现类 Map接口与实现类 一丶Map父接口 特点：存储一对数据（Key-Value），无序、无下标，键不可重复，值可重复。 方法： V put（K key，V value） //将对象存入到集合中，关联键值。key重复则覆盖原值。 Object get（Object key） //根据键获得对应的值 Set //返回所有key Collection va...
应用程序开发——集合（泛型、List与Set集合互转换、Map、Properties、集合工具类Collections、同步控制）
jin_luo的博客
03-24 1684
泛型：（规定集合中存放对象的数据类型）●  语法：集合类型&lt;数据类型&gt;  集合对象名  = new  接口实现类&lt;数据类型&gt;();●  例子：List&lt;Person&gt;  list  = new  ArrayList&lt;Person&gt;();注意：没有显示的指明泛型时，它的类型默认为Object，只能在泛型中存放引用数据类型，基本数据类型时必须使用其包装类...
TreeMap按VALUE排序
06-10
TreeMap按VALUE排序
java集合之Map家族
我要上天
06-08 522
Map家族类图关系
Java集合框架之Map家族
小诸葛的博客
08-28 319
1.HashMap 结构：数组+链表+红黑树 特点：线程不安全、无序 初始容量：8 初始负载因子：0.75 扩容：每次增加为原有容量的2倍 容量：2的n次幂 2.Hashtable 结构：数组+链表 特点：线程安全、重量级锁、无序 初始容量：11 初始负载因子：0.75 扩容：每次扩容后容量变为原有容量的2倍+1 3.TreeMap 结构：红黑树 特点：线程不安全、有序 4.LinkedHashMap 结构：继承自HashMap，在HashMap基础上增加了双向链表 特点
java集合大家族之Map
08-15 1164
MapMap也被称为映射表（关联数组），使得你可以用键来查找对象，键所关联的对象被称为值，因此你可以使用键来找值，用对象来查找对象。Map保存的键不重复，如果有相同的键被加入，那么原来的值将被加入的值覆盖。键必须是唯一的，而值可以有重复。标准的java类库中包含了Map的几种基本实现，包括：HashMap、TreeMap、LinkedHashMap、WeakHashMap、ConcurrentHas
TreeMap排序
.
09-01 1116
TreeMap 的两种排序 自然排序 pojo需要实现Comparable接口，调用compareTo方法进行比较 如：数组的.sort() 以及collections.sort()方法都是自然排序，调用集合元素的compareTo方法来比较元素的大小关系，然后将集合元素按照升序排列(从小到大）   自定义排序 实现compartor接口，重写Comparator方法即可   ...
【Java】Java集合（Collection 、Map、Collections工具类）
DempseyLee的博客
03-06 314
01 集合框架概述 集合，数组都是对多个数据进行存储操作的结构，简称Java容器。此时的存储，主要指内存层面的存储，不涉及持久化存储（指保存在文件里） 数组在存储多个数据方面的特点： .数组一旦初始化长度就确定了 数组声明的类型，就决定了元素初始化的类型 比如： Object[] arr1;String[] arr; 数组在存储多个数据的缺点 一旦初始化后，数组长度不可修改，不便于扩展。 数组中提供的方法有限，对于数据的添加，删除，插入等操作非常不便 获取数组中实际元素个
Java中的集合之Map接口的实现类
ganfanqiang的博客
07-21 356
111
单列集合Collection-双列集合Map
weixin_64650214的博客
09-30 1095
集合的简单使用
TreeMap实现排序
小泽
01-15 1541
TreeMap TreeMap实现SortMap接口，能够把它保存的记录根据键排序，默认是按键值的升序排序，也可以指定排序的比较器。当用Iterator遍历TreeMap时，得到的记录是排过序的。 TreeMap取出来的是排序后的键值对。但如果您要按自然顺序或自定义顺序遍历键，那么TreeMap会更好。 TreeMap基于红黑树实现。TreeMap没有调优选项，因为该树总处于平衡状态。 ...
集合家族
qq_46698210的博客
10-17 238
1、集合家族可分为collection和Map 2、List set继承至collection； 3、list与set的相同点与不同点 相同点：都是单列元素的集合，有一个共同的父接口Collection 区别：set里不允许有重复的元素。假设set集合里有一个A对象，现在再存进去一个B对象，但是B对象与A对象equals相等，则B对象就不能存进去，set集合的add方法有一个boolean返回值,当添加成功则返回true返回失败则返回false list表示与先后顺序的集合，当多次调用add方法时，就想排队
【集合详解】Java集合总结（中）-Map家族
博学之,审问之,慎思之,明辨之,笃行之
08-04 1656
接上文，本篇博客我们接着谈论有关集合的内容。 java所有的集合分成三大类。Set类似罐子，把一个对象添加到Set集合时,Set集合无法记住添加这个元素的顺序，所以Set里的元素不能重复。List集合非常想一个数组，可以记住每次添加元素的顺序，且List的长度可变。Map集合也想一个罐子，只是它里面的每个数据都有两个值组成。 List根据索引访问，Map根据Key访问其value,Set只能根据
TreeMap各种排序方式
yygr的博客
06-29 3608
https://www.jb51.net/article/90537.htmMap是键值对的集合接口，它的实现类主要包括：HashMap,TreeMap,Hashtable以及LinkedHashMap等。•TreeMap：基于红黑树（Red-Black tree）的 NavigableMap 实现，该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。•HashMap的值是没有顺序的，它是按照key的HashCode来实现的，对于这个无序的H
Java集合细究之TreeSet和TreeMap的两种排序方式
weixin_66813230的博客
03-15 2198
一、TreeSet比较常见形式 TreeSet可以对元素按照某种规则进行排序： public class test { public static void main(String[] args) { Set<Integer> s1=new TreeSet<>(); s1.add(23); s1.add(3); s1.add(2); s1.add(13); ...
【Java - D】重写TreeMap和sort
qq_38734403的博客
03-22 276
题目描述 统计频率，并按序输出 实现 public class Solution { public static void sortValue(int[] nums) { TreeMap<Integer, Integer> map = new TreeMap<>(new Comparator<Integer>() { @Override public int compare(Integer o1, I
TreeMap和TreeSet在排序时如何比较元素？Collections工具类中的sort()方法如何比较元素？...
weixin_30786617的博客
04-21 162
TreeSet要求存放的对象所属的类必须实现Comparable接口，该接口提供了比较元素的compareTo()方法，当插入元素时会回调该方法比较元素的大小。TreeMap要求存放的键值对映射的键必须实现Comparable接口从而根据键对元素进行排序。Collections工具类的sort方法有两种重载的形式，第一种要求传入的待排序容器中存放的对象比较实现Comparable接口以实现元素的比...
#一次性给集合添加多个元素 #Collections.addAll @FDDLC
LiuXingchang的博客
11-18 1590
需求：一次性给集合添加多个元素。 示例： import java.util.Collections; import java.util.LinkedList; import java.util.List; class Solution{ public static void main(String[] args) { List<Integer> list = new LinkedList<>(); Collections.addA.
聊一聊java中的SortedMap,TreeMap,以及SortedSet和TreeSet
最新发布
github_38727595的博客
04-10 1185
聊一聊java框架中的SortedMap,TreeMap,SortedSet和TreeSet
java集合类之map的treemap
06-06
TreeMap是Java集合框架中的一种Map实现，它基于红黑树数据结构实现。TreeMap中的元素按照键的自然顺序或者自定义顺序进行排序，因此它是一个有序的Map。TreeMap提供了一系列的方法来操作Map中的元素，例如添加、删除...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

雨霖先森

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值