Java Set集合及Map集合详解

一、LinkedHashSet使用

1.1知识点:

 HashSet怎么使用LinkedHashSet就怎么使用 

 1.2直接上代码,可以和前面的文章做对比

package com.qf.linkedhashset_class;

import java.util.LinkedHashSet;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;

public class Test01 {

	public static void main(String[] args) {
		/**
		 * class LinkedHashSet extends HashSet
		 * HashSet怎么使用,LinkedHashSet就怎么使用
		 */
		
		//创建LinkedHashSet集合对象
		LinkedHashSet set = new LinkedHashSet<>();
		
		//添加元素
		set.add("椎名空");
		set.add("李林俊");
		set.add("天使萌");
		set.add("佐佐木希");
		set.add("古川伊织");
		set.add("京香Julia");
		
		//将newSet1中所有的元素添加到set集合
		LinkedHashSet newSet1 = new LinkedHashSet<>();
		Collections.addAll(newSet1, "aaa","bbb","ccc","ccc");//利用集合工具类对集合进行批量添加
		set.addAll(newSet1);
		
		//获取元素个数
		int size = set.size();
		System.out.println("获取元素个数:" + size);
		
		//清空集合中所有的元素
		//set.clear();
		
		System.out.println("判断集合中是否有指定元素:" + set.contains("天使萌"));//true
		System.out.println("判断集合中是否有指定集合(判断包含关系):" + set.containsAll(newSet1));//true
		System.out.println("判断集合中是否没有元素:" + set.isEmpty());//false (true-没有元素 false-有元素)
		
		//依据元素删除元素
		set.remove("上原亚衣");
		
		//去除交集
		set.removeAll(newSet1);
		
		//保留交集
		LinkedHashSet newSet2 = new LinkedHashSet<>();
		Collections.addAll(newSet2, "佐佐木希","古川伊织","天使萌","天使萌");
		set.retainAll(newSet2);
		
		//将集合转换为数组
		Object[] array = newSet2.toArray();
		System.out.println(Arrays.toString(array));
		
		System.out.println("---------------");
		
		//遍历1 - foreach
		for (String element : set) {
			System.out.println(element);
		}
		
		System.out.println("---------------");
		
		//遍历2 - Iterator
		Iterator it = set.iterator();
		while(it.hasNext()){//判断是否有下一个可迭代的元素
			String next = it.next();//返回下一个元素
			System.out.println(next);
		}
	}
}

 1.3 LinkedHashSet特点

有序排序 + 去重

存储数据:
        1.获取对象的hash值
        2.通过hash值+散列算法获取到数组中的下标
        3.将元素添加到节点对象中(节点对象-双向链表)
取出数据:
        获取到第一个节点对象,再依次循环到下一个节点(有序的)  

 1.3.1 Node部分底层

package com.qf.linkedhashset_class;

public class Node {

	private E e;//元素
	private Node prev;//上一个节点的地址
	private Node next;//下一个节点的地址
	
	public Node() {
	}

	public Node(E e, Node prev, Node next) {
		this.e = e;
		this.prev = prev;
		this.next = next;
	}

	public E getE() {
		return e;
	}

	public void setE(E e) {
		this.e = e;
	}

	public Node getPrev() {
		return prev;
	}

	public void setPrev(Node prev) {
		this.prev = prev;
	}

	public Node getNext() {
		return next;
	}

	public void setNext(Node next) {
		this.next = next;
	}

	@Override
	public String toString() {
		return e + "";
	}
}
package com.qf.linkedhashset_class;

import java.util.LinkedHashSet;

public class Test02 {

	public static void main(String[] args) {
		
		LinkedHashSet set = new LinkedHashSet<>();
		
		set.add("椎名空");
		set.add("张三");
		set.add("天使萌");
		set.add("佐佐木希");
		set.add("古川伊织");
		set.add("京香Julia");
		set.add("京香Julia");
		
		for (String str : set) {
			System.out.println(str);
		}
		
		System.out.println("-------------");
		
		//稍微理解下双向链表
		//当前节点可以找到上一个节点,也可以找到下一个节点
		
		Node node1 = new Node<>("椎名空", null, null);
		Node node2 = new Node<>("张三", null, null);
		Node node3 = new Node<>("天使萌", null, null);
		
		node1.setNext(node2);
		node2.setPrev(node1);
		node2.setNext(node3);
		node3.setPrev(node2);
		
		Node first = node1;
		
		while(first != null){
			System.out.println(first);
			first = first.getNext();
		}
		
	}
}

1.4 TreeSet使用方法

 其实TreeSet的使用和LinkedHashSet的使用大同小异

 1.4.1TeeSet使用代码

package com.qf.treeset_class;

import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.TreeSet;

public class Test01 {

