本文共 7805 字，大约阅读时间需要 26 分钟。

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
   
     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
    
      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
   
     map = new HashMap<>();        map.put(1,"A");        map.put(2,"B");        map.put(3,"C");        map.put(4,"D");        //遍历 Map集合，所有的key是一个set集合        Set
    
      keys = map.keySet();        //通过迭代器遍历        Iterator
     
       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
      
       >  entrySet()        //以上这个方法是把Map集合直接全部转换成Set集合        //Set集合中的元素的类型是：Map.Entry        Set
       
        
         > set = map.entrySet(); //遍历Set集合，每次取出一个node Iterator
         
          
           > it2 = set.iterator(); while (it2.hasNext()){ Map.Entry
           
             node = it2.next(); Integer key = node.getKey(); String value = node.getValue(); System.out.println(key + " = " + value); } //foreach 实现 for (Map.Entry
            
              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
   
     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
   
     set = new TreeSet<>();		//第二种方式：使用匿名内部类方式        //TreeSet
    
      set = new TreeSet< >(new Comparator
     
      () {
           //    @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
      
       {
       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
   
     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
    
      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
     
       set = new HashSet<>();        set.add("A1");        set.add("A2");        set.add("A3");        set.add("A4");        //将Set集合转换成List集合        List
      
        myList = new ArrayList<>(set);        Collections.sort(myList);  //Collections.sort(List集合，比较器对象）        for (String s : myList){
               System.out.println(s);        }    }}class WuGui implements Comparable
       
        {
       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 +                ']';    }}
       
      
     
    
   

转载地址：http://leqwi.baihongyu.com/