面试问题整理(二)

最新整理:iOS面试题-面试常问问题(二) 前言: 最近把 iOS 面试中可能会遇到的问题整理了一番, 题目大部分是网上收录的, 方便自己巩固复习, 也分享给大家; 希望对大家有所帮助! 对于答案,不一定都合适,欢迎大家积极讨论;整理不易,如果您觉得还不错,麻烦在文末 “点个赞” ,或者留下您的评论“Mark” 一下,谢谢您的支持 iOS面试题-面试常问问题(二) 1.C和 OC 如何混编 xcode可以识别一下几种扩展名文件: .m文件,可以编写 OC语言 和 C 语言代码 .cpp: 只能识别C++ 或者C语言(C++兼容C) .mm: 主 阅读详情

1.浅拷贝和深拷贝的区别

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
参考链接:链接描述

2.接口和抽象类的区别

(1)抽象类:

1、抽象类使用abstract修饰;
2、抽象类不能实例化,即不能使用new关键字来实例化对象;
3、含有抽象方法(使用abstract关键字修饰的方法)的类是抽象类,必须使用abstract关键字修饰;
4、抽象类可以含有抽象方法,也可以不包含抽象方法,抽象类中可以有具体的方法;
5、如果一个子类实现了父类(抽象类)的所有抽象方法,那么该子类可以不必是抽象类,否则就是抽象类;
6、抽象类中的抽象方法只有方法体,没有具体实现;

(2)接口:

1、接口使用interface修饰;
2、接口不能被实例化;
3、一个类只能继承一个类,但是可以实现多个接口;
4、JDK1.8中为了加强接口的能力,使得接口可以存在具体的方法,前提是方法需要被default或static关键字所修饰

3.default关键字

两种使用方法:

  • 在switch语句的时候使用default
  • 在定义接口的时候使用default来修饰具体的方法

1、default修饰的目的是让接口可以拥有具体的方法,让接口内部包含了一些默认的方法实现。
2、既只要实现该接口的类,都具有这么一个默认方法,默认方法也可以被重写。
3、实现某个接口的类都具有某个同样的功能,如果像Java8以前的版本,那么每个实现类都需要写一段重复的代码去实现那个功能,显得没有必要。这就是存在的意义。

注意:
另外这里既然提到了接口的修饰符default,那么就要注意一点,如果一个类实现了两个接口(可以看做是“多继承”),这两个接口又同时都包含了一个名字相同的default方法,那么会发生什么情况? 在这样的情况下,编译器是会报错,得到一个编译器错误,因为编译器不知道应该在两个同名的default方法中选择哪一个,因此产生了二义性。
在这里插入图片描述

4.什么是面向对象

1、面向对象是一种思想,是基于面向过程而言的,就是说面向对象是将功能等通过对象来实现,将功能封装进对象之中,让对象去实现具体的细节;这种思想是将数据作为第一位,而方法或者说是算法作为其次,这是对数据一种优化,操作起来更加的方便,简化了过程。

2、 面向对象有三大特征:封装性、继承性、多态性,
(1)其中封装性指的是隐藏了对象的属性和实现细节,仅对外提供公共的访问方式,这样就隔离了具体的变化,便于使用,提高了复用性和安全性。

(2) 继承性,就是两种事物间存在着一定的所属关系,那么继承的类就可以从被继承的类中获得一些属性和方法;这就提高了代码的复用性。继承是作为多态的前提的。

(3)多态是说父类或接口的引用指向了子类对象,这就提高了程序的扩展性,也就是说只要实现或继承了同一个接口或类,那么就可以使用父类中相应的方法,提高程序扩展性,但是多态有一点不好之处在于:父类引用不能访问子类中的成员。

5.重载和重写的区别

在这里插入图片描述
使用同名方法实现不同的情况

在这里插入图片描述

6.ArrayList和LinkedList的底层实现

一个是动态数组,一个是双向链表
ArrayList适合于随机访问,LinkedList适合于增加删除