	public static void main(String[] args) {
		
		//创建TreeSet集合对象
		TreeSet set = new TreeSet<>();
		
		//添加元素
		set.add("椎名空");
		set.add("李林俊");
		set.add("天使萌");
		set.add("佐佐木希");
		set.add("古川伊织");
		set.add("京香Julia");
		
		//将newSet1中所有的元素添加到set集合
		TreeSet newSet1 = new TreeSet<>();
		Collections.addAll(newSet1, "aaa","bbb","ccc","ccc");//利用集合工具类对集合进行批量添加
		set.addAll(newSet1);
		
		//获取元素个数
		int size = set.size();
		System.out.println("获取元素个数:" + size);
		
		//清空集合中所有的元素
		//set.clear();
		
		System.out.println("判断集合中是否有指定元素:" + set.contains("天使萌"));//true
		System.out.println("判断集合中是否有指定集合(判断包含关系):" + set.containsAll(newSet1));//true
		System.out.println("判断集合中是否没有元素:" + set.isEmpty());//false (true-没有元素 false-有元素)
		
		//依据元素删除元素
		set.remove("上原亚衣");
		
		//去除交集
		set.removeAll(newSet1);
		
		//保留交集
		TreeSet newSet2 = new TreeSet<>();
		Collections.addAll(newSet2, "佐佐木希","古川伊织","天使萌","天使萌");
		set.retainAll(newSet2);
		
		//将集合转换为数组
		Object[] array = newSet2.toArray();
		System.out.println(Arrays.toString(array));
		
		System.out.println("---------------");
		
		//遍历1 - foreach
		for (String element : set) {
			System.out.println(element);
		}
		
		System.out.println("---------------");
		
		//遍历2 - Iterator
		Iterator it = set.iterator();
		while(it.hasNext()){//判断是否有下一个可迭代的元素
			String next = it.next();//返回下一个元素
			System.out.println(next);
		}
	}

}

1.5 TreeSet自身特点

自然排序 - 根究不同的类型自动找到对应的排序规则 

package com.qf.treeset_class;

import java.util.TreeSet;

public class Test02 {

	public static void main(String[] args) {

		//TreeSet存储String的排序方式:字典排序
		TreeSet set1 = new TreeSet<>();
		set1.add("b");
		set1.add("d");
		set1.add("a");
		set1.add("c");
		set1.add("c");
		for (String element : set1) {
			System.out.println(element);
		}
		
		//TreeSet存储Integer的排序方式:数字升序
		TreeSet set2 = new TreeSet<>();
		set2.add(5);
		set2.add(1);
		set2.add(3);
		set2.add(2);
		set2.add(4);
		set2.add(4);
		for (Integer element : set2) {
			System.out.println(element);
		}
	}
}

1.6 重点(内置比较器 - Comparable

1.创建一个学生类实现 Comparable 接口方法

2.实现排序规则(排序规则按照自己的需求写)

package com.qf.treeset_class;

public class Student implements Comparable{

	private String name;
	private char sex;
	private int age;
	private String classId;
	private String id;
	
	public Student() {
	}

	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(this.classId.equals(stu.classId) && this.id.equals(stu.id)){
				return true;
			}
		}
		return false;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", sex=" + sex + ", age=" + age + ", classId=" + classId + ", id=" + id + "]";
	}

	//排序规则:按照年龄排序
	@Override
	public int compareTo(Student o) {
		return this.age - o.age;
        //this.age 是传进来的值 o.age 是上一个根节点的值
	}
}
package com.qf.treeset_class;

import java.util.TreeSet;

public class Test03 {

	public static void main(String[] args) {
		/**
		 * 知识点:内置比较器 - Comparable
		 */
		
		TreeSet set = new TreeSet<>();
		
		set.add(new Student("天海翼", '女', 28, "2204", "001"));
		set.add(new Student("天使萌", '女', 21, "2204", "002"));
		set.add(new Student("水菜丽", '女', 25, "2204", "003"));
		set.add(new Student("佐佐木希", '女', 22, "2204", "004"));
		set.add(new Student("上原亚衣", '女', 27, "2204", "005"));
		set.add(new Student("濑亚美莉", '女', 18, "2204", "006"));
		set.add(new Student("深田咏美", '女', 23, "2204", "007"));
		set.add(new Student("泷泽萝拉", '女', 25, "2204", "008"));
		set.add(new Student("冲田杏梨", '女', 27, "2204", "009"));
		
		for (Student stu : set) {
			System.out.println(stu);
		}
	}
}

1.7外置比较器 - Comparator 

1.7.1使用条件 

 当内置比较器不满足排序规则时使用外置比较器(使用匿名内部类)

package com.qf.treeset_class;

import java.util.Comparator;
import java.util.TreeSet;

public class Test04 {

