首页 > 范文大全

java中的HashMap解析

时间：2023年08月08日

来源：GrenCallisto

编辑：本站小编

收藏本文

下载本文

以下是小编收集整理的java中的HashMap解析，本文共8篇，希望对大家有所帮助。本文原稿由网友“GrenCallisto”提供。

篇1：java中的HashMap解析

这篇文章准备从源码的角度带大家分析一下java中的hashMap的原理，在了解源码之前，我们先根据自己的理解创建一个hashMap，

先说明一下创建的具体原理是这样的，所谓hashMap,必然是用hash方法来区分不同的key值。学过hash的都知道，我们解决hash冲突的一种方法就是使用散列和桶，首先确定所在的桶号，然后在桶里面逐个查找。其实我们也可以单纯使用数组实现map,使用散列是为了获得更高的查询效率。

要写自己的hashmap前，必须说明一下两个方法，就是hashcode和equals()方法，要在map里面判断两个key是否相等，关键在于这个两个函数的返回值一定要相等（只有一个相等是没有用的，因为hashmap会先根据hashcode()方法查找桶，然后根据equals()方法获取value）

如果我们没有复写这个两个方法，object类是根据类所在内存地址来产生hashcode的，所以一般比较是不会相同的，又正因为这样，我们在使用自己构造的类当key值的时候，有时是有必要复写这两个方法的。下面是一个例子

class myClass{ int i = 0; public myClass(int i) { this.i = i; } @Override public int hashCode() {return i; } @Override public boolean equals(Object obj) {return obj instanceof myClass && i == ((myClass)obj).i; } }

注意上面的instanceof，我们首先要判断参数的类是否相同，这个非常重要，不过容易被忽略。（因为有可能是两个不同的类，有相同的属性，连属性值都相同，这样我们判断就会失误了）。另外我们要注意String类型重载了这两个方法，所以两个new String(“aa”)是相同的

在以下类中，我使用了一个arraylist来充当链，首先我们来看一个键值对类，用来保存键和值，这个是一个内部类，还有要实现hashmap必须先继承一个AbstractMap的抽象类

