这篇文章主要介绍了Java Map集合的使用及Collection工具类使用，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习吧!
Map接口
Map接口的特点
1. 用于存储任意键值对（key - value）
2. 键：无序、无下标、不允许重复（唯一）
3. 值：无序、无下标、允许重复
Map集合中的方法：
1. V put(K key, V value) 将对象存到集合中，关联键值
2. Object get(Object key) 根据键获得对应的值
3. Set<K> 返回所有的Key
4. Collection<V> values() 返回包含所有值的Collection集合
5. Set<Map.Entry<K, V>> 键值匹配的Set集合
Map接口的使用：
package com.collections.map;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* Map父接口的使用
* 特点：（1）存储键值对（2）键不能重复，值可以重复（3）无序
*/
public class Demo01 {
public static void main(String[] args) {
//创建Map集合
//添加 键不可重复
Map<String,String> map = new HashMap<>();
map.put("CN","中国");
map.put("USA","美国");
map.put("UN","英国");
map.put("CN","zhongguo");
map.put("ZH","中国");
System.out.println("元素个数："+map.size());
System.out.println(map.toString());
//删除 用键删除
map.remove("CN");
System.out.println("删除后："+map.size());
//3.遍历
//3.1使用keySet
//把map的键key转成Set集合，再用Set集合的遍历方法遍历出来
System.out.println("--------3.1使用keySet-------");
//Set<String> strings = map.keySet();
for (String key:map.keySet()) {
System.out.println(key+":"+map.get(key));//map.get(key) 取出map集合中对应key的值
}
//3.2使用entrySet
//把map的键和值放进Entry映射对中并放进Set集合，再用Set集合的遍历方法遍历出来
System.out.println("----------3.2使用entrySet---------");
//Set<Map.Entry<String, String>> entries = map.entrySet();
for (Map.Entry<String, String> entry:map.entrySet()) {
System.out.println(entry.getKey()+":"+entry.getValue());
}
//4.判断
System.out.println(map.containsKey("CN"));
System.out.println(map.containsValue("中国"));
}
}
遍历可以用keySet和entrySet。
运行结果：
HashMap
存储结构：哈希表（数组+链表+红黑树）
使用key可使hashcode和equals作为重复
HashMap的使用：
package com.collections.map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/**
* HashMap集合的使用
* 存储结构：哈希表（数组+链表+红黑树）
*/
public class Demo02 {
public static void main(String[] args) {
//创建集合
//刚创建HashMap时，table=null,size=0 目的：节省空间
//添加第一个元素的时候，table=16, size=16*0.75=12
//当元素个数超过阈值12时，会进行扩容，每次扩容时原来的两倍
HashMap<Student,String> students = new HashMap<>();
//添加元素
Student s1 = new Student("孙悟空",100);
Student s2 = new Student("猪八戒",101);
Student s3 = new Student("沙和尚",102);
students.put(s1,"北京");
students.put(s2,"上海");
students.put(s3,"杭州");
//键不可重复，键重复了值会被替换掉,不存在新增操作
//students.put(s3,"西安");
students.put(new Student("沙和尚",102),"南京");
System.out.println("元素个数"+students.size());
System.out.println(students.toString());
//遍历
//1.KeySet
System.out.println("--------------KeySet----------------");
Set<Student> students1 = students.keySet();
for (Student key: students1) {
System.out.println(key+":"+students.get(key));
}
//2.entrySet
System.out.println("------------entrySet------------------------");
Set<Map.Entry<Student, String>> entries = students.entrySet();
Iterator<Map.Entry<Student, String>> iterator = entries.iterator();
while (iterator.hasNext()){
Map.Entry<Student, String> key = iterator.next();
System.out.println(key);
}
}
}
Student类：
package com.collections.map;
import java.util.Objects;
public class Student {
private String name;
private int stuNo;
public Student() {
}
public Student(String name, int stuNo) {
this.name = name;
this.stuNo = stuNo;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getStuNo() {
return stuNo;
}
public void setStuNo(int stuNo) {
this.stuNo = stuNo;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", stuNo=" + stuNo +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return stuNo == student.stuNo &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, stuNo);
}
}
运行结果：
使用方法 增、删、遍历、判断与上述一致
HashMap原码分析总结：
- HashMap刚创建时，table是null，节省空间，当添加第一个元素时，table容量调整为16
- 当元素个数大于阈值（16*0.75 = 12）时，会进行扩容，扩容后的大小为原来的两倍，目的是减少调整元素的个数
- jdk1.8 当每个链表长度 >8 ，并且数组元素个数 ≥64时，会调整成红黑树，目的是提高效率
- jdk1.8 当链表长度 <6 时 调整成链表
- jdk1.8 以前，链表时头插入，之后为尾插入
Hashtable和Properties：
Hashtable线程安全，运行效率慢；不允许null作为key或是value。
Properties是hashtable的子类，要求key和value都是string，通常用于配置文件的读取。
TreeMap：
使用方式参考TreeSet：必须实现Comparable接口或者使用Compator比较器。
package com.collections.map;
import java.util.Comparator;
import java.util.TreeSet;
/**
* TreeSet的使用
*/
public class Demo03 {
public static void main(String[] args) {
TreeSet<Student> treeSet = new TreeSet<>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
int n1 = o1.getStuNo()-o2.getStuNo();
int n2 = o1.getName().compareTo(o2.getName());
return n1==0?n2:n1;
}
});
Student s1 = new Student("孙悟空",100);
Student s2 = new Student("猪八戒",101);
Student s3 = new Student("沙和尚",102);
treeSet.add(s1);
treeSet.add(s2);
treeSet.add(s3);
System.out.println(treeSet.toString());
}
}
Student类：
package com.collections.map;
import java.util.Objects;
public class Student {
private String name;
private int stuNo;
public Student() {
}
public Student(String name, int stuNo) {
this.name = name;
this.stuNo = stuNo;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getStuNo() {
return stuNo;
}
public void setStuNo(int stuNo) {
this.stuNo = stuNo;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", stuNo=" + stuNo +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return stuNo == student.stuNo &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, stuNo);
}
}
运行结果：
使用方法和上面一致。
Collection工具类：
概念：集合工具类，定义了除了存取以外的集合常用方法
直接二分查找int i = Collections.binarySearch(list, x);成功返回索引、copy复制、reverse反转、shuffle打乱
其他方法 ： 数组转成集合、集合转成数组
package com.collections;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
/**
* Collections类的使用
*/
public class Demo02 {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(10);
list.add(5);
list.add(20);
list.add(60);
list.add(1);
//sort 排序
System.out.println("排序之前"+list.toString());
Collections.sort(list);
System.out.println("排序之后"+list.toString());
//copy复制
ArrayList<Integer> arrayList = new ArrayList<>();
for (int i = 0; i <list.size() ; i++) {
arrayList.add(0);
}
Collections.copy(arrayList,list);
System.out.println(arrayList.toString());
//reverse反转
Collections.reverse(arrayList);
System.out.println(arrayList.toString());
//shuffle 打乱
Collections.shuffle(arrayList);
System.out.println(arrayList.toString());
//补充：集合转成数组
Integer[] integer = list.toArray(new Integer[0]);
System.out.println(integer.length);
System.out.println(Arrays.toString(integer));
//数组转成集合
//创建出来的集合是一个受限集合，无法添加和删除元素
String [] s = {"张三","李四","王五","赵六",};
List<String> strings = Arrays.asList(s);
System.out.println(strings);
//还要注意int类型的数组转出的集合最好是Integer类型，否则就是int[]数组类型了
Integer[] i = {100,200,300,400};
List<Integer> ints = Arrays.asList(i);
System.out.println(ints);
}
}
运行结果：
