细数 List 的10个坑，保证你一定遇到过！

news2024/10/5 19:19:43

List 在实际的业务开发中，使用的非常频繁，但同样也有不少的坑，一旦使用不当，就可能带来一系列的问题；今天我们主要来说一说这些问题，以及面对这些坑的时候我们要怎么解决。

Arrays.asList转换基本类型数组的坑

在实际的业务开发中，我们通常会进行数组转List的操作，通常我们会使用Arrays.asList来进行转换

但是在转换基本类型的数组的时候，却出现转换的结果和我们想象的不一致。

上代码

int[] arr = {1, 2, 3}; 
List list = Arrays.asList(arr); 
System.out.println(list.size()); 
// 1

实际上，我们想要转成的List应该是有三个对象而现在只有一个

public static List asList(T... a) { 
    return new ArrayList<>(a); 
}

可以观察到 asList方法 接收的是一个泛型T类型的参数，T继承Object对象

所以通过断点我们可以看到把 int数组 整体作为一个对象,返回了一个 List<int[]>

「那我们该如何解决呢？」

方案一：Java8以上，利用Arrays.stream(arr).boxed()将装箱为Integer数组

List collect = Arrays.stream(arr).boxed().collect(Collectors.toList()); System.out.println(collect.size()); 
System.out.println(collect.get(0).getClass()); 
// 3 
// class java.lang.Integer

方案二：声明数组的时候，声明类型改为包装类型

Integer[] integerArr = {1, 2, 3}; 
List integerList = Arrays.asList(integerArr); 
System.out.println(integerList.size()); System.out.println(integerList.get(0).getClass()); 
// 3 
// class java.lang.Integer

Arrays.asList返回的List不支持增删操作

我们将数组对象转成List数据结构之后，竟然不能进行增删操作了

private static void asListAdd(){
    String[] arr = {"1", "2", "3"};
    List<String> strings = new ArrayList<>(Arrays.asList(arr));
    arr[2] = "4";
    System.out.println(strings.toString());
    Iterator<String> iterator = strings.iterator();
    while (iterator.hasNext()){
        if ("4".equals(iterator.next())){
            iterator.remove();
        }
    }
    strings.forEach(val ->{
        strings.remove("4");
        strings.add("3");
    });

    System.out.println(Arrays.asList(arr).toString());
}

[1, 2, 4] 
Exception in thread "main" java.lang.UnsupportedOperationException at java.util.AbstractList.remove(AbstractList.java:161) at java.util.AbstractList$Itr.remove(AbstractList.java:374) at java.util.AbstractCollection.remove(AbstractCollection.java:293) at JavaBase.List.AsListTest.lambda$asListAdd$0(AsListTest.java:47) at java.util.Arrays$ArrayList.forEach(Arrays.java:3880) at JavaBase.List.AsListTest.asListAdd(AsListTest.java:46) at JavaBase.List.AsListTest.main(AsListTest.java:20)

初始化一个字符串数组，将字符串数组转换为 List，在遍历List的时候进行移除和新增的操作

抛出异常信息UnsupportedOperationException。

根据异常信息java.lang.UnsupportedOperationException，我们看到他是从AbstractList里面出来的，让我们进入源码一看究竟

我们在什么时候调用到了这个 AbstractList 呢？

其实 Arrays.asList(arr) 返回的 ArrayList 不是 java.util.ArrayList，而是 Arrays的内部类

private static class ArrayList<E> extends AbstractList<E>
        implements RandomAccess, java.io.Serializable{
    private static final long serialVersionUID = -2764017481108945198L;
    private final E[] a;
    ArrayList(E[] array) {
        a = Objects.requireNonNull(array);
    }

    @Override
    public E get(int index) {}

    @Override
    public E set(int index, E element) {...}

...
}
public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
    public boolean add(E e) {
        add(size(), e);
        return true;
    }
    public void add(int index, E element) {
        throw new UnsupportedOperationException();
    }

    public E remove(int index) {
        throw new UnsupportedOperationException();
    }

}

他是没有实现 AbstractList 中的 add() 和 remove() 方法,这里就很清晰了为什么不支持新增和删除，因为根本没有实现。