import java.util.AbstractMap;import java.util.ArrayList;import java.util.Map;import java.util.Set;public class MyHashMapextends AbstractMap{ //链表长度 final static int SIZE = 999; private Listkeys = new ArrayList(); private Listvalues = new ArrayList(); /** * Entry类，用于保存键值对 * @author Administrator * * @param* @param*/ static class MyEntryimplements Map.Entry{ private K key; private V value; public MyEntry(K key,V value) { this.key = key; this.value = value; } @Override public K getKey() {return key; } @Override public V getValue() {return value; } @Override public V setValue(V v) { V ldValue = value; value = v; return oldValue; } @Override public int hashCode() { //使用key和value的hashcode共同构造新的hashcode return (key==null?0:key.hashCode())^(value==null?0:value.hashCode()); } @Override public boolean equals(Object obj) { //注意要检查类型是否相同 if(!(obj instanceof MyEntry)) return false; MyEntry en = (MyEntry)obj; //注意空值的情况 return (key==null?en.getKey()==key:key.equals(en.getKey())) && (value==null?en.getKey()==value:value.equals(en.getValue())); } } @SuppressWarnings(“unchecked”) ArrayList>[] buckets = new ArrayList[SIZE]; @Override public Set>entrySet() { // TODO Auto-generated method stub return null; }}对于上面的键值对类MyEntry，我们要实现一个接口Map.Entry，因为我们一般使用hashmap都可以获得它的Entryset,继承这个类正是为了这个做准备

接下来我们先来实现put方法

/** * put方法 */ public V put(K key,V value){ //原值用于返回 V ldValue = null; //防止越界 int index = Math.abs(key.hashCode())%SIZE; //检查是否有桶，没有创建一个 if(buckets[index]==null){ buckets[index] = new ArrayList>(); } ArrayList>bucket = buckets[index]; //创建键值对对象entry MyEntrypair = new MyEntry(key, value); boolean found = false; ListIterator>it = bucket.listIterator(); //遍历桶 while(it.hasNext()){ MyEntryiPair = it.next(); //如果已经在map里面，更新 if(iPair.getKey().equals(key)){ oldValue = iPair.getValue(); it.set(pair); values.set(keys.indexOf(key),value); found = true; break; } } //不在map里面，新增 if(!found){ keys.add(key); values.add(value); bucket.add(pair); } return oldValue; }

这上面的思路应该说是非常清晰，首先查找桶，没有则新建，然后在桶里面查找key值，如果已经存在map里面了，更新，否则新增。

再来看get方法，就更加清晰了

/** * get方法 */ public V get(Object key){ int index = Math.abs(key.hashCode())%SIZE; if(buckets[index]==null) return null; for(MyEntrypair:buckets[index]){ if(pair.getKey().equals(key)){ return pair.getValue(); } } return null; }上面首先查找对应桶，没有返回null，如果有则在桶内遍历查找

最后再来看一下entrySet类

private class MyEntrySet extends AbstractSet>{ @Override public Iterator>iterator() { return new Iterator>() { private int index = -1; boolean canRemove; @Override public boolean hasNext() { return indexnext() { boolean canRemove = true; ++index; return new MyEntry(keys.get(index), values.get(index)); } @Override public void remove() { if(!canRemove){ throw new IllegalStateException(); } canRemove = false; keys.remove(index); values.remove(index--); } }; } @Override public int size() { return keys.size(); } }这个内部类主要是为我们提供entry用于外部遍历使用

下面是完整代码，大家可以测试一下

package test;import java.util.AbstractMap;import java.util.AbstractSet;import java.util.ArrayList;import java.util.HashSet;import java.util.Iterator;import java.util.List;import java.util.ListIterator;import java.util.Map;import java.util.Set;public class MyHashMapextends AbstractMap{ //链表长度 final static int SIZE = 999; private Listkeys = new ArrayList(); private Listvalues = new ArrayList(); /** * Entry类，用于保存键值对 * @author Administrator * * @param* @param*/ static class MyEntryimplements Map.Entry{ private K key; private V value; public MyEntry(K key,V value) { this.key = key; this.value = value; } @Override public K getKey() { return key; } @Override public V getValue() { return value; } @Override public V setValue(V v) { V ldValue = value; value = v; return oldValue; } @Override public int hashCode() { //使用key和value的hashcode共同构造新的hashcode return (key==null?0:key.hashCode())^(value==null?0:value.hashCode()); } @Override public boolean equals(Object obj) { //注意要检查类型是否相同 if(!(obj instanceof MyEntry)) return false; MyEntry en = (MyEntry)obj; //注意空值的情况 return (key==null?en.getKey()==key:key.equals(en.getKey())) && (value==null?en.getKey()==value:value.equals(en.getValue())); } } @SuppressWarnings(“unchecked”) ArrayList>[] buckets = new ArrayList[SIZE]; /** * put方法 */ public V put(K key,V value){ //原值用于返回 V ldValue = null; //防止越界 int index = Math.abs(key.hashCode())%SIZE; //检查是否有桶，没有创建一个 if(buckets[index]==null){ buckets[index] = new ArrayList>(); } ArrayList>bucket = buckets[index]; //创建键值对对象entry MyEntrypair = new MyEntry(key, value); boolean found = false; ListIterator>it = bucket.listIterator(); //遍历桶 while(it.hasNext()){ MyEntryiPair = it.next(); //如果已经在map里面，更新 if(iPair.getKey().equals(key)){ oldValue = iPair.getValue(); it.set(pair); values.set(keys.indexOf(key),value); found = true; break; } } //不在map里面，新增 if(!found){ keys.add(key); values.add(value); bucket.add(pair); } return oldValue; } /** * get方法 */ public V get(Object key){ int index = Math.abs(key.hashCode())%SIZE; if(buckets[index]==null) return null; for(MyEntrypair:buckets[index]){ if(pair.getKey().equals(key)){ return pair.getValue(); } } return null; } private class MyEntrySet extends AbstractSet>{ @Override public Iterator>iterator() { return new Iterator>() { private int index = -1; boolean canRemove; @Override public boolean hasNext() { return indexnext() { boolean canRemove = true; ++index; return new MyEntry(keys.get(index), values.get(index)); } @Override public void remove() { if(!canRemove){ throw new IllegalStateException(); } canRemove = false; keys.remove(index); values.remove(index--); } }; } @Override public int size() { return keys.size(); } } private MyEntrySet myEntrySet = new MyEntrySet(); @Override public Set>entrySet() { return myEntrySet; }}

OK，定义了我们自己hashmap以后，我们再来对照着看源代码，就比较容易，虽然还有些区别，但是希望加深大家的理解

首先来看get方法

/** * Returns the value of the mapping with the specified key. * * @param key *the key. * @return the value of the mapping with the specified key, or {@code null} * if no mapping for the specified key is found. */ public V get(Object key) { //检查key为null if (key == null) {HashMapEntrye = entryForNullKey;return e == null ? null : e.value; } // Doug Lea's supplemental secondaryHash function (inlined) //利用key的hashcode,计算新的hash int hash = key.hashCode(); hash ^= (hash >>>20) ^ (hash >>>12); hash ^= (hash >>>7) ^ (hash >>>4); //遍历数组查找是否存在对应值 HashMapEntry[] tab = table; for (HashMapEntrye = tab[hash & (tab.length - 1)]; e != null; e = e.next) {K eKey = e.key;if (eKey == key || (e.hash == hash && key.equals(eKey))) { return e.value;} } return null; }

用源代码跟我们写的代码比较，发现也是先处理null值，源码中使用了一个特定的对象来代表key为Null的entry

然后是计算新的hash，这个怎么计算我们不理它，只要知道为了hash更加完美，我们需要根据key的hashcode重新一次hash值

然后及时遍历查找对应value

接下来看put方法

/** * Maps the specified key to the specified value. * * @param key *the key. * @param value *the value. * @return the value of any previous mapping with the specified key or * {@code null} if there was no such mapping. */ @Override public V put(K key, V value) { //如果新增的key为null,直接返回新生成的一个特定对象 if (key == null) {return putValueForNullKey(value); } //重新计算hash值 int hash = secondaryHash(key.hashCode()); HashMapEntry[] tab = table; int index = hash & (tab.length - 1); //遍历，如果存在就更新 for (HashMapEntrye = tab[index]; e != null; e = e.next) {if (e.hash == hash && key.equals(e.key)) { preModify(e); V ldValue = e.value; e.value = value; return oldValue;} } // No entry for (non-null) key is present; create one modCount++; if (size++ >threshold) {tab = doubleCapacity();index = hash & (tab.length - 1); } //没有就新增 addNewEntry(key, value, hash, index); return null; } /** *为控制生产一个特定对象 */ private V putValueForNullKey(V value) { HashMapEntryentry = entryForNullKey; if (entry == null) { addNewEntryForNullKey(value); size++; modCount++; return null; } else { preModify(entry); V ldValue = entry.value; entry.value = value; return oldValue; } }对比我们的代码来看，思路差不多，就是处理null值的时候有不同

最后来看我们的entrySet

private final class EntrySet extends AbstractSet>{ public Iterator>iterator() {return newEntryIterator(); } public boolean contains(Object o) {if (!(o instanceof Entry)) return false;Entrye = (Entry) o;return containsMapping(e.getKey(), e.getValue()); } public boolean remove(Object o) {if (!(o instanceof Entry)) return false;Entrye = (Entry)o;return removeMapping(e.getKey(), e.getValue()); } public int size() {return size; } public boolean isEmpty() {return size == 0; } public void clear() {HashMap.this.clear(); } }

必须实现的方法有对应的实现，其中size是另外记录的一个变量，用来记录数据条数

这个必须结合iterator一起看，查找源代码以后，发现对应的是这个class

private final class EntryIterator extends HashIteratorimplements Iterator>{ public Entrynext() { return nextEntry(); } }继承自HashIterator

private abstract class HashIterator { int nextIndex; HashMapEntrynextEntry = entryForNullKey; HashMapEntrylastEntryReturned; int expectedModCount = modCount; HashIterator() {if (nextEntry == null) { HashMapEntry[] tab = table; HashMapEntrynext = null; while (next == null && nextIndex < tab.length) { next = tab[nextIndex++]; } nextEntry = next;} } public boolean hasNext() {return nextEntry != null; } HashMapEntrynextEntry() {if (modCount != expectedModCount) throw new ConcurrentModificationException();if (nextEntry == null) throw new NoSuchElementException();HashMapEntryentryToReturn = nextEntry;HashMapEntry[] tab = table;HashMapEntrynext = entryToReturn.next;while (next == null && nextIndex < tab.length) { next = tab[nextIndex++];}nextEntry = next;return lastEntryReturned = entryToReturn; } public void remove() {if (lastEntryReturned == null) throw new IllegalStateException();if (modCount != expectedModCount) throw new ConcurrentModificationException();HashMap.this.remove(lastEntryReturned.key);lastEntryReturned = null;expectedModCount = modCount; } }

篇2：java中的dom,XmlPullParser 解析xml,

新建xml文件：

安卓版本dom解析：

private void createXmlFile(){

File linceseFile=new File(BOOKS_PATH);

try {

linceseFile.createNewFile();

} catch (Exception e) {

Log.e(“IOException”, “exception in createNewFile() method”);

}

FileOutputStream fileos=null;

try {

fileos=new FileOutputStream(linceseFile);

} catch (Exception e) {

Log.e(“FileNotFoundException”,“can't create FileOutputStream”);

}

XmlSerializer serializer=Xml.newSerializer();

try {

serializer.setOutput(fileos,“UTF-8”);

serializer.startDocument(null,true);

serializer.startTag(null,“books”);

for(int i=0;i<3;i++){

serializer.startTag(null, “book”);

serializer.startTag(null, “bookname”);

serializer.text(“Android教程”+i);

serializer.endTag(null, “bookname”);

serializer.startTag(null, “bookauthor”);

serializer.text(“Frankie”+i);

serializer.endTag(null, “bookauthor”);

serializer.endTag(null, “book”);

}

serializer.endTag(null, “books”);

serializer.endDocument();

serializer.flush();

fileos.close();

} catch (Exception e) {

// TODO: handle exception

}

Toast.makeText(getApplicationContext(), “创建XML文件成功！”, Toast.LENGTH_LONG).show();

}

private void saxParserXML(){

}

private void domParserXML() {

File file=new File(BOOKS_PATH);

DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();

DocumentBuilder db=null;

try {

db=dbf.newDocumentBuilder();

} catch (Exception e) {

e.printStackTrace();

}

Document doc=null;

try {

doc=db.parse(file);

} catch (Exception e) {

e.printStackTrace();

}

Element root=doc.getDocumentElement();

NodeList books=root.getElementsByTagName(“book”);

String res=“本结果是通过dom 解析的:/n”;

for(int i=0;iElement book=(Element) books.item(i);

Element bookname=(Element)book.getElementsByTagName(“bookname”).item(0);

Element bookauthor=(Element)book.getElementsByTagName(“bookauthor”).item(0);

res+=“书名：”+bookname.getFirstChild().getNodeValue()+“ ”+“作者”+bookauthor.getFirstChild().getNodeValue()+“/n”;

}

tv.setText(res);

其中注意设定权限：

安卓版本pullparser解析：

try {

XmlPullParserFactory factory=XmlPullParserFactory.newInstance();

factory.setNamespaceAware(true);

XmlPullParser xpp=factory.newPullParser();

xpp.setInput(new StringReader(“zhangsan”));

int eventType=xpp.getEventType();

while(eventType!=XmlPullParser.END_DOCUMENT){

switch(eventType){

case XmlPullParser.START_DOCUMENT:

System.out.println(“Start document”);

break;

case XmlPullParser.START_TAG:

System.out.println(“Start tag”+xpp.getName());

if(xpp.getName().equals(“name”)){

Toast.makeText(getApplicationContext(), xpp.nextText(), Toast.LENGTH_SHORT).show();

}else if(xpp.getName().equals(“image”)){

Toast.makeText(getApplicationContext(), xpp.getAttributeValue(0), Toast.LENGTH_SHORT).show();

}

break;

case XmlPullParser.TEXT:

break;

case XmlPullParser.END_DOCUMENT:

break;

default :

break;

}

eventType=xpp.next();

}

篇3：java中方法重载

java中方法重载

方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。调用重载方法时，Java编译器能通过检查调用的方法的参数类型和个数选择一个恰当的方法。方法重载通常用于创建完成一组任务相似但参数的类型或参数的个数不同的方法。

java中重载与重写的区别

首先我们来讲讲：重载(Overloading)

(1) 方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在，具有不同的参数个数/类型。

重载Overloading是一个类中多态性的一种表现。

(2) Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。

调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。

(3) 重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准。

下面是重载的例子：

package c04.answer;//这是包名

//这是这个程序的第一种编程方法，在main方法中先创建一个Dog类实例，然后在Dog类的构造方法中利用this关键字调用不同的bark方法。

不同的重载方法bark是根据其参数类型的不同而区分的。

//注意：除构造器以外，编译器禁止在其他任何地方中调用构造器。

package c04.answer;

public class Dog {

Dog

{

this.bark();

}

void bark()//bark()方法是重载方法

{

System.out.println(\\“no barking!\\”);

this.bark(\\“female\\”, 3.4);

}

void bark(String m,double l)//注意：重载的方法的返回值都是一样的，

{

System.out.println(\\“a barking dog!\\”);

this.bark(5, \\“China\\”);

}

void bark(int a,String n)//不能以返回值区分重载方法，而只能以“参数类型”和“类名”来区分

{

System.out.println(\\“a howling dog\\”);

}

public static void main(String[] args)

{

Dog dog = new Dog();

//dog.bark(); [Page]

//dog.bark(\\“male\\”, \\“yellow\\”);

//dog.bark(5, \\“China\\”);

然后我们再来谈谈重写(Overriding)

(1) 父类与子类之间的多态性，对父类的函数进行重新定义。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。

但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。

方法重写又称方法覆盖。

(2)若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。

如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。

(3)子类函数的访问修饰权限不能少于父类的;

下面是重写的例子：

概念：即调用对象方法的机制。

动态绑定的内幕：

1、编译器检查对象声明的类型和方法名，从而获取所有候选方法。试着把上例Base类的test注释掉，这时再编译就无法通过。

2、重载决策：编译器检查方法调用的参数类型，从上述候选方法选出唯一的那一个(其间会有隐含类型转化)。

如果编译器找到多于一个或者没找到，此时编译器就会报错。试着把上例Base类的test(byte b)注释掉，这时运行结果是1 1。

3、若方法类型为priavte static final ，java采用静态编译，编译器会准确知道该调用哪个方法。

4、当程序运行并且使用动态绑定来调用一个方法时，那么虚拟机必须调用对象的实际类型相匹配的方法版本。

在例子中，b所指向的.实际类型是TestOverriding，所以b.test(0)调用子类的test。

但是，子类并没有重写test(byte b)，所以b.test((byte)0)调用的是父类的test(byte b)。

如果把父类的(byte b)注释掉，则通过第二步隐含类型转化为int,最终调用的是子类的test(int i)。

学习总结：

多态性是面向对象编程的一种特性，和方法无关，

简单说，就是同样的一个方法能够根据输入数据的不同，做出不同的处理，即方法的

重载——有不同的参数列表(静态多态性)

而当子类继承自父类的相同方法，输入数据一样，但要做出有别于父类的响应时，你就要覆盖父类方法，

即在子类中重写该方法——相同参数，不同实现(动态多态性)

OOP三大特性：继承，多态，封装。

public class Base

{

void test(int i)

{

System.out.print(i);

}

void test(byte b)

{

System.out.print(b);

}

public class TestOverriding extends Base

{

void test(int i)

{

i++;

System.out.println(i);

}

public static void main(String[]agrs)

{

Base b=new TestOverriding();

b.test(0)

b.test((byte)0)

}

这时的输出结果是1 0，这是运行时动态绑定的结果。

重写的主要优点是能够定义某个子类特有的特征：

public class Father{

public void speak(){

System.out.println(Father);

}

public class Son extends Father{

public void speak(){

System.out.println(“son”);

}

这也叫做多态性，重写方法只能存在于具有继承关系中，重写方法只能重写父类非私有的方法。

当上例中Father类speak()方法被private时，Son类不能重写出Father类speak()方法，此时Son类speak()方法相当与在Son类中定义的一个speak()方法。

Father类speak()方法一但被final时，无论该方法被public,protected及默认所修饰时，Son类根本不能重写Father类speak()方法，

试图编译代码时，编译器会报错。例：

public class Father{

final public void speak(){

System.out.println(“Father”);

}

public class Son extends Father{

public void speak(){

System.out.println(“son”);

}

} //编译器会报错;

Father类speak()方法被默认修饰时，只能在同一包中，被其子类被重写，如果不在同一包则不能重写。

Father类speak()方法被protoeted时，不仅在同一包中，被其子类被重写，还可以不同包的子类重写。

重写方法的规则：

1、参数列表必须完全与被重写的方法相同，否则不能称其为重写而是重载。

2、返回的类型必须一直与被重写的方法的返回类型相同，否则不能称其为重写而是重载。

3、访问修饰符的限制一定要大于被重写方法的访问修饰符(public>protected>default>private)

4、重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。例如：

父类的一个方法申明了一个检查异常IOException，在重写这个方法是就不能抛出Exception,只能抛出IOException的子类异常，可以抛出非检查异常。

而重载的规则：

1、必须具有不同的参数列表;

2、可以有不责骂的返回类型，只要参数列表不同就可以了;

3、可以有不同的访问修饰符;

4、可以抛出不同的异常;

重写与重载的区别在于：

重写多态性起作用，对调用被重载过的方法可以大大减少代码的输入量，同一个方法名只要往里面传递不同的参数就可以拥有不同的功能或返回值。

用好重写和重载可以设计一个结构清晰而简洁的类，可以说重写和重载在编写代码过程中的作用非同一般.

篇4：Java中的字符串

1.字符串可以被GC回收了

我们之前在表达式的陷阱中就说到“对于Java程序中的字符直接量，JVM会使用一个字符串池来保护他们：当第一次使用某个字符串直接时，JVM会将它们放入字符串池进行缓存，”在jdk1.7之前HotSpot将该字符串常量池放在永久代中，所以当初我们还说“在一般情况下，字符串缓冲池中字符串对象不会被垃圾回收”，但是jdk1.7以后HotSpot就将字符串常量池从永久代中移出。因此我们看到如下程序，并不会导致内存溢出：

image

public class StringTest {

public static void main(String[] args){

Listlist=new ArrayList();

int i=0;

while(true){

list.add(String.valueOf(i++).intern());

}

这段代码在jdk1.7中会一直循环下去，但是在jdk1.6中会报“OutOfMemoryError：PermGen space”错误。这样java字符串常量池就回归到了堆内存中，接受垃圾回收器的垃圾回收。

2.String是不可变的

创建好一个String之后，它就不会再被改变了，查看JDK文档会发现，String类中看似修改了String值的方法，实际上都是创建了一个全新的String对象，以包含修改后的字符串内容，而最初的String对象纹丝未动。

3.String重载了“+”运算符

Java不允许Java程序员重载运算符。

public class StringTest {

public static void main(String[] args){

String mango=“mango”;

String s=“abc”+mango+“def”+47;

System.out.println(s);

}

通过javap来反编译以上代码：

E:\\program\\Thinking_in_Java\\bin\\string>javap -c StringTest.class

Compiled from “StringTest.java”

public class string.StringTest {

public string.StringTest();

Code:

0: aload_0

1: invokespecial #8 // Method java/lang/Object.“”:()V

4: return

public static void main(java.lang.String[]);

Code:

0: ldc #16 // String mango

2: astore_1

3: new #18 // class java/lang/StringBuilder

6: dup

7: ldc #20 // String abc

9: invokespecial #22 // Method java/lang/StringBuilder.“”:(Ljava/lang/String;)V

12: aload_1

13: invokevirtual #25 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;

16: ldc #29 // String def

18: invokevirtual #25 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;

21: bipush 47

23: invokevirtual #31 // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;

26: invokevirtual #34 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;

29: astore_2

30: getstatic #38 // Field java/lang/System.out:Ljava/io/PrintStream;

33: aload_2

34: invokevirtual #44 // Method java/io/PrintStream.println:(Ljava/lang/String;)V

37: return

}

从上面的的反编译代码我们可以清楚的看到，编译器默认使用StringBuilder对我们的字符串做了优化。这样就避免了直接使用String和“+”运算符拼接所产生的中间垃圾。既然，JDK已经为我们做了字符串的优化，那我们是不是肆无忌怛的使用“+”了呢？那么我们再来看看编译器到底为我们优化到什么程度：

public class StringTest {

public String implicit(String[] fields){

String result=“”;

for(int i=0; i

result+=fields[i];

}

return result;

}

public String explicit(String[] fields){

StringBuilder result=new StringBuilder();

for(int i=0; i

result.append(fields[i]);

}

return result.toString();

}

public static void main(String[] args){

}

首先我们查看反编译后的第一个函数：

public java.lang.String implicit(java.lang.String[]);

Code:

0: ldc #16 // String

2: astore_2

3: iconst_0

4: istore_3

5: goto 32

8: new #18 // class java/lang/StringBuilder

11: dup

12: aload_2

13: invokestatic #20 // Method java/lang/String.valueOf:(Ljava/lang/Object;)Ljava/lang/String;

16: invokespecial #26 // Method java/lang/StringBuilder.“”:(Ljava/lang/String;)V

19: aload_1

20: iload_3

21: aaload

22: invokevirtual #29 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;

25: invokevirtual #33 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;

28: astore_2

29: iinc 3, 1

32: iload_3

33: aload_1

34: arraylength

35: if_icmplt 8

38: aload_2

39: areturn

从上面反编译的代码可以看出，从第4到第32行是for循环体，同时我们也看到，StringBuilder是在for循环中创建的，即每循环一次就创建一新的StringBuilder，

再看看第二个函数：

public java.lang.String explicit(java.lang.String[]);

Code:

0: new #18 // class java/lang/StringBuilder

3: dup

4: invokespecial #45 // Method java/lang/StringBuilder.“”:()V

7: astore_2

8: iconst_0

9: istore_3

10: goto 24

13: aload_2

14: aload_1

15: iload_3

16: aaload

17: invokevirtual #29 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;

20: pop

21: iinc 3, 1

24: iload_3

25: aload_1

26: arraylength

27: if_icmplt 13

30: aload_2

31: invokevirtual #33 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;

34: areturn

不仅代码缩短了，而且整个方法中只在for循环的外面生成了一个StringBuilder对象。

总结：循环中处理字符串最好自己创建一个StringBuilder对象，并用它来构造最终的结果，循环之外则可以信赖编译器对String的优化。

4.一个陷阱：

public class StringTest {

public static void main(String[] args){

String str1=“abc”;

StringBuilder sb=new StringBuilder();

sb.append(“is true? ”);

sb.append(str1+str1.length());

System.out.println(sb.toString());

}

这段代码，编译器会怎么处理呢？

public static void main(java.lang.String[]);

Code:

0: ldc #16 // String abc

2: astore_1

3: new #18 // class java/lang/StringBuilder

6: dup

7: invokespecial #20 // Method java/lang/StringBuilder.“”:()V

10: astore_2

11: aload_2

12: ldc #21 // String is true?

14: invokevirtual #23 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;

17: pop

18: aload_2

19: new #18 // class java/lang/StringBuilder

22: dup

23: aload_1

24: invokestatic #27 // Method java/lang/String.valueOf:(Ljava/lang/Object;)Ljava/lang/String;

27: invokespecial #33 // Method java/lang/StringBuilder.“”:(Ljava/lang/String;)V

30: aload_1

31: invokevirtual #36 // Method java/lang/String.length:()I

34: invokevirtual #40 // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;

37: invokevirtual #43 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;

40: invokevirtual #23 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;

43: pop

44: getstatic #47 // Field java/lang/System.out:Ljava/io/PrintStream;

47: aload_2

48: invokevirtual #43 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;

51: invokevirtual #53 // Method java/io/PrintStream.println:(Ljava/lang/String;)V

54: return

由上面代码我们可以看出，在sb.append(str1+str1.length()); 这句代码中，编译器还是采取了创建一个StringBuilder在拼接括号里面的字符串，然后将这个StringBuilder的toString传递给外围的StringBuilder。

篇5：在Java中使用枚举Java

从C++转到Java上的程序员一开始总是对Java有不少抱怨，其中没有枚举就是一个比较突出的问题，那么为什么Java不支持枚举呢？从程序语言的角度讲，支持枚举意味着什么呢？我们能不能找到一种方法满足C++程序员对枚举的要求呢？那么现在就让我们一起来探讨一

从C++转到Java上的程序员一开始总是对Java有不少抱怨，其中没有枚举就是一个比较突出的问题。那么为什么Java不支持枚举呢？从程序语言的角度讲，支持枚举意味着什么呢？我们能不能找到一种方法满足C++程序员对枚举的要求呢？那么现在就让我们一起来探讨一下这个问题。

枚举类型（Enumerated Types）

让我们先看下面这一段小程序：

enum Day {SUNDAY, MONDAY, TUESDAY,

WEDNESDAY, THURSDAY, FRIDAY, SATURDAY};

这种申明提供了一种用户友好的变量定义的方法，它枚举了这种数据类型所有可能的值，即星期一到星期天。抛开具体编程语言来看，枚举所具有的核心功能应该是:

类型安全（Type Safety）

紧凑有效的枚举数值定义 (Compact, Efficient Declaration of Enumerated Values)

无缝的和程序其它部分的交互操作（Seamless integration with other language features）

运行的高效率（Runtime efficiency）

现在我们就这几个特点逐一讨论一下。

1. 类型安全

枚举的申明创建了一个新的类型。它不同于其他的已有类型，包括原始类型（整数，浮点数等等）和当前作用域（Scope）内的其它的枚举类型。当你对函数的参数进行赋值操作的时候，整数类型和枚举类型是不能互换的（除非是你进行显式的类型转换），编译器将强制这一点。比如说，用上面申明的枚举定义这样一个函数：

public void foo(Day);

如果你用整数来调用这个函数，编译器会给出错误的。

foo(4); // compilation error

如果按照这个标准，那么Pascal, Ada, 和C++是严格意义上的支持枚举，而C语言都不是。

2. 紧凑有效的枚举数值定义

定义枚巨的程序应该很简单。比如说，在Java中我们有这样一种“准枚举”的定义方法：

public static final int SUNDAY = 0;

public static final int MONDAY = 1;

public static final int TUESDAY = 2;

public static final int WEDNESDAY = 3;

public static final int THURSDAY = 4;

public static final int FRIDAY = 5;

public static final int SATURDAY = 6;

这种定义就似乎不够简洁。如果有大量的数据要定义，这一点就尤为重要，你也就会感受更深。虽然这一点不如其他另外3点重要，但我们总是希望申明能尽可能的简洁。

3. 无缝的和程序其它部分的交互操作

语言的运算符，如赋值，相等/大于/小于判断都应该支持枚举。枚举还应该支持数组下标以及switch/case语句中用来控制流程的操作。比如：

for (Day d = SUNDAY; d <= SATURDAY; ++d) {

switch(d) {

case MONDAY: ...;

break;

case TUESDAY: ...;

break;

case WEDNESDAY: ...;

break;

case THURSDAY: ...;

break;

case FRIDAY: ...;

break;

case SATURDAY:

case SUNDAY: ...;

}

要想让这段程序工作，那么枚举必须是整数常数，而不能是对象（objects）。Java中你可以用equals 或是 compareTo() 函数来进行对象的比较操作，但是它们都不支持数组下标和switch语句。

4. 运行的高效率

枚举的运行效率应该和原始类型的整数一样高。在运行时不应该由于使用了枚举而导致性能比使用整数有下降。

如果一种语言满足这四点要求，那么我们可以说这种语言是真正的支持枚举。比如前面所说的Pascal, Ada, 和C++。很明显，Java不是。

Java的创始人James Gosling是个资深的C++程序员，他很清楚什么是枚举。但似乎他有意的删除了Java的枚举能力。其原因我们不得而知。可能是他想强调和鼓励使用多态性（polymorphism），不鼓励使用多重分支。而多重分支往往是和枚举联合使用的。不管他的初衷如何，我们在Java中仍然需要枚举。

Java中的几种“准枚举”类型

虽然Java 不直接支持用户定义的枚举。但是在实践中人们还是总结出一些枚举的替代品。

第一种替代品可以解释为“整数常数枚举”。如下所示：

public static final int SUNDAY = 0;

public static final int MONDAY = 1;

public static final int TUESDAY = 2;

public static final int WEDNESDAY = 3;

public static final int THURSDAY = 4;

public static final int FRIDAY = 5;

public static final int SATURDAY = 6;

这种方法可以让我们使用更有意义的变量名而不是直接赤裸裸的整数值。这样使得源程序的可读性和可维护性更好一些。这些定义可以放在任何类中。可以和其它的变量和方法混在一起。也可以单独放在一个类中。如果你选择将其单独放在一个类中，那么引用的时候要注意语法。比如“Day.MONDAY.”。如果你想在引用的时候省一点事，那么你可以将其放在一个接口中（interface），其它类只要申明实现（implement）它就可以比较方便的引用。比如直接使用MONDAY。就Java接口的使用目的而言，这种用法有些偏，不用也罢！

这种方法显然满足了条件3和4，即语言的集成和执行效率（枚举就是整数，没有效率损失）。但是他却不能满足条件1和2。它的定义有些嗦，更重要的是它不是类型安全的。这种方法虽然普遍被Java程序员采用，但它不是一种枚举的良好替代品。

第二种方法是被一些有名的专家经常提及的。我们可以称它为“对象枚举”。即为枚举创建一个类，然后用公用的该类的对象来表达每一个枚举的值。如下所示：

import java.util.Map;

import java.util.HashMap;

import java.util.Iterator;

import java.io.Serializable;

import java.io.InvalidObjectException;

public final class Day implements Comparable, Serializable {

private static int size = 0;

private static int nextOrd = 0;

private static Map nameMap = new HashMap(10);

private static Day first = null;

private static Day last = null;

private final int ord;

private final String label;

private Day prev;

private Day next;

public static final Day SUNDAY = new Day(“SUNDAY”);

public static final Day MONDAY = new Day(“MONDAY”);

public static final Day TUESDAY = new Day(“TUESDAY”);

public static final Day WEDNESDAY = new Day(“WEDNESDAY”);

public static final Day THURSDAY = new Day(“THURSDAY”);

public static final Day FRIDAY = new Day(“FRIDAY”);

public static final Day SATURDAY = new Day(“SATURDAY”);

/**

* 用所给的标签创建一个新的day.

* (Uses default value for ord.)

private Day(String label) {

this(label, nextOrd);

}

/**

* Constructs a new Day with its label and ord value.

private Day(String label, int ord) {

this.label = label;

this.ord = ord;

++size;

nextOrd = ord + 1;

nameMap.put(label, this);

if (first == null)

first = this;

if (last != null) {

this.prev = last;

last.next = this;

}

last = this;

}

/**

* Compares two Day objects based on their ordinal values.

* Satisfies requirements of interface java.lang.Comparable.

public int compareTo(Object obj) {

return ord - ((Day)obj).ord;

}

/**

* Compares two Day objects for equality. Returns true

* only if the specified Day is equal to this one.

public boolean equals(Object obj) {

return super.equals(obj);

}

/**

* Returns a hash code value for this Day.

public int hashCode() {

return super.hashCode();

}

/**

* Resolves deserialized Day objects.

* @throws InvalidObjectException if deserialization fails.

private Object readResolve() throws InvalidObjectException {

Day d = get(label);

if (d != null)

return d;

else {

String msg = “invalid deserialized object: label = ”;

throw new InvalidObjectException(msg + label);

}

/**

* Returns Day with the specified label.

* Returns null if not found.

public static Day get(String label) {

return (Day) nameMap.get(label);

}

/**

* Returns the label for this Day.

public String toString() {

return label;

}

/**

* Always throws CloneNotSupportedException; guarantees that

* Day objects are never cloned.

* @return (never returns)

protected Object clone() throws CloneNotSupportedException {

throw new CloneNotSupportedException();

}

/**

* Returns an iterator over all Day objects in declared order.

public static Iterator iterator() {

// anonymous inner class

return new Iterator()

{

private Day current = first;

public boolean hasNext() {

return current != null;

}

public Object next() {

Day d = current;

current = current.next();

return d;

}

public void remove() {

throw new UnsupportedOperationException();

}

};

}

/**

* Returns the ordinal value of this Day.

public int ord() {

return this.ord;

}

/**

* Returns the number of declared Day objects.

public static int size() {

return size;

}

/**

* Returns the first declared Day.

public static Day first() {

return first;

}

/**

* Returns the last declared Day.

public static Day last() {

return last;

}

/**

* Returns the previous Day before this one in declared order.

* Returns null for the first declared Day.

public Day prev() {

return this.prev;

}

/**

* Returns the next Day after this one in declared order.

* Returns null for the last declared Day.

public Day next() {

return this.next;

}

枚举值被定义为公用静态对象（public static object），

此外该类含有私有构造函数；一个循环器（Iterator）用以遍历所有的值；一些Java中常用的函数，如toString()，equals()和compareTo()，以及一些方便客户程序调用的函数，如ord()，prev()，next()，first()和 last()。

这种实现方法有很好的类型安全和运行效率（条件1和4）。但是去不满足条件2和3。首先它的定义比较繁琐，大多数程序员也许因为这个而不去使用它；同时他还不可以被用作数组下标或是用在switch/case语句。这在一定程度上降低了他的使用的广泛性。

看起来，没有一种替代品是理想的。我们虽然没有权利修改Java语言，但是我们也许可以想一些办法来克服“对象枚举”的缺点，使它成为合格的枚举替代品。

一个实现枚举的微型语言（AMini-Language for Enums）

假如我发明一种枚举专用的微型语言（且叫它jEnum），它专门用来申明枚举。然后我再用一个特殊的“翻译”程序将我用这种语言定义的枚举转化为对应的“对象枚举”定义，那不是就解决了“对象枚举”定义复杂的问题了吗。当然我们很容易让这个“翻译”程序多做一些工作。比如加入Package申明，加入程序注释，说明整数值和该对象的字符串标签名称等等。让我们看下面这样一个例子：

package com.softmoore.util;

/**

* Various USA coins

enum Coin { PENNY(“penny”) = 1, NICKEL(“nickel”) = 5, DIME(“dime”) = 10,

QUARTER(“quarter”) = 25, HALF_DOLLAR(“half dollar”) = 50 };

虽然“整数常数枚举”在有些情况下优点比较显著。但是总体上讲“对象枚举”提供的类型安全还是更为重要的，相比之下哪些缺点还是比较次要的。下面我们大概讲一下jEnum，使用它我们又可以得到紧凑和有效的枚举申明这一特点，也就是我们前面提到的条件2。

熟悉编译器的朋友可能更容易理解下面这一段jEnum微型语言。

compilationUnit = ( packageDecl )? ( docComment )? enumTypeDecl .

packageDecl = “package” packagePath “;” .

packagePath = packageName ( “.” packageName )* .

docComment = “/**” commentChars “*/” .

enumTypeDecl = “enum” enumTypeName “{” enumList “}” “;” .

enumList = enumDecl ( “,” enumDecl )* .

enumDecl = enumLiteral ( “(” stringLiteral “)” )? ( “=” intLiteral )? .

packageName = identifier .

enumTypeName = identifier .

enumLiteral = identifier .

commentChars = any-char-sequence-except-“*/”

这种语法允许在开始申明package，看起来和Java语言还挺像。你可以增加一些javadoc的注解，当然这不是必须的。枚举类型的申明以关键字“enum”开头，枚举的值放在花括号中{}，多个值之间用逗号分开。每一个值的申明包括一个标准的Java变量名，一个可选的字符串标签，可选的等号（=）和一个整数值。

如果你省略了字符串标签，那么枚举的变量名就会被使用；如果你省略了等号和后面的整数值，那么它将会自动按顺序给你的枚举赋值，如果没有使用任何数值，那么它从零开始逐步增加（步长为1）。字符串标签作为toString()方法返回值的一部分，而整数值则作为ord()方法的返回值。如下面这段申明：

enum Color { RED(“Red”) = 2, WHITE(“White”) = 4, BLUE };

RED 的标签是 “Red”，值为 2 ；

WHITE的标签是“White”，值为4；

BLUE的标签是“BLUE” ，值为5 。

要注意的是在Java中的保留字在jEnum也是保留的。比如你不可以使用this作为package名，不可以用for为枚举的变量名等等。枚举的变量名和字符串标签必须是不同的，其整数值也必须是严格向上增加的，象下面这段申明就是不对的，因为它的字符串标签不是唯一的。

enum Color { RED(“Red”), WHITE(“BLUE”), BLUE };

下面这段申明也是不对的，因为WHITE会被自动赋值2 ，和BLUE有冲突。

enum Color { RED = 1, WHITE, BLUE = 2 };

下面这是一个具体的实例。它将会被“翻译”程序使用，用以转换成我们枚举申明为可编译的Java源程序。

package com.softmoore.jEnum;

/**

* This class encapsulates the symbols (a.k.a. token types)

* of a language token.

enum Symbol {

identifier,

enumRW(“Reserved Word: enum”),

abstractRW(“Reserved Word: abstract”),

assertRW(“Reserved Word: assert”),

booleanRW(“Reserved Word: boolean”),

breakRW(“Reserved Word: break”),

byteRW(“Reserved Word: byte”),

caseRW(“Reserved Word: case”),

catchRW(“Reserved Word: catch”),

charRW(“Reserved Word: char”),

classRW(“Reserved Word: class”),

constRW(“Reserved Word: const”),

continueRW(“Reserved Word: continue”),

defaultRW(“Reserved Word: default”),

doRW(“Reserved Word: do”),

doubleRW(“Reserved Word: double”),

elseRW(“Reserved Word: else”),

extendsRW(“Reserved Word: extends”),

finalRW(“Reserved Word: final”),

finallyRW(“Reserved Word: finally”),

floatRW(“Reserved Word: float”),

forRW(“Reserved Word: for”),

gotoRW(“Reserved Word: goto”),

ifRW(“Reserved Word: if”),

implementsRW(“Reserved Word: implements”),

importRW(“Reserved Word: import”),

instanceOfRW(“Reserved Word: instanceOf”),

intRW(“Reserved Word: int”),

interfaceRW(“Reserved Word: interface”),

longRW(“Reserved Word: long”),

nativeRW(“Reserved Word: native”),

newRW(“Reserved Word: new”),

nullRW(“Reserved Word: null”),

packageRW(“Reserved Word: package”),

privateRW(“Reserved Word: private”),

protectedRW(“Reserved Word: protected”),

publicRW(“Reserved Word: public”),

returnRW(“Reserved Word: return”),

shortRW(“Reserved Word: short”),

staticRW(“Reserved Word: static”),

strictfpRW(“Reserved Word: strictfp”),

superRW(“Reserved Word: super”),

switchRW(“Reserved Word: switch”),

synchronizedRW(“Reserved Word: synchronized”),

thisRW(“Reserved Word: this”),

throwRW(“Reserved Word: throw”),

throwsRW(“Reserved Word: throws”),

transientRW(“Reserved Word: transient”),

tryRW(“Reserved Word: try”),

voidRW(“Reserved Word: void”),

volatileRW(“Reserved Word: volatile”),

whileRW(“Reserved Word: while”),

equals(“=”),

leftParen(“(”),

rightParen(“)”),

leftBrace(“”),

comma(“,”),

semicolon(“;”),

period(“.”),

intLiteral,

stringLiteral,

docComment,

EOF,

unknown

};

如果对Day的枚举申明存放在Day.enum文件中，那么我们可以将这个文件翻译成Java源程序。

$ java -jar jEnum.jar Day.enum

翻译的结果就是Day.javaJava源程序，内容和我们前面讲的一样，还包括程序注释等内容。如果想省一点事，你可以将上面比较长的命令写成一个批处理文件或是Unix，Linux上的shell script，那么以后使用的时候就可以简单一些，比如：

$ jec Day.enum

关于jEnum有四点注意事项要说明一下。

1．申明文件名不一定后缀为“.enum.”，其它合法文件后缀都可以。

2．如果文件后缀不是“.enum.”，那么翻译程序将首先按给出的文件名去搜索，如果没有，就假定给出的文件名是省略了“.enum.”后缀的。像这种命令是可以的：

$ java -jar jEnum.jar Day

3．生成的Java源程序文件名是按照申明文件内的定义得出的，而不是依据申明文件的名称。

4．翻译程序还接受以下几个开关

-o 生成“对象枚举”类枚举，是缺省值

-c 生成“整数常数枚举”类枚举，用类来实现

-i 生成“整数常数枚举”类枚举，用接口来实现

要注意的是，-C开关虽然生成“整数常数枚举”，但它同时还提供了一些“对象枚举”中所具有的方法，如first()， last()，toString(int n)，prev(int n)，和next(int n)。

jEnum工具可以从网上自由下载，其地址是：www.onjava.com/onjava//04/23/examples/jEnum.zip

原文转自：www.ltesting.net

篇6：Java 程序中的多线程Java

?在Java程序中使用多线程要比在 C 或 C++ 中容易得多，这是因为 Java 编程语言提供了语言级的支持，本文通过简单的编程示例来说明 Java 程序中的多线程是多么直观。读完本文以后，用户应该能够编写简单的多线程程序。 ?? 为什么会排队等待？ ??下面的这

?在Java程序中使用多线程要比在 C 或 C++ 中容易得多，这是因为 Java 编程语言提供了语言级的支持。本文通过简单的编程示例来说明 Java 程序中的多线程是多么直观。读完本文以后，用户应该能够编写简单的多线程程序。

??为什么会排队等待？

??下面的这个简单的 Java 程序完成四项不相关的任务。这样的程序有单个控制线程，控制在这四个任务之间线性地移动。此外，因为所需的资源 ― 打印机、磁盘、数据库和显示屏 -- 由于硬件和软件的限制都有内在的潜伏时间，所以每项任务都包含明显的等待时间。因此，程序在访问数据库之前必须等待打印机完成打印文件的任务，等等。如果您正在等待程序的完成，则这是对计算资源和您的时间的一种拙劣使用。改进此程序的一种方法是使它成为多线程的。

??四项不相关的任务

class myclass {

static public void main(String args[]) {

print_a_file();

manipulate_another_file();

access_database();

draw_picture_on_screen();

}

??在本例中，每项任务在开始之前必须等待前一项任务完成，即使所涉及的任务毫不相关也是这样。但是，在现实生活中，我们经常使用多线程模型。我们在处理某些任务的同时也可以让孩子、配偶和父母完成别的任务。例如，我在写信的同时可能打发我的儿子去邮局买邮票。用软件术语来说，这称为多个控制（或执行）线程。

??可以用两种不同的方法来获得多个控制线程：

??☆ 多个进程

??在大多数操作系统中都可以创建多个进程。当一个程序启动时，它可以为即将开始的每项任务创建一个进程，并允许它们同时运行。当一个程序因等待网络访问或用户输入而被阻塞时，另一个程序还可以运行，这样就增加了资源利用率。但是，按照这种方式创建每个进程要付出一定的代价：设置一个进程要占用相当一部分处理器时间和内存资源。而且，大多数操作系统不允许进程访问其他进程的内存空间。因此，进程间的通信很不方便，并且也不会将它自己提供给容易的编程模型。

??☆ 线程

??线程也称为轻型进程 (LWP)。因为线程只能在单个进程的作用域内活动，所以创建线程比创建进程要廉价得多。这样，因为线程允许协作和数据交换，并且在计算资源方面非常廉价，所以线程比进程更可取。线程需要操作系统的支持，因此不是所有的机器都提供线程。Java 编程语言，作为相当新的一种语言，已将线程支持与语言本身合为一体，这样就对线程提供了强健的支持。

??使用 Java 编程语言实现线程

??Java 编程语言使多线程如此简单有效，以致于某些程序员说它实际上是自然的。尽管在 Java 中使用线程比在其他语言中要容易得多，仍然有一些概念需要掌握。要记住的一件重要的事情是 main() 函数也是一个线程，并可用来做有用的工作。程序员只有在需要多个线程时才需要创建新的线程。

??Thread 类

??Thread 类是一个具体的类，即不是抽象类，该类封装了线程的行为。要创建一个线程，程序员必须创建一个从 Thread 类导出的新类。程序员必须覆盖 Thread 的 run() 函数来完成有用的工作。用户并不直接调用此函数；而是必须调用 Thread 的 start() 函数，该函数再调用 run()。下面的代码说明了它的用法：

??创建两个新线程

importjava.util.*;

class TimePrinter extends Thread {

int pauseTime;

String name;

public TimePrinter(int x, String n) {

pauseTime = x;

name = n;

}

public void run() {

while(true) {

try {

System.out.println(name + “:” + new

Date(System.currentTimeMillis()));

Thread.sleep(pauseTime);

} catch(Exception e) {

System.out.println(e);

}

static public void main(String args[]) {

TimePrinter tp1 = new TimePrinter(1000, “Fast Guy”);

tp1.start();

TimePrinter tp2 = new TimePrinter(3000, “Slow Guy”);

tp2.start();

}

??在本例中，我们可以看到一个简单的程序，它按两个不同的时间间隔（1 秒和 3 秒）在屏幕上显示当前时间。这是通过创建两个新线程来完成的，包括 main() 共三个线程。但是，因为有时要作为线程运行的类可能已经是某个类层次的一部分，所以就不能再按这种机制创建线程。虽然在同一个类中可以实现任意数量的接口，但 Java 编程语言只允许一个类有一个父类。同时，某些程序员避免从 Thread 类导出，因为它强加了类层次。对于这种情况，就要 runnable 接口。

??Runnable 接口

??此接口只有一个函数，run()，此函数必须由实现了此接口的类实现。但是，就运行这个类而论，其语义与前一个示例稍有不同。我们可以用 runnable 接口改写前一个示例。（不同的部分用黑体表示。）

??创建两个新线程而不强加类层次

import java.util.*;

class TimePrinterimplements Runnable{

int pauseTime;

String name;

public TimePrinter(int x, String n) {

pauseTime = x;

name = n;

}

public void run() {

while(true) {

try {

System.out.println(name + “:” + new

Date(System.currentTimeMillis()));

Thread.sleep(pauseTime);

} catch(Exception e) {

System.out.println(e);

}

static public void main(String args[]) {

Thread t1=new Thread(new TimePrinter(1000, “Fast Guy”));

t1.start();

Thread t2=new Thread(new TimePrinter(3000, “Slow Guy”));

t2.start();

}

??请注意，当使用 runnable 接口时，您不能直接创建所需类的对象并运行它；必须从 Thread 类的一个实例内部运行它。许多程序员更喜欢 runnable 接口，因为从 Thread 类继承会强加类层次。

??synchronized 关键字

??到目前为止，我们看到的示例都只是以非常简单的方式来利用线程。只有最小的数据流，而且不会出现两个线程访问同一个对象的情况。但是，在大多数有用的程序中，线程之间通常有信息流。试考虑一个金融应用程序，它有一个 Account 对象，如下例中所示：

??一个银行中的多项活动

public class Account {

String holderName;

float amount;

public Account(String name, float amt) {

holderName = name;

amount = amt;

}

public void deposit(float amt) {

amount += amt;

}

public void withdraw(float amt) {

amount -= amt;

}

public float checkBalance() {

return amount;

}

??在此代码样例中潜伏着一个错误。如果此类用于单线程应用程序，不会有任何问题。但是，在多线程应用程序的情况中，不同的线程就有可能同时访问同一个 Account 对象，比如说一个联合帐户的所有者在不同的 ATM 上同时进行访问，

在这种情况下，存入和支出就可能以这样的方式发生：一个事务被另一个事务覆盖。这种情况将是灾难性的。但是，Java 编程语言提供了一种简单的机制来防止发生这种覆盖。每个对象在运行时都有一个关联的锁。这个锁可通过为方法添加关键字 synchronized 来获得。这样，修订过的 Account 对象（如下所示）将不会遭受像数据损坏这样的错误：

??对一个银行中的多项活动进行同步处理

public class Account {

String holderName;

float amount;

public Account(String name, float amt) {

holderName = name;

amount = amt;

}

publicsynchronizedvoid deposit(float amt) {

amount += amt;

}

publicsynchronizedvoid withdraw(float amt) {

amount -= amt;

}

public float checkBalance() {

return amount;

}

??deposit() 和 withdraw() 函数都需要这个锁来进行操作，所以当一个函数运行时，另一个函数就被阻塞。请注意， checkBalance() 未作更改，它严格是一个读函数。因为 checkBalance() 未作同步处理，所以任何其他方法都不会阻塞它，它也不会阻塞任何其他方法，不管那些方法是否进行了同步处理。

??Java 编程语言中的高级多线程支持

??线程组

??线程是被个别创建的，但可以将它们归类到线程组中，以便于调试和监视。只能在创建线程的同时将它与一个线程组相关联。在使用大量线程的程序中，使用线程组组织线程可能很有帮助。可以将它们看作是计算机上的目录和文件结构。

??线程间发信

??当线程在继续执行前需要等待一个条件时，仅有 synchronized 关键字是不够的。虽然 synchronized 关键字阻止并发更新一个对象，但它没有实现线程间发信。Object 类为此提供了三个函数：wait()、notify() 和 notifyAll()。以全球气候预测程序为例。这些程序通过将地球分为许多单元，在每个循环中，每个单元的计算都是隔离进行的，直到这些值趋于稳定，然后相邻单元之间就会交换一些数据。所以，从本质上讲，在每个循环中各个线程都必须等待所有线程完成各自的任务以后才能进入下一个循环。这个模型称为屏蔽同步，下例说明了这个模型：

??屏蔽同步

public class BSync {

int totalThreads;

int currentThreads;

public BSync(int x) {

totalThreads = x;

currentThreads = 0;

}

public synchronized void waitForAll() {

currentThreads++;

if(currentThreads < totalThreads) {

try {

wait();

} catch (Exception e) {}

}

else {

currentThreads = 0;

notifyAll();

}

??当对一个线程调用 wait() 时，该线程就被有效阻塞，只到另一个线程对同一个对象调用 notify() 或 notifyAll() 为止。因此，在前一个示例中，不同的线程在完成它们的工作以后将调用 waitForAll() 函数，最后一个线程将触发 notifyAll() 函数，该函数将释放所有的线程。第三个函数 notify() 只通知一个正在等待的线程，当对每次只能由一个线程使用的资源进行访问限制时，这个函数很有用。但是，不可能预知哪个线程会获得这个通知，因为这取决于 Java 虚拟机 (JVM) 调度算法。

??将 CPU 让给另一个线程

??当线程放弃某个稀有的资源（如数据库连接或网络端口）时，它可能调用 yield() 函数临时降低自己的优先级，以便某个其他线程能够运行。

??守护线程

??有两类线程：用户线程和守护线程。用户线程是那些完成有用工作的线程。守护线程是那些仅提供辅助功能的线程。Thread 类提供了 setDaemon() 函数。Java 程序将运行到所有用户线程终止，然后它将破坏所有的守护线程。在 Java 虚拟机 (JVM) 中，即使在 main 结束以后，如果另一个用户线程仍在运行，则程序仍然可以继续运行。

??避免不提倡使用的方法

??不提倡使用的方法是为支持向后兼容性而保留的那些方法，它们在以后的版本中可能出现，也可能不出现。Java 多线程支持在版本 1.1 和版本 1.2 中做了重大修订，stop()、suspend() 和 resume() 函数已不提倡使用。这些函数在 JVM 中可能引入微妙的错误。虽然函数名可能听起来很诱人，但请抵制诱惑不要使用它们。

??调试线程化的程序

??在线程化的程序中，可能发生的某些常见而讨厌的情况是死锁、活锁、内存损坏和资源耗尽。

??死锁

??死锁可能是多线程程序最常见的问题。当一个线程需要一个资源而另一个线程持有该资源的锁时，就会发生死锁。这种情况通常很难检测。但是，解决方案却相当好：在所有的线程中按相同的次序获取所有资源锁。例如，如果有四个资源 ―A、B、C 和 D ― 并且一个线程可能要获取四个资源中任何一个资源的锁，则请确保在获取对 B 的锁之前首先获取对 A 的锁，依此类推。如果“线程 1”希望获取对 B 和 C 的锁，而“线程 2”获取了 A、C 和 D 的锁，则这一技术可能导致阻塞，但它永远不会在这四个锁上造成死锁。

??活锁

??当一个线程忙于接受新任务以致它永远没有机会完成任何任务时，就会发生活锁。这个线程最终将超出缓冲区并导致程序崩溃。试想一个秘书需要录入一封信，但她一直在忙于接电话，所以这封信永远不会被录入。

??内存损坏

??如果明智地使用 synchronized 关键字，则完全可以避免内存错误这种气死人的问题。

??资源耗尽

??某些系统资源是有限的，如文件描述符。多线程程序可能耗尽资源，因为每个线程都可能希望有一个这样的资源。如果线程数相当大，或者某个资源的侯选线程数远远超过了可用的资源数，则最好使用资源池。一个最好的示例是数据库连接池。只要线程需要使用一个数据库连接，它就从池中取出一个，使用以后再将它返回池中。资源池也称为资源库。

??调试大量的线程

??有时一个程序因为有大量的线程在运行而极难调试。在这种情况下，下面的这个类可能会派上用场：

public class Probe extends Thread {

public Probe() {}

public void run() {

while(true) {

Thread[] x = new Thread[100];

Thread.enumerate(x);

for(int i=0; i<100; i++) {

Thread t = x[i];

if(t == null)

break;

else

System.out.println(t.getName() + “\\t” + t.getPriority()

+ “\\t” + t.isAlive() + “\\t” + t.isDaemon());

}

??限制线程优先级和调度

??Java 线程模型涉及可以动态更改的线程优先级。本质上，线程的优先级是从 1 到 10 之间的一个数字，数字越大表明任务越紧急。JVM 标准首先调用优先级较高的线程，然后才调用优先级较低的线程。但是，该标准对具有相同优先级的线程的处理是随机的。如何处理这些线程取决于基层的操作系统策略。在某些情况下，优先级相同的线程分时运行；在另一些情况下，线程将一直运行到结束。请记住，Java 支持 10 个优先级，基层操作系统支持的优先级可能要少得多，这样会造成一些混乱。因此，只能将优先级作为一种很粗略的工具使用。最后的控制可以通过明智地使用 yield() 函数来完成。通常情况下，请不要依靠线程优先级来控制线程的状态。

??小结

??本文说明了在 Java 程序中如何使用线程。像是否应该使用线程这样的更重要的问题在很大程序上取决于手头的应用程序。决定是否在应用程序中使用多线程的一种方法是，估计可以并行运行的代码量。并记住以下几点：

??☆ 使用多线程不会增加 CPU 的能力。但是如果使用 JVM 的本地线程实现，则不同的线程可以在不同的处理器上同时运行（在多 CPU 的机器中），从而使多 CPU 机器得到充分利用。

??☆ 如果应用程序是计算密集型的，并受 CPU 功能的制约，则只有多 CPU 机器能够从更多的线程中受益。

??☆ 当应用程序必须等待缓慢的资源（如网络连接或数据库连接）时，或者当应用程序是非交互式的时，多线程通常是有利的。

??☆ 基于 Internet 的软件有必要是多线程的；否则，用户将感觉应用程序反映迟钝。例如，当开发要支持大量客户机的服务器时，多线程可以使编程较为容易。在这种情况下，每个线程可以为不同的客户或客户组服务，从而缩短了响应时间。

??某些程序员可能在 C 和其他语言中使用过线程，在那些语言中对线程没有语言支持。这些程序员可能通常都被搞得对线程失去了信心。

原文转自：www.ltesting.net

篇7：java中queue的使用

Queue接口与List、Set同一级别，都是继承了Collection接口，LinkedList实现了Queue接口。Queue接口窄化了对LinkedList的方法的访问权限（即在方法中的参数类型如果是Queue时，就完全只能访问Queue接口所定义的方法了，而不能直接访问 LinkedList的非Queue的方法），以使得只有恰当的方法才可以使用。BlockingQueue 继承了Queue接口。

队列是一种数据结构．它有两个基本操作：在队列尾部加人一个元素，和从队列头部移除一个元素就是说，队列以一种先进先出的方式管理数据，如果你试图向一个已经满了的阻塞队列中添加一个元素或者是从一个空的阻塞队列中移除一个元索，将导致线程阻塞．在多线程进行合作时，阻塞队列是很有用的工具。工作者线程可以定期地把中间结果存到阻塞队列中而其他工作者线线程把中间结果取出并在将来修改它们。队列会自动平衡负载。如果第一个线程集运行得比第二个慢，则第二个线程集在等待结果时就会阻塞。如果第一个线程集运行得快，那么它将等待第二个线程集赶上来。下表显示了jdk1.5中的阻塞队列的操作：

add 增加一个元索如果队列已满，则抛出一个IIIegaISlabEepeplian异常

remove 移除并返回队列头部的元素如果队列为空，则抛出一个NoSuchElementException异常

element 返回队列头部的元素如果队列为空，则抛出一个NoSuchElementException异常

offer 添加一个元素并返回true 如果队列已满，则返回false

poll 移除并返问队列头部的元素如果队列为空，则返回null

peek 返回队列头部的元素如果队列为空，则返回null

put 添加一个元素如果队列满，则阻塞

take 移除并返回队列头部的元素如果队列为空，则阻塞

remove、element、offer 、poll、peek 其实是属于Queue接口。

阻塞队列的操作可以根据它们的响应方式分为以下三类：aad、removee和element操作在你试图为一个已满的队列增加元素或从空队列取得元素时抛出异常。当然，在多线程程序中，队列在任何时间都可能变成满的或空的，所以你可能想使用offer、poll、peek方法。这些方法在无法完成任务时只是给出一个出错示而不会抛出异常。

注意：poll和peek方法出错进返回null。因此，向队列中插入null值是不合法的。

还有带超时的offer和poll方法变种，例如，下面的调用：

boolean success = q.offer(x,100,TimeUnit.MILLISECONDS);

尝试在100毫秒内向队列尾部插入一个元素。如果成功，立即返回true；否则，当到达超时进，返回false。同样地，调用：

Object head = q.poll(100, TimeUnit.MILLISECONDS);

如果在100毫秒内成功地移除了队列头元素，则立即返回头元素；否则在到达超时时，返回null。

最后，我们有阻塞操作put和take。put方法在队列满时阻塞，take方法在队列空时阻塞。

java.ulil.concurrent包提供了阻塞队列的4个变种。默认情况下，LinkedBlockingQueue的容量是没有上限的（说的不准确，在不指定时容量为Integer.MAX_VALUE，不要然的话在put时怎么会受阻呢），但是也可以选择指定其最大容量，它是基于链表的队列，此队列按 FIFO（先进先出）排序元素。

ArrayBlockingQueue在构造时需要指定容量，并可以选择是否需要公平性，如果公平参数被设置true，等待时间最长的线程会优先得到处理（其实就是通过将ReentrantLock设置为true来达到这种公平性的：即等待时间最长的线程会先操作）。通常，公平性会使你在性能上付出代价，只有在的确非常需要的时候再使用它。它是基于数组的阻塞循环队列，此队列按 FIFO（先进先出）原则对元素进行排序。

PriorityBlockingQueue是一个带优先级的队列，而不是先进先出队列。元素按优先级顺序被移除，该队列也没有上限（看了一下源码，PriorityBlockingQueue是对 PriorityQueue的再次包装，是基于堆数据结构的，而PriorityQueue是没有容量限制的，与ArrayList一样，所以在优先阻塞队列上put时是不会受阻的。虽然此队列逻辑上是无界的，但是由于资源被耗尽，所以试图执行添加操作可能会导致 OutOfMemoryError），但是如果队列为空，那么取元素的操作take就会阻塞，所以它的检索操作take是受阻的。另外，往入该队列中的元素要具有比较能力。

最后，DelayQueue（基于PriorityQueue来实现的）是一个存放Delayed 元素的无界阻塞队列，只有在延迟期满时才能从中提取元素。该队列的头部是延迟期满后保存时间最长的 Delayed 元素。如果延迟都还没有期满，则队列没有头部，并且poll将返回null。当一个元素的 getDelay(TimeUnit.NANOSECONDS) 方法返回一个小于或等于零的值时，则出现期满，poll就以移除这个元素了。此队列不允许使用 null 元素。下面是延迟接口：

public interface Delayed extends Comparable{

long getDelay(TimeUnit unit);

}

放入DelayQueue的元素还将要实现compareTo方法，DelayQueue使用这个来为元素排序。

下面的实例展示了如何使用阻塞队列来控制线程集。程序在一个目录及它的所有子目录下搜索所有文件，打印出包含指定关键字的文件列表。从下面实例可以看出，使用阻塞队列两个显著的好处就是：多线程操作共同的队列时不需要额外的同步，另外就是队列会自动平衡负载，即那边（生产与消费两边）处理快了就会被阻塞掉，从而减少两边的处理速度差距。下面是具体实现：

public class BlockingQueueTest {

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

System.out.print(“Enter base directory (e.g. /usr/local/jdk5.0/src): ”);

String directory = in.nextLine;

System.out.print(“Enter keyword (e.g. volatile): ”);

String keyword = in.nextLine();

final int FILE_QUEUE_SIZE = 10;// 阻塞队列大小

final int SEARCH_THREADS = 100;// 关键字搜索线程个数

// 基于ArrayBlockingQueue的阻塞队列

BlockingQueuequeue = new ArrayBlockingQueue(

FILE_QUEUE_SIZE);

//只启动一个线程来搜索目录

FileEnumerationTask enumerator = new FileEnumerationTask(queue,

new File(directory));

new Thread(enumerator).start();

//启动100个线程用来在文件中搜索指定的关键字

for (int i = 1; i <= SEARCH_THREADS; i++)

new Thread(new SearchTask(queue, keyword)).start();

}

class FileEnumerationTask implements Runnable {

//哑元文件对象，放在阻塞队列最后，用来标示文件已被遍历完

public static File DUMMY = new File(“”);

private BlockingQueuequeue;

private File startingDirectory;

public FileEnumerationTask(BlockingQueuequeue, File startingDirectory) {

this.queue = queue;

this.startingDirectory = startingDirectory;

}

public void run() {

try {

enumerate(startingDirectory);

queue.put(DUMMY);//执行到这里说明指定的目录下文件已被遍历完

} catch (InterruptedException e) {

}

// 将指定目录下的所有文件以File对象的形式放入阻塞队列中

public void enumerate(File directory) throws InterruptedException {

File[] files = directory.listFiles();

for (File file : files) {

if (file.isDirectory())

enumerate(file);

else

//将元素放入队尾，如果队列满，则阻塞

queue.put(file);

}

class SearchTask implements Runnable {

private BlockingQueuequeue;

private String keyword;

public SearchTask(BlockingQueuequeue, String keyword) {

this.queue = queue;

this.keyword = keyword;

}

public void run() {

try {

boolean done = false;

while (!done) {

//取出队首元素，如果队列为空，则阻塞

File file = queue.take();

if (file == FileEnumerationTask.DUMMY) {

//取出来后重新放入，好让其他线程读到它时也很快的结束

queue.put(file);

done = true;

} else

search(file);

}

} catch (IOException e) {

e.printStackTrace();

} catch (InterruptedException e) {

}

public void search(File file) throws IOException {

Scanner in = new Scanner(new FileInputStream(file));

int lineNumber = 0;

while (in.hasNextLine()) {

lineNumber++;

String line = in.nextLine();

if (line.contains(keyword))

System.out.printf(“%s:%d:%s%n”, file.getPath(), lineNumber,

line);

}

in.close();

}

篇8：中软Java面试试题

Java面试题目(一)

一、判断题(30分)

1.Java程序里,创建新的类对象用关键字new，回收无用的类对象使用关键字free。

2.对象可以赋值，只要使用赋值号(等号)即可，相当于生成了一个各属性与赋值对象相同的新对象。

3.有的类定义时可以不定义构造函数，所以构造函数不是必需的。

4.类及其属性、方法可以同时有一个以上的修饰符来修饰。

5.Java的屏幕坐标是以像素为单位，容器的左下角被确定为坐标的起点

6.抽象方法必须在抽象类中，所以抽象类中的方法都必须是抽象方法。

7.Final类中的属性和方法都必须被final修饰符修饰。

8.最终类不能派生子类，最终方法不能被覆盖。

9.子类要调用父类的方法，必须使用super关键字。

10.一个Java类可以有多个父类。

11.如果p是父类Parent的对象，而c是子类Child的对象，则语句c = p是正确的。

12.在java集合中，Vector和HashMap是线程安全的。

13.当一个方法在运行过程中产生一个异常，则这个方法会终止，但是整个程序不一定终止运行。

14.接口是特殊的类，所以接口也可以继承，子接口将继承父接口的所有常量和抽象方法。

15.用“+”可以实现字符串的拼接，用- 可以从一个字符串中去除一个字符子串。

二、选择题(30分)

1、关于垃圾收集的哪些叙述是正确的( )：

A.程序开发者必须自己创建一个线程进行内存释放的工作

B.垃圾收集允许程序开发者明确指定并立即释放该内存

C.垃圾收集将检查并释放不再使用的内存

D.垃圾收集能够在期望的时间释放被java对象使用的内存

2、下面的哪些赋值语句是不正确的( )：

A.float f=11.1;

B.double d=5.3E12;

C.double d=3.14159;

D.double d=3.14D;

3、下面关于变量及其范围的陈述哪些是不正确的( )：

A.实例变量是类的成员变量

B.实例变量用关键字static声明

C.在方法中定义的局部变量在该方法被执行时创建

D.局部变量在使用前必须被初始化

4、下列关于修饰符混用的说法，错误的是( )：

A.abstract不能与final并列修饰同一个类

B.abstract类中不可以有private的成员

C.abstract方法必须在abstract类中

D.static方法中能处理非static的属性

5、容器Panel和Applet缺省使用的布局编辑策略是( )：

A、BorderLayout B、FlowLayout C、GridLayout D、CardLayout

6、以下标识符中哪项是不合法的( )：

A、BigMeaninglessName B、$int

C、1 st D、$1

7、main方法是Java Application程序执行的入口点，关于main方法的方法头以下哪项是合法的( )：

A、public static void main()

B、public static void main(String[ ] args)

C、public static int main(String[ ] arg)

D、public void main(String arg[ ])

将本文的Word文档下载到电脑，方便收藏和打印

推荐度：

点击下载文档