搜索树的应用——Map和Set接口

Map(映射)

Map<K,V> K是key的类型；V是value的类型
key不允许重复；value允许重复

1. put<K key,V value> 将key-value映射关系放入map集合中;用新的key-value替换老的key-value映射（key已经在集合中）
2. get(K key) 通过key获取对应的value；如果之前没有key，返回null
3. getOrDefault(K key,V defaultValue) 通过key获取对应的value；如果key不存在，返回对应的defaultValue；但是不会修改集合本身
4. remove(K key) 删除key-value映射；key存在返回value;key不存在返回null；回修改集合
5. Set<Map.Entry<K, V>> entrySet() 返回所有的 key-value 映射关系
6. containsKey(K key) 判断是否包含 key
7. containsValue(V value) 判断是否包含 value

Map.Entry<K, V> 静态内部类
Map.Entry<K, V> 是Map内部实现的用来存放<key, value>键值对映射关系的内部类，该内部类中主要提供了<key, value>的获取，value的设置以及Key的比较方式

注意：

1. Map是一个接口，不能直接实例化对象，如果要实例化对象只能实例化其实现类TreeMap或者HashMap
2. Map中存放键值对的Key是唯一的，value是可以重复的
3. 在Map中插入键值对时，key不能为空，否则就会抛NullPointerException异常，但是value可以为空
4. Map中的Key可以全部分离出来，存储到Set中来进行访问(因为Key不能重复)。
5. Map中的value可以全部分离出来，存储在Collection的任何一个子集合中(value可能有重复)。
6. Map中键值对的Key不能直接修改，value可以修改，如果要修改key，只能先将该key删除掉，然后再来进行 重新插入

package Map;

import java.util.Map;
import java.util.TreeMap;

public class Test {
    public static void main(String[] args) {
        Map<String,Integer> 通讯录 = new TreeMap<>();
        //第一次建立映射关系 
        //如果key不存在，会将key-value的键值对插入到map中,返回null
        Integer v = 通讯录.put("t",123); 
        System.out.println(v); //null
        System.out.println(通讯录); //{t=123}
        v = 通讯录.put("t",456);
        System.out.println(v); //123
        System.out.println(通讯录); //{t=456}

        v = 通讯录.get("t");
        System.out.println(v); //456 只是将key对应的映射关系取出来，再次取还是456
        v = 通讯录.get("t");
        System.out.println(v); //456

        v = 通讯录.get("tt");
        System.out.println(v); //null
        v = 通讯录.get("tt");
        System.out.println(v); //null
        v = 通讯录.get("tt");
        System.out.println(v);  //null

        v = 通讯录.getOrDefault("y",789); //并未放入map中
        System.out.println(v); //789
        System.out.println(通讯录); //{t=456}

        v = 通讯录.remove("y");
        System.out.println(v); //null
        System.out.println(通讯录); //{t=456}
        v = 通讯录.remove("t");
        System.out.println(v); //456
        System.out.println(通讯录); //{}

    }
}

Set

方法名	说明
boolean add(E e)	添加元素（但是重复元素不能添加成功）–O(lon(n))
void clear()	清空集合 --O(1)
int size()	返回set中的元素个数
boolean isEmpty()	检测set是否为空
boolean remove(Object o)	删除集合中的o–O(lon(n))
boolean contains(Object o）	判断o是否在集合中–O(lon(n))
retainAll	求this和o的交集

基本使用：

package Set;

import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class test {
    public static void main(String[] args) {
        Set<String> set = new TreeSet<>();

        System.out.println(set.add("apple")); //true
        System.out.println(set.add("peach")); //true
        System.out.println(set.add("banana")); //true
        System.out.println(set.add("orange")); //true

        System.out.println(set.size()); //4
        System.out.println(set);  //[apple, banana, orange, peach]

        System.out.println(set.add("apple")); //false
        System.out.println(set.contains("watermelon")); //false
        System.out.println(set.add("apple")); //false

        System.out.println(set.remove("watermelon")); //false
        System.out.println(set.remove("apple")); //true
        System.out.println(set); //[banana, orange, peach]

        System.out.println(set.isEmpty()); //false
        set.clear();
        System.out.println(set.isEmpty()); //true
        System.out.println(set.size()); //0

        set.add("西瓜");
        set.add("冬瓜");
        set.add("南瓜");
        set.add("北瓜");
        set.add("地瓜");
        set.add("甜瓜");
        for (String fruit : set) {
            System.out.println(fruit);
        }
        //替换成为for
//        Iterator<String> iterator = set.iterator();
//        while (iterator.hasNext()) {
//            String fruit = iterator.next();
//            System.out.println(fruit);
//        }
        //输出：冬瓜 北瓜 南瓜 地瓜 甜瓜 西瓜
    }
}

实现：

1. 直接实现java.util.Set接口
2. 实现java.util.Set
3. 有些方法不会实现，抛出 throw new NoSuchOperationException();

package Set;

import java.util.Collection;
import java.util.Iterator;
import java.util.Set;

public class MyTreeSet implements Set<Integer> {
    private TreeNode root;
    private  int size;

    @Override
    public int size() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    //红黑树
    @Override
    public boolean contains(Object o) {
        Comparable<Integer> comparable = (Comparable<Integer>) o;
        TreeNode cur = root;
        while (cur != null) {
            int cmp = comparable.compareTo(cur.key);
            if (cmp == 0) {
                return true;
            } else if (cmp < 0) {
                cur = cur.left;
            } else {
                cur = cur.right;
            }
        }
        return false;
    }


    @Override
    public boolean add(Integer integer) {
        if (root == null) {
            root = new TreeNode(integer);
            size++;
            return true;
        }
        TreeNode parent = null;
        TreeNode cur = root;
        int cmp = 0;
        while (cur != null) {
            cmp = integer.compareTo(cur.key);
            if (cmp == 0) {
                return false;
            } else if (cmp < 0) {
                parent = cur;
                cur = cur.left;
            } else {
                parent = cur;
                cur = cur.right;
            }
        }
        if (cmp < 0) {
            parent.left = new TreeNode(integer);
        } else {
            parent.right = new TreeNode(integer);
        }
        size++;
        return true;
    }

    @Override
    public void clear() {
        root = null;
        size = 0;
    }
    
    @Override
    public Iterator<Integer> iterator() {
        //TODO
        throw new UnsupportedOperationException("");
    }

    @Override
    public Object[] toArray() {
        throw new UnsupportedOperationException("");
        //return new Object[0];
    }

    @Override
    public <T> T[] toArray(T[] a) {
        throw new UnsupportedOperationException("");
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        throw new UnsupportedOperationException("");
    }

    @Override
    public boolean addAll(Collection<? extends Integer> c) {
        throw new UnsupportedOperationException("");
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        throw new UnsupportedOperationException("");
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        throw new UnsupportedOperationException("");
    }
    @Override
    public boolean remove(Object o) {
        throw new UnsupportedOperationException("");
    }

}