	public static void main(String[] args) {
		/**
		 * 知识点:外置比较器 - Comparator
		 * 
		 * 应用场景:
		 * 			联合开发
		 * 
		 * Comparable vs Comparator
		 * 优先级别:Comparator > Comparable
		 */
		
		TreeSet set = new TreeSet<>(new Comparator() {
			
			//排序规则:按照名字长度排序,名字长度一致按照年龄排序
			@Override
			public int compare(Student o1, Student o2) {
				if(o1.equals(o2)){
					return 0;
				}
				
				int nameLen1 = o1.getName().length();
				int nameLen2 = o2.getName().length();
				if(nameLen1 != nameLen2){
					return nameLen1 - nameLen2;
				}
				
				int age1 = o1.getAge();
				int age2 = o2.getAge();
				if(age1 != age2){
					return age1 - age2;
				}
				
				return 1;
			}
		});
		
		set.add(new Student("水菜丽", '女', 25, "2204", "003"));
		set.add(new Student("佐佐木希", '女', 22, "2204", "004"));
		set.add(new Student("天使萌", '女', 21, "2204", "002"));
		set.add(new Student("上原亚衣", '女', 27, "2204", "005"));
		set.add(new Student("濑亚美莉", '女', 18, "2204", "006"));
		set.add(new Student("天海翼", '女', 28, "2204", "001"));
		set.add(new Student("深田咏美", '女', 23, "2204", "007"));
		set.add(new Student("泷泽萝拉", '女', 25, "2204", "008"));
		set.add(new Student("冲田杏梨", '女', 27, "2204", "009"));
		set.add(new Student("冲田杏梨", '女', 27, "2204", "009"));
		
		for (Student stu : set) {
			System.out.println(stu);
		}
	}
}

 1.8二叉树(图片来着网络)

Java Set集合及Map集合详解_第1张图片

 二、HashMap

package com.qf.hashmap_class;

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

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 知识点:HashMap的使用
		 * 
		 * 特点:无序 + key唯一(去重)
		 */
		
		//创建HashMap对象
		HashMap map = new HashMap<>();
		
		//添加数据
		Integer put1 = map.put("麻生希", 28);
		Integer put2 = map.put("椎名空", 23);
		Integer put3 = map.put("天使萌", 26);
		Integer put4 = map.put("水菜丽", 26);
		Integer put5 = map.put("爱田奈奈", 25);
		Integer put6 = map.put("小峰由衣", 29);
		System.out.println(put1);//null
		System.out.println(put2);//null
		System.out.println(put3);//null
		System.out.println(put4);//null
		System.out.println(put5);//null
		System.out.println(put6);//null
		
		//将newMap集合添加到map集合中
		HashMap newMap = new HashMap<>();
		newMap.put("aaa", 10);
		newMap.put("bbb", 20);
		newMap.put("ccc", 30);
		newMap.put("ccc", 40);
		map.putAll(newMap);
		
		//如果集合中有该key就获取对应的value值
		//如果集合中没有该key就添加数据
		Integer putIfAbsent = map.putIfAbsent("椎名空1", 25);
		System.out.println("putIfAbsent -- " + putIfAbsent);
		
		
		//替换数据 -- 返回被替换的值
		Integer put7 = map.put("小峰由衣", 30);
		System.out.println(put7);//29
		
		//根据Key替换数据 -- 返回被替换的值
		Integer replace1 = map.replace("小峰由衣", 31);
		System.out.println(replace1);//30
		
		//根据Key+Value替换数据
		boolean replace2 = map.replace("小峰由衣", 31, 32);
		System.out.println(replace2);//true

		//通过key获取到value
		Integer integer1 = map.get("天使萌");
		System.out.println("通过key获取到value:" + integer1);
		
		//通过key获取到value,如果key不存在则返回默认值
		Integer integer2 = map.getOrDefault("天使萌111", 888);
		System.out.println("通过key获取到value,如果key不存在则返回默认值:" + integer2);
		
		//清空集合中的数据
		//map.clear();
		
		System.out.println("判断集合中是否包含某个key:" + map.containsKey("天使萌"));
		System.out.println("判断集合中是否包含某个value:" + map.containsValue(26));
		
		System.out.println("判断集合是否没有元素:" + map.isEmpty());
		
		//删除元素
		map.remove("椎名空1");//通过key删除映射关系
		map.remove("小峰由衣", 32);//通过key+value删除映射关系
		
		System.out.println("获取元素(映射关系)个数:" + map.size());
		
		//获取map中所有的value,返回一个Collection集合
		Collection values = map.values();
		System.out.println(Arrays.toString(values.toArray()));
		
		System.out.println("-----------------");
		
		//遍历1 -- keySet()
		//遍历思路:
		//	1.将map中所有的key获取出并存放在Set集合中
		//	2.遍历Set集合,依次取出key,再使用map.get(key)获取出对应的value值
		Set keySet = map.keySet();
		for (String key : keySet) {
			Integer value = map.get(key);
			System.out.println(key + " -- " + value);
		}
		System.out.println("-----------------");
		
		//遍历2 -- entrySet()
		//遍历思路:
		//	1.将map中所有的映射关系对象获取出并存放在Set集合中
		//	2.遍历Set集合,依次取出映射关系对象,映射关系对象中包含的key和value也就取出了
		Set> entrySet = map.entrySet();
		for (Entry entry : entrySet) {
			String key = entry.getKey();
			Integer value = entry.getValue();
			System.out.println(key + " -- " + value);
		}
		
	}
}

