Java队列集合的性能测试
同时开10个线程存入和取出100万的数据，结论如下：
DoubleBufferedQueue < ConcurrentLinkedQueue < ArrayBlockingQueue < LinkedBlockingQueue
执行结果如下：
100万 DoubleBufferedQueue入队时间：9510 出队时间：10771
100万 DoubleBufferedQueue入队时间：8169 出队时间：9789
1000万 DoubleBufferedQueue入队时间：98285 出队时间：101088
1000万 DoubleBufferedQueue入队时间：101859 出队时间：105964
100万 ConcurrentLinkedQueue入队时间：10557 出队时间：13716
100万 ConcurrentLinkedQueue入队时间：25298 出队时间：25332
1000万 ConcurrentLinkedQueue队列时间：121868 出队时间：136116
1000万 ConcurrentLinkedQueue队列时间：134306 出队时间：147893
100万 ArrayBlockingQueue入队时间：21080 出队时间：22025
100万 ArrayBlockingQueue入队时间：17689 出队时间：19654
1000万 ArrayBlockingQueue入队时间：194400 出队时间：205968
1000万 ArrayBlockingQueue入队时间：192268 出队时间：197982
100万 LinkedBlockingQueue入队时间：38236 出队时间：52555
100万 LinkedBlockingQueue入队时间：30646 出队时间：38573
1000万 LinkedBlockingQueue入队时间：375669 出队时间：391976
1000万 LinkedBlockingQueue入队时间：701363 出队时间：711217
doubleBufferedQueue：
package test.MoreThread.d; import java.util.ArrayList;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import test.MoreThread.l.linkedBlockingQueue;
import comrt.util.DoubleBufferedQueue; //DoubleBufferedQueue入队时间：9510 出队时间：10771
//DoubleBufferedQueue入队时间：8169 出队时间：9789
public class doubleBufferedQueue {
private static final Logger log = LoggerFactory
.getLogger(doubleBufferedQueue.class); public final static int size1 = 1000000;
public static DoubleBufferedQueue<Object> queue = new DoubleBufferedQueue<Object>(
size1);
public final static int threadNumber = 10;
public static boolean isOver = false; public static void main(String[] args) throws InterruptedException,
ExecutionException { // long timestart = System.currentTimeMillis();
Thread thread1 = new Thread(new Runnable() {
public void run() {
ExecutorService executorService = Executors
.newFixedThreadPool(threadNumber);
ArrayList<Future<Long>> results = new ArrayList<Future<Long>>();
for (int i = 0; i < threadNumber; i++) {
Future<Long> future = executorService
.submit(new ExecDoubleBufferedQueue());
results.add(future);
} long allTime = 0;
for (Future<Long> fs : results) {
try {
allTime += fs.get();
// log.info("" + fs.get());
} catch (InterruptedException e) {
log.info("" + e);
return;
} catch (ExecutionException e) {
log.info("" + e);
} finally {
executorService.shutdown();
}
}
doubleBufferedQueue.isOver = true;
log.info("入队列总共执行时间：" + allTime);
}
});
thread1.start();
// log.info("主线程执行时间：" + (System.currentTimeMillis() - timestart));
// ------------------------------
Thread thread2 = new Thread(new Runnable() {
public void run() {
ExecutorService executorService2 = Executors
.newFixedThreadPool(threadNumber);
ArrayList<Future<Long>> results_out = new ArrayList<Future<Long>>();
for (int i = 0; i < threadNumber; i++) {
Future<Long> future = executorService2
.submit(new ExecDoubleBufferedQueue_Out());
results_out.add(future);
} long allTime_out = 0;
for (Future<Long> fs : results_out) {
try {
allTime_out += fs.get();
// log.info("" + fs.get());
} catch (InterruptedException e) {
log.info("" + e);
return;
} catch (ExecutionException e) {
log.info("" + e);
} finally {
executorService2.shutdown();
}
}
log.info("出队列总共执行时间：" + allTime_out);
}
});
thread2.start();
}
} class ExecDoubleBufferedQueue implements Callable<Long> {
private static final Logger log = LoggerFactory
.getLogger(doubleBufferedQueue.class); @Override
public Long call() throws Exception {
long time = System.currentTimeMillis(); for (int i = 0; i < doubleBufferedQueue.size1; i++) {
doubleBufferedQueue.queue.offer(i);
}
long time2 = System.currentTimeMillis() - time;
// log.info("执行时间：" + time2);
return time2;
}
} class ExecDoubleBufferedQueue_Out implements Callable<Long> {
private static final Logger log = LoggerFactory
.getLogger(doubleBufferedQueue.class); @Override
public Long call() throws Exception {
long time = System.currentTimeMillis();
while (!doubleBufferedQueue.isOver) {
doubleBufferedQueue.queue.poll();
}
long time2 = System.currentTimeMillis() - time;
// log.info("执行时间：" + time2);
return time2;
}
}
concurrentLinkedQueue：
package test.MoreThread.c; import java.util.ArrayList;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory; //ConcurrentLinkedQueue入队时间：10557 出队时间：13716
//ConcurrentLinkedQueue入队时间：25298 出队时间：25332
public class concurrentLinkedQueue {
private static final Logger log = LoggerFactory
.getLogger(concurrentLinkedQueue.class); public static ConcurrentLinkedQueue<Object> queue = new ConcurrentLinkedQueue<Object>(); public final static int size1 = 1000000;
public final static int threadNumber = 10;
public static boolean isOver = false; public static void main(String[] args) throws InterruptedException,
ExecutionException { // long timestart = System.currentTimeMillis();
Thread thread1 = new Thread(new Runnable() {
public void run() {
ExecutorService executorService = Executors
.newFixedThreadPool(threadNumber);
ArrayList<Future<Long>> results = new ArrayList<Future<Long>>();
for (int i = 0; i < threadNumber; i++) {
Future<Long> future = executorService.submit(new Exec());
results.add(future);
} long allTime = 0;
for (Future<Long> fs : results) {
try {
allTime += fs.get();
// log.info("" + fs.get());
} catch (InterruptedException e) {
log.info("" + e);
return;
} catch (ExecutionException e) {
log.info("" + e);
} finally {
executorService.shutdown();
}
}
concurrentLinkedQueue.isOver = true;
log.info("队列总共执行时间：" + allTime);
}
});
thread1.start(); // ------------------------------
Thread thread2 = new Thread(new Runnable() {
public void run() {
ExecutorService executorService2 = Executors
.newFixedThreadPool(threadNumber);
ArrayList<Future<Long>> results_out = new ArrayList<Future<Long>>();
for (int i = 0; i < threadNumber; i++) {
Future<Long> future = executorService2
.submit(new Exec_Out());
results_out.add(future);
} long allTime_out = 0;
for (Future<Long> fs : results_out) {
try {
allTime_out += fs.get();
// log.info("" + fs.get());
} catch (InterruptedException e) {
log.info("" + e);
return;
} catch (ExecutionException e) {
log.info("" + e);
} finally {
executorService2.shutdown();
}
}
log.info("出队列总共执行时间：" + allTime_out);
}
});
thread2.start();
// log.info("主线程执行时间：" + (System.currentTimeMillis() - timestart));
}
} class Exec implements Callable<Long> {
private static final Logger log = LoggerFactory
.getLogger(concurrentLinkedQueue.class); @Override
public Long call() throws Exception {
long time = System.currentTimeMillis(); for (int i = 0; i < concurrentLinkedQueue.size1; i++) {
concurrentLinkedQueue.queue.offer(i);
} long time2 = System.currentTimeMillis() - time;
// log.info("执行时间：" + time2);
return time2;
}
} class Exec_Out implements Callable<Long> {
private static final Logger log = LoggerFactory
.getLogger(concurrentLinkedQueue.class); @Override
public Long call() throws Exception {
long time = System.currentTimeMillis();
while (!concurrentLinkedQueue.isOver) {
concurrentLinkedQueue.queue.poll();
}
long time2 = System.currentTimeMillis() - time;
// log.info("执行时间：" + time2);
return time2;
}
}
arrayBlockingQueue：
package test.MoreThread.a; import java.util.ArrayList;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory; //ArrayBlockingQueue入队时间：21080 出队时间：22025
//ArrayBlockingQueue入队时间：17689 出队时间：19654
public class arrayBlockingQueue {
private static final Logger log = LoggerFactory
.getLogger(arrayBlockingQueue.class); public final static int size1 = 1000000;
public static ArrayBlockingQueue<Object> queue = new ArrayBlockingQueue<Object>(
size1);
public final static int threadNumber = 10;
public static boolean isOver = false; public static void main(String[] args) throws InterruptedException,
ExecutionException { // long timestart = System.currentTimeMillis();
Thread thread1 = new Thread(new Runnable() {
public void run() {
ExecutorService executorService = Executors
.newFixedThreadPool(threadNumber);
ArrayList<Future<Long>> results = new ArrayList<Future<Long>>();
for (int i = 0; i < threadNumber; i++) {
Future<Long> future = executorService
.submit(new ExecArrayBlockingQueue());
results.add(future);
} long allTime = 0;
for (Future<Long> fs : results) {
try {
allTime += fs.get();
// log.info("" + fs.get());
} catch (InterruptedException e) {
log.info("" + e);
return;
} catch (ExecutionException e) {
log.info("" + e);
} finally {
executorService.shutdown();
}
}
arrayBlockingQueue.isOver = true;
log.info("队列总共执行时间：" + allTime);
}
});
thread1.start();
// log.info("主线程执行时间：" + (System.currentTimeMillis() - timestart)); // ------------------------------
Thread thread2 = new Thread(new Runnable() {
public void run() {
ExecutorService executorService2 = Executors
.newFixedThreadPool(threadNumber);
ArrayList<Future<Long>> results_out = new ArrayList<Future<Long>>();
for (int i = 0; i < threadNumber; i++) {
Future<Long> future = executorService2
.submit(new ExecArrayBlockingQueue_Out());
results_out.add(future);
} long allTime_out = 0;
for (Future<Long> fs : results_out) {
try {
allTime_out += fs.get();
// log.info("" + fs.get());
} catch (InterruptedException e) {
log.info("" + e);
return;
} catch (ExecutionException e) {
log.info("" + e);
} finally {
executorService2.shutdown();
}
}
log.info("出队列总共执行时间：" + allTime_out);
}
});
thread2.start();
}
} class ExecArrayBlockingQueue implements Callable<Long> {
private static final Logger log = LoggerFactory
.getLogger(arrayBlockingQueue.class); @Override
public Long call() throws Exception {
long time = System.currentTimeMillis(); for (int i = 0; i < arrayBlockingQueue.size1; i++) {
arrayBlockingQueue.queue.offer(i);
} long time2 = System.currentTimeMillis() - time;
// log.info("执行时间：" + time2);
return time2;
}
} class ExecArrayBlockingQueue_Out implements Callable<Long> {
private static final Logger log = LoggerFactory
.getLogger(arrayBlockingQueue.class); @Override
public Long call() throws Exception {
long time = System.currentTimeMillis();
while (!arrayBlockingQueue.isOver) {
arrayBlockingQueue.queue.poll();
}
long time2 = System.currentTimeMillis() - time;
// log.info("执行时间：" + time2);
return time2;
}
}
linkedBlockingQueue：
package test.MoreThread.l; import java.util.ArrayList;
import java.util.Vector;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory; //LinkedBlockingQueue入队时间：38236 出队时间：52555
//LinkedBlockingQueue入队时间：30646 出队时间：38573
public class linkedBlockingQueue {
private static final Logger log = LoggerFactory
.getLogger(linkedBlockingQueue.class); public final static int size1 = 1000000;
public static LinkedBlockingQueue<Object> queue = new LinkedBlockingQueue<Object>(
size1);
public final static int threadNumber = 10;
public static boolean isOver = false; public static void main(String[] args) throws InterruptedException,
ExecutionException {
long timestart = System.currentTimeMillis(); Thread thread1 = new Thread(new Runnable() {
public void run() {
ExecutorService executorService = Executors
.newFixedThreadPool(threadNumber);
ArrayList<Future<Long>> results = new ArrayList<Future<Long>>();
for (int i = 0; i < threadNumber; i++) {
Future<Long> future = executorService
.submit(new ExecLinkedBlockingQueue());
results.add(future);
} long allTime = 0;
for (Future<Long> fs : results) {
try {
allTime += fs.get();
// log.info("" + fs.get());
} catch (InterruptedException e) {
log.info("" + e);
return;
} catch (ExecutionException e) {
log.info("" + e);
} finally {
executorService.shutdown();
}
}
linkedBlockingQueue.isOver = true;
log.info("入队列总共执行时间：" + allTime);
}
});
thread1.start(); // log.info("主线程执行时间：" + (System.currentTimeMillis() - timestart));
// System.out.println(linkedBlockingQueue.queue.size());
// ------------------------------ Thread thread2 = new Thread(new Runnable() {
public void run() {
ExecutorService executorService2 = Executors
.newFixedThreadPool(threadNumber);
ArrayList<Future<Long>> results_out = new ArrayList<Future<Long>>();
for (int i = 0; i < threadNumber; i++) {
Future<Long> future = executorService2
.submit(new ExecLinkedBlockingQueue_Out());
results_out.add(future);
} long allTime_out = 0;
for (Future<Long> fs : results_out) {
try {
allTime_out += fs.get();
// log.info("" + fs.get());
} catch (InterruptedException e) {
log.info("" + e);
return;
} catch (ExecutionException e) {
log.info("" + e);
} finally {
executorService2.shutdown();
}
}
log.info("出队列总共执行时间：" + allTime_out);
}
});
thread2.start(); }
} class ExecLinkedBlockingQueue implements Callable<Long> {
private static final Logger log = LoggerFactory
.getLogger(linkedBlockingQueue.class); @Override
public Long call() throws Exception {
long time = System.currentTimeMillis(); for (int i = 0; i < linkedBlockingQueue.size1; i++) {
linkedBlockingQueue.queue.offer(i);
} long time2 = System.currentTimeMillis() - time;
// log.info("执行时间：" + time2);
return time2;
}
} class ExecLinkedBlockingQueue_Out implements Callable<Long> {
private static final Logger log = LoggerFactory
.getLogger(linkedBlockingQueue.class); @Override
public Long call() throws Exception {
long time = System.currentTimeMillis(); while (!linkedBlockingQueue.isOver) {
linkedBlockingQueue.queue.poll();
} long time2 = System.currentTimeMillis() - time;
// log.info("执行时间：" + time2);
return time2;
}
}
DoubleBufferedQueue双缓冲队列
package comrt.util; import java.util.AbstractQueue;
import java.util.Collection;
import java.util.Iterator;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; //双缓冲队列，线程安全
public class DoubleBufferedQueue<E> extends AbstractQueue<E> implements BlockingQueue<E>, java.io.Serializable {
private static final long serialVersionUID = 1011398447523020L;
public static final int DEFAULT_QUEUE_CAPACITY = 5000000;
public static final long DEFAULT_MAX_TIMEOUT = 0;
public static final long DEFAULT_MAX_COUNT = 10;
private Logger logger = LoggerFactory.getLogger(DoubleBufferedQueue.class.getName());
/** The queued items */
private ReentrantLock readLock;
// 写锁
private ReentrantLock writeLock;
// 是否满
private Condition notFull;
private Condition awake;
// 读写数组
private transient E[] writeArray;
private transient E[] readArray;
// 读写计数
private volatile int writeCount;
private volatile int readCount;
// 写数组下标指针
private int writeArrayTP;
private int writeArrayHP;
// 读数组下标指针
private int readArrayTP;
private int readArrayHP;
private int capacity; public DoubleBufferedQueue(int capacity) {
// 默认
this.capacity = DEFAULT_QUEUE_CAPACITY; if (capacity > 0) {
this.capacity = capacity;
} readArray = (E[]) new Object[capacity];
writeArray = (E[]) new Object[capacity]; readLock = new ReentrantLock();
writeLock = new ReentrantLock();
notFull = writeLock.newCondition();
awake = writeLock.newCondition();
} private void insert(E e) {
writeArray[writeArrayTP] = e;
++writeArrayTP;
++writeCount;
} private E extract() {
E e = readArray[readArrayHP];
readArray[readArrayHP] = null;
++readArrayHP;
--readCount;
return e;
} /**
* switch condition: read queue is empty && write queue is not empty
*
* Notice:This function can only be invoked after readLock is grabbed,or may
* cause dead lock
*
* @param timeout
* @param isInfinite
* : whether need to wait forever until some other thread awake
* it
* @return
* @throws InterruptedException
*/
private long queueSwap(long timeout, boolean isInfinite) throws InterruptedException {
writeLock.lock();
try {
if (writeCount <= 0) {
// logger.debug("Write Count:" + writeCount
// + ", Write Queue is empty, do not switch!");
try {
// logger.debug("Queue is empty, need wait....");
if (isInfinite && timeout <= 0) {
awake.await();
return -1;
} else if (timeout > 0) {
return awake.awaitNanos(timeout);
} else {
return 0;
}
} catch (InterruptedException ie) {
awake.signal();
throw ie;
}
} else {
E[] tmpArray = readArray;
readArray = writeArray;
writeArray = tmpArray; readCount = writeCount;
readArrayHP = 0;
readArrayTP = writeArrayTP; writeCount = 0;
writeArrayHP = readArrayHP;
writeArrayTP = 0; notFull.signal();
// logger.debug("Queue switch successfully!");
return 0;
}
} finally {
writeLock.unlock();
}
} @Override
public boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException {
if (e == null) {
throw new NullPointerException();
} long nanoTime = 0; if (timeout > 0) {
nanoTime = unit.toNanos(timeout);
} writeLock.lockInterruptibly(); try {
for (int i = 0; i < DEFAULT_MAX_COUNT; i++) {
if (writeCount < writeArray.length) {
insert(e);
if (writeCount == 1) {
awake.signal();
}
return true;
} // Time out
if (nanoTime <= 0) {
// logger.debug("offer wait time out!");
return false;
}
// keep waiting
try {
// logger.debug("Queue is full, need wait....");
nanoTime = notFull.awaitNanos(nanoTime);
} catch (InterruptedException ie) {
notFull.signal();
throw ie;
}
}
} finally {
writeLock.unlock();
} return false;
} // 取
@Override
public E poll(long timeout, TimeUnit unit) throws InterruptedException {
long nanoTime = 0; if (timeout > 0) {
nanoTime = unit.toNanos(timeout);
} readLock.lockInterruptibly(); try {
if (nanoTime > 0) {
for (int i = 0; i < DEFAULT_MAX_COUNT; i++) {
if (readCount > 0) {
return extract();
} if (nanoTime <= 0) {
// logger.debug("poll time out!");
return null;
}
nanoTime = queueSwap(nanoTime, false);
}
} else {
if (readCount > 0) {
return extract();
} queueSwap(nanoTime, false); if (readCount > 0) {
return extract();
}
}
} finally {
readLock.unlock();
} return null;
} // 等待500毫秒
@Override
public E poll() {
E ret = null;
try {
ret = poll(DEFAULT_MAX_TIMEOUT, TimeUnit.MILLISECONDS);
} catch (Exception e) {
ret = null;
}
return ret;
} // 查看
@Override
public E peek() {
E e = null;
readLock.lock(); try {
if (readCount > 0) {
e = readArray[readArrayHP];
}
} finally {
readLock.unlock();
} return e;
} // 默认500毫秒
@Override
public boolean offer(E e) {
boolean ret = false;
try {
ret = offer(e, DEFAULT_MAX_TIMEOUT, TimeUnit.MILLISECONDS);
} catch (Exception e2) {
ret = false;
}
return ret;
} @Override
public void put(E e) throws InterruptedException {
// never need to // block
offer(e, DEFAULT_MAX_TIMEOUT, TimeUnit.MILLISECONDS); } @Override
public E take() throws InterruptedException {
return poll(DEFAULT_MAX_TIMEOUT, TimeUnit.MILLISECONDS);
} @Override
public int remainingCapacity() {
return this.capacity;
} @Override
public int drainTo(Collection<? super E> c) {
return 0;
} @Override
public int drainTo(Collection<? super E> c, int maxElements) {
return 0;
} @Override
public Iterator<E> iterator() {
return null;
} // 当前读队列中还有多少个
@Override
public int size() {
int size = 0;
readLock.lock(); try {
size = readCount;
} finally {
readLock.unlock();
} return size;
} /**
* 当前已写入的队列大小
* */
public int WriteSize() {
int size = 0;
writeLock.lock(); try {
size = writeCount;
} finally {
writeLock.unlock();
} return size;
} public int unsafeReadSize() {
return readCount;
} public int unsafeWriteSize() {
return writeCount;
} public int capacity() {
return capacity;
} public String toMemString() {
return "--read: " + readCount + "/" + capacity + "--write: " + writeCount + "/" + capacity;
}
// 清理
/*
* public void clear() { readLock.lock(); writeLock.lock(); try { readCount
* = 0; readArrayHP = 0; writeCount = 0; writeArrayTP = 0;
* //logger.debug("Queue clear successfully!"); } finally {
* writeLock.unlock(); readLock.unlock(); } }
*/
}
Java队列集合的性能测试的更多相关文章
- 【Java】集合_学习笔记
一.集合 1.集合类也称容器类,主要负责保存.盛装其他数据. 2.集合可以保存数量不确定的数据,保存具有映射关系的数据(也称关联数组). 3.Java5后提供一些多线程安全的集合类,放在java.ut ...
- java的集合框架最全详解
java的集合框架最全详解(图) 前言:数据结构对程序设计有着深远的影响,在面向过程的C语言中,数据库结构用struct来描述,而在面向对象的编程中,数据结构是用类来描述的,并且包含有对该数据结构操作 ...
- 谈谈Java的集合组件
让我们一起谈谈Java的集合组件 我们在使用Java的时候,都会遇到并使用到Java的集合.在这里通过自己的理解和网上的资源对Java的集合方面的使用做一个简单的讲解和总结. Java主要分为3个集合 ...
- java.util 集合框架集合
java的集合框架为程序提供了一种处理对象组的标准方式.设计了一系列标准泛型接口: ⑴Collection ()接口,扩展了Iterable接口,位于集合层次结构的顶部,因此所有的集合都实现Colle ...
- Java基础——集合框架
Java的集合框架是Java中很重要的一环,Java平台提供了一个全新的集合框架.“集合框架”主要由一组用来操作对象的接口组成.不同接口描述一组不同数据类型.Java平台的完整集合框架如下图所示: 上 ...
- Java学习-集合（转）
在编写java程序中,我们最常用的除了八种基本数据类型,String对象外还有一个集合类,在我们的的程序中到处充斥着集合类的身影!java中集合大家族的成员实在是太丰富了,有常用的ArrayList. ...
- java的集合框架之一
java是一套很成熟的东西,很多商用的东西都喜欢用它,用的人多,稳定.不过一般也不怎么说起它,因为太常见了,私下里说,写java应用层得就像农民工,每一处都是搭积木,根据设计师的东西如何优雅地搭好积木 ...
- 浅谈Java的集合框架
浅谈Java的集合框架 一. 初识集合 重所周知,Java有四大集合框架群,Set.List.Queue和Map.四种集合的关注点不同,Set 关注事物的唯一性,List 关注事物的索引列表,Q ...
- Java之集合初探（一）
一.集合概述.区别 集合是一种容器,数组也是一种容器 在Java编程中,装各种各样的对象(引用类型)的叫做容器. 为什么出现集合类? 面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的 ...
随机推荐
- Unity3D研究院之使用Animation编辑器编辑动画
Unity提供了Animation编辑器,它可以为我们编辑物理动画.举个例子比如场景中有一个来回摇动的秋千,这个秋千在项目中完全只起到衬托作用,它不会与别的游戏对象有任何交互.如果这个秋千也用代码来 ...
- 【转载】关于Python中的yield
在介绍yield前有必要先说明下Python中的迭代器(iterator)和生成器(constructor). 一.迭代器(iterator) 在Python中,for循环可以用于Python中的任何 ...
- Python列表操作——模拟实现栈和队列
1.实现栈: stack=[] def pushit(): stack.append(raw_input('Enter New String:').strip()) def popit(): if l ...
- Linux体系结构(五)： 文件系统
上一节主要对Linux系统中的内核空间与用户空间做了简单的分析,在这一节里,将从内核空间和用户空间对Linux文件系统进行一定的剖析. 谈及文件系统,很多Linux用户都会有一个比较模糊和神秘的概念, ...
- 删除除了Src属性以后的全部属性
public static string RemoveAllAttributesWithoutSrc(string input) { string p ...
- javascript 停止事件冒泡以及阻止默认事件冒泡
停止事件冒泡 function stopBubble(e) { // 如果提供了事件对象,则这是一个非IE浏览器 if ( e && e.stopPropagation ) { // ...
- 计时器Chronometer和时钟（AnalogClock和DigitalClock）
计时器Chronometer和时钟(AnalogClock和DigitalClock) (1)Android提供了两个时钟组件:AnalogClock和DigitalClock,DigitalCloc ...
- 简单了解ddos攻击
1.一种为流量攻击,主要是针对网络带宽的攻击,即大量攻击包导致网络带宽被阻塞,合法网络包被虚假的攻击包淹没而无法到达主机: 2.另一种为资源耗尽攻击,主要是针对服务器主机的攻击,即通过大量攻击包导致主 ...
- du命令 实现Linux 某个文件夹下的文件按大小排序
1. df -lh 2. du -s /usr/* | sort -rn这是按字节排序 3. du -sh /usr/* | sort -rn这是按兆(M)来排序 4.选出排在前面的10个du -s ...
- 修改oracle数据库密码
1.用Xshell远程连接安装数据库的服务器,切换到安装oracle数据库的用户下,(我的oracle数据库就安装在oracle用户下) 命令: su - oracle; 2.进入oracle控制台 ...