7.HashMap和LinkedHashMap和TreeMap的底层区别

(1)按照有序无序

参考:链接描述

(2)按照底层实现

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

8.HashSet和TreeSet底层有什么区别

参考:链接描述

9.ArrayList和HashMap的底层数据接口和增删改查和扩容操作
(1)ArrayList(JDK1.8版)

1.概述

ArrayList是实现List接口的动态数组,所谓动态就是它的大小是可变的。实现了所有可选列表操作,并允许包括 null 在内的所有元素。除了实现 List 接口外,此类还提供一些方法来操作内部用来存储列表的数组的大小。每个ArrayList实例都有一个容量,该容量是指用来存储列表元素的数组的大小。默认初始容量为10。随着ArrayList中元素的增加,它的容量也会不断的自动增长。

在每次添加新的元素时,ArrayList都会检查是否需要进行扩容操作,扩容操作带来数据向新数组的重新拷贝,所以如果我们知道具体业务数据量,在构造ArrayList时可以给ArrayList指定一个初始容量,这样就会减少扩容时数据的拷贝问题。当然在添加大量元素前,应用程序也可以使用ensureCapacity操作来增加ArrayList实例的容量,这可以减少递增式再分配的数量。

注意,ArrayList实现不是同步的。如果多个线程同时访问一个ArrayList实例,而其中至少一个线程从结构上修改了列表,那么它必须保持外部同步。所以为了保证同步,最好的办法是在创建时完成,以防止意外对列表进行不同步的访问:

 List list = Collections.synchronizedList(new ArrayList(...)); 

2.继承关系

ArrayList继承AbstractList抽象父类,实现了List接口(规定了List的操作规范)、RandomAccess(可随机访问)、Cloneable(可拷贝)、Serializable(可序列化)。

3.底层数据结构

ArrayList的底层是一个object数组,并且由transient修饰。

transient Object[] elementData; 

关于transient语法:

non-private to simplify nested class access //ArrayList底层数组不会参与序列化,而是使用另外的序列化方式。

4.常用方法(增删改查)

4.1 添加元素

4.1.1 add(int index, E element)

添加元素时,首先判断索引是否合法,然后检测是否需要扩容,最后使用System.arraycopy方法来完成数组的复制。

这个方法无非就是使用System.arraycopy()方法将C集合(先准换为数组)里面的数据复制到elementData数组中。这里就稍微介绍下System.arraycopy(),因为下面还将大量用到该方法

。该方法的原型为:

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

它的根本目的就是进行数组元素的复制。将源数组src从srcPos位置开始复制到dest数组中,复制长度为length,数据从dest的destPos位置开始粘贴。

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

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
        size - index);
        elementData[index] = element;
        size++;
    }

4.2 删除元素(数组元素会往前移动,那么用原始size肯定有问题)

删除元素时,同样判断索引是否和法,删除的方式是把被删除元素右边的元素左移,方法同样是使用System.arraycopy进行拷贝。

    public E remove ( int index){
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);

        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index + 1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }

4.3 清空元素

ArrayList提供一个清空数组的办法,方法是将所有元素置为null,这样就可以让GC自动回收掉没有被引用的元素了。

    /**
    * Removes all of the elements from this list.  The list will
    * be empty after this call returns.
    */
    public void clear() {
        modCount++;

        // clear to let GC do its work
        for (int i = 0; i < size; i++)
        elementData[i] = null;

        size = 0;
    }

4.4 设置元素

修改元素时,只需要检查下标即可进行修改操作

    public E set(int index, E element) {
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

    public E get(int index) {
        rangeCheck(index);

        return elementData[index];
    }

上述方法都使用了rangeCheck方法,其实就是简单地检查下标而已。

     private void rangeCheckForAdd(int index) {
        if (index > this.size || index < 0) {
            throw new IndexOutOfBoundsException(this.outOfBoundsMsg(index));
        }
    }}

modCount

    protected transient int modCount = 0;

modCount设计Fail-fast机制,参考:https://www.cnblogs.com/songanwei/p/9387745.html