三、LinkedHashMap的使用

package com.qf.linkedhashmap_class;

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

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 知识点:LinkedHashMap的使用
		 * 
		 * 特点:有序 + key唯一(去重)
		 */
		
		//创建LinkedHashMap对象
		LinkedHashMap map = new LinkedHashMap<>();
		
		//添加数据
		Integer put1 = map.put("麻生希", 28);
		Integer put2 = map.put("椎名空", 23);
		Integer put3 = map.put("天使萌", 26);
		Integer put4 = map.put("水菜丽", 26);
		Integer put5 = map.put("爱田奈奈", 25);
		Integer put6 = map.put("小峰由衣", 29);
		System.out.println(put1);//null
		System.out.println(put2);//null
		System.out.println(put3);//null
		System.out.println(put4);//null
		System.out.println(put5);//null
		System.out.println(put6);//null
		
		//将newMap集合添加到map集合中
		LinkedHashMap newMap = new LinkedHashMap<>();
		newMap.put("aaa", 10);
		newMap.put("bbb", 20);
		newMap.put("ccc", 30);
		newMap.put("ccc", 40);
		map.putAll(newMap);
		
		//如果集合中有该key就获取对应的value值
		//如果集合中没有该key就添加数据
		Integer putIfAbsent = map.putIfAbsent("椎名空1", 25);
		System.out.println("putIfAbsent -- " + putIfAbsent);
		
		
		//替换数据 -- 返回被替换的值
		Integer put7 = map.put("小峰由衣", 30);
		System.out.println(put7);//29
		
		//根据Key替换数据 -- 返回被替换的值
		Integer replace1 = map.replace("小峰由衣", 31);
		System.out.println(replace1);//30
		
		//根据Key+Value替换数据
		boolean replace2 = map.replace("小峰由衣", 31, 32);
		System.out.println(replace2);//true

		//通过key获取到value
		Integer integer1 = map.get("天使萌");
		System.out.println("通过key获取到value:" + integer1);
		
		//通过key获取到value,如果key不存在则返回默认值
		Integer integer2 = map.getOrDefault("天使萌111", 888);
		System.out.println("通过key获取到value,如果key不存在则返回默认值:" + integer2);
		
		//清空集合中的数据
		//map.clear();
		
		System.out.println("判断集合中是否包含某个key:" + map.containsKey("天使萌"));
		System.out.println("判断集合中是否包含某个value:" + map.containsValue(26));
		
		System.out.println("判断集合是否没有元素:" + map.isEmpty());
		
		//删除元素
		map.remove("椎名空1");//通过key删除映射关系
		map.remove("小峰由衣", 32);//通过key+value删除映射关系
		
		System.out.println("获取元素(映射关系)个数:" + map.size());
		
		//获取map中所有的value,返回一个Collection集合
		Collection values = map.values();
		System.out.println(Arrays.toString(values.toArray()));
		
		System.out.println("-----------------");
		
		//遍历1 -- keySet()
		//遍历思路:
		//	1.将map中所有的key获取出并存放在Set集合中
		//	2.遍历Set集合,依次取出key,再使用map.get(key)获取出对应的value值
		Set keySet = map.keySet();
		for (String key : keySet) {
			Integer value = map.get(key);
			System.out.println(key + " -- " + value);
		}
		System.out.println("-----------------");
		
		//遍历2 -- entrySet()
		//遍历思路:
		//	1.将map中所有的映射关系对象获取出并存放在Set集合中
		//	2.遍历Set集合,依次取出映射关系对象,映射关系对象中包含的key和value也就取出了
		Set> entrySet = map.entrySet();
		for (Entry entry : entrySet) {
			String key = entry.getKey();
			Integer value = entry.getValue();
			System.out.println(key + " -- " + value);
		}
		
	}
}

 四、Hashtable的使用

