1. 散列表
散列表:可以理解为数组中保存的每个元素都是一个链表
散列表中保存的是键值对(K和V)
添加过程:
1.先调用添加的K,调用hashCode生成hash值
2.根据hash值计算数组下标
3.判断数组中该下标对应的的位置上是否有元素
3.1如果没有保存数据,就把该对象放到对应的下标中
3.2如果保存了数据,此时调用添加的K的equals方法,和数组中该下标对应的所有数据的key值进行比较
3.3如果和数组下标对应的链表中的数据都不想等,就把该数据添加到对应的链表中】
3.4如果和链表中的数据一致了,则key不添加,把value值替换(用新的替换原来的)
4.java1.8新改动,如果该链表中节点个数大于7,则该链表被自动转换为红黑树
在java中没有散列表这个说法,只是把散列表封装为了HashMap和HashTable,并且HashTable已经过时
HashSet底层就是一个HashMap,并且只是Map的key部分,没有value
static class Node<K,V> implements Map.Entry<K,V>{
final int hash;//key的hash值
final K key;//key
V value;//value
Node<K,V> next;//下一个节点
import java.util.HashSet;
public class Collection_01_HashSet {
public static void main(String[] args) {
HashSet<String> set = new HashSet<String>();
set.add("123");
set.add("123");
set.add("1");
set.add("2");
set.add("3");
System.out.println(set.size());
}
}
1.2 hashSet的使用
package com;
import java.util.HashSet;
import java.util.Objects;
import java.util.Set;
public class Collection_02_HashSet {
public static void main(String[] args) {
//规定姓名相同认为是同一个对象
User u1 = new User(18,"张三");
User u2 = new User(20,"张三");
Set<User> users = new HashSet<User>();
users.add(u2);
users.add(u1);
System.out.println(users.size());
for (User user : users) {
System.out.println();
}
}
}
class User{
@Override
public int hashCode() {
return Objects.hash(age, name);
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
User other = (User) obj;
return age == other.age && Objects.equals(name, other.name);
}
@Override
public String toString() {
return "User [age=" + age + ", name=" + name + "]";
}
private int age;
private String name;
public User(int age,String name) {
super();
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
2. Map
2.1 继承体系
2.2 Map特性
Map:无序,key不可重复,value可重复
Map和Collection不一样,但是操作基本上是一样的
集合保存单个对象,而Map保存映射关系
2.3 常用方法
put(K,V);添加数据
remove(K):删除数据
clear():清空
size():个数
isEmpty():判断是否为空
get(K):根据key获取value
values():获取所有value,返回集合
containsKey():判断是否包含某个key
containsValue():判断是否包含某个value
Set keySet():获取map中的所有key,返回set
Set entrySet():获取map中的键值对,返回set
2.4 HashMap
public class Map_03_HashMap {
public static void main(String[] args) {
//创建map
Map<String,Integer> map = new HashMap<String,Integer>();
map.put("q", 1);
map.put("q", 2);
map.put("A", 21);
map.put("'A'", 20);
map.put("65", 23);
//个数为4
System.out.println(map.size());
//根据key获取value 2,因为key重复,value替换
System.out.println(map.get("q"));
//是否包含某个key
System.out.println(map.containsKey("65"));
//是否包含某个value
System.out.println(map.containsValue(20));
//根据key删除该映射关系(K和V都删除,相当于在链表中把该节点删除)
map.remove("q");
//3
System.out.println(map.size());
//map不能直接遍历,要获取所有的value
Collection values = map.values();
for (Object object : values) {
//3,20,21,23
System.out.println(object);
//获取所有的key
Set<Entry<String,Integer>> entries = map.entrySet();
for (Entry<String,Integer> entry : entries) {
System.out.println(entry);
System.out.println(entry.getKey()+"-->"+entry.getKey());
}
}
}
}
2.5 Properties
Properties:key和value强制要求必须是字符串
public class Map_04_Properties {
public static void main(String[] args) {
Properties p = new Properties();
//添加数据
p.setProperty("driver", "mysql");
p.setProperty("username", "root");
//获取数据
System.out.println(p.getProperty("driver"));
System.out.println(p.getProperty("username"));
//不存在key的时候得到null
System.out.println(p.getProperty("qwewqeqw"));
//有个方法重载,第二个参数为默认值,假如找不到key时就返回该默认值,为不是null
//返回默认值的时候并不会添加进去
System.out.println(p.getProperty("qwewqeqw","123"));
//
}
}
2.6 TreeMap
TreeMap : 保存的元素可以按照一定的规则进行排序 排序 :
1.要添加的元素 实现了Comparable接口
2.编写比较器类,实现Comparator接口 treeMap 在添加的时候会自动调用key对象的compareTo方法,是用key进行比较,而不是value
package com;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeMap;
public class Map_05_TreeMap {
public static void main(String[] args) {
TreeMap<Integer, String> map = new TreeMap<Integer, String>(new Comparator<Integer>() {
public int compare(Integer o1, Integer o2) {
return o1 - o2;
}
});
map.put(1, "a");
map.put(2, "a");
map.put(3, "a");
map.put(4, "a");
Set set = map.entrySet();
for (Object object : set) {
System.out.println(object);
}
}
}
2.7 面试题
package com;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/**
* Map转换为List存储,并以value进行排序
* map没办法以value排序,因为TreeMap中是按照key排序的,所以想要balue排序需要转换为list
*
* @author 势不可挡的内鬼
*
*/
public class Map_06_MapToList {
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<String, Integer>();
map.put("a", 1);
map.put("qqq", 2);
map.put("zzz", 1);
map.put("aq", 12);
// 把K和V封装到entry中去,然后保存到set中
Set<Entry<String, Integer>> set = map.entrySet();
// set转换为list
List<Entry<String, Integer>> list = new ArrayList<Map.Entry<String, Integer>>(set);
// 更改排序
Collections.sort(list, new Comparator<Entry<String, Integer>>() {
public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
return o1.getValue() - o2.getValue();
}
});
System.out.println(list);
}
}