Java集合（二）
Java.util.Map接口中常用的方法：
1.Map和Collection 没有继承关系
2.Map集合是以key和value的方式存储数据：键值对
key和value都是引用数据类型
key和value都是存储对象的内存地址
key起主导的地位，value与key相匹配
注意：Map 中可以放置键值对，也就是每一个元素都包含键对象和值对象，Map 实现较常用的为
HashMap，HashMap 对键对象的存取和 HashSet 一样，仍然采用的是哈希算法，所以如果使用
自定类作为 Map 的键对象，必须复写 equals 和 hashCode 方法
Map集合常用方法：
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
public class MapTest {
public static void main(String[] args) {
//创建Map集合对象
Map<Integer, String> map = new HashMap<>();
//向Map集合中添加键值对
map.put(1, "zhangsan");
map.put(2, "lisi");
map.put(3, "wangwu");
map.put(4, "zhaoliu");
//通过key获取value
String value = map.get(2);
System.out.println(value);
//获取键值对的数量
System.out.println("键值对的数量：" + map.size()); //4
//通过key删除key-value
map.remove(2);
System.out.println("键值对的数量：" + map.size()); //3
//判断是否包含某个key
//contains方法底层调用的都是equals方法进行比对的，所以自定义的类型需要重写equals方法
System.out.println(map.containsKey(4)); //true
System.out.println(map.containsKey(new Integer(1))); //true
//判断是否包含某个value
System.out.println(map.containsValue("zhangsan")); //true
System.out.println(map.containsValue(new String("zhaoliu")));//true
//获取所有的values
Collection<String> v = map.values();
for (String s : v){
System.out.println(s);
}
//清空map集合
map.clear();
//判断是否为空
System.out.println(map.isEmpty()); //true
}
}
Map集合的遍历（重要）
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapTest02 {
public static void main(String[] args) {
//第一种方式：获取所有的key,通过遍历key,来遍历value
Map<Integer, String> map = new HashMap<>();
map.put(1,"A");
map.put(2,"B");
map.put(3,"C");
map.put(4,"D");
//遍历 Map集合，所有的key是一个set集合
Set<Integer> keys = map.keySet();
//通过迭代器遍历
Iterator<Integer> iterator = keys.iterator();
while (iterator.hasNext()){
Integer key = iterator.next();
String value = map.get(key);
System.out.println(key + " = " + value);
}
//foreach也可以
for (Integer key : keys){
System.out.println(key + " = " + map.get(key));
}
//第二种方式：Set<Map, Entry<K,V>> entrySet()
//以上这个方法是把Map集合直接全部转换成Set集合
//Set集合中的元素的类型是：Map.Entry
Set<Map.Entry<Integer, String>> set = map.entrySet();
//遍历Set集合，每次取出一个node
Iterator<Map.Entry<Integer, String>> it2 = set.iterator();
while (it2.hasNext()){
Map.Entry<Integer, String> node = it2.next();
Integer key = node.getKey();
String value = node.getValue();
System.out.println(key + " = " + value);
}
//foreach 实现
for (Map.Entry<Integer, String> node : set){
System.out.println(node.getKey() + "--------->" + node.getValue());
}
}
}
HashMap集合
HashMap集合底层是哈希表/散列表的数据结构，是非线程安全的
哈希表是一个数组和单向链表的结合体
map.put(k, v)
v = map.get(k)
HashMap集合的key部分特点：
无序，不可重复
为什么无序？因为不一定挂到哪个单向链表上
不可重复是怎么保证的？equals方法来保证HashMap集合的key不可重复，如果key重复了，value会覆盖
放到HashMap集合key部分的元素其实就是放到HashMap集合中了
所以HashMap集合中的元素也需要同时重写hashCode() 和equals() 方法
import java.util.HashSet;
import java.util.Objects;
import java.util.Set;
public class HashMapTest {
public static void main(String[] args) {
//放到HashMap集合key部分的，以及放到HashSet集合中的元素，需要同时重写hashcode方法和equals方法
Student s1 = new Student("AA");
Student s2 = new Student("AA");
System.out.println(s1.equals(s2)); //true
System.out.println("s1的hashcode = " +s1.hashCode()); //2111
System.out.println("s2的hashcode = " +s2.hashCode()); //2111
Set<Student> set = new HashSet<>();
set.add(s1);
set.add(s2);
System.out.println(set.size()); //1
}
}
class Student{
private String name;
public Student(){
}
public Student(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public boolean equals(Object o) { //重写equals方法
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return name.equals(student.name);
}
@Override
public int hashCode() { //重写hashcode方法
return Objects.hash(name);
}
}
了解：在JDK8之后，如果哈希表单向链表的元素超过8个，单向链表这种数据结构会变成红黑树数据结构。当红黑树上的节点数量小于6时，会重新把红黑树变成单向链表数据结构
属性类Properties类
Properties是一个Map集合，继承Hashtable，Properties的key和value都是String类型
Properties被称为属性类对象，Properties是线程安全的
Properties pro = new Properties（）；
pro.setProperty("username", "123");
//通过key取元素
String username = pro.getProperty("username");
TreeSet
TreeSet集合底层实际上是一个TreeMap
TreeMap底层是二叉树
放到TreeSet集合中的元素，等同于放到TreeMap集合key部分了
TreeSet集合中的元素：无序不可重复，但是可以按照元素的大小顺序自动排序，称为：可排序集合
import java.util.TreeSet;
public class TreeSetTest {
public static void main(String[] args) {
Customer c1 =new Customer(22);
Customer c2 =new Customer(23);
Customer c3 =new Customer(24);
Customer c4 =new Customer(25);
TreeSet<Customer> set = new TreeSet<>();
//第二种方式：使用匿名内部类方式
//TreeSet<Customer> set = new TreeSet< >(new Comparator<Customer>() {
// @Override
// public int compare(Customer o1, Customer o2) {
// return o1.age - o2.age;
// }
//});
set.add(c1);
set.add(c2);
set.add(c3);
set.add(c4);
System.out.println(set); //[Customer{age=22}, Customer{age=23}, Customer{age=24}, Customer{age=25}]
}
}
class Customer implements Comparable<Customer>{
int age;
public Customer(int age ){
this.age = age;
}
@Override
public int compareTo(Customer customer) { //按照年龄升序
return this.age - customer.age;
}
@Override
public String toString() {
return "Customer{" +
"age=" + age +
'}';
}
}
放到TreeSet或者TreeMap集合key部分的元素要想做到排序，包括两种方式：
1.放在集合中的元素实现Java.lang.Comparable接口
2.在构造TreeSet或者TreeMap集合的时候给它传一个比较器对象
Comparable和Comparator怎么选择呢？
当比较规则不会发生改变时，或者说当比较规则只用一个的时候，建议使用Comparable接口
如果比较规则有多个，并且需要多个比较规则之间频繁切换，建议使用Comparator接口
Collections集合工具类
Java.util.Collection 集合接口
Java.util.Collections 集合工具类，方便集合的操作
import java.util.*;
public class CollectionsTest {
public static void main(String[] args) {
List<String> list = new ArrayList<>(); //ArrayList不是线程安全的
Collections.synchronizedList(list);//变成线程安全的
list.add("ABD");
list.add("ABA");
list.add("ABB");
list.add("ABC");
Collections.sort(list); //排序
for (String s : list){
System.out.println(s);
}
List<WuGui> wuGuis = new ArrayList<>();
wuGuis.add(new WuGui(1000));
wuGuis.add(new WuGui(500));
wuGuis.add(new WuGui(800));
//注意：对List集合中的元素排序，需要保证list集合中的元素实现了：Comparable接口
Collections.sort(wuGuis);
for (WuGui wg :wuGuis){
System.out.println(wg);
}
//对Set集合中的元素排序
Set<String> set = new HashSet<>();
set.add("A1");
set.add("A2");
set.add("A3");
set.add("A4");
//将Set集合转换成List集合
List<String> myList = new ArrayList<>(set);
Collections.sort(myList); //Collections.sort(List集合，比较器对象）
for (String s : myList){
System.out.println(s);
}
}
}
class WuGui implements Comparable<WuGui>{
int age;
public WuGui(int age){
this.age = age;
}
@Override
public int compareTo(WuGui o) {
return this.age - o.age;
}
@Override
public String toString() {
return "WuGui[" +
"age=" + age +
']';
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
