Java学习笔记 -集合2

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Java学习笔记 -集合2，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含8007字，纯文字阅读大概需要12分钟。

内容图文

鉴于HashSet、TreeSet和Map集合中的HashMap、TreeMap关联，所以放在一起
主要内容：
1.TreeSet、TreeMap、比较器
2.HashSet、HashMap、哈希表

继承结构图

Map接口

1.概述

• Map和Collection没有继承关系
• Map集合以key和value的方式存储数据：键值对
• key和value都是引用数据类型
• key和value都是存储对象的内存地址
• key起到主导地位，value是key的一个附属品

2.常用方法：

• V put(K key, V value) 向集合中添加键值对

• V get(Object key) 通过key 获取value

• void clear() 清空Map集合

• boolean containsKey(Object key) 判断Map中是否包含某个key

• boolean containsValue(Object value) 判断Map中是否包含某个value

• boolean isEmpty() 判断Map集合中元素个数是否为0

• Set keySet() 获取Map集合所有的key(所有的键是一个set集合)

• Collection values() 获取Map集合中所有的value,返回一个Collection

• V remove(Object key) 通过key删除键值对

• int size() 获取Map集合这键值对的个数

• Set<Map.Entry<K,V>> entrySet() 将Map集合转换成Set集合

• 以及Map.Entry静态内部类中的实例方法：

• K getKey() 获取key

• V getValue() 获取value
  Map集合通过entrySet()方法转换成成的这个Set集合，Set集合中元素的类型是Map.Entry(静态内部类)

例如：
HashMap<Integer,String> map1 = new HashMap<>;
key       value
1          zhangsan
2          lisi

Set<Map.Entry<Integer,String>> s = map1.entrySet();

则s集合对象如下：
1=zhangsan    
2=lisi

示例程序

public class MapTest01 {
    public static void main(String[] args) {
        //创建Map对象
        Map<Integer, String> map = new HashMap<>();
        map.put(1,"zhagnsan");
        map.put(2,"lisi");

        //通过key获取value
        String value = map.get(2);
        System.out.println(value);

        //判断集合是否包含某个key
        System.out.println(map.containsKey(1));   //true

        //判断集合是否包含某个value
        System.out.println(map.containsValue("lisi"));  //true

        //获取Map集合所有的key(所有的键是一个set集合)
        Set<Integer> set = map.keySet();
        for(Integer integer : set){
            System.out.println(integer);    // 1\n   2
        }

        //获取Map集合所有的value(所有的值是一个Collection集合)
        Collection<String> collection = map.values();
        for(String str : collection){
            System.out.println(str);
        }

        //遍历Map的第一种方式 : KeySet + get方法来遍历键值对
        for(Integer integer : set){
            System.out.println(integer + "=" + map.get(integer));
        }

        //遍历Map的第二种方式 :  Set<Map.Entry<K,V>> entrySet()
        //推荐第二种方式，第二种方式的效率高
        Set<Map.Entry<Integer,String>> set1 = map.entrySet();

        Iterator<Map.Entry<Integer, String>> it2 = set1.iterator();
        while(it2.hasNext()){
            Map.Entry<Integer, String> node = it2.next();
            Integer key = node.getKey();
            String value1 = node.getValue();
            System.out.println(key + "=" + value1);
        }
        //foreach
        for(Map.Entry<Integer,String> node : set1){
            Integer key = node.getKey();
            String value1 = node.getValue();
            System.out.println(key + "=" + value1);
        }
    }
}

如何理解静态内部类？

可以通过以下程序类比：

public class StaticInClassTest {

    //声明一个静态内部类
    private static class InnerClass{
        public static void m1(){
            System.out.println("静态内部类的静态方法");
        }

        public void m2(){
            System.out.println("静态内部类的实例方法");
        }
    }

    public static void main(String[] args) {
        StaticInClassTest.InnerClass mi = new StaticInClassTest.InnerClass();
        mi.m2();

        //Set集合中存储的StaticInClassTest.InnerClass类型
        Set<StaticInClassTest.InnerClass> s = new HashSet<>();
    }
}

TreeMap & TreeSet

1.概述

• TreeSet集合底层实际上是一个TreeMap
• TreeMap集合底层是一个二叉树
• 放在TreeSet集合的元素，等同于放在了TreeMap集合的key部分
• treeSet集合中的元素：无序不可重复，但可以按照元素的大小顺序自动排序，称为：可排序集合

2.TreeSet TreeMap可以自动排序的原理：

部分源码：