对原始数组的修改会影响到我们获得的那个List

一不小心修改了父List，却影响到了子List，在业务代码中，这会导致产生的数据发生变化，严重的话会造成影响较大的生产问题。

第二个坑的源码中，完成字符串数组转换为List之后，

我们将字符串数组的第三个对象的值修改为4，但是很奇怪在打印List的时候，发现List也发生了变化。

public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
}

ArrayList(E[] array) {
    a = Objects.requireNonNull(array);
}

asList中创建了 ArrayList，但是他直接引用了原本的数组对象

所以只要原本的数组对象一发生变化，List也跟着变化

所以在使用到引用的时候，我们需要特别的注意。

解决方案：

重新new一个新的 ArrayList 来装返回的 List

List strings = new ArrayList<>(Arrays.asList(arr));  

java.util.ArrayList如果不正确操作也不支持增删操作

在第二个坑的时候，我们说到了 Arrays.asList 返回的 List 不支持增删操作，

是因为他的自己实现了一个内部类 ArrayList，这个内部类继承了 AbstractList 没有实现 add() 和 remove() 方法导致操作失败。

但是第三个坑的时候，我们利用 java.util.ArrayList 包装了返回的 List，进行增删操作还是会失败，那是为什么呢？

删除方法逻辑：

在foreach中操作增删，因为因为 modCount 会被修改，与第一步保存的数组修改次数不一致，抛出异常 ConcurrentModificationException

在正确操作是什么？我总结了四种方式

ArrayList中的 subList 强转 ArrayList 导致异常

阿里《Java开发手册》上提过

“

[强制] ArrayList的sublist结果不可強转成ArrayList,否则会抛出ClassCastException异常，即java.util.RandomAccesSubList cannot be cast to java. util.ArrayList.

说明: subList 返回的是ArrayList 的内部类SubList, 并不是ArrayList ，而是ArrayList

的一个视图，対于SubList子列表的所有操作最终会反映到原列表上。

private static void subListTest(){  
    List<String> names = new ArrayList<String>() {{  
    add("one");  
    add("two");  
    add("three");  
}};  
    ArrayList strings = (ArrayList) names.subList(0, 1);  
    System.out.println(strings.toString());  
}  
  
Exception in thread "main" java.lang.ClassCastException: java.util.ArrayList$SubList cannot be cast to java.util.ArrayList  

我猜问题是有八九就是出现在subList这个方法上了

private class SubList extends AbstractList<E> implements RandomAccess {  
  
    private final AbstractList<E> parent;  
    private final int parentOffset;  
    private final int offset;  
    int size;  
    SubList(AbstractList<E> parent,  
  
    int offset, int fromIndex, int toIndex) {  
    this.parent = parent;  
    this.parentOffset = fromIndex;  
    this.offset = offset + fromIndex;  
    this.size = toIndex - fromIndex;  
    this.modCount = ArrayList.this.modCount;  
}  
}  

其实 SubList 是一个继承 AbstractList 的内部类，在 SubList 的构建函数中的将 List 中的部分属性直接赋予给自己

SubList 没有创建一个新的 List，而是直接引用了原来的 List(this.parent = parent)，指定了元素的范围

所以 subList 方法不能直接转成 ArrayList，他只是ArrayList的内部类，没有其他的关系

因为是引用的关系，所以在这里也需要特别的注意，如果对原来的List进行修改，会对产生的 subList结果产生影响。

List<String> names = new ArrayList<String>() {{
    add("one");
    add("two");
    add("three");
}};

List strings = names.subList(0, 1);
strings.add(0, "ongChange");
System.out.println(strings.toString());
System.out.println(names.toString());
[ongChange, one]
[ongChange, one, two, three]

对subList产生的List做出结构型修改，操作会反应到原来的List上，ongChange也添加到了names中

如果修改原来的List则会抛出异常ConcurrentModificationException

List<String> names = new ArrayList<String>() {{
    add("one");
    add("two");
    add("three");
}};

List strings = names.subList(0, 1);
names.add("four");
System.out.println(strings.toString());
System.out.println(names.toString());
Exception in thread "main" java.util.ConcurrentModificationException

