亚洲精品无码鲁网中文电影,亚洲伦理中文字幕,亚洲xxxxxx

achan2bj — Sat, 29 Sep 2012 01:38:00 GMT

Vector �q�是ArrayList――哪一个更好，��Z��么？

要回�{�这个问题不能一概而论�Q�有时候��用Vector比较好；有时是ArrayList�Q�有时候这两个都不�?nbsp;

最好的选择。你别指望能够获得一个简单肯定答案，因�ؓ�q�要看你用它们干什么。下面有4个要考虑

的因素：

l API

l 同步处理

l 数据增长�?nbsp;

l 使用模式

下面针对�q?个方面进行一一探讨

API

在由Ken Arnold�{�编著的《Java Programming Language�?Addison-Wesley, June 2000)一书中有这

��L��描述�Q�Vector�c�M��于ArrayList.。所有从API的角度来看这两个�c�非常相[b]伹{��但他们之间也还

是有一些主要的区别的�?br />同步�?/strong>

Vector是同步的。这个类中的一些方法保证了Vector中的对象是线�E�安全的。而ArrayList则是异步

的，因此ArrayList中的对象�q�不是线�E�安全的。因为同步的要求会媄响执行的效率�Q�所以如果你�?nbsp;

需要线�E�安全的集合那么使用ArrayList是一个很好的选择�Q�这样可以避免由于同步带来的不必要的

性能开销�?nbsp;

数据增长

从内部实现机制来讲ArrayList和Vector都是使用数组(Array)来控刉��合中的对象。当你向�q�两�U�类

型中增加元素的时候，如果元素的数目超��Z��内部数组目前的长度它们都需要扩展内部数�l�的长度�Q?nbsp;

Vector�~�省情况下自动增长原来一倍的数组长度�Q�ArrayList是原来的50%,所以最后你获得的这个集

合所占的�I�间��L��比你实际需要的要大。所以如果你要在集合中保存大量的数据那么使用Vector有一

些优势，因�ؓ你可以通过讄��集合的初始化大小来避免不必要的资源开销�?nbsp;

使用模式

在ArrayList和Vector中，从一个指定的位置�Q�通过索引�Q�查找数据或是在集合的末��֢�加、移除一

个元素所��p��的时间是一��L��Q�这个时间我们用O(1)表示。但是，如果在集合的其他位置增加或移�?nbsp;

元素那么��p��的时间会呈线形增长：O(n-i)�Q�其中n代表集合中元素的个数�Q�i代表元素增加或移除元

素的索引位置。�ؓ什么会�q�样呢？以�ؓ在进行上�q�操作的时候集合中�W�i和第i个元素之后的所有元�?nbsp;

都要执行位移的操作。这一切意味着什么呢�Q?nbsp;

�q�意味着�Q�你只是查找特定位置的元素或只在集合的末端增加、移除元素，那么使用Vector�?nbsp;

ArrayList都可以。如果是其他操作�Q�你最好选择其他的集合操作类。比如，LinkList集合�c�d��增加

或移除集合中��M��位置的元素所��p��的时间都是一��L��—O(1)�Q�但它在索引一个元素的使用�~�比较慢

�Q�O(i),其中i是烦引的位置.使用ArrayList也很�Ҏ��Q�因��Z��可以��单的使用索引来代替创�?nbsp;

iterator对象的操作。LinkList也会为每个插入的元素创徏对象�Q�所有你要明白它也会带来额外的开

销�?nbsp;

最后，在《Practical Java》一书中Peter Haggar��使用一个简单的数组�Q�Array�Q�来代替Vector

或ArrayList。尤其是对于执行效率要求高的�E�序更应如此。因��Z��用数�l?Array)避免了同步、额�?nbsp;

的方法调用和不必要的重新分配�I�间的操作�?/p>

achan2bj 2012-09-29 09:38 发表评论

java面试题及�{�案�Q�基��?22道，代码�?9道） [转]

achan2bj — Sat, 29 Sep 2012 01:31:00 GMT
     摘要: JAVA相关基础知识1、面向对象的特征有哪些方�?1.抽象�Q�抽象就是忽略一个主题中与当前目标无关的那些斚w��Q�以便更充分地注意与当前目标有关的方面。抽象�ƈ不打��了解全部问题，而只是选择其中的一部分�Q�暂时不用部分细节。抽象包括两个方面，一是过�E�抽象，二是数据抽象�?.�l�承�Q��承是一�U�联�l�类的层�ơ模型，�q�且允许和鼓��q��的重用，它提供了一�U�明��表�q�共性的�Ҏ��。对象的一个新�c�d��以从现有的类中派生，�q�个�q�程�U?..  阅读全文

achan2bj 2012-09-29 09:31 发表评论

JAVA的多�U�程实现

achan2bj — Mon, 24 Sep 2012 03:18:00 GMT
1.JAVA多线�E�实现方�?br />JAVA多线�E�实现方式主要有三种�Q��承Thread�c�R��实现Runnable接口、��用ExecutorService、Callable、Future实现有返回结果的多线�E�。其中前两种方式�U�程执行完后都没有返回��|��只有最后一�U�是带返回值的�?p>2.�l�承Thread�c�d��现多�U�程
�l�承Thread�cȝ��Ҏ��管被我列�ؓ一�U�多�U�程实现方式�Q�但Thread本质上也是实��C��Runnable接口的一个实例，它代表一个线�E�的实例�Q��ƈ且，启动�U�程的唯一�Ҏ��是通过Thread�cȝ��start()实例�Ҏ��。start()�Ҏ��是一个native�Ҏ��Q�它��启动一个新�U�程�Q��ƈ执行run()�Ҏ��。这�U�方式实现多�U�程很简单，通过自己的类直接extend Thread�Q��ƈ复写run()�Ҏ��Q�就可以启动新线�E��ƈ执行自己定义的run()�Ҏ��。例如：
public class MyThread extends Thread {
　　public void run() {
　　 System.out.println("MyThread.run()");
　　}
}
在合适的地方启动�U�程如下�Q?br />MyThread myThread1 = new MyThread();
MyThread myThread2 = new MyThread();
myThread1.start();
myThread2.start();
3.实现Runnable接口方式实现多线�E?br />如果自己的类已经extends另一个类�Q�就无法直接extends Thread�Q�此�Ӟ��必须实现一个Runnable接口�Q�如下：
public class MyThread extends OtherClass implements Runnable {
　　public void run() {
　　 System.out.println("MyThread.run()");
　　}
}
��Z��启动MyThread�Q�需要首先实例化一个Thread�Q��ƈ传入自己的MyThread实例�Q?br />MyThread myThread = new MyThread();
Thread thread = new Thread(myThread);
thread.start();
事实上，当传入一个Runnable target参数�l�Thread后，Thread的run()�Ҏ��׃��调用target.run()�Q�参考JDK源代码：
public void run() {
　　if (target != null) {
　　 target.run();
　　}
}
4.使用ExecutorService、Callable、Future实现有返回结果的多线�E?/strong>
ExecutorService、Callable、Future�q�个对象实际上都是属于Executor框架中的功能�c�R��想要详�l�了解Executor框架的可以访�?a >http://www.javaeye.com/topic/366591 �Q�这里面对该框架做了很详�l�的解释。返回结果的�U�程是在JDK1.5中引入的新特征，��实很实用，有了�q�种特征我就不需要再��Z��得到�q�回��D��大费周折了�Q�而且即便实现了也可能漏洞癑և��?br />可返回值的��d��必须实现Callable接口�Q�类似的�Q�无�q�回值的��d��必须Runnable接口。执行Callable��d��后，可以获取一个Future的对象，在该对象上调用get��可以获取到Callable��d��q�回的Object了，再结合线�E�池接口ExecutorService��可以实��C��说中有返回结果的多线�E�了。下面提供了一个完整的有返回结果的多线�E�测试例子，在JDK1.5下验证过没问题可以直接��用。代码如下：
import java.util.concurrent.*;
import java.util.Date;
import java.util.List;
import java.util.ArrayList;
/**
* Java�U�程�Q�有�q�回值的�U�程
*
* @author wb_qiuquan.ying
*/
@SuppressWarnings("unchecked")
public class Test {
public static void main(String[] args) throws ExecutionException,
    InterruptedException {
   System.out.println("----�E�序开始运�?---");
   Date date1 = new Date();
   int taskSize = 5;
   // 创徏一个线�E�池
   ExecutorService pool = Executors.newFixedThreadPool(taskSize);
   // 创徏多个有返回值的��d��
   List list = new ArrayList();
   for (int i = 0; i < taskSize; i++) {
    Callable c = new MyCallable(i + " ");
    // 执行��d��q�获取Future对象
    Future f = pool.submit(c);
    // System.out.println(">>>" + f.get().toString());
    list.add(f);
   }
   // 关闭�U�程�?br />   pool.shutdown();
   // 获取所有�ƈ发�Q务的�q�行�l�果
   for (Future f : list) {
    // 从Future对象上获取�Q务的�q�回��|��q�输出到控制�?br />    System.out.println(">>>" + f.get().toString());
   }
   Date date2 = new Date();
   System.out.println("----�E�序�l�束�q�行----�Q�程序运行时间�?
     + (date2.getTime() - date1.getTime()) + "毫秒�?);
}
}
class MyCallable implements Callable {
private String taskNum;
MyCallable(String taskNum) {
   this.taskNum = taskNum;
}
public Object call() throws Exception {
   System.out.println(">>>" + taskNum + "��d��启动");
   Date dateTmp1 = new Date();
   Thread.sleep(1000);
   Date dateTmp2 = new Date();
   long time = dateTmp2.getTime() - dateTmp1.getTime();
   System.out.println(">>>" + taskNum + "��d��l�止");
   return taskNum + "��d��q�回�q�行�l�果,当前��d��旉��? + time + "毫秒�?;
}
}

代码说明�Q?br />上述代码中Executors�c�，提供了一�p�d��工厂�Ҏ��用于创先�U�程池，�q�回的线�E�池都实��C��ExecutorService接口�?br />public static ExecutorService newFixedThreadPool(int nThreads)
创徏固定数目�U�程的线�E�池�?br />public static ExecutorService newCachedThreadPool()
创徏一个可�~�存的线�E�池�Q�调用execute ��重用以前构造的�U�程�Q�如果线�E�可用）。如果现有线�E�没有可用的�Q�则创徏一个新�U�程�q�添加到池中。终止�ƈ从缓存中�U�除那些已有 60 �U�钟未被使用的线�E��?br />public static ExecutorService newSingleThreadExecutor()
创徏一个单�U�程化的Executor�?br />public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
创徏一个支持定时及周期性的��d��执行的线�E�池�Q�多数情况下可用来替代Timer�c�R�?/p>
ExecutoreService提供了submit()�Ҏ��Q�传递一个Callable�Q�或Runnable�Q�返回Future。如果Executor后台�U�程池还没有完成Callable的计��，�q�调用返回Future对象的get()�Ҏ��Q�会��d��直到计算完成�?/p>

achan2bj 2012-09-24 11:18 发表评论

String,StringBuffer及StringBuilder

achan2bj — Mon, 24 Sep 2012 01:44:00 GMT

String和StringBuffer的区别，�|�上资料可以说是��C��胜数�Q�但是看到这��文章，感觉里面做的��例子很有代表性，所以�{一下，�q�自己做了一�Ҏ�ȝ��?/p>

在java中有3个类来负责字�W�的操作�?
1.Character 是进行单个字�W�操作的�Q?/p>
2.String 对一串字�W�进行操作。不可变�c�R�?/p>
3.StringBuffer 也是对一串字�W�进行操作，但是可变�c�R�?/p>
String:
是对象不是原始类�?
��Z��可变对象,一旦被创徏,��׃��能修改它的�?
对于已经存在的String对象的修攚w��是重新创��Z��个新的对�?然后把新的��g��存进�?
String 是final�c?即不能被�l�承.
StringBuffer:
是一个可变对�?当对他进行修改的时候不会像String那样重新建立对象
它只能通过构造函数来建立,
StringBuffer sb = new StringBuffer();
note:不能通过付值符号对他进行付�?
sb = "welcome to here!";//error
对象被徏立以�?在内存中��׃��分配内存�I�间,�q�初始保存一个null.向StringBuffer
中付值的时候可以通过它的append�Ҏ��.
sb.append("hello");
字符串连接操作中StringBuffer的效率要比String�?
String str = new String("welcome to ");
str += "here";
的处理步骤实际上是通过建立一个StringBuffer,让侯调用append(),最�?br />再将StringBuffer toSting();
�q�样的话String的连接操作就比StringBuffer多出了一些附加操�?当然效率上要打折�?
�q�且�׃��String 对象是不可变对象,每次操作Sting 都会重新建立新的对象来保存新的�?
�q�样原来的对象就没用�?��p��被垃圑֛��?�q�也是要影响性能�?
看看以下代码�Q?br />��?6个英文字母重复加�?000�ơ，
        String tempstr = "abcdefghijklmnopqrstuvwxyz";
        int times = 5000;
        long lstart1 = System.currentTimeMillis();
        String str = "";
        for (int i = 0; i < times; i++) {
            str += tempstr;
        }
        long lend1 = System.currentTimeMillis();
        long time = (lend1 - lstart1);
        System.out.println(time);
可惜我的计算��Z��是超�U�计��机�Q�得到的�l�果每次不一定一样一般�ؓ 46687左右�?br />也就�?6�U��?br />我们再看看以下代�?/p>
        String tempstr = "abcdefghijklmnopqrstuvwxyz";
        int times = 5000;
        long lstart2 = System.currentTimeMillis();
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < times; i++) {
            sb.append(tempstr);
        }
        long lend2 = System.currentTimeMillis();
        long time2 = (lend2 - lstart2);
        System.out.println(time2);
得到的结果�ؓ 16 有时�q�是 0
所以结论很明显�Q�StringBuffer 的速度几乎是String 上万倍。当然这个数据不是很准确。因为��@环的�ơ数�?00000�ơ的时候，差异更大。不信你试试�?/p>

�Ҏ��上面所��_��
str += "here";
的处理步骤实际上是通过建立一个StringBuffer,让侯调用append(),最�?br />再将StringBuffer toSting();
所以str += "here";可以�{�同�?/p>
StringBuffer sb = new StringBuffer(str);
sb.append("here");
str = sb.toString();
所以上面直接利�?+"来连接String的代码可以基本等同于以下代码
        String tempstr = "abcdefghijklmnopqrstuvwxyz";
        int times = 5000;
        long lstart2 = System.currentTimeMillis();
        String str = "";
        for (int i = 0; i < times; i++) {
            StringBuffer sb = new StringBuffer(str);
            sb.append(tempstr);
            str = sb.toString();
        }
        long lend2 = System.currentTimeMillis();
        long time2 = (lend2 - lstart2);
        System.out.println(time2);
�q�_��执行旉��?6922左右�Q�也��是46�U��?/p>

�ȝ��: 如果在程序中需要对字符串进行频�J�的修改�q�接操作的话.使用StringBuffer性能会更�?br />
===========================================================================================

自从Java 5.0发布以后�Q�我们的比较列表上将多出一个对象了�Q�这��是StringBuilder�c�R��String�c�L��不可变类�Q��Q何对String的改变都会引发新的String对象的生成；而StringBuffer则是可变�c�，��M��对它所指代的字�W�串的改变都不会产生新的对象�Q�可变和不可变类�q�一对对象已�l�齐全了�Q�那么�ؓ什么还要引入新的StringBuilder�c�d��吗？�怿�大家都有此疑问，我也如此。下面，我们��来看看引入该类的原因�?
      ��Z��么会出现那么多比较String和StringBuffer的文章？
      原因在于当改变字�W�串内容�Ӟ��采用StringBuffer能获得更好的性能。既然是��Z��获得更好的性能�Q�那么采用StringBuffer能够获得最好的性能吗？
      �{�案是NO�Q?
      ��Z��么？
      如果你读�q�《Think in Java》，而且寚w��面描�q�HashTable和HashMap区别的那部分章节比较熟悉的话�Q�你一定也明白了原因所在。对�Q�就是支持线�E�同步保证线�E�安全而导致性能下降的问题�?span style="color: red;">HashTable是线�E�安全的�Q�很多方法都是synchronized�Ҏ��Q�而HashMap不是�U�程安全的，但其在单�U�程�E�序中的性能比HashTable要高。StringBuffer和StringBuilder�cȝ��区别也在于此�Q?span style="color: red;">新引入的StringBuilder�c�M��是线�E�安全的�Q�但其在单线�E�中的性能比StringBuffer�?/span>。如果你�Ҏ��不太�怿��Q�可以试试下面的例子�Q?/p>
package com.hct.test;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* @author: chengtai.he
* @created:2009-12-9 上午09:59:57
*/
public class StringBuilderTester {
private static final String base = " base string. ";
private static final int count = 2000000;
public static void stringTest() {
long begin, end;
begin = System.currentTimeMillis();
String test = new String(base);
for (int i = 0; i < count/100; i++) {
   test = test + " add ";
}
end = System.currentTimeMillis();
System.out.println((end - begin)
    + " millis has elapsed when used String. ");
}
public static void stringBufferTest() {
long begin, end;
begin = System.currentTimeMillis();
StringBuffer test = new StringBuffer(base);
for (int i = 0; i < count; i++) {
   test = test.append(" add ");
}
end = System.currentTimeMillis();
System.out.println((end - begin)
    + " millis has elapsed when used StringBuffer. ");
}
public static void stringBuilderTest() {
long begin, end;
begin = System.currentTimeMillis();
StringBuilder test = new StringBuilder(base);
for (int i = 0; i < count; i++) {
   test = test.append(" add ");
}
end = System.currentTimeMillis();
System.out.println((end - begin)
    + " millis has elapsed when used StringBuilder. ");
}
public static String appendItemsToStringBuiler(List list) {
StringBuilder b = new StringBuilder();
for (Iterator i = list.iterator(); i.hasNext();) {
   b.append(i.next()).append(" ");
}
return b.toString();
}
public static void addToStringBuilder() {
List list = new ArrayList();
list.add(" I ");
list.add(" play ");
list.add(" Bourgeois ");
list.add(" guitars ");
list.add(" and ");
list.add(" Huber ");
list.add(" banjos ");
System.out.println(StringBuilderTester.appendItemsToStirngBuffer(list));
}
public static String appendItemsToStirngBuffer(List list) {
StringBuffer b = new StringBuffer();
for (Iterator i = list.iterator(); i.hasNext();) {
   b.append(i.next()).append(" ");
}
return b.toString();
}
public static void addToStringBuffer() {
List list = new ArrayList();
list.add(" I ");
list.add(" play ");
list.add(" Bourgeois ");
list.add(" guitars ");
list.add(" and ");
list.add(" Huber ");
list.add(" banjos ");
System.out.println(StringBuilderTester.appendItemsToStirngBuffer(list));
}
public static void main(String[] args) {
stringTest();
stringBufferTest();
stringBuilderTest();
addToStringBuffer();
addToStringBuilder();
}
}
上面的程序结果如下：
5266 millis has elapsed when used String.
375 millis has elapsed when used StringBuffer.
281 millis has elapsed when used StringBuilder.
I   play   Bourgeois   guitars   and   Huber   banjos
I   play   Bourgeois   guitars   and   Huber   banjos
从上面的�l�果来看�Q�这三个�c�d��单线�E�程序中的性能差别一目了�Ӟ��采用String对象�Ӟ��即�ɘq�行�ơ数仅是采用其他对象�?/100�Q�其执行旉��仍然比其他对象高�?5倍以上；而采用StringBuffer对象和采用StringBuilder对象的差别也比较明显�Q�前者是后者的1.5倍左叟뀂由此可见，如果我们的程序是在单�U�程下运行，或者是不必考虑到线�E�同步问题，我们应该优先使用StringBuilder�c�；当然�Q�如果要保证�U�程安全�Q�自焉��StringBuffer莫属了�?/p>
除了对多�U�程的支持不一样外�Q�这两个�cȝ��使用几乎没有��M��差别�Q�上面的例子��是个很好的说明。appendItemsToStringBuiler和appendItemsToStirngBuffer两个�Ҏ��除了采用的对象分别�ؓStringBuilder和StringBuffer外，其他完全相同�Q�而效果也完全相同�?/p>

achan2bj 2012-09-24 09:44 发表评论

亚洲精品无码鲁网中文电影,亚洲伦理中文字幕,亚洲xxxxxx

java面试题及�{�案�Q�基����?22道，代码�?9道） [转]

JAVA的多�U�程实现

String,StringBuffer及StringBuilder

java面试题及�{�案�Q�基��?22道，代码�?9道） [转]