随笔档案(496)

　　1：清除sam文件：

　　WinNT系列的系统账户信息是存在%systemroot%\system32\config\sam这个注册表文件里的。 如果系统里没有重要的账户，或者账户比较少，用删除%systemroot%\system32\config\sam的方法是比较简单的，不过因为系统会还原为只有administrator（密码为空）和guest二个账户，所以有些程序因为它们所依赖的账户丢失了，如iis、vmware就不能启动了。

　　　原来听说这种方法只能适用于nt workstation系列（2kpro），不能用于server，我在2000professional和2000 advanced server上试验都是成功的。不知道为什么会有上述说法，可能是活动目录ad下不行吧。

　　　当然首先你要能够访问系统分区，来把sam文件改名或者删除。如果是fat32、fat分区，使用98启动盘就行了。如果是ntfs分区，可以使用winternal的ntfs for dos、ntfs for 98或者是支持ntfs的启动光盘，再或者挂到其他win2000、linux等机器上，再再或者重新安装一个新的win2000。 　　

　　2：专用工具：

　　windows管理员密码丢失还有一个解决方法是使用Petter Nordahl-Hagen的The Offline NT Password Editor(http://home.eunet.no/~pnordahl/ntpasswd/)，这个工具是离线修改注册表文件sam来设置密码的。需要用他的映像文件制作启动盘来引导，进而访问ntfs分区重新设置密码；虽然作者经常更新他的程序，不过我还是会担心他直接操作sam文件的安全性，可能有时会导致系统出错。可能还有其他类似工具吧，恕我无知。

　　3：还有一种想法就是用一个修改密码的小程序来替换系统启动的必要程序，然后系统启动时就会替换密码，随后把被替换的程序在还原就行了。当然首先你还是要能够访问系统分区，来替换随系统启动的程序。 　　

　　替换系统启动的必要程序的一种方法是我写的一个清除administrator密码的小程序(CleanPwd：http://www.BingleSite.net/myprog/CleanPwd/CleanPwd.rar)，他所作的就是把administrator密码清空。使用方法如下：

　　1)：用双系统或者启动盘或者挂到别的系统上，如果是NTFS分区其他系统或启动盘要能读写NTFS分区，把windows安装目录下的system32\svchost.exe改名svchost.bak.exe备份，把CleanPwd.exe拷贝成svchost.exe。 　　

　　2)：启动该系统，就把administrator的密码清空了，可以直接登陆。 　　

　　3)：把svchost.bak.exe 恢复就行了（如果使用替换的是svchost，最好再启动rpc服务）。为什么选用svchost.exe而不是其他程序，因为每个windows2000系统都有这几个进程，System(kernel Executive and kernel)、smss(session manager)、csrss(win32 subsystem)、winlogon(logon process)、services(Service control manager)、lsass(local security authentication server ) 如果任何一个被杀掉或者出错，系统将重新启动。不过在lsass启动之前你不能修改密码，所以不能选用这几个程序。

　　另外系统中一般还有以下一些程序：svchost.exe(Remote Procedure Call (RPC) 还有其他一些服务)、WBEM\WinMgmt.exe(Windows Management Instrumentation)、mstask.exe(Task Scheduler)、regsvc.exe(Remote Registry Service) 可能还有其他服务程序，你可能禁止了除RPC之外的其他服务，但不会禁止rpc，否则系统工作就不正常了。所以我选择了svchost，如果你知道其他服务会自动启动，你也可以选择它。当然如果系统安装了杀毒软件的话，你替换杀毒软件也可以，因为一般杀毒软件都会在系统启动是启动杀毒防火墙来杀毒的。

        2007 年将是载入史册的一年，Sun Microsystems 公司将于这一年在开源许可协议下发布 Java 开发包(JDK)，从而放弃了对 Java? 平台的统驭，将权力交给了 Java 开发人员社区!在本文中，Java 开发人员 Elliotte Rusty Harold 从各个方面预测了 Java 平台的新方向，从脚本到 bug 修复到新语法。

