BlogJava-流浪的蜗牛-文章分类-Java

Java字符串处理机制

vagasnail — Wed, 04 Nov 2009 12:57:00 GMT

* 简单的总结下：intern()方法
* 这个方法是扣留的意思。呵呵。
* 把当前字符串扣留到池中，然后用同样的字符串时就是从内存池中取，而不会产生新对象，提供效率了撒。
* 都知道我们在JVM中内置了一个字符串池。
* 所有的字面值字符串和字符串赋值常量表达式都用intern()方法进行操作。
* 但是有一点不同，就是通过new生成的字符串对象，这个对象生成了两个字符串对象，
* 一个是字面字符串（这个可以从池中取，或者生成新字符串对象，并扣留到池中），然后在将这个字符串对象
* 的值传给new出来的字符串对象的构造器，生成一个新字符串对象（这个字符串是没有扣留到池中的），记住new关键字总是生成了对象。
* 而我们给这个new出的字符串调用intern()方法，就会把这个字符串对象扣留到池中，而且如果池中有相同的字面值的字符串，
* 就会返回池中的字符串，如果我们将该字符串引用赋给原先字符串的引用变量，那么我们就会省去一个对象，原先的字符串对象就会被某一个时刻回收，
* 如果池中没有相同值的字符串就返回该对象自身。

vagasnail 2009-11-04 20:57 发表评论

Toolkit与AWT

vagasnail — Wed, 04 Nov 2009 12:56:00 GMT

一个 AWT 组件通过一个 Toolkit 对象，与对应的 Peer 对象进行通信，一个本地的对象必须实现了 Peer 接口才可以成为一个 Peer 对象，从而与对应的 AWT 组件通信。因而应用程序程序员无需考虑具体的开发平台，就能进行“ Writer once ， run anywhere ”。

Toolkit 中的方法是一种胶水将 AWT 组件与 Peer 对象连接起来。大多数的程序不应直接调用 Toolkit 中的方法。此类是所有 AWT 实际实现的抽象超类，也就是每个 AWT 组件中应该的都封装了一个 Tookit 的子类的对象，当 AWT 组件要显示的时候（调用 addNotify() ）方法是对应的 peer 对象（ Java 组件在本地环境的实现，并实现对应的 peer 接口）被 Toolkit ，调用相应的方法创建出来，然后调用该 peer 对象实现的 peer 接口，将组件显示出来。然后 AWT 组件和 peer 组件就通过 Toolkit 进行通信。

vagasnail 2009-11-04 20:56 发表评论

Java异常使用的“最佳实践”

vagasnail — Wed, 04 Nov 2009 12:55:00 GMT

