JAVAlist,javalist转数组

发布时间:2023-01-07

本文目录一览:

  1. Java的List如何实现线程安全?
  2. java中list后面加是什么意思?
  3. java list集合什么意思

Java的List如何实现线程安全?

Java的List如何实现线程安全? Collections.synchronizedList(names);效率最高,线程安全 Java的List是我们平时很常用的集合,线程安全对于高并发的场景也十分的重要,那么List如何才能实现线程安全呢? 加锁 首先大家会想到用Vector,这里我们就不讨论了,首先讨论的是加锁,例如下面的代码

public class Synchronized {
    private List<String> names = new LinkedList();
    public synchronized void addName(String name) {
        names.add("abc");
    }
    public String getName(Integer index) {
        Lock lock = new ReentrantLock();
        lock.lock();
        try {
            return names.get(index);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        return null;
    }
}

synchronized一加,或者使用lock可以实现线程安全,但是这样的List要是很多个,代码量会大大增加。

java自带类

在java中我找到自带有两种方法

CopyOnWriteArrayList

CopyOnWrite 写入时复制,它使一个List同步的替代品,通常情况下提供了更好的并发性,并且避免了再迭代时候对容器的加锁和复制。通常更适合用于迭代,在多插入的情况下由于多次的复制性能会一定的下降。 下面是add方法的源代码

public boolean add(E e) {
    final ReentrantLock lock = this.lock; // 加锁 只允许获得锁的线程访问
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        // 创建个长度加1的数组并复制过去
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        newElements[len] = e; // 赋值
        setArray(newElements); // 设置内部的数组
        return true;
    } finally {
        lock.unlock();
    }
}

Collections.synchronizedList

Collections中有许多这个系列的方法例如 主要是利用了装饰者模式对传入的集合进行调用 Collotions中有内部类SynchronizedList

static class SynchronizedList<E>
    extends SynchronizedCollection<E>
    implements List<E> {
    private static final long serialVersionUID = -7754090372962971524L;
    final List<E> list;
    SynchronizedList(List<E> list) {
        super(list);
        this.list = list;
    }
    public E get(int index) {
        synchronized (mutex) { return list.get(index); }
    }
    public E set(int index, E element) {
        synchronized (mutex) { return list.set(index, element); }
    }
    public void add(int index, E element) {
        synchronized (mutex) { list.add(index, element); }
    }
    public E remove(int index) {
        synchronized (mutex) { return list.remove(index); }
    }
}
static class SynchronizedCollection<E> implements Collection<E>, Serializable {
    private static final long serialVersionUID = 3053995032091335093L;
    final Collection<E> c;  // Backing Collection
    final Object mutex;     // Object on which to synchronize
    ...
}

这里上面的mutex就是锁的对象,在构建时候可以指定锁的对象,主要使用synchronized关键字实现线程安全。

static class SynchronizedList<E>
    extends SynchronizedCollection<E>
    implements List<E> {
    private static final long serialVersionUID = -7754090372962971524L;
    final List<E> list;
    SynchronizedList(List<E> list) {
        super(list);
        this.list = list;
    }
    SynchronizedList(List<E> list, Object mutex) {
        super(list, mutex);
        this.list = list;
    }
}

这里只是列举SynchronizedList,其他类类似,可以看下源码了解下。

测试

public class Main {
    public static void main(String[] args) {
        List<String> names = new LinkedList();
        names.add("sub");
        names.add("jobs");
        // 同步方法1 内部使用lock
        long a = System.currentTimeMillis();
        List<String> strings = new CopyOnWriteArrayList(names);
        for (int i = 0; i < 100000; i++) {
            strings.add("param1");
        }
        long b = System.currentTimeMillis();
        // 同步方法2 装饰器模式使用 synchronized
        List<String> synchronizedList = Collections.synchronizedList(names);
        for (int i = 0; i < 100000; i++) {
            synchronizedList.add("param2");
        }
        long c = System.currentTimeMillis();
        System.out.println("CopyOnWriteArrayList time == " + (b - a));
        System.out.println("Collections.synchronizedList time == " + (c - b));
    }
}

两者内部使用的方法都不一样,CopyOnWriteArrayList内部是使用lock进行加锁解锁完成单线程访问,synchronizedList使用的是synchronized 进行了100000次添加后时间对比如下: 可以看出来还是使用了synchronized的集合工具类在添加方面更加快一些,其他方法这里篇幅关系就不测试了,大家有兴趣去试一下。

java中list后面加是什么意思?

这是泛型,保证List传入类型跟ArrayList传入类型一致;例如:

List<String> list = new ArrayList<Integer>();

以上代码List指定类型是String,而真正传入的Integer这样编译是不会通过的。 如果List指定了泛型,那么编译就会检测,如果不定义泛型,编译通过,运行不合理值会报错。 泛型(Generic type 或者generics)是对Java语言的类型系统的一种扩展,以支持创建可以按类型进行参数化的类。可以把类型参数看作是使用参数化类型时指定的类型的一个占位符,就像方法的形式参数是运行时传递的值的占位符一样。

用法:

实际上有两种List:一种是基本的ArrayList,其优点在于随机访问元素,另一种是更强大的LinkedList,它并不是为快速随机访问设计的,而是具有一套更通用的方法。次序是List最重要的特点:它保证维护元素特定的顺序。 List为Collection添加了许多方法,使得能够向List中间插入与移除元素(这只推荐LinkedList使用)。一个List可以生成ListIterator,使用它可以从两个方向遍历List,也可以从List中间插入和移除元素。 以上内容参考:百度百科-java列表

java list集合什么意思

  1. 集合可以有list,vector等,其实map也是一个集合
  2. 这些集合有啥用呢,就好比你有一堆数据要存:
[name='张三',
age=20,
address='北京']
[name='李四',
age=15,
address='湖南']
[name='王五',
age=18,
address='甘肃']

这样一条一条的数据你就能够用集合来保存起来,放到一条集合中去 3. 例如用list来保存,保存形式就如下:

list = {
    [name='张三',
    age=20,
    address='北京'],
    [name='李四',
    age=15,
    address='湖南'],
    [name='王五',
    age=18,
    address='甘肃']
};

这样的形式了,然后取值的时候你就可以根据list.get(i)来分别取值了。 4. 如果要取到每一条里面的属性,那么可以配合map或者存储的是实体类对象,来分别取值就对了,非常的简单且实用