Java算法

最新推荐文章于 2022-12-17 10:26:58 发布

家有萌犬

最新推荐文章于 2022-12-17 10:26:58 发布

阅读量92

点赞数

分类专栏： android基础

本文链接：https://blog.csdn.net/lynnlee_36/article/details/104727646

版权

android基础专栏收录该内容

10 篇文章 0 订阅

订阅专栏

Connection接口:

1.1 List 有序,可重复

1.ArrayList
优点: 底层数据结构是数组，查询快，增删慢。
缺点: 线程不安全，效率高
2.Vector
优点: 底层数据结构是数组，查询快，增删慢。
缺点: 线程安全，效率低
3.LinkedList
优点: 底层数据结构是链表，查询慢，增删快。
缺点: 线程不安全，效率高

1.2 Set 无序,唯一

1.HashSet
底层数据结构是哈希表。(无序,唯一)
如何来保证元素唯一性?
1.依赖两个方法：hashCode()和equals()
2.LinkedHashSet
底层数据结构是链表和哈希表。(FIFO插入有序,唯一)
1.由链表保证元素有序
2.由哈希表保证元素唯一
3.TreeSet
底层数据结构是红黑树。(唯一，有序)

如何保证元素排序的呢?
自然排序
比较器排序

如何保证元素唯一性的呢?
根据比较的返回值是否是0来决定

一、ArrayList：

底层实现就是数组（顺序表），超过当前容量就重新new 数据扩容，并且增、删要执行System.arrayCopy函数进行数据位移拷贝，因此增、删较慢。

二、LinkedList

底层是链表实现的。一个节点除了包含元素内容之外，同时包含前一个节点和后一个节点的引用。

LinkedList

2.1 Node

从节点Node的构造也可以看出，参数有三个，第一个是前一个节点，第二个是数据，第三个是下一个节点。

private static class Node<E> {
	E item;
	Node<E> next;
	Node<E> prev;

	Node(Node<E> prev, E element, Node<E> next) {
		this.item = element;
		this.next = next;
		this.prev = prev;
	}
}

2.2 LinkedList.add

public void add(int index, E element) {
	checkPositionIndex(index);

	if (index == size)//说明插入位置是LinkedList的尾部
		linkLast(element);
	else
		linkBefore(element, node(index));//插入的不是尾部，就插入之前
}

接下来看下linkBefore函数

void linkBefore(E e, Node<E> succ) {
	// assert succ != null;
	final Node<E> pred = succ.prev;//succ是插入位置的原来要插入位的的数据节点，此处获取succ的前节点
	final Node<E> newNode = new Node<>(pred, e, succ);//succ的前节点作为插入新数据的pred节点，succ节点作为插入新数据的后后节点
	succ.prev = newNode;
	if (pred == null)
		first = newNode;
	else
		pred.next = newNode;
	size++;
	modCount++;
}

由此看一看出，add数据就是将链表的数据的前后节点改变，大大减少了增、删的时间。

三、HashMap

非线程安全的，实际上是一个“链表散列”的数据结构，即数组和链表的结合体。hashMap的默认初始容量是16个，其会有一个负载因子，用于当hashMap中的数据量等于容量*负载因子时，hashMap会进行扩容，扩大的容量是原本的2倍。负载因子的默认初始值为0.75。

List	优点	缺点
ArrayList	增、删慢	改、查快
LinkedList	增、删快	改、查慢

ArrayList&LinkedList各有优缺点，那有没有综合ArrayList&LinkedList各自优点的算法就是HashMap。Hash表融合了顺序表和链表（单链表）。 hash表
每一个对象都有一个hashCode函数函数，可以把对象转为int值。

public class Object {
    ......
    public int hashCode() {
        return identityHashCode(this);
    }
    ......
}

在hash表中，存入的key值会被转为hashCode的int值，然后hash值%table.length-1(等同位运算(n - 1) & hash)，求模的值就是0~length-1，如果出现hash碰撞，就会把相同index的value存入链表中。

key值是唯一的，不能重复，如果重复，value会被覆盖。

public V put(K key, V value) {
	return putVal(hash(key), key, value, false, true);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
			   boolean evict) {
	Node<K,V>[] tab; Node<K,V> p; int n, i;
	if ((tab = table) == null || (n = tab.length) == 0)//table为null 代表是初始化，直接扩容
		n = (tab = resize()).length;
	if ((p = tab[i = (n - 1) & hash]) == null)//如果第(n - 1) & hash个为null 直接放入新的节点
		tab[i] = newNode(hash, key, value, null);
	else {
		Node<K,V> e; K k;
		if (p.hash == hash &&
			((k = p.key) == key || (key != null && key.equals(k))))//如果相同，覆盖
			e = p;
		else if (p instanceof TreeNode)
			e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
		else {
			for (int binCount = 0; ; ++binCount) {//链表中已有数据
				if ((e = p.next) == null) {
					p.next = newNode(hash, key, value, null);
					if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
						treeifyBin(tab, hash);
					break;
				}
				if (e.hash == hash &&
					((k = e.key) == key || (key != null && key.equals(k))))
					break;
				p = e;
			}
		}
		if (e != null) { // existing mapping for key
			V oldValue = e.value;
			if (!onlyIfAbsent || oldValue == null)
				e.value = value;
			afterNodeAccess(e);
			return oldValue;
		}
	}
	++modCount;
	if (++size > threshold)
		resize();
	afterNodeInsertion(evict);
	return null;
}