　　2006 年又是 Java 平台繁荣的一年。尽管遭遇了来自 Microsoft(C#)和脚本语言社区(Ruby)的冲击，但 Java 语言仍然保持着其世界头号编程语言的地位。同时，尽管 Java 6 的发布很值得庆祝，但比起宣布 Java 将在 GNU General Public License 下完全开源这一事件来说，却不免有些黯然失色。Java 在 2007 年还能保持这种势头吗?让我们来看一下成败的可能。

　　Java 平台将成为开源平台

　　2007 年上半年，Sun 将在一个开源许可协议下发布 Java 开发包(JDK)。解除 JDK 的禁锢对于 Java 开发人员社区来说是巨大的一步，它将在今后的十年中推动 Java 平台的发展。

　　JDK 的质量将会显著改善，因为程序员们不再仅仅报告 bug 并开始修复。Java Developer Connection 的 bug 报告将会包括对 JDK 中的问题部分的详细分析，并提供修复的补丁。正如Linus 法则 所陈述的那样，“只要给予足够的关注，任何 bug 都是显而易见”，即调试是可并行进行的。优化也是一样。开源使两者得以 并行。

　　分支项目

　　遗憾的是，设计并不是和调试、优化一样可以并行完成的。清洁的 API 有时也需要有一只独裁的手。但独裁者的缺点是：有时他们知道在做什么，有时却不知道。意图成为独裁者的各方面之间的竞争往往是发现问题最佳解决方案的惟一方式。

　　很少有公司能够负担得起这样的代价，为一个产品开发多个独立的实现，以便在多个产品中选定保留一个而摒弃其余的产品，但开源社区却在朝这个方向努力。所以，您会在 Java 平台的各个层次中发现分支产品：语言、虚拟机和库。大多数的分支产品会失败，但这没什么。好主意会脱颖而出。一些分支产品会一直存在下去，一些会重新并入标准 JDK 中。明年的这个时候，分支产品与主流产品之间的差异也许不会很明显，但这个过程会继续下去。

　　Sun 会在几个月后发布 Java 7，Dolphin 的一个早期的 beta 版，以此作为开端。Sun 无法发布更早的 JDK 版本，因为存在一些只有在 Dolphin 中才能解决的构建问题和许可协议问题。尽管如此，仍有望看到第三方着手进一步细分 Sun 的版本，来提供 Java 6、Java 5、Java 1.4，甚至更早版本的流行开源实现。

　　早期的一些探寻分支产品的人们可能会侵犯 Sun 公司的商标，收到 Sun 的律师寄来的讨厌的律师信。我们需要一个通用的未注册为商标的名字，让所有人都能使用。我建议用 “J” —— 我希望没人用单字母作商标。

　　开源项目从未消亡，只是有些褪色。就像之前的 Blackdown Project、GNU Classpath、Kaffe 和其他开源 JDK 项目一样，他们的开发人员都转向其他事情了。如果一个项目至今还没有达到 1.0，那么恐怕以后永远也达不到了。

　　期待 Java 7

　　Dolphin 不会在 2007 年发布。2008 年是更为现实的目标。那就是说，工作尚在进行中，它的一些功能也许会作为早期的标准扩展或至少作为 beta 登场。

　　遗憾的是，为一门语言添加功能远比删除功能要简单得多。几乎不可避免地，随着时间的推移，语言不是朝着简单的方向发展，而是越来越复杂，越来越让人困惑。即使是那些单独看起来很好的功能，在彼此叠加后也会出现问题。

　　令人遗憾，Java 社区没有接受这个教训，尽管这种失败并无特殊性。但总有一些太酷又太让人激动的新语法令语言设计者难以抗拒 —— 即便这样的新语法不能解决任何实际问题。于是对 Java 7 的新语言功能就有了巨大的要求，包括闭包、多继承和操作符重载。

　　我猜想在这一年结束前，会在 Java 7 beta 中看到闭包，也许还能看到操作符重载(有五成的把握)，但不会出现多继承。Java 中有太多东西是基于单个根的继承层次。没有可行的方式改进多继承，使之适应这门语言。

　　目前有许多语法糖方面的提议，有一些有意义，有一些没有。许多提议都专注于将像 getFoo() 这样的方法替换为像 -> 这样的操作符。

import java.lang.reflect.*;

/*************************************************
md5 类实现了RSA Data Security, Inc.在提交给IETF
的RFC1321中的MD5 message-digest 算法。
*************************************************/

public class MD5
{
// 下面这些S11-S44实际上是一个4*4的矩阵，这样写是方便修改
static final int S11 = 7;
static final int S12 = 12;
static final int S13 = 17;
static final int S14 = 22;

static final int S21 = 5;
static final int S22 = 9;
static final int S23 = 14;
static final int S24 = 20;

static final int S31 = 4;
static final int S32 = 11;
static final int S33 = 16;
static final int S34 = 23;

static final int S41 = 6;
static final int S42 = 10;
static final int S43 = 15;
static final int S44 = 21;

static final byte[] PADDING = { -128, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

// 下面的三个成员是MD5计算过程中用到的3个核心数据，在原始的C实现中
// 被定义到MD5_CTX结构中

private long[] state = new long[4];    // state (ABCD)
private long[] count = new long[2];    // number of bits, modulo 2^64 (lsb first)
private byte[] buffer = new byte[64]; // input buffer

// digestHexStr是MD5的唯一一个公共成员，是最新一次计算结果的
//    16进制ASCII表示.

public String digestHexStr;

// digest,是最新一次计算结果的2进制内部表示，表示128bit的MD5值.

private byte[] digest = new byte[16];

// getMD5ofStr是类MD5最主要的公共方法，入口参数是你想要进行MD5变换的字符串
//    返回的是变换完的结果，这个结果是从公共成员digestHexStr取得的．
  
public String getMD5ofStr(String inbuf)
{
    md5Init();
    md5Update(inbuf.getBytes(), inbuf.length());
    md5Final();
    digestHexStr = "";
    for (int i = 0; i < 16; i++)
    {
     digestHexStr += byteHEX(digest[i]);
    }
    return digestHexStr;
}

// 这是MD5这个类的标准构造函数，JavaBean要求有一个public的并且没有参数的构造函数
public MD5()
{
    md5Init();
    return;
}

// md5Init是一个初始化函数，初始化核心变量，装入标准的幻数

private void md5Init()
{
    count[0] = 0L;
    count[1] = 0L;
    // Load magic initialization constants.

    state[0] = 0x67452301L;
    state[1] = 0xefcdab89L;
    state[2] = 0x98badcfeL;
    state[3] = 0x10325476L;

    return;
}

// F, G, H ,I 是4个基本的MD5函数，在原始的MD5的C实现中，由于它们是
//    简单的位运算，可能出于效率的考虑把它们实现成了宏，在java中，我们把它们
// 实现成了private方法，名字保持了原来C中的。
  
private long F(long x, long y, long z) {
    return (x & y) | ((~x) & z);
}
private long G(long x, long y, long z) {
    return (x & z) | (y & (~z));
}
private long H(long x, long y, long z) {
    return x ^ y ^ z;
}
private long I(long x, long y, long z) {
    return y ^ (x | (~z));
}

// FF,GG,HH和II将调用F,G,H,I进行近一步变换

private long FF(long a, long b, long c, long d, long x, long s,long ac) {
    a += F (b, c, d) + x + ac;
    a = ((int) a << s) | ((int) a >>> (32 - s));
    a += b;
    return a;
}

private long GG(long a, long b, long c, long d, long x, long s,long ac) {
    a += G (b, c, d) + x + ac;
    a = ((int) a << s) | ((int) a >>> (32 - s));
    a += b;
    return a;
}
private long HH(long a, long b, long c, long d, long x, long s,long ac) {
    a += H (b, c, d) + x + ac;
    a = ((int) a << s) | ((int) a >>> (32 - s));
    a += b;
    return a;
}
private long II(long a, long b, long c, long d, long x, long s,long ac) {
    a += I (b, c, d) + x + ac;
    a = ((int) a << s) | ((int) a >>> (32 - s));
    a += b;
    return a;
}

// md5Update是MD5的主计算过程，inbuf是要变换的字节串，inputlen是长度，这个
// 函数由getMD5ofStr调用，调用之前需要调用md5init，因此把它设计成private的
  
private void md5Update(byte[] inbuf, int inputLen) {
    int i, index, partLen;
    byte[] block = new byte[64];
    index = (int)(count[0] >>> 3) & 0x3F;
    // /* Update number of bits */
    if ((count[0] += (inputLen << 3)) < (inputLen << 3))
     count[1]++;
    count[1] += (inputLen >>> 29);

    partLen = 64 - index;

    // Transform as many times as possible.
    if (inputLen >= partLen) {
     md5Memcpy(buffer, inbuf, index, 0, partLen);
     md5Transform(buffer);

     for (i = partLen; i + 63 < inputLen; i += 64) {

      md5Memcpy(block, inbuf, 0, i, 64);
      md5Transform (block);
     }
     index = 0;

    } else
     i = 0;

    ///* Buffer remaining input */
    md5Memcpy(buffer, inbuf, index, i, inputLen - i);
}
private void md5Final () {
    byte[] bits = new byte[8];
    int index, padLen;

    ///* Save number of bits */
    Encode (bits, count, 8);

    ///* Pad out to 56 mod 64.
    index = (int)(count[0] >>> 3) & 0x3f;
    padLen = (index < 56) ? (56 - index) : (120 - index);
    md5Update (PADDING, padLen);

    ///* Append length (before padding) */
    md5Update(bits, 8);

    ///* Store state in digest */
    Encode (digest, state, 16);
}

// md5Memcpy是一个内部使用的byte数组的块拷贝函数，从input的inpos开始把len长度的
    //    字节拷贝到output的outpos位置开始
  
private void md5Memcpy (byte[] output, byte[] input,int outpos, int inpos, int len){
    int i;

    for (i = 0; i < len; i++)
     output[outpos + i] = input[inpos + i];
}

// md5Transform是MD5核心变换程序，有md5Update调用，block是分块的原始字节
  
private void md5Transform (byte block[]) {
    long a = state[0], b = state[1], c = state[2], d = state[3];
    long[] x = new long[16];

    Decode (x, block, 64);

    /* Round 1 */
    a = FF (a, b, c, d, x[0], S11, 0xd76aa478L); /* 1 */
    d = FF (d, a, b, c, x[1], S12, 0xe8c7b756L); /* 2 */
    c = FF (c, d, a, b, x[2], S13, 0x242070dbL); /* 3 */
    b = FF (b, c, d, a, x[3], S14, 0xc1bdceeeL); /* 4 */
    a = FF (a, b, c, d, x[4], S11, 0xf57c0fafL); /* 5 */
    d = FF (d, a, b, c, x[5], S12, 0x4787c62aL); /* 6 */
    c = FF (c, d, a, b, x[6], S13, 0xa8304613L); /* 7 */
    b = FF (b, c, d, a, x[7], S14, 0xfd469501L); /* 8 */
    a = FF (a, b, c, d, x[8], S11, 0x698098d8L); /* 9 */
    d = FF (d, a, b, c, x[9], S12, 0x8b44f7afL); /* 10 */
    c = FF (c, d, a, b, x[10], S13, 0xffff5bb1L); /* 11 */
    b = FF (b, c, d, a, x[11], S14, 0x895cd7beL); /* 12 */
    a = FF (a, b, c, d, x[12], S11, 0x6b901122L); /* 13 */
    d = FF (d, a, b, c, x[13], S12, 0xfd987193L); /* 14 */
    c = FF (c, d, a, b, x[14], S13, 0xa679438eL); /* 15 */
    b = FF (b, c, d, a, x[15], S14, 0x49b40821L); /* 16 */

    /* Round 2 */
    a = GG (a, b, c, d, x[1], S21, 0xf61e2562L); /* 17 */
    d = GG (d, a, b, c, x[6], S22, 0xc040b340L); /* 18 */
    c = GG (c, d, a, b, x[11], S23, 0x265e5a51L); /* 19 */
    b = GG (b, c, d, a, x[0], S24, 0xe9b6c7aaL); /* 20 */
    a = GG (a, b, c, d, x[5], S21, 0xd62f105dL); /* 21 */
    d = GG (d, a, b, c, x[10], S22, 0x2441453L); /* 22 */
    c = GG (c, d, a, b, x[15], S23, 0xd8a1e681L); /* 23 */
    b = GG (b, c, d, a, x[4], S24, 0xe7d3fbc8L); /* 24 */
    a = GG (a, b, c, d, x[9], S21, 0x21e1cde6L); /* 25 */
    d = GG (d, a, b, c, x[14], S22, 0xc33707d6L); /* 26 */
    c = GG (c, d, a, b, x[3], S23, 0xf4d50d87L); /* 27 */
    b = GG (b, c, d, a, x[8], S24, 0x455a14edL); /* 28 */
    a = GG (a, b, c, d, x[13], S21, 0xa9e3e905L); /* 29 */
    d = GG (d, a, b, c, x[2], S22, 0xfcefa3f8L); /* 30 */
    c = GG (c, d, a, b, x[7], S23, 0x676f02d9L); /* 31 */
    b = GG (b, c, d, a, x[12], S24, 0x8d2a4c8aL); /* 32 */

    /* Round 3 */
    a = HH (a, b, c, d, x[5], S31, 0xfffa3942L); /* 33 */
    d = HH (d, a, b, c, x[8], S32, 0x8771f681L); /* 34 */
    c = HH (c, d, a, b, x[11], S33, 0x6d9d6122L); /* 35 */
    b = HH (b, c, d, a, x[14], S34, 0xfde5380cL); /* 36 */
    a = HH (a, b, c, d, x[1], S31, 0xa4beea44L); /* 37 */
    d = HH (d, a, b, c, x[4], S32, 0x4bdecfa9L); /* 38 */
    c = HH (c, d, a, b, x[7], S33, 0xf6bb4b60L); /* 39 */
    b = HH (b, c, d, a, x[10], S34, 0xbebfbc70L); /* 40 */
    a = HH (a, b, c, d, x[13], S31, 0x289b7ec6L); /* 41 */
    d = HH (d, a, b, c, x[0], S32, 0xeaa127faL); /* 42 */
    c = HH (c, d, a, b, x[3], S33, 0xd4ef3085L); /* 43 */
    b = HH (b, c, d, a, x[6], S34, 0x4881d05L); /* 44 */
    a = HH (a, b, c, d, x[9], S31, 0xd9d4d039L); /* 45 */
    d = HH (d, a, b, c, x[12], S32, 0xe6db99e5L); /* 46 */
    c = HH (c, d, a, b, x[15], S33, 0x1fa27cf8L); /* 47 */
    b = HH (b, c, d, a, x[2], S34, 0xc4ac5665L); /* 48 */

    /* Round 4 */
    a = II (a, b, c, d, x[0], S41, 0xf4292244L); /* 49 */
    d = II (d, a, b, c, x[7], S42, 0x432aff97L); /* 50 */
    c = II (c, d, a, b, x[14], S43, 0xab9423a7L); /* 51 */
    b = II (b, c, d, a, x[5], S44, 0xfc93a039L); /* 52 */
    a = II (a, b, c, d, x[12], S41, 0x655b59c3L); /* 53 */
    d = II (d, a, b, c, x[3], S42, 0x8f0ccc92L); /* 54 */
    c = II (c, d, a, b, x[10], S43, 0xffeff47dL); /* 55 */
    b = II (b, c, d, a, x[1], S44, 0x85845dd1L); /* 56 */
    a = II (a, b, c, d, x[8], S41, 0x6fa87e4fL); /* 57 */
    d = II (d, a, b, c, x[15], S42, 0xfe2ce6e0L); /* 58 */
    c = II (c, d, a, b, x[6], S43, 0xa3014314L); /* 59 */
    b = II (b, c, d, a, x[13], S44, 0x4e0811a1L); /* 60 */
    a = II (a, b, c, d, x[4], S41, 0xf7537e82L); /* 61 */
    d = II (d, a, b, c, x[11], S42, 0xbd3af235L); /* 62 */
    c = II (c, d, a, b, x[2], S43, 0x2ad7d2bbL); /* 63 */
    b = II (b, c, d, a, x[9], S44, 0xeb86d391L); /* 64 */

    state[0] += a;
    state[1] += b;
    state[2] += c;
    state[3] += d;
}

// Encode把long数组按顺序拆成byte数组，因为java的long类型是64bit的，
// 只拆低32bit，以适应原始C实现的用途
  
private void Encode (byte[] output, long[] input, int len)
{
    int i, j;

    for (i = 0, j = 0; j < len; i++, j += 4) {
     output[j] = (byte)(input[i] & 0xffL);
     output[j + 1] = (byte)((input[i] >>> 8) & 0xffL);
     output[j + 2] = (byte)((input[i] >>> 16) & 0xffL);
     output[j + 3] = (byte)((input[i] >>> 24) & 0xffL);
    }
}

// Decode把byte数组按顺序合成成long数组，因为java的long类型是64bit的，
    //    只合成低32bit，高32bit清零，以适应原始C实现的用途
  
private void Decode (long[] output, byte[] input, int len)
{
    int i, j;

    for (i = 0, j = 0; j < len; i++, j += 4)
     output[i] = b2iu(input[j]) |
      (b2iu(input[j + 1]) << 8) |
      (b2iu(input[j + 2]) << 16) |
      (b2iu(input[j + 3]) << 24);

     return;
}

// b2iu是一个把byte按照不考虑正负号的原则的＂升位＂程序，因为java没有unsigned运算
  
public static long b2iu(byte b) {
    return b < 0 ? b & 0x7F + 128 : b;
}

// byteHEX()，用来把一个byte类型的数转换成十六进制的ASCII表示，
//     因为java中的byte的toString无法实现这一点，我们又没有C语言中的
//     sprintf(outbuf,"%02X",ib)
  
    public static String byteHEX(byte ib)
{
     char[] Digit = { '0','1','2','3','4','5','6','7','8','9',
      'A','B','C','D','E','F' };
     char [] ob = new char[2];
     ob[0] = Digit[(ib >>> 4) & 0X0F];
     ob[1] = Digit[ib & 0X0F];
     String s = new String(ob);
     return s;
}

public static String toMD5(String source)
{
    MD5 md5 = new MD5();
    return md5.getMD5ofStr(source);
}

public static void main(String[] args)
{
MD5 md5 = new MD5();
System.out.println(md5.toMD5(args[0]));
}
}

先编译javac MD5.java,后带字符串参数运行,如:java MD5 abc

//结果生成 32位的加密字符串，有的实例中截取的是加密字串的 8--24位，长度为16位．

         Java技术自问世时光已经过去了9个年头。作为一名一直关注其成长的记者，曾经一段时间有过这样的想法：“Java技术已经成熟，是不是发展速度该放慢一些了呢”。然而，这种想法错了。近来Java技术的进化相当显著。Java技术正在迎来“又一次革命”的风暴。这就是本文的结论。

　　“又一次”指的是什么？“革命”指的又是什么？光看结论的话肯定是一头雾水。其实，笔者要讲的并不是变化这样一个事实，而是“促进变化的原动力”。是什么让Java技术发生变化？让我们从这一角度出发，先看一下Java的变化历程。

　　Java正处于转变期

　　回顾Java技术的发展历程，人们一定会感慨：2004年到2005年发生的变化如此之大，可以说“现在”正是Java技术的转换期。 Java技术由编程语言（Java语言）、运行环境（JVM：Java虚拟机）、框架（Java API群）组成，目前在每一个层面上都发生着巨大的变化。

　　（1）编程语言的变化

　　Java语言标准出现明显变化。在2004年9月发布的正式版本J2SE5.0（J2SE:Java2 Standard, Standard Edition，Java技术的核心运行环境）中，对Java语言标准中的Generics与元数据进行了大幅扩展。出现了被认为是“自Java问世以来的最大一次语言标准变化”（美国Sun Microsystems）。这次语言标准的变化给许多Java API带来了影响。许多企业API的新版本都引入了基于元数据的注解（程序中记录的附加信息），以较短的编码记述更多的信息。

　　（2）Java运行环境的变化

　　在J2SE5.0中，大幅度强化了JVM的管理功能与实用性，换句话说就是具备了Java执行OS（操作系统）的特征。例如，原来在J2EE （Java2 Platform, Enterprise Edition，构筑企业系统的Java技术）领域，标准配备有作为管理功能的应用软件管理框架JMX。不仅如此，还配备有JVM自身监控功能（（JSR 174: Monitoring and Management Specification for the Java Virtual Machine）。在标准功能架构中可以实时监视JVM运行时的状态，也就是内存使用量、线程状态等。

　　J2SE5.0中新追加的功能中包括并行处理实用程序（JSR 166），其基础是纽约州立大学Doug Lea提供的程序库。也就是说，标准规格中采用了来自民间的程序库。

　　（3）框架的变化

　　服务器端的Java框架也发生了巨大变化。企业级Java技术--J2EE的“使用方法”说明文件“J2EE Blueprint”中，提出了将应用软件分为Web层、EJB层（Enterprise JavaBeans，将包括事务处理在内的业务进程模块化的框架）来构筑的思路。这两种层次都迎来了架构更替时期。Web层的新框架为JSF （JavaServer Faces，将模块组合起来构筑Web应用程序的框架），EJB层为标准方案中刚刚公布的下一代EJB规格“EJB3.0”。

　　值得注意的是，促成框架发生变化的正是来自民间的源码开放软件。

　　对JSF产生影响的是作为源码开放的Web层框架得到普及的Apache Struts。JSF是对Struts的思路进行改进的产物，JSF的Spec Lead（规格制定领袖）之一Craig R. McClanahan就是Struts的作者。

        对EJB3.0造成影响的也是民间源码开放软件。EJB3.0引入了DI（Dependency Injection，依赖注入）容器类（Container）与POJO（Plain Old Java Object）持久类这些新功能，大大减轻了编程的复杂性。这些概念因PicoContainer、Spring等源码开放软件的导入而引人注目。

　　其背景在于用户对“目前的EJB过于复杂”的批评。原本由EJB反对派提出的设计思想与源码开放软件，却变成了EJB3.0的中心概念，显出了巨大的影响力。

　　（4）脚本语言

　　在Java技术标准中新增加了编程语言Groovy（JSR 241）。这是一种可与Java语言无缝连接的脚本语言，有望以极短的程序完成相关处理。“在Java技术中添加Java以外的语言”，这听起来也许有些别扭，其实以前就有这样的呼声，希望将可以充分利用Java技术资源的脚本作为语言使用。Groovy本来是源码开放软件，最终得到认可，被采纳为标准规格。

　　由上述可以看出，Java技术的构成要素正在发生巨大变化。就在不久以前，一提起服务器Java，“Servlet、JSP、EJB是重要的 API”这样的说明还占主流，但现在基于JSF和EJB3.0的应用程序已经变成了“面目全非”的程序。而在运行短程序或测试时，甚至还出现了不仅是 Java语言，连脚本语言都开始调用Java框架的情况。

　　这些变化从大的方面来看的话，可以说是进一步发挥了Java面向对象的优势。当然，也包括提高开发效率、提高运行稳定性、简化运行管理等业务上的优势。

　　开发者团体是真正的“变革推动者”

　　那么，这些变化的原动力来自哪里呢？为什么说“目前”正面临着“又一次变革”呢？理由如下：

　　在Java技术的发展过程中，1999年到2000年是一个大的转折点。J2EE概念于1999年出现。日本国内的J2EE也在随后2～3年内得到正式普及，但这一技术体系早在5年前就已经确立。在我们眼前，新一代Java技术的轮廓正逐渐显现出来。

　　JCP（Java Community Process）2.0于2000年问世。以会员制的组织形式推进Java技术的规格制订、总体发展方向则以委员会的方式决定。从而形成了不依赖特定企业的规格制订流程。这一组织形式历经近5年的时间，逐渐发展成“变革的推动者”。

　　J2EE此前一直饱受批评，认为“Web层与EJB层的差距太大”、“EJB过于复杂”，但这也是因为这是一项实际使用的技术。JCP同样也遇到很多批评，称其“没有完全公开”、“制定的技术标准却不可思议地让Sun拥有知识产权”，但JCP却作为一个团体不断发展壮大。

　　直接推动Java技术变化的当事者为5年前形成的基于团体的标准制订流程--JCP，但真正将讨论与技术纳入JCP的却是包括Java技术批评者在内的众多Java开发者团体。他们也是早期开展Java技术变革的先行者。由此诞生的下一代技术将会在2～3年后逐渐波及主流企业用户。

　　Java技术的“变革推动者”为开发者团体。不受制于特定企业，通过众多需要Java的开发者的建议，Java技术正在不断发展进步。

import java.security.*;

public class MD5 {

      /**
      * 字符串加密方法。传入一个字符串，返回经过<b>MD5</b>加密后的一个字符串
      *   @param   strInput
      *   @return
       */
      public    static   String encryptMD5(String strInput) {
         StringBuffer buf=null;
         try {
             MessageDigest md = MessageDigest.getInstance("MD5");
             md.update(strInput.getBytes());
             byte b[] = md.digest();
              buf = new StringBuffer(b.length * 2);
             for(int i=0;i<b.length;i++) {
                 if (((int)b[i] & 0xff) < 0x10) { // & 0xff转换无符号整型
                     buf.append("0");
                 }
                // buf.append(Long.toString((int) b[i] & 0xff, 16));//转换16进制,下方法同
                buf.append(Long.toHexString((int)b[i] & 0xff));
             }
         }catch(NoSuchAlgorithmException ex) {
              ex.printStackTrace();
         }
        return buf.toString();
     }

      public    static    void   main(String args[]) {
         String test   =    "abc" ;
         System.out.println(encryptMD5(test));
     }
}

/**
* 下面是一些测试数据：
*   MD5 ("") = d41d8cd98f00b204e9800998ecf8427e
*
*   MD5 ("a") = 0cc175b9c0f1b6a831c399e269772661
*
*   MD5 ("abc") = 900150983cd24fb0d6963f7d28e17f72
*
*   MD5 ("message digest") = f96b697d7cb7938d525a2f31aaf161d0
*
*   MD5 ("abcdefghijklmnopqrstuvwxyz") = c3fcd3d76192e4007dfb496cca67e13b
*/

/* 主要使用的是java.util.Robot类来捕获屏幕,
* 可以实现对屏幕一个矩形区域的捕获,通过这个类,
* 我们也可以实现一个远程桌面控制的程序
*/

package com.qiu.util;
import java.io.*;
import java.net.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import javax.imageio.*;
import java.io.*;

public class ScreenCapture {
//test main
public static void main(String[] args) throws Exception{
   String userdir = System.getProperty("user.dir");
   File tempFile = new File("d:","temp.png");
   ScreenCapture capture = ScreenCapture.getInstance();
   capture.captureImage();  
   JFrame frame = new JFrame();
   JPanel panel = new JPanel();
   panel.setLayout(new BorderLayout());
   JLabel imagebox = new JLabel();
   panel.add(BorderLayout.CENTER,imagebox);  
   imagebox.setIcon(capture.getPickedIcon());
   capture.saveToFile(tempFile);
   capture.captureImage();
   imagebox.setIcon(capture.getPickedIcon());
   frame.setContentPane(panel);
   frame.setSize(400,300);
   frame.show();
   System.out.println("Over");
}

private ScreenCapture() {
  
   try{
    robot = new Robot();
   }
   catch(AWTException e) {
    System.err.println("Internal Error: " + e);
    e.printStackTrace();
   }  
   JPanel cp = (JPanel)dialog.getContentPane();
   cp.setLayout(new BorderLayout());  
   labFullScreenImage.addMouseListener(new MouseAdapter() {
     public void mouseReleased(MouseEvent evn) {
       isFirstPoint = true;
       pickedImage = fullScreenImage.getSubimage(recX,recY,recW,recH);
       dialog.setVisible(false);     
     }
    });
   
   labFullScreenImage.addMouseMotionListener(new MouseMotionAdapter() {
     public void mouseDragged(MouseEvent evn) {
      if(isFirstPoint) {
       x1 = evn.getX();
       y1 = evn.getY();
       isFirstPoint = false;  
      }
      else {
       x2 = evn.getX();
       y2 = evn.getY();
       int maxX = Math.max(x1,x2);
       int maxY = Math.max(y1,y2);
       int minX = Math.min(x1,x2);
       int minY = Math.min(y1,y2);
       recX = minX;
       recY = minY;
       recW = maxX-minX;
       recH = maxY-minY;
       labFullScreenImage.drawRectangle(recX,recY,recW,recH);    
      }
     }
    
     public void mouseMoved(MouseEvent e) {
      labFullScreenImage.drawCross(e.getX(),e.getY());
     }
    });
   
   cp.add(BorderLayout.CENTER,labFullScreenImage);
   dialog.setCursor(Cursor.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR));
   dialog.setAlwaysOnTop(true);
   dialog.setMaximumSize(
    Toolkit.getDefaultToolkit().getScreenSize());
   dialog.setUndecorated(true);
   dialog.setSize(dialog.getMaximumSize());
   dialog.setModal(true);
}
//Singleton Pattern
public static ScreenCapture getInstance() {
   return defaultCapturer;
}
/**捕捉全屏慕*/
public Icon captureFullScreen() {
   fullScreenImage = robot.createScreenCapture(new Rectangle(
    Toolkit.getDefaultToolkit().getScreenSize()));
   ImageIcon icon = new ImageIcon(fullScreenImage);
   return icon;
}
/**捕捉屏幕的一个矫形区域
   */
public void captureImage() {
   fullScreenImage = robot.createScreenCapture(new Rectangle(
    Toolkit.getDefaultToolkit().getScreenSize()));
   ImageIcon icon = new ImageIcon(fullScreenImage);
   labFullScreenImage.setIcon(icon);  
   dialog.setVisible(true);
}
/**得到捕捉后的BufferedImage*/
public BufferedImage getPickedImage() {
   return pickedImage;
}
/**得到捕捉后的Icon*/
public ImageIcon getPickedIcon() {
   return new ImageIcon(getPickedImage());
}
/**储存为一个文件,为PNG格式
  *@deprecated
   *replaced by saveAsPNG(File file)
   **/
@Deprecated
public void saveToFile(File file) throws IOException{
   ImageIO.write(getPickedImage(),defaultImageFormater,file);
}
/**储存为一个文件,为PNG格式*/
public void saveAsPNG(File file) throws IOException {
   ImageIO.write(getPickedImage(),"png",file);
}
/**储存为一个JPEG格式图像文件*/
public void saveAsJPEG(File file) throws IOException {
   ImageIO.write(getPickedImage(),"JPEG",file);
}

/**写入一个OutputStream*/
public void write(OutputStream out) throws IOException{
   ImageIO.write(getPickedImage(),defaultImageFormater,out);
}

//singleton design pattern
private static ScreenCapture defaultCapturer = new ScreenCapture();
private int x1,y1,x2,y2;
private int recX,recY,recH,recW; //截取的图像
private boolean isFirstPoint   = true;
private BackgroundImage labFullScreenImage = new BackgroundImage();
private Robot robot;
private BufferedImage fullScreenImage;
private BufferedImage pickedImage;
private String defaultImageFormater = "png";
private JDialog dialog = new JDialog();
}

/**显示图片的Label*/
class BackgroundImage extends JLabel{
public void paintComponent(Graphics g) {
   super.paintComponent(g);
   g.drawRect(x,y,w,h);
   String area = Integer.toString(w)+" * "+ Integer.toString(h);
   g.drawString(area,x+(int)w/2-15,y+(int)h/2);
   g.drawLine(lineX,0,lineX,getHeight());
   g.drawLine(0,lineY,getWidth(),lineY);
}

public void drawRectangle(int x,int y,int width,int height) {
   this.x = x;
   this.y = y;
   h = height;
   w = width;
   repaint();
}

public void drawCross(int x,int y) {
   lineX = x;
   lineY = y;
   repaint();
}

int lineX,lineY;
int x,y,h,w;
}

import java.io.*;

public class FileReadTest
{
public static void main(String[] args)
{
   FileReadTest t = new FileReadTest();
   t.readMyFile();
}
void readMyFile()
{
   String temp = null;
   int count = 0;
   try
   {
    FileReader fr = new FileReader("mydata.txt");
    BufferedReader br = new BufferedReader(fr);
    temp = new String();
    while((temp = br.readLine()) != null)
    {
     count++;
     System.out.println(count + ":" + temp);
    }
    br.close();
    fr.close();
   }
   catch(IOException e)
   {
    System.out.println("OH,got an IOException error!");
    e.printStackTrace();
   }
}
}

import java.io.*;

public class FileInputDemo
{
public static void main(String[] args)
{
   try
   {
    FileInputStream f = new FileInputStream("mydata.txt");
    DataInputStream in = new DataInputStream(f);
    //BufferedReader br = new BufferedReader(new InputStreamReader(f));
    while(in.available() != 0)
     System.out.println(in.readLine());
     /**
      * DataInputStream.readLine()已经过时
      * 使用 DataInputStream 类读取文本行的程序可以改为使用BufferedReader类
      * 改用BufferedReader.readLine()方法
      * 只要将以下形式的代码：DataInputStream d = new DataInputStream(in);
      * 替换为：BufferedReader d = new BufferedReader(new InputStreamReader(in));
      */
    in.close();
   }
   catch(Exception e)
   {
    System.err.println("File input error!");
   }
}
}

import java.io.*;

public class FileWriterTest
{
public static void main(String[] args)
{
   FileWriterTest t = new FileWriterTest();
   t.WriteMyFile();
}

void WriteMyFile()
{
   try
   {
    FileWriter fw = new FileWriter("mydata.txt");
    PrintWriter out =new PrintWriter(fw);
    out.print("Hello,World!");
    out.close();
    fw.close();
   }
   catch(IOException e)
   {
    System.out.println("OH,got an IOException error!");
    e.printStackTrace();
   }
}
}

1

//用FileOutputStream将内容写入文本文件

import java.io.*;
public class FileOutputDemo
{
public static void main(String[] args)
{
   FileOutputStream out;
   PrintStream p;
   try
   {
    out = new FileOutputStream("myfile.txt");
    p = new PrintStream(out);
    p.println("Hello,World!");
    p.close();
   }
   catch(Exception e)
   {
    System.err.println("Error writing to file!");
   }
}

}

2

import java.io.*;

class FSODemo
{
   public static void main(String args[]) throws Exception
   {
     String source="Beijing is the capital of China\n"
     +"and it is a very beautiful city.\n"
     +"Welcome to Beijing!";
     byte buf[] = source.getBytes();
     FileOutputStream f=new FileOutputStream("file.txt");
     f.write(buf);
     f.close();
     System.out.println("文本已经成功写入文件！");
   }
}