概述
集合是存储元素的容器。
集合分为两大类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() + ")";
}
}
}