package com.qf.hashtable_class;

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

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 知识点:Hashtable的使用
		 * 
		 * 特点:无序 + key唯一(去重) + 线程安全的(加锁)
		 * 
		 * 注意:Hashtable方法上加锁,效率低,弃用
		 */
		
		//创建Hashtable对象
		Hashtable map = new Hashtable<>();
		
		//添加数据
		Integer put1 = map.put("麻生希", 28);
		Integer put2 = map.put("椎名空", 23);
		Integer put3 = map.put("天使萌", 26);
		Integer put4 = map.put("水菜丽", 26);
		Integer put5 = map.put("爱田奈奈", 25);
		Integer put6 = map.put("小峰由衣", 29);
		System.out.println(put1);//null
		System.out.println(put2);//null
		System.out.println(put3);//null
		System.out.println(put4);//null
		System.out.println(put5);//null
		System.out.println(put6);//null
		
		//将newMap集合添加到map集合中
		Hashtable newMap = new Hashtable<>();
		newMap.put("aaa", 10);
		newMap.put("bbb", 20);
		newMap.put("ccc", 30);
		newMap.put("ccc", 40);
		map.putAll(newMap);
		
		//如果集合中有该key就获取对应的value值
		//如果集合中没有该key就添加数据
		Integer putIfAbsent = map.putIfAbsent("椎名空1", 25);
		System.out.println("putIfAbsent -- " + putIfAbsent);
		
		
		//替换数据 -- 返回被替换的值
		Integer put7 = map.put("小峰由衣", 30);
		System.out.println(put7);//29
		
		//根据Key替换数据 -- 返回被替换的值
		Integer replace1 = map.replace("小峰由衣", 31);
		System.out.println(replace1);//30
		
		//根据Key+Value替换数据
		boolean replace2 = map.replace("小峰由衣", 31, 32);
		System.out.println(replace2);//true

		//通过key获取到value
		Integer integer1 = map.get("天使萌");
		System.out.println("通过key获取到value:" + integer1);
		
		//通过key获取到value,如果key不存在则返回默认值
		Integer integer2 = map.getOrDefault("天使萌111", 888);
		System.out.println("通过key获取到value,如果key不存在则返回默认值:" + integer2);
		
		//清空集合中的数据
		//map.clear();
		
		System.out.println("判断集合中是否包含某个key:" + map.containsKey("天使萌"));
		System.out.println("判断集合中是否包含某个value:" + map.containsValue(26));
		
		System.out.println("判断集合是否没有元素:" + map.isEmpty());
		
		//删除元素
		map.remove("椎名空1");//通过key删除映射关系
		map.remove("小峰由衣", 32);//通过key+value删除映射关系
		
		System.out.println("获取元素(映射关系)个数:" + map.size());
		
		//获取map中所有的value,返回一个Collection集合
		Collection values = map.values();
		System.out.println(Arrays.toString(values.toArray()));
		
		System.out.println("-----------------");
		
		//遍历1 -- keySet()
		//遍历思路:
		//	1.将map中所有的key获取出并存放在Set集合中
		//	2.遍历Set集合,依次取出key,再使用map.get(key)获取出对应的value值
		Set keySet = map.keySet();
		for (String key : keySet) {
			Integer value = map.get(key);
			System.out.println(key + " -- " + value);
		}
		System.out.println("-----------------");
		
		//遍历2 -- entrySet()
		//遍历思路:
		//	1.将map中所有的映射关系对象获取出并存放在Set集合中
		//	2.遍历Set集合,依次取出映射关系对象,映射关系对象中包含的key和value也就取出了
		Set> entrySet = map.entrySet();
		for (Entry entry : entrySet) {
			String key = entry.getKey();
			Integer value = entry.getValue();
			System.out.println(key + " -- " + value);
		}
		
	}
}

五、ConcurrentHashMap的使用 

package com.qf.concurrenthashmap_class;