// 在java.util.TreeMap中
Comparator<? super K> cpr = comparator;
 if (cpr != null) {         //比较器分支
            do {
                parent = t;
                cmp = cpr.compare(key, t.key);  //直接调用比较器的compare方法
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        else {           //Comparable接口分支
            if (key == null)
                //先强制类型转换之后，在调用compareTo方法
                Comparable<? super K> k = (Comparable<? super K>) key;
            do {
                parent = t;
                cmp = k.compareTo(t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }

• 所以，如果需要使用TreeSet&TreeMap存储自定义的类，需要实现Comparable接口或者编写比较器类实现Comparator接口

Comparable接口和Comparator接口如何选择？

• Comprable接口是强制类型转换后，调用comparaTo方法，所以它的比较规则是固定的（Integer & String均是选择这种方法）
• 如果比较规则有多个，需要频繁切换，那么建议编写多个比较器，在不同情况下传递不同的比较器；（还可以使用匿名内部类的语法）

示例程序：

public class TreeMapTest01 {
    public static void main(String[] args) {
        //Comparable接口的方式：
        //如果没有实现接口Comparable,会报类型转换异常：java.lang.ClassCastException
        TreeSet<Person> people = new TreeSet<>();
        Person p1 = new Person("zs",20);
        Person p2 = new Person("ls",12);
        Person p3 = new Person("zd",20);

        people.add(p1);
        people.add(p2);
        people.add(p3);
        for(Person p : people){
            System.out.println(p);
        }

        //===================================================
        //Comparator接口，编写一个类的方式实现Comparator接口
        //有参数构造方法：TreeSet(Comparator<? super E> comparator)   传递比较器
        TreeSet<Person> people1 = new TreeSet<>(new PerSonComparator());
        people1.add(p1);
        people1.add(p2);
        people1.add(p3);
        for(Person p : people1){
            System.out.println(p);
        }

        //=================================================
        //Comparator接口，使用匿名内部类的语法实现Comparator接口
        TreeSet<Person> people2 = new TreeSet<>(new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.age - o2.age;
            }
        });
    }
}

//Comparable接口是java.lang下的
class Person implements Comparable<Person>{
    String name;
    int age;

    public  Person(){
    }
    public Person(String name, int age){
        this.age = age;
        this.name = name;
    }


    //compareTo方法的返回值
    //返回值相同,value会覆盖，返回值>0，会在右子树上找
    @Override
    public int compareTo(Person o) {
        if(this.age == o.age){
            return this.name.compareTo(o.name);
        }else {
            return this.age - o.age;
        }
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

//编写类实现java.util.Comparator接口。
class PerSonComparator implements Comparator<Person>{
    @Override
    public int compare(Person o1, Person o2) {
        if(o1.age == o2.age){
            return o1.name.compareTo(o2.name);
        }else {
            return o1.age - o2.age;
        }
    }
}

HashSet、HashMap、哈希表

1.概述

• HashMap集合底层是哈希表/散列表的数据结构

• 哈希表是一个数组和单向链表的结合体
  -hashMap集合的默认初始化容量是16，默认加载因子是0.75（数组使用75%时就开始扩容）扩容为二倍

• (重点)HashMap集合初始化容量必须是2的倍数，这是因为达到散列均匀，为了提高HashMap集合的存取效率所必需的

2.HashMap集合底层的源代码：

public class HashMap{
    //HashMap底层实际上是一个数组
    Node<K,V>[] table;

    //静态内部类HashMap.Node
    static class Node<K,V>{
        final int hash;  //哈希值
        final K key;
        V value;
        Node<K,V> next; //next对象
        }
    }

3.两个重要方法的原理（图示）：

• map.put(k,v)
• v = map.get(k)
  

5.hashCode()

如果hashCode()方法返回值为某个固定值，会导致哈希表变成一个单向链表
如果hashCode()方法返回值均不相同，会导致哈希表变成一个一维数组
这些情况都称之为： 散列分布不均匀
要想实现散列分布均匀，需要重写hashCode()方法有一定的技巧

6.(重点)HashMap的Key类和HashSet集合中的元素的equals & hashCode方法

• 如果一个类的equals方法重写，那么hashCode()方法必须重写
• 且如果equals方法显示两个对象相同，那么他们hashCode()方法的返回值必须相同
• hashCode equals方法可以直接使用IDEA生成，必须同时生成防止出错

示例程序：

public class HashMapTest01 {
    public static void main(String[] args) {

        Map<Integer, String> map = new HashMap<>();

    }
}

class Usr {
    private String name;

    public Usr(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Usr)) return false;
        Usr usr = (Usr) o;
        return getName().equals(usr.getName());
    }
    @Override
    public int hashCode() {
        return Objects.hash(getName());
    }
}

属性类：Properties

• 是一个Map集合，继承Hashtale,它的key和value都是String类型
• 也被称之为属性类对象 是线程安全的

示例程序

import java.util.Properties;

public class PropertiesTest01 {
    public static void main(String[] args) {
        Properties pro = new Properties();

        //需要掌握两个方法
        pro.setProperty("a","ddddf");
        pro.setProperty("b","dfbgdfd");

        //通过key获取value
        System.out.println(pro.getProperty("a"));
        System.out.println(pro.getProperty("b"));
    }
}

内容总结

以上是互联网集市为您收集整理的Java学习笔记 -集合2全部内容，希望文章能够帮你解决Java学习笔记 -集合2所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端