集合和映射

概述

集合是存储元素的容器。
集合分为两大类collection和Map。
Collection又分为list（ArrayList,LInkedList）和set(HashSet,TreeSet)两大类。
linkedSet 是由 链表 实现的，有序
TreeSet是由 二分搜索树 实现的，有序 ，自然排序
HashSet是由 哈希表 实现的，无序

映射是存储数据对的数据结构。（键值对，Key,Value,K_V对），根据key寻找value。

Map就是一种映射，它有由链表实现的LinkedMap（有序），由二分搜索树实现的TreeMap（有序），有哈希表实现的HashMap（无序）。
HashMap 允许null值, 无序, 线程不安全 ,哈希表+链表(元素过多 红黑树)
HashSet其实就是HashMap的特殊情况
实现子类
LinkedHashMap 允许null值 ,有序 ,线程不安全 哈希表+双向链表
LinkedHashSet其实就是LinkedHashMap的特殊情况
Hashtable 禁止null值 ,无序 ,线程安全, 哈希表+链表

K_V 键（Key）一定不能重复；可以一对一，多对一，但不能一对多。

集合Set

接口

public interface Set<E> extends Iterable<e>{
		public void add(E e);
		public void remove(E e);
		public boolean contains(E e);
		public int size();
		public boolean isEmpty();
}

linkedSet：
底层由链表实现，所以其大部分方法可以使用链表的方法实现。

package 集合;

import 接口.List;
import 接口.Set;

import java.util.Iterator;
import java.util.LinkedList;

//由链表实现的集合
public class LinkedSet<E> implements Set<E> {
    private LinkedList<E> list;
    public LinkedSet(){
        list = new LinkedList<>();
    }

    @Override
    public void add(E element) {
        if (!list.contains(element)){
            list.add(element);
        }
    }

    @Override
    public void remove(E element) {
        list.remove(element);

    }

    @Override
    public boolean contains(E element) {
        return list.contains(element);
    }

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

    @Override
    public boolean isEmpty() {
        return list.isEmpty();
    }

    @Override
    public Iterator iterator() {
        return list.iterator();
    }

    @Override
    public String toString() {
        return list.toString();
    }
}

TreeSet：
底层是由 二分搜索树 实现的，有序 ，实现它时和上面LinkedSet一样，只需要构建一个底层的数据结构对象，new一个树，然后他的所有方法都可以通过树的相同方法来实现。

映射Map

不存在索引，不实现迭代器接口，所以本身不支持遍历，若想遍历map，则需把map转换成set。
EntrySet ： 将键和值转换成set
KeySet：将键转换成set
Values：将值转换成collection

接口

package 接口;

public interface Map<K,V> {
    public void put(K key,V value);//若key不存在，添加一对，若key已经存在，则覆盖原先值
    public V remove(K key);//根据key删除
    public boolean contains(K key);//判断是否包含
    public V get(K key);//获取key 对应的 value
    public void set(K key,V value);//修改
    public int size();
    public boolean isEmpty();
    public Set<K> keySet();//键的集合
    public List<V> values();//值的集合
    public Set<Entry<K,V>> entrySet();//键值对集合
    public interface Entry<K,V>{
        public K getKey();
        public V getValue();
    }
}

TreeMap实现：

由于Map中存储的数据是键和值，而二分搜索树只是针对单个数据，所以不能直接用BST实现，要对键和值以及键值对区分处理，具体代码如下：

package 集合;

import 接口.List;
import 接口.Map;
import 接口.Set;
import 树形结构.BinarySearchTree;

import java.util.LinkedList;

public class TreeMap<K extends Comparable<K>,V> implements Map<K,V> {

    private class  Node{
        public K key;
        public V value;
        Node left,right;
        public Node(){
            this(null,null);
        }
        public Node(K key,V value){
            this.key = key;
            this.value = value;
            this.left = null;
            this.right = null;
        }
    }
    private Node root;
    private int size;
    public TreeMap(){
        root = null;
        size = 0;
    }
    //以node为根的二分搜索树中查键为key的结点对象
    private Node getNode(Node node,K key){
        if (node == null){
            return null;
        }
        if (key.compareTo(node.key) < 0){
           return getNode(node.left,key);
        }
        else if (key.compareTo(node.key) > 0){
            return getNode(node.right,key);
        }
        else {
            return node;
        }
    }
    @Override
    public void put(K key, V value) {
        root = put(root,key,value);

    }