import java.util.Arrays;
import java.util.Collection;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 知识点:ConcurrentHashMap的使用
		 * 
		 * 特点:无序 + key唯一(去重) + 线程安全的(加锁)
		 * 
		 * 注意:ConcurrentHashMap是局部加锁+CAS实现的线程安全,效率高
		 */
		
		//创建ConcurrentHashMap对象
		ConcurrentHashMap map = new ConcurrentHashMap<>();
		
		//添加数据
		Integer put1 = map.put("麻生希", 28);
		Integer put2 = map.put("椎名空", 23);
		Integer put3 = map.put("天使萌", 26);
		Integer put4 = map.put("水菜丽", 26);
		Integer put5 = map.put("爱田奈奈", 25);
		Integer put6 = map.put("小峰由衣", 29);
		System.out.println(put1);//null
		System.out.println(put2);//null
		System.out.println(put3);//null
		System.out.println(put4);//null
		System.out.println(put5);//null
		System.out.println(put6);//null
		
		//将newMap集合添加到map集合中
		ConcurrentHashMap newMap = new ConcurrentHashMap<>();
		newMap.put("aaa", 10);
		newMap.put("bbb", 20);
		newMap.put("ccc", 30);
		newMap.put("ccc", 40);
		map.putAll(newMap);
		
		//如果集合中有该key就获取对应的value值
		//如果集合中没有该key就添加数据
		Integer putIfAbsent = map.putIfAbsent("椎名空1", 25);
		System.out.println("putIfAbsent -- " + putIfAbsent);
		
		
		//替换数据 -- 返回被替换的值
		Integer put7 = map.put("小峰由衣", 30);
		System.out.println(put7);//29
		
		//根据Key替换数据 -- 返回被替换的值
		Integer replace1 = map.replace("小峰由衣", 31);
		System.out.println(replace1);//30
		
		//根据Key+Value替换数据
		boolean replace2 = map.replace("小峰由衣", 31, 32);
		System.out.println(replace2);//true

		//通过key获取到value
		Integer integer1 = map.get("天使萌");
		System.out.println("通过key获取到value:" + integer1);
		
		//通过key获取到value,如果key不存在则返回默认值
		Integer integer2 = map.getOrDefault("天使萌111", 888);
		System.out.println("通过key获取到value,如果key不存在则返回默认值:" + integer2);
		
		//清空集合中的数据
		//map.clear();
		
		System.out.println("判断集合中是否包含某个key:" + map.containsKey("天使萌"));
		System.out.println("判断集合中是否包含某个value:" + map.containsValue(26));
		
		System.out.println("判断集合是否没有元素:" + map.isEmpty());
		
		//删除元素
		map.remove("椎名空1");//通过key删除映射关系
		map.remove("小峰由衣", 32);//通过key+value删除映射关系
		
		System.out.println("获取元素(映射关系)个数:" + map.size());
		
		//获取map中所有的value,返回一个Collection集合
		Collection values = map.values();
		System.out.println(Arrays.toString(values.toArray()));
		
		System.out.println("-----------------");
		
		//遍历1 -- keySet()
		//遍历思路:
		//	1.将map中所有的key获取出并存放在Set集合中
		//	2.遍历Set集合,依次取出key,再使用map.get(key)获取出对应的value值
		Set keySet = map.keySet();
		for (String key : keySet) {
			Integer value = map.get(key);
			System.out.println(key + " -- " + value);
		}
		System.out.println("-----------------");
		
		//遍历2 -- entrySet()
		//遍历思路:
		//	1.将map中所有的映射关系对象获取出并存放在Set集合中
		//	2.遍历Set集合,依次取出映射关系对象,映射关系对象中包含的key和value也就取出了
		Set> entrySet = map.entrySet();
		for (Entry entry : entrySet) {
			String key = entry.getKey();
			Integer value = entry.getValue();
			System.out.println(key + " -- " + value);
		}
		
	}
}

 六、HashMap vs LinkedHashMap vs Hashtable vs ConcurrentHashMap

HashMap:无序 + key去重 + 线程不安全
LinkedHashMap:有序 + key去重 + 线程不安全
Hashtable:无序 + key去重 + 线程安全(方法加锁,效率低,弃用)
ConcurrentHashMap:无序 + key去重 + 线程安全(局部加锁+CAS,效率高)
存储nullKey nullValue
HashMap                 Ok
LinkedHashMap         OK
Hashtable             NO
ConcurrentHashMap     NO 

七、TreeMap的使用

package com.qf.treemap_class;

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

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 知识点:TreeMap的使用
		 */
		
		//创建TreeMap对象
		TreeMap map = new TreeMap<>();
		
		//添加数据
		Integer put1 = map.put("麻生希", 28);
		Integer put2 = map.put("椎名空", 23);
		Integer put3 = map.put("天使萌", 26);
		Integer put4 = map.put("水菜丽", 26);
		Integer put5 = map.put("爱田奈奈", 25);
		Integer put6 = map.put("小峰由衣", 29);
		System.out.println(put1);//null
		System.out.println(put2);//null
		System.out.println(put3);//null
		System.out.println(put4);//null
		System.out.println(put5);//null
		System.out.println(put6);//null
		
		//将newMap集合添加到map集合中
		TreeMap newMap = new TreeMap<>();
		newMap.put("aaa", 10);
		newMap.put("bbb", 20);
		newMap.put("ccc", 30);
		newMap.put("ccc", 40);
		map.putAll(newMap);
		
		//如果集合中有该key就获取对应的value值
		//如果集合中没有该key就添加数据
		Integer putIfAbsent = map.putIfAbsent("椎名空1", 25);
		System.out.println("putIfAbsent -- " + putIfAbsent);
		
		
		//替换数据 -- 返回被替换的值
		Integer put7 = map.put("小峰由衣", 30);
		System.out.println(put7);//29
		
		//根据Key替换数据 -- 返回被替换的值
		Integer replace1 = map.replace("小峰由衣", 31);
		System.out.println(replace1);//30
		
		//根据Key+Value替换数据
		boolean replace2 = map.replace("小峰由衣", 31, 32);
		System.out.println(replace2);//true

		//通过key获取到value
		Integer integer1 = map.get("天使萌");
		System.out.println("通过key获取到value:" + integer1);
		
		//通过key获取到value,如果key不存在则返回默认值
		Integer integer2 = map.getOrDefault("天使萌111", 888);
		System.out.println("通过key获取到value,如果key不存在则返回默认值:" + integer2);
		
		//清空集合中的数据
		//map.clear();
		
		System.out.println("判断集合中是否包含某个key:" + map.containsKey("天使萌"));
		System.out.println("判断集合中是否包含某个value:" + map.containsValue(26));
		
		System.out.println("判断集合是否没有元素:" + map.isEmpty());
		
		//删除元素
		map.remove("椎名空1");//通过key删除映射关系
		map.remove("小峰由衣", 32);//通过key+value删除映射关系
		
		System.out.println("获取元素(映射关系)个数:" + map.size());
		
		//获取map中所有的value,返回一个Collection集合
		Collection values = map.values();
		System.out.println(Arrays.toString(values.toArray()));
		
		System.out.println("-----------------");
		
		//遍历1 -- keySet()
		//遍历思路:
		//	1.将map中所有的key获取出并存放在Set集合中
		//	2.遍历Set集合,依次取出key,再使用map.get(key)获取出对应的value值
		Set keySet = map.keySet();
		for (String key : keySet) {
			Integer value = map.get(key);
			System.out.println(key + " -- " + value);
		}
		System.out.println("-----------------");
		
		//遍历2 -- entrySet()
		//遍历思路:
		//	1.将map中所有的映射关系对象获取出并存放在Set集合中
		//	2.遍历Set集合,依次取出映射关系对象,映射关系对象中包含的key和value也就取出了
		Set> entrySet = map.entrySet();
		for (Entry entry : entrySet) {
			String key = entry.getKey();
			Integer value = entry.getValue();
			System.out.println(key + " -- " + value);
		}
		
	}
}