原因：

subList的时候记录this.modCount为3

原来的List插入了一个新元素，导致this.modCount不第一次保存的不一致则抛出异常

解决方案：在操作SubList的时候，new一个新的ArrayList来接收创建subList结果的拷贝

List strings = new ArrayList(names.subList(0, 1));

ArrayList中的subList切片造成OOM

在业务开发中的时候，他们经常通过subList来获取所需要的那部分数据

在上面的例子中，我们知道了subList所产生的List，其实是对原来List对象的引用

这个产生的List只是原来List对象的视图，也就是说虽然值切片获取了一小段数据，但是原来的List对象却得不到回收，这个原来的List对象可能是一个很大的对象

为了方便我们测试，将vm调整一下 -Xms20m -Xmx40m

private static void subListOomTest(){  
  
    IntStream.range(0, 1000).forEach(i ->{  
        List<Integer> collect = IntStream.range(0, 100000).boxed().collect(Collectors.toList());  
            data.add(collect.subList(0, 1));  
        });    
    }}  
  
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space  

出现OOM的原因，循环1000次创建了1000个具有10万个元素的List

因为始终被collect.subList(0, 1)强引用，得不到回收

解决方式：

  1. 在subList方法返回SubList，重新使用new ArrayList，来构建一个独立的ArrayList

List list = new ArrayList<>(collect.subList(0, 1));  

  1. 利用Java8的Stream中的skip和limit来达到切片的目的

List list = collect.stream().skip(0).limit(1).collect(Collectors.toList());  

在这里我们可以看到，只要用一个新的容器来装结果，就可以切断与原始List的关系。

LinkedList的插入速度不一定比ArrayList快

学习数据结构的时候，我们就已经得出了结论

  • 对于数组，随机元素访问的时间复杂度是0(1)， 元素插入操作是O(n);

  • 对于链表，随机元素访问的时间复杂度是O(n), 元素插入操作是0(1).

元素插入对于链表来说应该是他的优势

但是他就一定比数组快? 我们执行插入1000w次的操作

private static void test(){
    StopWatch stopWatch = new StopWatch();
    int elementCount = 100000;
    stopWatch.start("ArrayList add");
    List<Integer> arrayList = IntStream.rangeClosed(1, elementCount).boxed().collect(Collectors.toCollection(ArrayList::new));
    // ArrayList插入数据
    IntStream.rangeClosed(0, elementCount).forEach(i ->arrayList.add(ThreadLocalRandom.current().nextInt(elementCount), 1));
    stopWatch.stop();

    stopWatch.start("linkedList add");
    List<Integer> linkedList = IntStream.rangeClosed(1, elementCount).boxed().collect(Collectors.toCollection(LinkedList::new));
    // ArrayList插入数据
    IntStream.rangeClosed(0, elementCount).forEach(i -> linkedList.add(ThreadLocalRandom.current().nextInt(elementCount), 1));
    stopWatch.stop();
    System.out.println(stopWatch.prettyPrint());
}

StopWatch '': running time = 44507882 ns
---------------------------------------------
ns         %     Task name
---------------------------------------------
043836412  098%  elementCount 100 ArrayList add
000671470  002%  elementCount 100 linkedList add

StopWatch '': running time = 196325261 ns
---------------------------------------------
ns         %     Task name
---------------------------------------------
053848980  027%  elementCount 10000 ArrayList add
142476281  073%  elementCount 10000 linkedList add

StopWatch '': running time = 26384216979 ns
---------------------------------------------
ns         %     Task name
---------------------------------------------
978501580  004%  elementCount 100000 ArrayList add
25405715399  096%  elementCount 100000 linkedList add

看到在执行插入1万、10完次操作的时候，LinkedList的插入操作时间是 ArrayList的两倍以上

那问题主要就是出现在linkedList的 add()方法上

public void add(int index, E element) {  
  
    checkPositionIndex(index);  
  
    if (index == size)  
        linkLast(element);  
    else  
        linkBefore(element, node(index));  
}  
      