下面作者将介绍界中使用异常的最佳实践（ Best Practices for Using Exceptions ）
1 ．总是要做一些清理工作（ Always clean up after yourself ）
如果你使用一些资源例如数据库连接或者网络连接，请记住要做一些清理工作（如
关闭数据库连接或者网络连接），如果你的 API 抛出 Unchecked exception ，那么你
要用 try-finally 来做必要的清理工作：
public void dataAccessCode(){
Connection conn = null;
try{
conn = getConnection();
..some code that throws SQLException
}catch(SQLException ex){
ex.printStacktrace();
} finally{
DBUtil.closeConnection(conn); } }
class DBUtil{
public static void closeConnection
(Connection conn){
try{
conn.close();
} catch(SQLException ex){
logger.error("Cannot close connection");
throw new RuntimeException(ex); } } }
DBUtil 是一个工具类来关闭 Connection. 有必要的说的使用的 finally 的重要性是不
管程序是否碰到异常，它都会被执行。在上边的例子中， finally 中关闭连接，如果
在关闭连接的时候出现错误就抛出 RuntimeException.
2 ．不要使用异常来控制流程（ Never use exceptions for flow control ）
下边代码中， MaximumCountReachedException 被用于控制流程：
public void useExceptionsForFlowControl() {
try {
while (true) {
increaseCount(); }
} catch (MaximumCountReachedException ex) { }
//Continue execution }
public void increaseCount()
throws MaximumCountReachedException {
if (count >= 5000)
throw new MaximumCountReachedException(); }
上边的 useExceptionsForFlowControl() 用一个无限循环来增加 count 直到抛出异常
，这种做法并没有说让代码不易读，但是它是程序执行效率降低。
记住，只在要会抛出异常的地方进行异常处理。
3 ．不要忽略异常
当有异常被抛出的时候，如果你不想恢复它，那么你要毫不犹豫的将其转换为
unchecked exception ，而不是用一个空的 catch 块或者什么也不做来忽略它，以至
于从表面来看象是什么也没有发生一样。
4 ．不要捕获顶层的 Exception
unchecked exception 都是 RuntimeException 的子类， RuntimeException 又继承
Exception, 因此，如果单纯的捕获 Exception, 那么你同样也捕获了
RuntimeException, 如下代码：
try{ ..
}catch(Exception ex){ }
一旦你写出了上边的代码（注意 catch 块是空的），它将忽略所有的异常，包括
unchecked exception.
5 ． Log exceptions just once
Logging the same exception stack trace more than once can confuse the
programmer examining the stack trace about the original source of
exception. So just log it once.
总结
这里给出了一些关于异常处理的一些最佳实践，我并不想开始另一轮的关于 checked
exception 和 unchecked exception 的争论。你可以根据自己的实际情况定制自己
异常处理，我坚信我们将有更好的办法来处理我们代码中的异常。
在此，我将感谢 Bruce Eckel, Joshua Kerievsky, 和 Somik Raha 对于写这篇文章所
给于我的支持。

我的理解：

1 ．尽量不要在发布的程序中使用打印调用栈的信息处理异常，因为这样在发布的程序中根本不可见，就如同忽略处理异常一样。而是要么将其处理，要么将其包装后抛出，我们对于客户端不能处理，也没必要处理的异常通常包装为 RuntimeExcepion 。这样客户程序可以选择是否获取其异常信息，给客户程序一个选择处理的机会。如：显示到客户端。更不要忽略异常，记住只打印调用堆栈和忽略异常是等价的，当然开发及调试的时候除外。

2 ．因为异常是非常消耗资源的，所以不要使用异常做流程控制。

3 ．总是优先使用 UnCheckedException 。

4 ．不要自定义过多的异常类，因为 Java 的异常信息已经将这个异常描述得够清晰了。要么使这个异常类承担更多的责任。

5. 不要将过多的代码写入到一个 try 语句中，通常 try 语句只包含需要处理的代码。

6. Checked 异常只是为了使程序员写出更健壮的代码而发明的。但是由于设计的失误对于一些无法恢复，或者很难恢复的异常也作为 Checked 异常，是一个错误的决定。事实证明不适用的 Checked 异常的 C++ 和 C# 的异常处理机制比 Java 更成功。

7. 不要在程序中包含过多的异常处理语句，这样会使你的语句难以理解，会使你的程序的效率变慢。只在需要的处理的地方处理异常

8. 不要把底层的异常抛给业务层，要么处理要么包装后抛给业务层。因为业务层不关心这个。

9. 对于能处理的异常尽量处理，否则抛出。优先考虑 RuntimeExcepion 包装。

vagasnail 2009-11-04 20:55 发表评论

Java的ClassLoader

vagasnail — Wed, 04 Nov 2009 12:53:00 GMT

  //当前类的getResource等取得本地资源的方法是以当前类所在的文件夹为当前目录，以bin目录
  //也就是发布后的user.dir目录为根目录。
  //当前ClassLoader去本地资源是以bin目录，或发布后的user.dir目录为当前目录。
  //而ClassLoader的根目录恕我不知。
  //通过如下测试，可得出ClassLoader是没有根目录的。
//  URL ss = SoundPlayTest.class.getClassLoader().getResource("");
//  System.out.println(ss.getPath());
  //我想Eclipse没有使用系统的ClassPath，它的ClassPath是在工程的.classpath文件中定义的。而且我想eclipse是使用的自己的ClassLoader的。

ClassLoader的机制：

Bootstrap ClassLoader/启动类加载器
主要负责jdk_home/lib目录下的核心 api 或 -Xbootclasspath 选项指定的jar包装入工作。
Extension ClassLoader/扩展类加载器
主要负责jdk_home/lib/ext目录下的jar包或 -Djava.ext.dirs 指定目录下的jar包装入工作。
System ClassLoader/系统类加载器
主要负责java -classpath/-Djava.class.path所指的目录下的类与jar包装入工作。
User Custom ClassLoader/用户自定义类加载器(java.lang.ClassLoader的子类)
在程序运行期间, 通过java.lang.ClassLoader的子类动态加载class文件, 体现java动态实时类装入特性。

  //getResourceAsStream和ClassLoader.getSystemResourceAsStream的关系
  //首先getResourceAsStream调用自己的ClassLoader加载，如果没有就是用ClassLoader.getSystemResourceAsStream
  //来加载资源。getSystemResourceAsStream从当前ClassLoader的类加载搜索路径中查找资源。所以使用getResourceAsStream
  //也可以加载当前Classpath中的资源。

vagasnail 2009-11-04 20:53 发表评论

Java的HashCode

vagasnail — Wed, 04 Nov 2009 12:52:00 GMT

* 我们可以讲每个Hash地址看做一个Hash桶，而对象就保存在这些桶中，
* 相同的hashcode的对象保存在相同的桶中。
* 而查找对象时，就根据对象的HashCode到Hash表中查找，找到相应的桶，
* 然后再比较它们的equals方法看其是否逻辑相等。如果两项都满足，那么
* 将对象的引用返回。
* hash查找时相当的快的，但是使用equals做比较就比较费时。
* 所以一般来说我们对于HashCode要做到：
* equals相同的对象，必须返回相同的整数类型hashcode，这是必须的。
* 但是为了提高效率，equals为false的对象的，hashCode我们也要使之最大的
* 可能不相同。

vagasnail 2009-11-04 20:52 发表评论

《Effective Java》学习笔记

vagasnail — Wed, 04 Nov 2009 12:51:00 GMT

1、终结函数守卫者
* 通过终结函数守卫者，我们能够保证在外部类对象被回收之前的外部类对象的终结函数的调用
* 应外匿名类的对象的生命周期和Foo相同，而且在回收时先被回收，就守卫了终结函数的调用
* 能够防止忘记或者恶意的不调用终结函数
2、final 变量只能在声明时初始化或者在构造方法中初始化
3、Junit中每次的运行测试案例，将会运行该案例中所有的测试方法。
4、因为HashMap使用Hash桶来放置对象，理想的情况每个Hash桶只有一个对象，但是一般而言很难，甚至可以形成具有相同的HashCode的链表

5、volatile 保证任何一个线程在读取一个域的时候都将会看到最近刚刚被写入的值。
简单的说volatile提供synchronized的可见性，而不提供互斥性。
* 我想volatile，是这用关键字volatile修饰过的变量，放在主内存中而不是线程的工作内存
* 这样每次当该变量的值改变的时候，就会在主内存中改变。
* 而一般的变量，将会在线程的工作内存中保持一份拷贝，然后只在适当的时机，才会将变化写入到主内存
* 对于同步块而言，这个时机就是同步块开始或结束，而其它的时机，我想是在当前使用该变量语句后。
* 当然volatile变量不保证原子性（也就是volatile变量的使用，可能被其它的线程干扰，比如两个线程同时对该变量操作，但是要在高压的情况下才能出现,要实现原子性必须对该变量加锁。），仅保证可见性（总是得到最新修改的值）。

6、计算机无法进行正确的浮点运算，因为计算机是二进制的，我们在 Java 中可以使用BigDecimal、int或者long进行浮点运算，这样可以得到准确的结果。
7、不要使用字符串连接操作符来连接字符串，除非性能无关紧要，否则使用StringBuffer中的append方法，或者使用更好的StringBuilder。
(通常应该优先使用 StringBuilder 类，因为它支持所有相同的操作，但由于它不执行同步，所以速度更快)。
8、添加join后当前线程必须要等待该线程结束后在执行，也就是将该线程加入到当前线程运行周期之内
9、如果不想被恶意攻击，请使用私有的对象监视器。永远不要使用线程组ThreadGroup。
10、serialVersionUID 表示一个可序列化的类的版本信息，我们应该总是提供一个手动的serialVersionUID，而不是由系统自动生成。这样可以保证
类的兼容性和节省略微的性能开销。
11、应该总是实现自定义的序列化，除非一个对象的物理结构和逻辑结构式一样的，即使是这样我们最好也用自定义的序列化，提供一个readObject方法来
保证约束关系和安全性。
12、为了实现序列化的Singleton，那么我们应当提供一个readResolve方法。
13、从本质上来讲，readResolve方法将readObject从事实上的公有构造函数变成事实上的公有静态工厂（针对于反序列化是产生的对象）。

vagasnail 2009-11-04 20:51 发表评论