7.1TreeMap的特点 

package com.qf.treemap_class;

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

public class Test02 {

	public static void main(String[] args) {
		/**
		 * 知识点:TreeMap的特点
		 * 
		 * 特点:针对于Key排序
		 */
		
		TreeMap map = new TreeMap<>();
		
		map.put("c", 24);
		map.put("d", 28);
		map.put("a", 21);
		map.put("b", 23);
		map.put("b", 26);
		
		Set> entrySet = map.entrySet();
		for (Entry entry : entrySet) {
			String key = entry.getKey();
			Integer value = entry.getValue();
			System.out.println(key + " -- " + value);
		}
	}
}

 7.3内置比较器

package com.qf.treemap_class;

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

import com.qf.treeset_class.Student;

public class Test03 {

	public static void main(String[] args) {
		/**
		 * 知识点:内置比较器
		 */
		
		TreeMap map = new TreeMap<>();
		
		map.put(new Student("水菜丽", '女', 25, "2204", "003"), "拍电影");
		map.put(new Student("佐佐木希", '女', 22, "2204", "004"), "吃马赛克");
		map.put(new Student("天使萌", '女', 21, "2204", "002"), "吹喇叭");
		map.put(new Student("上原亚衣", '女', 27, "2204", "005"), "骑马");
		map.put(new Student("濑亚美莉", '女', 18, "2204", "006"), "交朋友");
		map.put(new Student("天海翼", '女', 28, "2204", "001"), "按摩");
		map.put(new Student("深田咏美", '女', 23, "2204", "007"), "写代码");
		map.put(new Student("泷泽萝拉", '女', 25, "2204", "008"), "看书");
		map.put(new Student("冲田杏梨", '女', 27, "2204", "009"), "补课");
		
		Set> entrySet = map.entrySet();
		for (Entry entry : entrySet) {
			
			System.out.println(entry);
		}
		
	}
}

7.4外置比较器

package com.qf.treemap_class;

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

import com.qf.treeset_class.Student;

public class Test04 {

	public static void main(String[] args) {
		/**
		 * 知识点:外置比较器
		 */
		
		TreeMap map = new TreeMap<>(new Comparator() {

			//排序规则:按照名字长度排序,名字长度一致按照年龄排序
			@Override
			public int compare(Student o1, Student o2) {
				if(o1.equals(o2)){
					return 0;
				}
				
				int nameLen1 = o1.getName().length();
				int nameLen2 = o2.getName().length();
				if(nameLen1 != nameLen2){
					return nameLen1 - nameLen2;
				}
				
				int age1 = o1.getAge();
				int age2 = o2.getAge();
				if(age1 != age2){
					return age1 - age2;
				}
				
				return 1;
			}
		});
		
		map.put(new Student("水菜丽", '女', 25, "2204", "003"), "拍电影");
		map.put(new Student("佐佐木希", '女', 22, "2204", "004"), "吃马赛克");
		map.put(new Student("天使萌", '女', 21, "2204", "002"), "吹喇叭");
		map.put(new Student("上原亚衣", '女', 27, "2204", "005"), "骑马");
		map.put(new Student("濑亚美莉", '女', 18, "2204", "006"), "交朋友");
		map.put(new Student("天海翼", '女', 28, "2204", "001"), "按摩");
		map.put(new Student("深田咏美", '女', 23, "2204", "007"), "写代码");
		map.put(new Student("泷泽萝拉", '女', 25, "2204", "008"), "看书");
		map.put(new Student("冲田杏梨", '女', 27, "2204", "009"), "补课");
		
		Set> entrySet = map.entrySet();
		for (Entry entry : entrySet) {
			
			System.out.println(entry);
		}
		
	}
}

 八、Hashtable的使用(弃用,作为了解)