/**  
* Returns the (non-null) Node at the specified element index.  
    */  
Node<E> node(int index) {  
  
    // assert isElementIndex(index);  
  
    if(index < (size >> 1)) {  
        Node<E> x = first;  
        for (int i = 0; i < index; i++)  
            x = x.next;  
        return x;  
    } else {  
        Node<E> x = last;  
        for (int i = size - 1; i > index; i--)  
            x = x.prev;  
        return x;  
    }  
}  

linkedList的 add()方法主要逻辑

 

  1. 通过遍历找到那个节点的Node

  2. 执行插入操作

ArrayList的 add()方法

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++;
} 

  1. 计算最小容量

  2. 最小容量大于数组对象，则进行扩容

  3. 进行数组复制,根据插入的index将数组向后移动一位

  4. 最后在空位上插入新值

根据试验的测试，我们得出了在实际的随机插入中，LinkedList并没有比ArrayList的速度快

所以在实际的使用中，如果涉及到头尾对象的操作，可以使用LinkedList数据结构来进行增删的操作，发挥LinkedList的优势

最好再进行实际的性能测试评估，来得到最合适的数据结构。

CopyOnWriteArrayList内存占用过多

CopyOnWrite，顾名思义就是写的时候会将共享变量新复制一份出来，这样做的好处是读操作完全无锁。

CopyOnWriteArrayList的add()方法

public boolean add(E e) {
    // 获取独占锁
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        // 获取array
        Object[] elements = getArray();
        // 复制array到新数组，添加元素到新数组
        int len = elements.length;
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        newElements[len] = e;
        // 替换数组
        setArray(newElements);
        return true;
    } finally {
        // 释放锁
        lock.unlock();
    }
}

CopyOnWriteArrayList 内部维护了一个数组，成员变量 array 就指向这个内部数组，所有的读操作都是基于新的array对象进行的。

因为上了独占锁，所以如果多个线程调用add()方法只有一个线程会获得到该锁，其他线程被阻塞，知道锁被释放， 由于加了锁，所以整个操作的过程是原子性操作

CopyOnWriteArrayList 会将 新的array复制一份，然后在新复制处理的数组上执行增加元素的操作，执行完之后再将复制的结果指向这个新的数组。

由于每次写入的时候都会对数组对象进行复制，复制过程不仅会占用双倍内存，还需要消耗 CPU 等资源，所以当列表中的元素比较少的时候，这对内存和 GC 并没有多大影响，但是当列表保存了大量元素的时候，

对 CopyOnWriteArrayList 每一次修改，都会重新创建一个大对象，并且原来的大对象也需要回收，这都可能会触发 GC，如果超过老年代的大小则容易触发Full GC，引起应用程序长时间停顿。

CopyOnWriteArrayList是弱一致性的

public Iterator<E> iterator() {
    return new COWIterator<E>(getArray(), 0);
}

static final class COWIterator<E> implements ListIterator<E> {
    /** Snapshot of the array */
    private final Object[] snapshot;
    /** Index of element to be returned by subsequent call to next.  */
    private int cursor;

    private COWIterator(Object[] elements, int initialCursor) {
        cursor = initialCursor;
        snapshot = elements;
    }

    public boolean hasNext() {
        return cursor < snapshot.length;
    }

    public boolean hasPrevious() {
        return cursor > 0;
    }

