Map集合
Map集合用于保存具有映射关系的数据,Map集合中 保存着两组值key和value,key和value可以是任意类型的数据,但是key值不允许重复,而且key和value存在着一对一的关系,所有Map集合的数据结构,只跟键有关,跟值没关系。
Map三个子类的特点:
HashMap:键的 数据结构是哈希表,允许插入null键 null值,线程不安全效率高
LinkedHashMap: 底层的数据结构是链表和哈希表 元素有序 并且唯一
TreeMap: 键的数据结构是红黑树,可保证键的排序和唯一性
HashMap
方法:
public V put(K key, V value):
给集合中插入键值对元素
public void clear():
清空集合中的全部元素
public V remove(Object key):
删除某一对元素
public boolean containsKey(Object key):
判断有没有这个键
public boolean containsValue(Object value):
判断有没有这个值
public boolean isEmpty():
判断集合是否是空
public Set<Map.Entry<K,V>> entrySet():
获取键值对对象的集合
public V get(Object key):
键找值
public Set keySet() :
获取所有键的集合
public Collection values():
获取所有值的集合
public int size():
获取集合中键值对个数
public static void main(String[] args) {
HashMap<String, String> map = new HashMap<>();
map.put("文章", "马伊琍");
map.put("贾乃亮", "李小璐");
map.put("陈思成", "佟丽娅");
map.put("大郎", "金莲");
//删除某一对
String s = map.remove("大郎"); //根据键,删除键值对,返回的是,这个键,对应的那个值
System.out.println(s);
//全部情清空集合中的元素
map.clear();
boolean b = map.isEmpty(); //判断集合是否为空
int size = map.size(); //获取集合的长度
//判断有没有这个键
boolean b = map.containsKey("文章");
//判断有没有这个值
boolean b1 = map.containsValue("李小璐2");
键找值
String value = map.get("文章");
System.out.println(value);
//遍历 键找值
//获取所有键的集合
Set<String> keySet = map.keySet();
//遍历键集 键找值
for (String key : keySet) {
System.out.println(key+"=="+map.get(key));
}
System.out.println("--------------------------");
//获取所有值的集合
Collection<String> values = map.values();
System.out.println(values);
集合的遍历:
一种是键找值,另一种是遍历键值对集合,通过键值对集合中的的方法去除键和值
HashMap<String, String> map = new HashMap<>();
map.put("文章", "马伊琍");
map.put("贾乃亮", "李小璐");
map.put("陈思成", "佟丽娅");
map.put("大郎", "金莲");
System.out.println(map.size());
//遍历方式1
Set<String> keySet = map.keySet();
for (String key : keySet) {
System.out.println(key+"===="+map.get(key));
}
System.out.println("---------------------------------");
//遍历方式2
//获取出,键值对 对象 的集合
Set<Map.Entry<String, String>> entries = map.entrySet();
//遍历键值对 集合 ,通过键值对 对象 里面的方法取出键和值
for (Map.Entry<String, String> entry : entries) {
String key = entry.getKey();//获取键
String value = entry.getValue();//获取值
System.out.println(key+"====="+value);
}
HashMap和HashTable的区别:
HashMap 允许存储null键和null值 线程不安全效率高
Hashtable 不允许null键和null值 线程安全效率低
LinkedHashMap
public static void main(String[] args) {
//键唯一且有序,链表保证了键有序,哈希表保证了键唯一
LinkedHashMap<Integer, String> linkedHashMap = new LinkedHashMap<>();
linkedHashMap.put(10,"abc");
linkedHashMap.put(20, "abc");
linkedHashMap.put(30, "abc");
linkedHashMap.put(40, "abc");
linkedHashMap.put(50, "abc");
linkedHashMap.put(60, "abc");
linkedHashMap.put(70, "abc");
linkedHashMap.put(70, "abcdddd");
System.out.println(linkedHashMap);
}
TreeMap
TreeMap<Integer, String> treeMap = new TreeMap<>();
treeMap.put(14,"abc");
treeMap.put(16, "abc");
treeMap.put(155, "abc");
treeMap.put(11, "abc");
treeMap.put(12, "abc");
System.out.println(treeMap);
TreeMap的排序
TreeMap有自然排序和比较器排序两种,
空参构造,自然排序
有参构造,比较器排序
我们以自定义学生对象为例,
public class Student implements Comparable<Student>{
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public int compareTo(Student s) {
int i = this.age - s.age;
int j=i==0?this.name.compareTo(s.name):i;
return j;
}
}
TreeMap<Integer, String> treeMap = new TreeMap<>();
treeMap.put(14,"abc");
treeMap.put(16, "abc");
treeMap.put(155, "abc");
treeMap.put(11, "abc");
treeMap.put(12, "abc");
System.out.println(treeMap);
比较器排序使用的是有参构造
public class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public static void main(String[] args) {
//Map集合的数据结构,只跟键有关
TreeMap<Student, Integer> treeMap = new TreeMap<>(new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
int i = s1.getAge() - s2.getAge();
int j=i==0?s1.getName().compareTo(s2.getName()):i;
return j;
}
});
new TreeSet<Integer>().add(100);
treeMap.put(new Student("zhangsan",1),1);
treeMap.put(new Student("zhangsan", 10), 1);
treeMap.put(new Student("zhangsan", 12), 1);
treeMap.put(new Student("zhangsan", 122), 1);
treeMap.put(new Student("zhangsan", 144), 1);
treeMap.put(new Student("zhangsan", 109), 1);
treeMap.put(new Student("zhangsan", 156), 1);
treeMap.put(new Student("zhangsan", 124), 1);
treeMap.put(new Student("zhangsan", 124), 1);
Set<Map.Entry<Student, Integer>> entries = treeMap.entrySet();
for (Map.Entry<Student, Integer> en : entries) {
Student key = en.getKey();
Integer value = en.getValue();
System.out.println(key.getName()+"=="+key.getAge()+"======="+value);
}
}
Set和Map的区别
set是一种关联式容器,其特性如下:
set以RBTree作为底层容器
所得元素的只有key没有value,value就是key
不允许出现键值重复
所有的元素都会被自动排序
不能通过迭代器来改变set的值,因为set的值就是键
map和set一样是关联式容器,它们的底层容器都是红黑树,区别就在于map的值不作为键,键和值是分开的。它的特性如下:
map以RBTree作为底层容器
所有元素都是键+值存在
不允许键重复
所有元素是通过键进行自动排序的
map的键是不能修改的,但是其键对应的值是可以修改的