5.扩容机制

    // 扩容发生在add元素时,传入当前元素容量加一
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }


    // 使用无参构造方法时,设置该初始化数组
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    // 如果数组还是初始数组,那么最小的扩容大小就是size+1和初始容量中较大的一个,初始容量为10。
    // 因为addall方法也会调用该函数,所以此时需要做判断
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

    // 开始精确地扩容
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        // 如果此时扩容容量大于数组长度吗,执行grow,否则不执行。
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

真正执行扩容的方法grow

扩容方式是让新容量等于旧容量的1.5倍。当新容量大于最大数组容量时,执行大数扩容。

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
        // 数组此时是空数组或者addAll,一直添加大容量数据,导致频繁扩容,所以OOM,刚开始最好设定默认容量构造elementData
        newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }  

当新容量大于最大数组长度,有两种情况,一种是溢出,抛异常,一种是没溢出,返回整数的最大值。

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

在grow函数中有一个变量需要注意一下MAX_ARRAY_SIZE:

img

还有这里为什么要用Integer.MAX_VALUE-8呢,因为数组在虚拟机中存储时需要8字节来存储其自身的大小。

在这里有一个疑问,为什么每次扩容处理会是1.5倍,而不是2.5、3、4倍呢?

通过google查找,发现1.5倍的扩容是最好的倍数。因为一次性扩容太大(例如2.5倍)可能会浪费更多的内存(1.5倍最多浪费33%,而2.5被最多会浪费60%,3.5倍则会浪费71%……)。但是一次性扩容太小,需要多次对数组重新分配内存,对性能消耗比较严重。所以1.5倍刚刚好,既能满足性能需求,也不会造成很大的内存消耗。

ArrayList还给我们提供了将底层数组的容量调整为当前列表保存的实际元素的大小的功能。它可以通过trimToSize()方法来实现。该方法可以最小化ArrayList实例的存储量。

    public void trimToSize() {
        modCount++;
        int oldCapacity = elementData.length;
        if (size < oldCapacity) {
            elementData = Arrays.copyOf(elementData, size);
        }
    }
public ArrayList(Collection<? extends E> c) {
        this.elementData = c.toArray();
        if ((this.size = this.elementData.length) != 0) {
            if (this.elementData.getClass() != Object[].class) {
                // 因为底层存储的是Object数据,所以这里又创建了Object数组
                this.elementData = Arrays.copyOf(this.elementData, this.size, Object[].class);
            }
        } else {
            this.elementData = EMPTY_ELEMENTDATA;
        }

    }
@HotSpotIntrinsicCandidate
public static <T, U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    T[] copy = newType == Object[].class ? new Object[newLength] : (Object[])Array.newInstance(newType.getComponentType(), newLength);
    System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
    return copy;
}

6.线程安全

ArrayList是线程不安全的。在其迭代器iteator中,如果有多线程操作导致modcount改变,会执行fastfail。抛出异常。

    final void checkForComodification() {
        if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
    }

7.fail-fast机制

    // 1.使用迭代器遍历数组元素
    Iterator it = arr.iterator();

    // 2.判断是否有可以迭代的元素
    while(it.hasNext()){
        // 取出一个元素,并指向下一个元素
        Object obj = it.next();
    }

参考:链接描述

(2)HashMap

HashMap也是我们使用非常多的Collection,HashMap是基于哈希表的 Map 接口的实现类,以key-value的形式存在。在HashMap中,key-value总是会当做一个整体来处理,系统会根据hash算法来来计算key-value的存储位置,我们总是可以通过key快速地存、取value。下面就来分析HashMap的存取。

1.定义

HashMap实现了Map接口,继承AbstractMap。其中Map接口定义了键映射到值的规则,而AbstractMap类提供 Map 接口的骨干实现,以最大限度地减少实现此接口所需的工作,其实AbstractMap类已经实现了Map

public class HashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable

2.构造函数

