强化基础-Java-集合

news2024/11/28 11:38:51

这块的知识点比较零碎也是看到了就过来记录一点，可能是之前没有特别注意的，会持续补充

集合

1 通用实现

List
Set
SortedSet（如果表达是有序的,返回签名使用有序set来表达）
NavigableSet(since 1.6)
Queue (since 1.5)
Deque(since 1.6)
SortedMap
NavigableMap(since 1.6)

Map允许为空的的value
ConcurrentHashMap value 不允许为空，如果value为空在查询数据时会产生歧义，到底是值为空还是线程不可见

2 并发实现

ConcurrentMap(since 1.5)
ConcurrentNavigableMap(since 1.6)
BlockingQueue
TransferQueue
BlockingDeque
LinkedBlockingQueue
ArrayBlockingQueue
PriorityBlockingQueue
DelayQueue
SynchronousUqueu
LinkedBlockingDeque
LinkedTransferQueue
CopyOnWriteArrayList
CopyOnWriteArraySet
ConcurrentSkipListSet
ConcurrentSkipListMap

3 遗留实现

Vector
vector 是数组实现线程安全的，他也是实现了List,一般对标的是ArrayList
如果在一个方法里面使用vector 几乎没有同步的消耗，因为它不存在资源竞争。
Stack
Hashtable
Enumeration
BitSet
这里Vector，Stack，Hashtable都是线程安全的

Collection 顶层接口

这里只对值得记录的知识点做一个记录，其它平时比较熟悉的基础知识这里不再记录。

int size();

public interface Collection<E> extends Iterable<E> {
    // 这个size最多为Integer.MAX_VALUE
    int size();
}

为什么不用Long类型呢?
因为Long和double 是非线程安全的，有两个四字节，高位和地位。
补充知识:

// 这两个都是true
System.out.println(Integer.MAX_VALUE + 1 == Integer.MIN_VALUE);
System.out.println(Integer.MAX_VALUE + 2 == Integer.MIN_VALUE + 1);

Object[] toArray() 与 T[] toArray(T[] a) 的区别

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
// 区别转换为对象数组
Object[] one = list.toArray();
System.out.println("length : " + one.length);
Arrays.stream(one).forEach(System.out::println);
System.out.println("========>");
// 允许我们指定输出的类型,并且如果我们指定的数组比真实数据多,后面的空间全赋值为null
Integer[] two = list.toArray(new Integer[10]);
// 并且如果我们指定了数组的长度我们的长度以指定的数组为准
System.out.println("length : " + two.length);
Arrays.stream(two).forEach(System.out::println);
System.out.println("========>");
// 如果我们指定的数组长度小于原始,它会以原始的数据为准,也就是说不会少数据
Integer[] three = list.toArray(new Integer[3]);
System.out.println("length : " + three.length);
Arrays.stream(three).forEach(System.out::println);

为什么Collection里面有add 队列里面还有自己的add方法呢？
我们看到这个约束其实是不一样的，集合可能是只读的，所以有UnsupportedOperationException异常。
在这里插入图片描述

在这里插入图片描述

Set 与 Map

1 set是map key 的实现，Set底层调用Map实现。

// 我们还可以看到如果是set其实他的value都是指向同一个对象
private static final Object PRESENT = new Object();
public HashSet() {
   map = new HashMap<>();
}

2 treeSet底层用了TreeMap

public TreeSet() {
    this(new TreeMap<E,Object>());
}

3 LinkedHashMap

// 有一个这个属性 其实就是实现的LRU算法
final boolean accessOrder;

在插入元素以后：

//执行了这个方法 LinkedHashMap 是有实现的
afterNodeInsertion()
// 而HashMap没有实现这个方法里面是空的什么也没有做
void afterNodeInsertion(boolean evict) { }

为什么HashSet不能保证有序？

public class TT {
    public static void main(String[] args) {
        // 不能保证有序
        Set<String> values = new HashSet<>();
        values.add("a");
        values.add("b");
        values.add("c");
        values.forEach(System.out::println);
        values.clear();
        values.add("1");
        values.add("2");
        values.add("3");
        values.forEach(System.out::println);
        // 上面的这两个场景之所以能保证有序是因为这些例子都是 ASCII码
        // 字符数组底部就是一个char数组
        // char 的 hash 转换为了int
        public static int hashCode(char value) {
            return (int)value;
        }
        // String hash 按照下面规则进行计算所以看起来是有序的样子
        public int hashCode() {
            int h = hash;
            if (h == 0 && value.length > 0) {
                char val[] = value;

                for (int i = 0; i < value.length; i++) {
                    h = 31 * h + val[i];
                }
                hash = h;
            }
            return h;
        }
       
    }
}

设计贴士：

// 这里之所以要设计为传对象是兼容多维数组
public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);