package com.qf.hashtable_class;

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

public class Test01 {

	public static void main(String[] args) {
		/**
		 * 知识点:Hashtable的使用
		 * 
		 * 特点:无序 + key唯一(去重) + 线程安全的(加锁)
		 * 
		 * 注意:Hashtable方法上加锁,效率低,弃用
		 */
		
		//创建Hashtable对象
		Hashtable map = new Hashtable<>();
		
		//添加数据
		Integer put1 = map.put("麻生希", 28);
		Integer put2 = map.put("椎名空", 23);
		Integer put3 = map.put("天使萌", 26);
		Integer put4 = map.put("水菜丽", 26);
		Integer put5 = map.put("爱田奈奈", 25);
		Integer put6 = map.put("小峰由衣", 29);
		System.out.println(put1);//null
		System.out.println(put2);//null
		System.out.println(put3);//null
		System.out.println(put4);//null
		System.out.println(put5);//null
		System.out.println(put6);//null
		
		//将newMap集合添加到map集合中
		Hashtable newMap = new Hashtable<>();
		newMap.put("aaa", 10);
		newMap.put("bbb", 20);
		newMap.put("ccc", 30);
		newMap.put("ccc", 40);
		map.putAll(newMap);
		
		//如果集合中有该key就获取对应的value值
		//如果集合中没有该key就添加数据
		Integer putIfAbsent = map.putIfAbsent("椎名空1", 25);
		System.out.println("putIfAbsent -- " + putIfAbsent);
		
		
		//替换数据 -- 返回被替换的值
		Integer put7 = map.put("小峰由衣", 30);
		System.out.println(put7);//29
		
		//根据Key替换数据 -- 返回被替换的值
		Integer replace1 = map.replace("小峰由衣", 31);
		System.out.println(replace1);//30
		
		//根据Key+Value替换数据
		boolean replace2 = map.replace("小峰由衣", 31, 32);
		System.out.println(replace2);//true

		//通过key获取到value
		Integer integer1 = map.get("天使萌");
		System.out.println("通过key获取到value:" + integer1);
		
		//通过key获取到value,如果key不存在则返回默认值
		Integer integer2 = map.getOrDefault("天使萌111", 888);
		System.out.println("通过key获取到value,如果key不存在则返回默认值:" + integer2);
		
		//清空集合中的数据
		//map.clear();
		
		System.out.println("判断集合中是否包含某个key:" + map.containsKey("天使萌"));
		System.out.println("判断集合中是否包含某个value:" + map.containsValue(26));
		
		System.out.println("判断集合是否没有元素:" + map.isEmpty());
		
		//删除元素
		map.remove("椎名空1");//通过key删除映射关系
		map.remove("小峰由衣", 32);//通过key+value删除映射关系
		
		System.out.println("获取元素(映射关系)个数:" + map.size());
		
		//获取map中所有的value,返回一个Collection集合
		Collection values = map.values();
		System.out.println(Arrays.toString(values.toArray()));
		
		System.out.println("-----------------");
		
		//遍历1 -- keySet()
		//遍历思路:
		//	1.将map中所有的key获取出并存放在Set集合中
		//	2.遍历Set集合,依次取出key,再使用map.get(key)获取出对应的value值
		Set keySet = map.keySet();
		for (String key : keySet) {
			Integer value = map.get(key);
			System.out.println(key + " -- " + value);
		}
		System.out.println("-----------------");
		
		//遍历2 -- entrySet()
		//遍历思路:
		//	1.将map中所有的映射关系对象获取出并存放在Set集合中
		//	2.遍历Set集合,依次取出映射关系对象,映射关系对象中包含的key和value也就取出了
		Set> entrySet = map.entrySet();
		for (Entry entry : entrySet) {
			String key = entry.getKey();
			Integer value = entry.getValue();
			System.out.println(key + " -- " + value);
		}
		
	}
}

九、Properties

package com.qf.properties_class;

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

public class Test01 {

	public static void main(String[] args) throws IOException {
		/**
		 * 知识点:Properties
		 * 含义:配置文件类
		 * 
		 * 注意:配置文件创建在src目录下
		 */
		
		//创建配置文件对象
		Properties p = new Properties();
		
		//加载配置文件
		p.load(Test01.class.getClassLoader().getResourceAsStream("DBConfig.properties"));
	
		//获取配置文件中的数据
		String username = p.getProperty("username");
		String password = p.getProperty("password");
		
		System.out.println(username + " -- " + password);
	}
}

你可能感兴趣的:(java,开发语言)