HashMap 中有四个构造方法,它们分别如下:

    // 默认构造函数。
    public HashMap() {
        // 默认容量为16
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all   other fields defaulted
     }

     // 包含另一个“Map”的构造函数
     public HashMap(Map<? extends K, ? extends V> m) {
         this.loadFactor = DEFAULT_LOAD_FACTOR;
         putMapEntries(m, false);//下面会分析到这个方法
     }

     // 指定“容量大小”的构造函数
     public HashMap(int initialCapacity) {
         this(initialCapacity, DEFAULT_LOAD_FACTOR);
     }
	 
     // 指定“容量大小”和“加载因子”的构造函数
     public HashMap(int initialCapacity, float loadFactor) {
         if (initialCapacity < 0)
             throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
         if (initialCapacity > MAXIMUM_CAPACITY)
             initialCapacity = MAXIMUM_CAPACITY;
         if (loadFactor <= 0 || Float.isNaN(loadFactor))
             throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
         this.loadFactor = loadFactor;
         this.threshold = tableSizeFor(initialCapacity);
     }

putMapEntries方法:

    final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
        int s = m.size();
        if (s > 0) {
            // 判断table是否已经初始化
            if (table == null) { // pre-size
                // 你需要存放元素,必须table是否初始化, 判断要存放这些元素,数组长度应该多大
                float ft = ((float)s / loadFactor) + 1.0f;

                int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                        (int)ft : MAXIMUM_CAPACITY);

                // 计算得到的t大于阈值,则初始化阈值(阈值是衡量当前是否应该扩增的标准,threshold也就是当前数组容量)
                if (t > threshold)
                    threshold = tableSizeFor(t);
            }
            // 已初始化,并且m元素个数大于阈值,进行扩容处理
            else if (s > threshold)
                resize();
            // 如果已经大于threshold,那么就进行扩若resize,否则初始化tableSizeFor(t)
            
            // 将m中的所有元素添加至HashMap中
            for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
                K key = e.getKey();
                V value = e.getValue();
                putVal(hash(key), key, value, false, evict);
            }
        }
    }

3.put方法

HashMap只提供了put用于添加元素,putVal方法只是给put方法调用的一个方法,并没有提供给用户使用。

对putVal方法添加元素的分析如下:

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;
    // table未初始化或者长度为0,进行扩容
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // (n - 1) & hash 确定元素存放在哪个桶中,桶为空,新生成结点放入桶中(此时,这个结点是放在数组中)
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    // 桶中已经存在元素
    else {
        Node<K,V> e; K k;
        // 比较桶中第一个元素(数组中的结点)的hash值相等,key相等
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
                // 将第一个元素赋值给e,用e来记录
                e = p;
        // hash值不相等,即key不相等;为红黑树结点
        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;
                }
                // 判断链表中结点的key值与插入的元素的key值是否相等
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    // 相等,跳出循环
                    break;
                // 用于遍历桶中的链表,与前面的e = p.next组合,可以遍历链表
                p = e;
            }
        }
        // 表示在桶中找到key值、hash值与插入元素相等的结点uii
        if (e != null) { 
            // 记录e的value
            V oldValue = e.value;
            // onlyIfAbsent为false或者旧值为null
            if (!onlyIfAbsent || oldValue == null)
                //用新值替换旧值
                e.value = value;
            // 访问后回调
            afterNodeAccess(e);
            // 返回旧值
            return oldValue;
        }
    }
    // 结构性修改
    ++modCount;
    // 实际大小大于阈值则扩容
    if (++size > threshold)
        resize();
    // 插入后回调
    afterNodeInsertion(evict);
    return null;
} 

JDK1.8使用的是尾插法

我们再来对比一下 JDK1.7 put方法的代码

对于put方法的分析如下:

  • ①如果定位到的数组位置没有元素 就直接插入。
  • ②如果定位到的数组位置有元素,遍历以这个元素为头结点的链表,依次和插入的key比较,如果key相同就直接覆盖,不同就采用头插法插入元素。
