`
taiwei.peng
  • 浏览: 234384 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

java 集合初始化

    博客分类:
  • java
阅读更多

ArrayList
1.ArrayList构造一个默认初始容量为10的空列表。
2.自动容量1.5倍。

3.单线程中才使用而在多线程中可以选择Vector。

 

ArrayList和LinkedList的大致区别: 

1.ArrayList是实现了基于动态数组的数据结构,LinkedList基于链表的数据结构。 
2.对于随机访问get,ArrayList觉得优于LinkedList,因为LinkedList要移动指针。 
3.对于在列表中间新增和删除操作add和remove,LinedList比较占优势,因为ArrayList要移动 数据。 


HashMap
1.线程不安全
2.默认初始容量16,必须为2的幂
3.加载因子默认0.75
4.多线程中使用ConcurrentHashMap

BlockingQueue 阻塞队列
在多线程领域:所谓阻塞,在某些情况下会挂起线程(即阻塞),一旦条件满足,被挂起的线程又会自动被唤醒
BlockingQueue的核心方法:

1)offer(anObject):表示如果可能的话,将anObject加到BlockingQueue里,即如果BlockingQueue可以容纳,则返回true,否则返回false.

3)poll(time):取走BlockingQueue里排在首位的对象,若不能立即取出,则可以等time参数规定的时间,取不到时返回null

 

2)put(anObject):把anObject加到BlockingQueue里,如果BlockQueue没有空间,则调用此方法的线程被阻断直到BlockingQueue里面有空间再继续

 

4)take():取走BlockingQueue里排在首位的对象,若BlockingQueue为空,阻断进入等待状态直到Blocking有新的对象被加入为止

 

作为开发者,我们需要注意的是,如果构造一个LinkedBlockingQueue对象,而没有指定其容量大小,LinkedBlockingQueue会默认一个类似无限大小的容量(Integer.MAX_VALUE),这样的话,如果生产者的速度一旦大于消费者的速度,也许还没有等到队列满阻塞产生,系统内存就有可能已被消耗殆尽了。

 

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
 
/**
 * @author jackyuj
 */
public class BlockingQueueTest {
 
    public static void main(String[] args) throws InterruptedException {
        // 声明一个容量为10的缓存队列
        BlockingQueue<String> queue = new LinkedBlockingQueue<String>(10);
 
        Producer producer1 = new Producer(queue);
        Producer producer2 = new Producer(queue);
        Producer producer3 = new Producer(queue);
        Consumer consumer = new Consumer(queue);
 
        // 借助Executors
        ExecutorService service = Executors.newCachedThreadPool();
        // 启动线程
        service.execute(producer1);
        service.execute(producer2);
        service.execute(producer3);
        service.execute(consumer);
 
        // 执行10s
        Thread.sleep(10 * 1000);
        producer1.stop();
        producer2.stop();
        producer3.stop();
 
        Thread.sleep(2000);
        // 退出Executor
        service.shutdown();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
import java.util.Random;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
 
/**
 * 消费者线程
 *
 * @author jackyuj
 */
public class Consumer implements Runnable {
 
    public Consumer(BlockingQueue<String> queue) {
        this.queue = queue;
    }
 
    public void run() {
        System.out.println("启动消费者线程!");
        Random r = new Random();
        boolean isRunning = true;
        try {
            while (isRunning) {
                System.out.println("正从队列获取数据...");
                String data = queue.poll(2, TimeUnit.SECONDS);
                if (null != data) {
                    System.out.println("拿到数据:" + data);
                    System.out.println("正在消费数据:" + data);
                    Thread.sleep(r.nextInt(DEFAULT_RANGE_FOR_SLEEP));
                } else {
                    // 超过2s还没数据,认为所有生产线程都已经退出,自动退出消费线程。
                    isRunning = false;
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
            Thread.currentThread().interrupt();
        } finally {
            System.out.println("退出消费者线程!");
        }
    }
 
    private BlockingQueue<String> queue;
    private static final int      DEFAULT_RANGE_FOR_SLEEP = 1000;
}
 
import java.util.Random;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
 
/**
 * 生产者线程
 *
 * @author jackyuj
 */
public class Producer implements Runnable {
 
    public Producer(BlockingQueue queue) {
        this.queue = queue;
    }
 
    public void run() {
        String data = null;
        Random r = new Random();
 
        System.out.println("启动生产者线程!");
        try {
            while (isRunning) {
                System.out.println("正在生产数据...");
                Thread.sleep(r.nextInt(DEFAULT_RANGE_FOR_SLEEP));
 
                data = "data:" + count.incrementAndGet();
                System.out.println("将数据:" + data + "放入队列...");
                if (!queue.offer(data, 2, TimeUnit.SECONDS)) {
                    System.out.println("放入数据失败:" + data);
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
            Thread.currentThread().interrupt();
        } finally {
            System.out.println("退出生产者线程!");
        }
    }
 
    public void stop() {
        isRunning = false;
    }
 
    private volatile boolean      isRunning               = true;
    private BlockingQueue queue;
    private static AtomicInteger  count                   = new AtomicInteger();
    private static final int      DEFAULT_RANGE_FOR_SLEEP = 1000;
分享到:
评论

相关推荐

    6种方法初始化JAVA中的list集合

    本文将详细介绍6种初始化Java List集合的方法,并通过代码示例帮助理解每种方法的使用和特点。 1. 常规方式 这是最常见的初始化List的方式,通过创建ArrayList实例并逐个添加元素。自JDK 7以后,可以省略泛型类型的...

    Java中初始化数据域的四种方法

    // 静态初始化块用于初始化静态集合 } } ``` 静态初始化块常用于初始化静态数据结构或一次性设置全局配置。 以上四种方法在不同的场景下各有优劣。直接赋值简单快速,但缺乏灵活性;构造器初始化可以根据对象...

    java初级视频教程系列之-java初始化

    9. **集合初始化**:Java提供了ArrayList, LinkedList, HashSet等集合类,它们可以通过初始化列表来创建和填充。 10. **枚举类型初始化**:枚举是Java 5引入的特性,每个枚举实例在编译时自动初始化。 这个视频...

    java初始化和清理

    Java初始化和清理是Java语言中非常重要的两个过程,它们确保了Java程序的正确运行和资源的有效管理。Java的初始化包括类的加载、连接和初始化三个过程,而清理则主要指垃圾回收机制。 首先,Java初始化的主要特性...

    java在hashmap初始化时赋初值过程解析

    Java 在 HashMap 初始化时赋初值过程解析 Java 中的 HashMap 是一种常用的数据结构,一般用来做数据字典或者 Hash 查找的容器。在初始化并赋初值时,我们通常使用 `HashMap, Object&gt; map = new HashMap();` 的方式...

    java集合深度学习

    在哈希表的初始化和扩容策略上,HashTable的初始容量是11,扩容时通过old*2+1的方式。而HashMap的默认容量是16,并且总是2的幂次方。这种设计使得HashMap在计算索引时可以通过位运算提高效率,而不是使用模运算。 ...

    java知识集合

    类加载机制:类加载过程包括加载、验证、准备、解析和初始化等步骤。 Java IO/NIO: Java的IO库提供了丰富的类和接口用于进行输入和输出操作,包括流的读取和写入。 NIO(New IO)是Java提供的一种新的IO API,支持...

    java集合课程3.docx

    6. **集合初始化**: - `HashMap`的容量(Capacity)和负载因子(Load Factor)是其关键参数,决定何时进行扩容。默认容量16,负载因子0.75,当元素数量达到阈值(Capacity * Load Factor)时,HashMap会自动扩容。...

    java开发集合例子

    在这些例子中,我们可能会看到如何创建和初始化这些集合对象,例如: ```java List&lt;String&gt; list = new ArrayList(); Set&lt;Integer&gt; set = new HashSet(); Map, String&gt; map = new HashMap(); ``` 接着,我们还会...

    Java初始化List方法代码实例

    首先,List是Java集合框架中的一种数据结构,用于存储有序的集合。List接口是Collection接口的子接口,提供了对元素的添加、删除、修改、遍历等操作。List接口有多个实现类,如ArrayList、LinkedList、Vector等。 ...

    Java中List与Map初始化的一些写法

    Java的在还没有发现新写法之前时,我一直是这么初始化List跟Map: //初始化List List list = new ArrayList(); list.add("string1"); list.add("string2"); //some other list.add() code…… list.add(...

    java集合知识点总结.doc

    构造方法是指在创建对象时使用的方法,用于初始化对象的状态。构造方法的定义包括访问修饰符、返回值类型、方法名和参数列表四个部分。 Java 集合知识点总结涵盖了集合的定义、分类、操作和实现等方面,同时也涵盖...

    java实验数组和集合

    本实验中我们学习了 Java 语言中的数组和集合操作,掌握了 Java 中的数组声明、初始化、索引访问、遍历等操作,并使用冒泡排序算法将数组元素排序。同时,我们还学习了 Java 中的输入输出操作和异常处理。

    三歪教你学Java集合(1).pdf

    文档的内容包含了集合框架的初始化,集合的基本操作,以及不同集合的特定实现类的使用方法。 从文档提供的部分内容来看,主要涉及了Java集合框架的几个主要接口和类的介绍和使用方法。以下是对文档中提及知识点的...

    java各公司笔试题集合

    7. 数组:创建、初始化和操作数组,以及数组与集合的区别。 二、Java集合框架 Java集合框架是面试中常考的部分,包括List、Set、Queue和Map接口,以及ArrayList、LinkedList、HashSet、HashMap等实现类: 1. 集合...

    Java课件 (包括基础语法,数组与语句,面向对象编程,java异常处理,java常用基础类,java集合与泛型

    学习如何声明、初始化和操作数组至关重要,包括一维数组、二维数组和多维数组。此外,语句如跳转语句(break和continue)和声明语句也是程序流程控制的重要组成部分。 3. **面向对象编程**:Java是纯面向对象的语言...

    JAVA集合介绍

    ### JAVA集合介绍——深入理解ArrayList #### 一、ArrayList概述 `ArrayList` 是 `java.util.List` 接口的一种实现,其本质是一个动态数组。它能够根据需要动态地调整其大小,以适应列表中元素数量的变化。`...

    Java集合框架ArrayListJava开发Java经验

    1. 初始化容量:如果你知道集合可能包含的元素数量,最好在创建ArrayList时指定初始容量,避免不必要的扩容操作,提高性能。 2. 使用迭代器:当遍历ArrayList时,使用Iterator比for-each循环更高效,因为迭代器不...

Global site tag (gtag.js) - Google Analytics