    private Node put(Node node, K key, V value) {
        if (node == null){
            size++;
            return new Node(key,value);
        }
        if (key.compareTo(node.key) < 0){
            node.left = put(node.left,key,value);
        }
        else if (key.compareTo(node.key) > 0){
            node.right = put(node.right,key,value);
        }
        else {
            node.value = value;
        }
        return node;
    }

    @Override
    public V remove(K key) {
        Node delNode = getNode(root,key);
        if (delNode != null){
            root = remove(root,key);
            return delNode.value;
        }
        return null;
    }

    private Node remove(Node node, K key) {
        if (key.compareTo(node.key) < 0){
            node.left = remove(node.left,key);
            return node;
        }
        else if (key.compareTo(node.key) > 0){
            node.right = remove(node.right,key);
            return node;
        }
        else {
            if (node.left == null){
                Node rightNode = node.right;
                node.right = null;
                size--;
                return rightNode;
            }
             if (node.right == null){
                Node leftNode = node.left;
                node.left = null;
                size--;
                return leftNode;
            }
             Node successor = minnum(node.right);
             successor.right = removeMin(node.right);
             successor.left = node.left;
             node.left = node.right = null;
             return successor;
        }
    }

    private Node removeMin(Node node) {
        if (node.left == null){
            Node rightNode = node.right;
            node.right = null;
            size--;
            return rightNode;
        }
        node.left = removeMin(node.left);
        return node;
    }

    private Node minnum(Node node) {
        if (node.left == null){
            return node;
        }
        return removeMin(node.left);
    }

    @Override
    public boolean contains(K key) {
        return getNode(root,key) != null;

    }

    @Override
    public V get(K key) {
      Node n = getNode(root,key);
      return n == null ? null : n.value;
    }

    @Override
    public void set(K key, V value) {
        Node n = getNode(root,key);
        if (n == null){
            throw new IllegalArgumentException("Key is not exits");
        }
        n.value = value;
    }

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

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

    @Override
    public Set<K> keySet() {
        TreeSet<K> set = new TreeSet<>();
        inOrderKeySet(root,set);
        return null;
    }

    @Override
    public List<V> values() {
        LinkedList<V> list = new LinkedList<>();
        inOrderValueSet(root,list);
        return (List<V>) list;
    }

    private void inOrderValueSet(Node node, LinkedList<V> list) {
        if (node == null){
            return;
        }
        inOrderValueSet(node.left,list);
        list.add(node.value);
        inOrderValueSet(node.right,list);
    }

    private void inOrderKeySet(Node node, TreeSet<K> set) {
        if (node == null){
            return;
        }
        inOrderKeySet(node.left,set);
        set.add(node.key);
        inOrderKeySet(node.right,set);
    }

    @Override
    public Set<Entry<K, V>> entrySet() {
       LinkedList<Entry<K,V>> entries = new LinkedList<Entry<K,V>>();
       inOrderEntrySet(root,entries);
        return (Set<Entry<K, V>>) entries;
    }

    private void inOrderEntrySet(Node node, LinkedList<Entry<K,V>> entries) {
        if (node == null){
            return;
        }
        inOrderEntrySet(node.left,entries);
        entries.add(new BSTEntry<>(node.key,node.value));
        inOrderEntrySet(node.right,entries);
    }

    @Override
    public String toString() {
        StringBuilder sb  = new StringBuilder();
        sb.append('[');
        if (isEmpty()){
            sb.append(']');
        }
        else {
            Set<Entry<K,V>> set = entrySet();
            for (Entry<K,V> entry:set) {
                sb.append(entry);
                sb.append(',');
            }
            sb.deleteCharAt(sb.length() - 1);
            sb.append(']');
        }
        return sb.toString();
    }

    private class BSTEntry<K ,V> implements Entry<K, V> {
        private K key;
        private V value;

        public BSTEntry(K key,V value){
            this.key = key;
            this.value = value;
        }
        @Override
        public K getKey() {
            return key;
        }

        @Override
        public V getValue() {
            return value;
        }

        @Override
        public String toString() {
           return "(" + key.toString() + ":" + value.toString() + ")";
        }
    }
}