public V put(K key, V value)
    if (table == EMPTY_TABLE) { 
    inflateTable(threshold); 
}  
    if (key == null)
        return putForNullKey(value);
    int hash = hash(key);
    int i = indexFor(hash, table.length);
    for (Entry<K,V> e = table[i]; e != null; e = e.next) { // 先遍历
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue; 
        }
    }

    modCount++;
    addEntry(hash, key, value, i);  // 再插入
    return null;
}

4.get方法

public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        // 数组元素相等
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        // 桶中不止一个节点
        if ((e = first.next) != null) {
            // 在树中get
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            // 在链表中get
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

5.resize扩容方法

进行扩容,会伴随着一次重新hash分配,并且会遍历hash表中所有的元素,是非常耗时的。在编写程序中,要尽量避免resize。

jdk1.7时会rehash,这里有hash分配,也有rehash

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0; 
    if (oldCap > 0) {
        // 超过最大值就不再扩充了,就只好随你碰撞去吧
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        // 没超过最大值,就扩充为原来的2倍 
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    else { 
        // signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    // 计算新的resize上限
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr;
    @SuppressWarnings({"rawtypes","unchecked"})
     Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    if (oldTab != null) {
        // 把每个bucket都移动到新的buckets中
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { 
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        next = e.next;
                        // 和源长度偶数进行位&只有两种结果,一种是0,一种是源长度,根据这种方法,可以将两者分开,
                        // 源长度是2的n次方,能和偶数对上就为源长度,否则为0,为0的话就是低位
                        // 使用尾插法的形式,将数据分开
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        // 原索引+oldCap
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    // 低位放到原来bucket里面
                    // 原索引放到bucket里
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    // 高位放到原来的bucket+oldCap位置
                    // 原索引+oldCap放到bucket里
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}
大模型面试最新高频问题整理(二)原创Attention的优化?大模型面试之注意力机制的优化总结解码方式有哪些?如 l层transformer模型的可训练模型参数量为l(12h^2+ 13h)+ Vh:词嵌入矩阵的参数量为Vh。最后的输出层的权重矩阵通常与词嵌入矩阵是参数共享的。位置编码参数量较少,如果采用相对位置编码如RoPE和ALiBi,则不包含可训练的参数。Self-attention块的参数量为4h^2+4h。MLP块的参数量为(4h^2+4h)+(4h^2+h)=8h^2 + 5h。两个layer norm的参数量为4h。2024年07月15日 16:44。 阅读详情

相关推荐

AUTOSAR RTE配置实战:从ECU分区到Task映射的完整指南

本文提供了一份AUTOSAR RTE配置的完整实战指南。从创建ECU分区、定义OS任务,到实现Runnable Entity与Task的精确映射,详细解析了每一步的操作要点与常见陷阱。文章结合配置工具界面,旨在帮助开发者高效完成RTE配置,确保系统实时性与数据一致性,是掌握AUTOSAR核心开发流程的实用参考。

weixin_29228203的博客 487

Java之ArrayList源码分析(第六篇:修改元素)

temp

王员外的博客 3931

PID循迹控制算法

前言  让小车进行循迹最重要的是获取车相对于循迹线的位置,关于循迹模块的原理我已经在之前的一篇博客上讲过,如果大家没看过的话可以点此链接:PID循迹模块原理。 PID循迹原理简介 图1 循迹车寻线行走图示 图2 市场常见循迹传感器  PID循迹的原理我们大致可以用常识性思维去思考下,如图1所示为循迹车寻线行走图示,现在小车要按照中间那条黑线循迹行走,如果车头往左偏则需要控制方向盘让车往右转,车头往又偏则需要让车往左转。但是仅仅只有左转和右转的话,车一到左边就向右转,一到右边就向左转,则车会来回在线左右晃动

Dinvent的博客 7万+

JAVA集合框架探究(二)

JAVA集合框架探究(二) 文章目录JAVA集合框架探究(二)一、SubList源码解析1、SubList2、get set3、add4、rangeCheck5、rangeCheckForAdd6、checkForComodification二、ArrayList源码解析1、构造方法2、add3、remove3.addAll4.grow5.indexOf 一、SubList源码解析 在上一篇Abs...

平台开发组技术博客 248

SpringBoot3 + Vben5.0实战:从零搭建企业级管理后台(附完整代码)

本文详细介绍了如何从零开始,使用SpringBoot3与Vben5.0技术栈搭建现代化企业级管理后台。通过对比分析,阐述了该组合在开发效率、性能(如虚拟线程)和权限模型(RBAC)方面的优势,并提供了从项目初始化、核心功能开发到部署运维的完整实战指南,帮助开发者快速构建高性能、易维护的后台系统。

weixin_29306317的博客 172

14、微电网控制方法与建模分析

本文详细探讨了微电网的控制方法与建模分析,包括逆变器的小信号状态空间模型、网络模型、负载模型及其组合形成的完整微电网模型。通过对系统特征值和灵敏度因子的分析,揭示了不同模式与系统参数之间的关系。文章还提出了多个研究问题,如岛式系统控制器设计、风力发电控制、并网变换器控制等,为微电网的稳定性分析和优化控制提供了理论支持和实践方向。

elastic6hunter的博客 127

delphi遇“Range check error”越界错误的解决经验分享

昨天也不知修改了编译器Compiler页的什么项,导致软件编译后,大部分操作都提示“Range check error”越界错误。中断后,发现代码停在操作MemoryStream的Write行处,Fuck了!这是正常的操作内存流啊,以前一直正常! 解决过程: 1.尝试新建工程,把原程序中所谓的异常代码(内存流的write句)在这里编译,正常编译运行。。。。。 2.无奈了,只好将原程...

3416

sim800c插卡后指示灯还是一秒一闪无法接收发送短信,如何解决?

🏆 本文收录于《全栈Bug调优(实战版)》专栏,致力于分享我在项目实战过程中遇到的各类Bug及其原因,并提供切实有效的解决方案。无论你是初学者还是经验丰富的开发者,本文将为你指引出一条更高效的Bug修复之路,助你早日登顶,迈向财富自由的梦想🚀!同时,欢迎大家关注、收藏、订阅本专栏,更多精彩内容正在持续更新中。让我们一起进步,Up!Up!Up!    备注: 部分问题/难题源自互联网,经过精心筛选和整理,结合数位十多年大厂实战经验资深大佬经验总结所得,数条可行方案供所需之人参考。

**My Coding Family** 1172

Java之ArrayList源码分析(第三篇:删除元素)

(注意:本文基于JDK1.8) 删除元素的4个方法 清空元素的clear()方法 remove(int)方法分析 public E remove(int index) { rangeCheck(index); modCount++; E oldValue = elementData(index); int numMoved = size - index - 1; if (numMoved &gt

王员外的博客 1241

汇川H5U PLC通过EtherCAT总线控制SV660N和X3E伺服

首先我们看下系统硬件和软件配置:汇川H5U PLC的编程软件是:AutoShop V4.6.3.0 硬件:PLC H5U-1614MTD-A16,汇川伺服型号:SV660NS1R6I 电机型号:MS1H1-10B30CB 100W 220V 3000R/M 0.32N*M 1.3A,禾川伺服驱动器型号:SV-X3EB075A-A2 伺服电机型号:SV-X2MH075A-N2LA。

RXXW_Dor的博客 2万+

【AI大模型:架构实战】31、工业级AI大模型系统全景解析:从架构设计到提示语引擎实践

本文系统解析了工业级AI大模型的核心架构与技术体系。整体采用分层解耦设计,包含数据工程、模型训练、模型部署、应用集成和监控运维五大核心模块,以及分布式计算、高速网络、异构硬件三大支撑体系。数据工程构建高质量数据处理流水线;模型训练实现从预训练到业务适配的全流程;模型部署优化服务性能与可用性;应用集成连接业务场景;监控运维保障系统持续优化。三大支撑能力专注于千亿参数管理、高并发低延迟处理和持续学习进化。该架构设计既满足当前需求,又为技术演进预留空间,为企业在数字化转型中提供AI工业化落地的完整解决方案。

2025博客之星Top81。专注AI工程化与架构实战。从分布式思维到模型部署,用工程化视角为你厘清AI落地的真实路径。 1996

MFC编程过程的错误笔记 ------出现__fastfail并提示RangeCheck错误(提示数组超限)

使用串口CMSCOMM控件通讯时,一旦第一条的报文返回的报文超过87个字节并需要将报文完整显示在list control控件的报表模式下的某行;经过排查发现并非是程序的数据超出范围,而是报表的数据显示的长度超出了范围,导致程序出现如图所示错误。为list控件的类添加下图的两个函数,使list控件可自适应长度,这样就可以解决这个错误。

weixin_45982243的博客 195

手机端实时检测:YOLOv8n轻量化改进,骁龙865上35FPS,mAP+3.2%

YOLOv8n-Lite的改进不是简单的“砍通道、降分辨率”,而是结合手机端硬件特性(NPU加速、内存限制)和场景需求(小目标检测),通过“卷积拆分减少计算、通道瘦身适配内存、特征强化保留精度”的协同策略,在骁龙865上实现35FPS实时性与mAP+3.2%的双赢。该方案已在手机端AR应用中落地,支持实时手势识别、物体测量等功能,功耗比原始模型降低40%(连续检测1小时仅耗电12%)。

专注于Python爬虫开发,分享爬虫技巧、项目实战与反爬经验,使用Scrapy、BeautifulSoup等工具,解决数据抓取难题。 727

vue面试常被问到的问题整理(二)

1.vue数据双向绑定原理 2.生命周期 3.vue-router 4.路由钩子 5.axios 6.跨域

喵大嗷的博客 1万+

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

数字IC验证高频面试问题整理附答案(二)

数字IC验证高频面试问题整理附答案

coachip的博客 1172

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

面试基础问题整理(二)

请说一下你对JDK, JRE, JVM的理解 JVM是Java的虚拟机; 作用: 实现了Java语言的跨平台 JRE是Java的运行环境, 包含JVM和Java开发工具; 作用: 开发Java程序 JDK 是Java的开发工具包, 包含JRE和Java开发工具; 作用:开发java程序 请简述什么是关键字, 关键字的特点, 请列举5个插件的关键字 关键字是被Java赋予特殊含义的单词 关键字的特点: 全部由小写字母组成 常用的代码编辑器, 针对关键字由特殊的颜色标记 常见的关键字有: pu.

bayer_zeng的博客 271

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

C++面试基础问题整理笔记二

qq_40429562的博客 688

截止10月19日,复盘秋招23场面试(二)按方面整理罗列面试官问过的问题

关于实习和项目经历:关于技术栈和基础知识:关于数据结构和算法:关于C++语言特性:关于操作系统和计算机组成:关于数据库:关于编译原理:关于硬件和计算机组成:关于软件工程:关于安全问题:关于个人能力和学习:关于职业规划:

JimDu_dwj的博客 427

关于Java面试过程中常见问题的整理(二)

1、Dubbo的集群容错策略 ① 默认的失败重试策略,Failover Cluster:失败重试 重试2次,一共执行3次,这通常用于读操作或者具有幂等的写操作 ② Failfast Cluster:快速失败 当服务消费方调用服务提供者失败后,立即报错,也就是只调用一次。通常这种模式用于非幂等性的写操作 ③Failsafe Cluster:失败安全 当服务消费者调用服务出现异常时,直接忽略异常。这种模式通常用于写入审计日志等操作 ④Failback Cluster:失败自动恢复 当服务消费端用

奇点 511

MySQL面试问题整理二(非个人面试题,持续更新)

char(4)跟varchar(4)有何不同? char跟varchar类型相似,都是用来存储字符串,但是他们的保存和检索方式不同。char属于固定长度的字符类型,而varchar属于可变长度的字符类型。 值 char(4) 存储需求 varchar(4) 存储需求 ‘’ ' ' 四个字节 ‘’ 一个字节 ‘ab’ 'ab' ...

weixin_44569143的博客 233

2024年Web前端最全面试过程中常见的 非技术性质的问题 二,2024年最新2024前端面试真题精选干货整理

开源分享:【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】回答提示:企业对这个问题很感兴趣,只有有备而来的求职者能够过关。求职者可以直接在网上查找对你所申请的行业部门的信息,只有深入了解才能产生独特的见解。企业认为最聪明的求职者是对所面试的公司预先了解很多,包括公司各个部门,发展情况,在面试回答问题的时候可以提到所了解的情况,企业欢迎进入企业的人是“知己”,而不是“盲人”。对工作的期望与目标何在?回答提示:这是面试者用来评断求职者是否对自己有一定程度的期望、对这份工作是否了解的问题。

2401_84418883的博客 901

B端产品经理面试问题及答案(二)面试攻略大全

B端产品经理面试问题及答案(二)面试攻略大全 去发现同类优质开源项目:https://gitcode.com/ 这是一份专为B端产品经理面试准备的全套攻略资料,名为《B端产品经理面试问题及答案(二)【11年大厂面试官呕心制作】.pdf》。本资料基于作者11年大厂面试官及10年产品经理的丰富经验,精心整理而成。 内容概述 本攻略资料包括以下内容: 高清完整版B端产品经理面试问题大全及答案合集脑图...

gitblog_06740的博客 384

一个程序员的面试经历-前言

自从上次发表了《一个程序员的面试经历》的目录,不觉间已经将近3周了! 原因在于: 1)刚开始工作,忙得一塌糊涂 2)现在我的面试经历还在继续,这实在是事先没有想到的,所以又无法完整的整理面试的心情了。 难道真是好事多磨吗?就在我以为已经可以安心工作的时候,却又出现了好几个心仪已久的公司的机会。所以近来的心情较乱,又要做好现在的工作,又要准备新的面试。而且,为了参加面试,已经请假了几回,实在是不好,

ecai的专栏 2129

“面试造飞机,上岗拧螺丝“?软件测试岗面试真题超全面整理

兼容测试主要是检查软件在不同的硬件平台、软件平台上是否可以正常的运行,即是通常说的软件的可移植性。兼容的类型,如果细分的话,有平台的兼容,网络兼容,数据库兼容,以及数据格式的兼容。兼容测试的重点是,对兼容环境的分析。通常,是在运行软件的环境不是很确定的情况下,才需要做兼容。根据软件运行的需要,或者根据需求文档,一般都能够得出用户会在什么环境下使用该软件,把这些环境整理成表单,就得出做兼容测试的兼容环境了。

2301_79535618的博客 646

前端面试题资料

2017年10月WEB前端开发实习生面试题总结 前端实习生面试题分析(一) 前端实习生面试题分析(二) 最全前端开发面试问题及答案整理 转载于:https://www.cnblogs.com/knuzy/p/9220447.html...

weixin_30500663的博客 109

面试三剑客,少一个都不行!

面试八股文准备方式不要一直是拿着一个面试八股文就开始看,因为面试中,面试官大部分都喜欢针对一个点进行深入挖局和扩展,有点类似于猜考试题一样,但凡猜中几个并且自己也准备的不错,那这个面试岂不是里成功很近了吗?梳理好简历中的项目,以及自己在项目中做过什么,一定不要说简历中的项目自己都忘了,这会让面试官很无语的。这里需要注意任何项目都有自己的挑战,不然,在这AI盛行的年代,你迟早会被淘汰。不过,在面试中,我也遇到过很多朋友介绍自己项目时,很混乱,不知道先说什么再说什么,面试官听了都是云里雾里的。

田维常 385
上一篇: 对无序链表归并排序
下一篇: 华为2016研发工程师编程题(二)
念殊15
博客等级 码龄8年 17粉丝 177原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值