Java基础知识和常用数据结构整理与分析--Framwork篇_java数据结构基础知识

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上物联网嵌入式知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、电子书籍、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

   private static class HashtableEntry<K, V> implements Entry<K, V> {
    final K key;
    V value;
    final int hash;
    HashtableEntry<K, V> next;

    HashtableEntry(K key, V value, int hash, HashtableEntry<K, V> next) {
        this.key = key;
        this.value = value;
        this.hash = hash;
        this.next = next;
    }

hashtable是线程安全的。继承自Dictionary。hashmap实现Cloneable和Serializable接口。

（9）HashMap和ConcurrentHashMap的区别，HashMap的底层源码
hashmap源码：

    transient HashMapEntry<K, V>[] table；//存储数组

    //数组内存储类型结构
    static class HashMapEntry<K, V> implements Entry<K, V> {
    final K key;
    V value;
    final int hash;
    HashMapEntry<K, V> next;

    HashMapEntry(K key, V value, int hash, HashMapEntry<K, V> next) {
        this.key = key;
        this.value = value;
        this.hash = hash;
        this.next = next;
    }
    }

hashtable谁先线程安全时，是锁住整个整个结构，每次只能一个线程进入取操作结构数据。
ConcurrentHashMap就是解决了hashtable的效率问题，写入数据时每次只锁住要操作的那一个桶（数组中操作的那个单元），这样就可以同时16（默认数组大小）个线程对结构数据进行操作，显著提升了效率。当读取时没有用到锁，完全并发的操作。在求size的时候会锁住整个结构。在进行数据迭代时，集合再发生改变不会抛出异常取而代之的是在改变时new新的数据从而不影响原有的数据，iterator完成后再将头指针替换为新的数据，这样iterator线程可以使用原来老的数据，而写线程也可以并发的完成改变，更重要的，这保证了多个线程并发执行的连续性和扩展性，是性能提升的关键  

（10）TreeMap、HashMap、LindedHashMap的区别
LinkedHashMap设计思想:采用双向链表存储数据。

 transient LinkedEntry<K, V> header;

static class LinkedEntry<K, V> extends HashMapEntry<K, V> {
    LinkedEntry<K, V> nxt;
    LinkedEntry<K, V> prv;

    /\*\* Create the header entry \*/
    LinkedEntry() {
        super(null, null, 0, null);
        nxt = prv = this;
    }

    /\*\* Create a normal entry \*/
    LinkedEntry(K key, V value, int hash, HashMapEntry<K, V> next,
                LinkedEntry<K, V> nxt, LinkedEntry<K, V> prv) {
        super(key, value, hash, next);
        this.nxt = nxt;
        this.prv = prv;
    }
}

treemap设计思想：

Node<K, V> root;

static class Node<K, V> implements Map.Entry<K, V> {
    Node<K, V> parent;
    Node<K, V> left;
    Node<K, V> right;
    final K key;
    V value;
    int height;

    Node(Node<K, V> parent, K key) {
        this.parent = parent;
        this.key = key;
        this.height = 1;
    }

（11）Collection包结构，与Collections的区别
collection是集合的上级接口（存放单值），它的自接口包括set，list.
collections是集合的帮助类，提供操作集合的工具方法。

（12）try catch finally，try里有return，finally还执行么？
先执行try里面的语句，如果try代码块中有return，先计算出return后代码块的值，完成后将这个值保存在内存中。如果try代码块出现异常，则进入catch中。最后都会进入finally结构中。
先执行完finally中语句才会执行try中的return语句，计算完return的值之后，无论在什么地方修改了参数的值，retnrn需要返回的值都是确定的，在执行finally前就已经确定了，不会改变。

（13）Override和Overload的含义去区别。

Override 特点
1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；
2、覆盖的方法的返回值必须和被覆盖的方法的返回一致；
3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；
4、方法被定义为final不能被重写。
5、对于继承来说，如果某一方法在父类中是访问权限是private，那么就不能在子类对其进行重写覆盖，如果定义的话，也只是定义了一个新方法，而不会达到重写覆盖的效果。（通常存在于父类和子类之间。）

Overload 特点
1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int, float)， 但是不能为fun(int, int)）；
2、不能通过访问权限、返回类型、抛出的异常进行重载；
3、方法的异常类型和数目不会对重载造成影响；
4、重载事件通常发生在同一个类中，不同方法之间的现象。
5、存在于同一类中，但是只有虚方法和抽象方法才能被覆写。

(14)Interface与abstract类的区别
1.abstract class 在Java中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。
2.在abstract class 中可以有自己的数据成员，也可以有非abstarct的方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是static final的，不过在 interface中一般不定义数据成员），所有的方法都是public abstract的。
3.抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以重新赋值。接口中定义的变量默认是public static final 型，且必须给其赋初值，所以实现类中不能重新定义，也不能改变其值。
4.abstract class和interface所反映出的设计理念不同。其实abstract class表示的是”is-a”关系，interface表示的是”like-a”关系。
5.实现抽象类和接口的类必须实现其中的所有方法。抽象类中可以有非抽象方法。接口中则不能有实现方法

（15）ThreadLocal的设计理念与作用
Java中的ThreadLocal类允许我们创建只能被同一个线程读写的变量。因此，如果一段代码含有一个ThreadLocal变量的引用，即使两个线程同时执行这段代码，它们也无法访问到对方的ThreadLocal变量。

threadlocal的set方法：

public void set(T value) {
    Thread currentThread = Thread.currentThread();
    Values values = values(currentThread);
    if (values == null) {
        values = initializeValues(currentThread);
    }
    values.put(this, value);
}

threadlocal的get方法：

public T get() {
// Optimized for the fast path.
Thread currentThread = Thread.currentThread();
Values values = values(currentThread);
if (values != null) {
Object[] table = values.table;
int index = hash & values.mask;
if (this.reference == table[index]) {
return (T) table[index + 1];
}
} else {
values = initializeValues(currentThread);
}

return (T) values.getAfterMiss(this);
}

上面提到的values是创建在threadlocal中的values实例，其结构如下：

static class Values {

    /\*\*
 \* Size must always be a power of 2.
 \*/
    private static final int INITIAL_SIZE = 16;

    /\*\*
 \* Placeholder for deleted entries.
 \*/
    private static final Object TOMBSTONE = new Object();

    /\*\*
 \* Map entries. Contains alternating keys (ThreadLocal) and values.
 \* The length is always a power of 2.
 \*/
    private Object[] table;

    /\*\* Used to turn hashes into indices. \*/
    private int mask;

    /\*\* Number of live entries. \*/
    private int size;

    /\*\* Number of tombstones. \*/
    private int tombstones;

    /\*\* Maximum number of live entries and tombstones. \*/
    private int maximumLoad;

    /\*\* Points to the next cell to clean up. \*/
    private int clean;

    /\*\*
 \* Constructs a new, empty instance.
 \*/
    Values() {
        initializeTable(INITIAL_SIZE);
        this.size = 0;
        this.tombstones = 0;
    }

实际上threadlocal 存储数据就是将数据添加到一个指定好的数组（Object[] table;）上。每个线程都有一个localvalues对象实例，用于存储数据。
values存储数据的put方法核心代码：

void put(ThreadLocal<?> key, Object value) 
table[index] = key.reference;//threadlocal的引用
table[index + 1] = value;

收集整理了一份《2024年最新物联网嵌入式全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升的朋友。

如果你需要这些资料，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人

都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

[外链图片转存中…(img-4Mdnqf9x-1715678556790)]
[外链图片转存中…(img-qRkH4mpg-1715678556791)]

如果你需要这些资料，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人

都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！