    @SuppressWarnings("unchecked")
    public E next() {
        if (! hasNext())
            throw new NoSuchElementException();
        return (E) snapshot[cursor++];
    }

调用iterator方法获取迭代器返回一个COWIterator对象

COWIterator的构造器里主要是 保存了当前的list对象的内容和遍历list时数据的下标。

snapshot是list的快照信息，因为CopyOnWriteArrayList的读写策略中都会使用getArray()来获取一个快照信息，生成一个新的数组。

所以在使用该迭代器元素时，其他线程对该lsit操作是不可见的，因为操作的是两个不同的数组所以造成弱一致性。

private static void CopyOnWriteArrayListTest(){
    CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList();
    list.add("test1");
    list.add("test2");
    list.add("test3");
    list.add("test4");
    
    Thread thread = new Thread(() -> {
        System.out.println(">>>> start");
        list.add(1, "replaceTest");
        list.remove(2);
    });
    
    // 在启动线程前获取迭代器
    Iterator<String> iterator = list.iterator();

    thread.start();

    try {
        // 等待线程执行完毕
        thread.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    while (iterator.hasNext()){
        System.out.println(iterator.next());
    }
}

>>>> start
test1
test2
test3
test4

上面的demo中在启动线程前获取到了原来list的迭代器，

在之后启动新建一个线程，在线程里面修改了第一个元素的值，移除了第二个元素

在执行完子线程之后，遍历了迭代器的元素，发现子线程里面操作的一个都没有生效，这里提现了迭代器弱一致性。

CopyOnWriteArrayList的迭代器不支持增删改

private static void CopyOnWriteArrayListTest(){
    CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
    list.add("test1");
    list.add("test2");
    list.add("test3");
    list.add("test4");

    Iterator<String> iterator = list.iterator();

    while (iterator.hasNext()){
        if ("test1".equals(iterator.next())){
            iterator.remove();
        }
    }

    System.out.println(list.toString());
}

Exception in thread "main" java.lang.UnsupportedOperationException
 at java.util.concurrent.CopyOnWriteArrayList$COWIterator.remove(CopyOnWriteArrayList.java:1178)

CopyOnWriteArrayList 迭代器是只读的，不支持增删操作

CopyOnWriteArrayList迭代器中的 remove()和 add()方法，没有支持增删而是直接抛出了异常。

因为迭代器遍历的仅仅是一个快照，而对快照进行增删改是没有意义的。

/**
 * Not supported. Always throws UnsupportedOperationException.
 * @throws UnsupportedOperationException always; {@code remove}
 *         is not supported by this iterator.
 */
public void remove() {
    throw new UnsupportedOperationException();
}

/**
 * Not supported. Always throws UnsupportedOperationException.
 * @throws UnsupportedOperationException always; {@code set}
 *         is not supported by this iterator.
 */
public void set(E e) {
    throw new UnsupportedOperationException();
}

/**
 * Not supported. Always throws UnsupportedOperationException.
 * @throws UnsupportedOperationException always; {@code add}
 *         is not supported by this iterator.
 */
public void add(E e) {
    throw new UnsupportedOperationException();
}

总结

由于篇幅的限制，我们只对一些在业务开发中常见的关键点进行梳理和介绍

在实际的工作中，我们不单单是要清除不同类型容器的特性，还要选择适合的容器才能做到事半功倍。

我们主要介绍了Arrays.asList转换过程中的一些坑，以及因为操作不当造成的OOM和异常，

到最后介绍了线程安全类CopyOnWriteArrayList的一些坑，让我们认识到在丰富的API下藏着许多的陷阱。

在使用的过程中，需要更加充分的考虑避免这些隐患的发生。

最后一张思维导图来回顾一下~

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/704786.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

深度学习----第J2周：ResNet50V2算法实现

深度学习----第J2周：ResNet50V2算法实现

深度学习----第J2周&#xff1a;ResNet50V2算法实现 文章目录 深度学习----第J2周&#xff1a;ResNet50V2算法实现前言一、ResNetV2与ResNet结构对比二、模型复现2.1 Residual Block2.2 堆叠的 Residual Block2.3 ResNet50V22.4 查看模型结构2.5 tf下全部代码 三、Pytorch复现3…
阅读更多...
有哪些数据分析的工具？

有哪些数据分析的工具？

来了&#xff0c;9款大数据&数据分析工具推荐&#xff0c;分享点和别人不一样的。 一、基于 Apache Hudi 的 Onehouse https://www.onehouse.ai 近日&#xff0c;开源大数据项目 Apache Hudi 创始人 Vinoth Chandar 发文官宣基于 Hudi 构建的商业公司和产品 Onehouse&…
阅读更多...
Linux +Docker镜像打包导出，上传至内网服务器

Linux +Docker镜像打包导出，上传至内网服务器

1. docker容器打包成镜像和压缩 &#xff08;1&#xff09;首先查看镜像所在的容器&#xff0c;获取到容器id docker ps -a&#xff08;2&#xff09;将容器保存成镜像 sudo docker commit -a yjw e007d8b7e1b7 my_projectv2:v2sudo&#xff1a;以管理员权限运行命令&#x…
阅读更多...
Unity快速上手系列1之：2D物理弹球

Unity快速上手系列1之：2D物理弹球

大家好。 以“跳一跳”为开端&#xff0c;微信小游戏从前几年起以迅雷不及掩耳盗铃儿响叮当之势席卷了用户的手机。从创意小游戏&#xff0c;到页游遗风的挂机游戏&#xff0c;一时间百花齐放。 当然&#xff0c;前者说是创意&#xff0c;其实绝大部分也就是直接把其他平台上的…
阅读更多...
5.8.2 TCP报文段首部格式

5.8.2 TCP报文段首部格式

5.8.2 TCP报文段首部格式 TCP报文段首部格式在很大程度上体现了TCP协议的功能 一、数据封装过程 如图 应用层报文传送到传输层之后&#xff0c;加上TCP报文段的首部构成了TCP数据传送单位&#xff0c;我们称之为TCP报文段。在发送时TCP报文段是作为IP数据报的数据部分&#…
阅读更多...
linux虚拟内存管理

linux虚拟内存管理

目录 虚拟内存分布 进程虚拟内存空间的管理 内核如何划分用户态和内核态虚拟内存空间 内核如何管理虚拟内存区域 定义虚拟内存区域的访问权限和行为规范 关联内存映射中的映射关系 虚拟内存区域在内核中是如何被组织的 程序编译后的二进制文件如何映射到虚拟内存空间中 …
阅读更多...
探索图像处理的利器——OpenCV

探索图像处理的利器——OpenCV

目录 引言&#xff1a; 一、OpenCV简介&#xff1a; 二、OpenCV的特点&#xff1a; 三、OpenCV的应用领域&#xff1a; 四、实际案例&#xff1a; 结论&#xff1a; 引言&#xff1a; 在当今信息化的时代&#xff0c;图像处理已经成为了日常生活中不可或缺的一部分。从社…
阅读更多...
4742. 电(acw每日一题)

4742. 电(acw每日一题)

来源&#xff1a;Google Kickstart2022 Round H Problem C 题目描述 某城市有 N个电力节点&#xff0c;编号 1∼N。 这些电力节点形成的电力网络&#xff0c;可以看作一个 N 个节点 N−1 条边的连通图。 每个电力节点都有一个固定的电容&#xff0c;其中第 i 个节点的电容为…
阅读更多...
CSS 备忘录-基础内容

CSS 备忘录-基础内容

目录 1、CSS的基本结构 2、样式表的来源以及优先级 3、选择器的优先级 4、源码顺序 5、px、em、rem单位 6、视口相对单位 7、使用 calc() 来定义属性值 8、一些无单位的属性 9、自定义属性 10、使用 JavaScript 来动态修改自定义属性 11、overflow 属性 12、子元素…
阅读更多...
【单片机】STM32单片机的各个定时器的定时中断程序，标准库，STM32F103

【单片机】STM32单片机的各个定时器的定时中断程序，标准库，STM32F103

文章目录 定时器1_定时中断定时器2_定时中断定时器3_定时中断定时器4_定时中断定时器5_定时中断 高级定时器和普通定时器的区别&#xff08;https://zhuanlan.zhihu.com/p/557896041&#xff09;&#xff1a; 定时器1_定时中断 TIM1是高级定时器&#xff0c;使用的时钟总线是R…
阅读更多...
bochs编译安装

bochs编译安装

编译命令 ./configure --prefix‘/usr/local/bochs2.7’ --enable-debugger --enable-disasm --enable-iodebug --enable-x86-debugger --with-x --with-x11 make sudo make install 配置文件 bochsrc # configuration file generated by Bochs plugin_ctrl: unmapped1, biosde…
阅读更多...
让开源项目从易用到好用 | 亚马逊的开源文化

让开源项目从易用到好用 | 亚马逊的开源文化

亚马逊的领导力准则是亚马逊文化的核心&#xff0c;它如同亚马逊的 DNA 融入贯穿每一个重要决策&#xff0c;深深影响着每一位亚麻人、影响着每一位亚马逊的客户、合作伙伴以及每一位亚马逊云科技的构建者。同时&#xff0c;亚马逊的领导力准则对亚马逊与开源的互动方式也产生着…
阅读更多...
如何设计一个文件系统？需要考虑哪些因素？

如何设计一个文件系统？需要考虑哪些因素？

文件系统的实现 在对文件有了基本认识之后&#xff0c;现在是时候把目光转移到文件系统的实现上了。之前用户关心的一直都是文件是怎样命名的、可以进行哪些操作、目录树是什么&#xff0c;如何找到正确的文件路径等问题。而设计人员关心的是文件和目录是怎样存储的、磁盘空间…
阅读更多...
数字孪生和GIS融合会为城市交通带来哪些便利？

数字孪生和GIS融合会为城市交通带来哪些便利？

数字孪生和GIS的融合对于城市交通领域带来了诸多便利&#xff0c;从智能交通管理到出行体验的提升&#xff0c;为城市交通带来了全新的发展机遇。 首先&#xff0c;数字孪生技术与GIS的结合可以实现智能交通管理。通过GIS建立城市交通网络的数字孪生模型&#xff0c;可以实时模…
阅读更多...
程序员找工作难！拿到外包公司的 offer 我应该去么？

程序员找工作难！拿到外包公司的 offer 我应该去么？

引言 前一阵子有一个帖子引起了非常广泛的讨论&#xff0c;描述的就是一个公司的外包工作人员&#xff0c;加班的时候因为吃了公司给员工准备的零食,被公司的HR当场批评&#xff01;这个帖子一发出来&#xff0c;让现在测试行业日益新增的外包公司备受关注。那么外包公司和非外…
阅读更多...
Qt开发1--QCustomPlot的第一个示例

Qt开发1--QCustomPlot的第一个示例

本文记录了在Linux上使用QCustomPlot进行一个基本绘制所需的完整过程&#xff0c;包括如何使用qtcreator&#xff0c;编辑ui以及编写相应的C代码。以下是详细步骤&#xff1a; 1、使用qtcreator启动开发环境&#xff1a; [blctrlmain-machine qt]$ qtcreator 启动后&#xf…
阅读更多...
GBDT精讲

GBDT精讲

GBDT算法的流程 首先GBDT是通过采用加法模型(即基函数的线性组合)&#xff0c;以及不断减小训练过程产生的残差来达到将数据分类或回归的算法。 GBDT通过多轮迭代&#xff0c;每轮迭代产生一个弱分类器&#xff0c;每个分类器在上一轮分类器的梯度(如果损失函数是平方损失函数…
阅读更多...
Quiz 4: Functions | Python for Everybody 配套练习_解题记录

Quiz 4: Functions | Python for Everybody 配套练习_解题记录

文章目录 课程简介Quiz 4: Functions 单选题&#xff08;1-9&#xff09;编程题Exercise 4.6 课程简介 Python for Everybody 零基础程序设计&#xff08;Python 入门&#xff09; This course aims to teach everyone the basics of programming computers using Python. 本课…
阅读更多...
JAVA2

JAVA2

文章目录 前言 前言 创建&#xff0c;编译java&#xff08;每4修改一次就要重新编译&#xff01;&#xff09; 第一个程序&#xff1a; 解决中文乱码问题&#xff1a; 效果&#xff1a; 总结&#xff1a;
阅读更多...
管理类联考——英语——趣味篇——词根词汇——按频次分类——高频词汇——List1

管理类联考——英语——趣味篇——词根词汇——按频次分类——高频词汇——List1

优化原书记忆方法&#xff0c;轻松搞定考研单词 摒弃了传统的以字母顺序排序的方法&#xff0c;结合近20年考研真题&#xff0c;通过电脑搜索等方法对核心词进行科学统计&#xff0c;将核心词有机地分为高频词汇、常考词汇、中频词汇、低频词汇等4大部分&#xff0c;同时还补充…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023