中文编码基础知识介绍(理论基础)

Java 编程技术中汉字问题的分析及解决

String.getBytes()方法中的中文编码问题 （这篇最为简单易懂且结合实际）

Unicode和UTF-8之间的转换详解

附录：

unicode编码表

GBK
汉字内码扩展规范编码表(二)

代码示例：

public String changeCharset(String str)
            throws UnsupportedEncodingException {
        if (str != null) {
           //得到gbk编码的字节串
             byte[] bs = str.getBytes(”GBK”);
             System.out.println(”gbk:”);          
             System.out.println(”hex format is:”+encodeHex(bs));
          //得到utf8编码的字节串 
             byte[] ns = str.getBytes(”UTF-8″);
             System.out.println(”utf8:”);         
             System.out.println(”hex format is:”+encodeHex(ns));
             System.out.println(”Bin format is:”+encodeBin(ns)
                );
         //将编码为utf8的字节串再生成新的字符串，然后解码，看看转换过程中是否出错
             String newutf=new String(ns,”UTF-8″);
             System.out.println(”convert back from utf8:”+encodeHex(newutf.getBytes(”UTF-8″)));
             return newutf;
}

public static final String encodeHex (byte[] bytes)
    {
        StringBuffer buff =
        new StringBuffer(bytes.length * 2);
        String b;
        for (int i=0; i<bytes.length ; i++)
        {
            b = Integer.toHexString(bytes[i]); 
            // byte是两个字节的， 而上面的Integer.toHexString会把字节扩展为4个字节
            buff.append(b.length() > 2 ? b.substring(6,8) : b); 
            buff.append(” “);
        }
        return buff.toString();
    }
public static final String encodeBin (byte[] bytes)
    {
        StringBuffer buff =
        new StringBuffer(bytes.length * 2);
        String b;
        for (int i=0; i<bytes.length ; i++)
        {
            b = Integer.toBinaryString(bytes[i]); 
            // byte是两个字节的， 而上面的Integer.toHexString会把字节扩展为4个字节
            buff.append(b.substring(24,b.length())); 
            buff.append(” “);
        }
        return buff.toString();
    }

在Java中，String.getBytes(”GBK”)获得的是gbk编码的字节串，打印出来之后得到的是对应编码的十进制值，转换成16进制后就和编码表中的值一样了。
最后可以根据输出的二进制编码，和unicode表对比。

示例：
str: 中国
gbk:
hex format is:d6 d0 b9 fa
utf8:
hex format is:e4 b8 ad e5 9b bd
Bin format is:11100100 10111000 10101101 11100101 10011011 10111101
convert back from utf8:e4 b8 ad e5 9b bd
其中，“中”的unicode编码是4e2d，二进制表示为0100 1110 0010 1101，从低位到高位按六位截取及补齐高位后就可以得到11100100 10111000 1010110 ，即为utf8编码。

Java线程要点：
http://www.jdon.com/concurrent/thread.htm
http://dev2dev.bea.com.cn/bbs/thread.jspa?forumID=126&threadID=19439&tstart=0

线程基础：

线程（thread）是"进程"中某个单一顺序的控制流。
也被称为轻量进程（lightweight processes）。计算机科学术语，指运行中的程序的调度单位。

  线程是进程中的实体，一个进程可以拥有多个线程，一个线程必须有一个父进程。
线程不拥有系统资源，只有运行必须的一些数据结构；它与父进程的其它线程共享该进程所拥有的全部资源。
线程可以创建和撤消线程，从而实现程序的并发执行。一般，线程具有就绪、阻塞和运行三种基本状态。

  在多中央处理器的系统里，不同线程可以同时在不同的中央处理器上运行，甚至当它们属于同一个进程时
也是如此。大多数支持多处理器的操作系统都提供编程接口来让进程可以控制自己的线程与各处理器之间
的关联度（affinity）。

   有时候，线程也称作轻量级进程。就象进程一样，线程在程序中是独立的、并发的执行路径，
每个线程  有它自己的堆栈、自己的程序计数器和自己的局部变量。
但是，与分隔的进程相比，进程中的线程之间的隔离程度要小。
它们共享内存、文件句柄和其它每个进程应有的状态。

    进程可以支持多个线程，它们看似同时执行，但互相之间并不同步。
一个进程中的多个线程共享相同的内存地址空间，这就意味着它们可以访问相同的变量和对象，
而且它们从同一堆中分配对象。尽管这让线程之间共享信息变得更容易，
但您必须小心，确保它们不会妨碍同一进程里的其它线程。

   一个程序或进程能够包含多个线程，这些线程可以根据程序的代码执行相应的指令。
多线程看上去似乎在并行执行它们各自的工作，就像在一台计算机上运行着多个处理机一样。
在多处理机计算机上实现多线程时，它们确实可以并行工作。
和进程不同的是，线程共享地址空间。也就是说，多个线程能够读写相同的变量或数据结构。

×××××××××××××××××××××××
以上总之一句话，线程可以共享地址空间。
下面为java实现线程的两种方法，以及启动线程、停止线程、同步线程和线程间通信的Java实现方法。
不涉及线程基本理论的讨论。
×××××××××××××××××××××

在Java中实现一个线程有两种方法，第一是实现Runnable接口实现它的run()方法，第二种是继承Thread类，覆盖它的run()方法。下面是代码示例：

 　　public class DoSomething implements Runnable {
public void run(){
// here is where you do something
}
}
public class DoAnotherThing extends Thread {
public void run(){
// here is where you do something
}
}

这两种方法的区别是，如果你的类已经继承了其它的类，那么你只能选择实现Runnable接口了，因为Java只允许单继承的。

Java中的线程有四种状态分别是：运行、就绪、挂起、结束。如果一个线程结束了也就说明他是一个死线程了。当你调用一个线程实例的start()的方法的时候，这个时候线程进入就绪状态，注意并不是运行状态，当虚拟机开始分配给他CPU的运行时间片的时候线程开始进入运行状态，当线程进入等待状态，例如等待某个事件发生的时候，这时候线程处于挂起状态。

启动一个线程你只需要调用start()方法，针对两种实现线程的方法也有两种启动线程的方法，分别如下：

 　　DoSomething doIt = new DoSomething();
Thread myThread = new Thread( doIt );
myThread.start();
DoAnotherThing doIt = new DoAnotherThing();
doIt.start();
 

由于安全等因素Thread中的stop()方法已经不推荐使用了，因此如果你想要停止一个线程的时候可以通过设置一个信号量，例如：

 　　public class MyThread implements Runnable {
private boolean quit = false;
public void run(){
while( !quit ){
// do something
}
}

public void quit(){
quit = true;
}
}
 

如果每个线程只做它自己的事情，那么就很简单了，但是有的时候几个线程可能要同时访问一个对象并可能对它进行修改，这个时候你必须使用线程的同步在方法或者代码块使用关键字synchronized，例如：

 　　public class Counter {
private int counter;
public synchronized int increment(){
return ++counter;
}

public synchronized int decrement(){
if( –counter < 0 ){
counter = 0;
}

return counter;
}
}
 

每个java对象都可以最为一个监视器，当线程访问它的synchronized方法的时候，他只允许在一个时间只有一个线程对他访问，让其他得线程排队等候。这样就可以避免多线程对共享数据造成破坏。记住synchronized是会耗费系统资源降低程序执行效率的，因此一定要在需要同步的时候才使用，尤其在J2ME的开发中要小心。

如果你要是想让线程等待某个事件的发生然后继续执行的话，那么这就涉及到线程的调度了。在java中通过wait ()，notify(),notifyAll()来实现，这三个方法是在Object类中定义的，当你想让线程挂起的时候调用obj.wait()方法，在同样的obj上调用notify()则让线程重新开始运行。　最后以SUN提供的Producer/Consumer的例子来结束这篇文章，内容是 Producer产生一个数字而Consumer消费这个数字，这个小程序里面基本覆盖了本文所有的知识点。请详细研究一下代码

 　　public class Producer extends Thread {
private CubbyHole cubbyhole;
private int number;
public Producer(CubbyHole c, int number) {
cubbyhole = c;
this.number = number;
}

public void run() {
for (int i = 0; i < 10; i++) {
cubbyhole.put(i);
System.out.println("Producer #" + this.number
+ " put: " + i);
try {
sleep((int)(Math.random() * 100));
} catch (InterruptedException e) { }
}
}
}
 

public class CubbyHole {
private int contents;
private boolean available = false;

public synchronized int get() {
while (available == false) {
try {
wait();
} catch (InterruptedException e) { }
}
available = false;
notifyAll();
return contents;
}

public synchronized void put(int value) {
while (available == true) {
try {
wait();
} catch (InterruptedException e) { }
}
contents = value;
available = true;
notifyAll();
}
}

public class Consumer extends Thread {
private CubbyHole cubbyhole;
private int number;

public Consumer(CubbyHole c, int number) {
cubbyhole = c;
this.number = number;
}

public void run() {
int value = 0;
for (int i = 0; i < 10; i++) {
value = cubbyhole.get();
System.out.println("Consumer #" + this.number
+ " got: " + value);
}
}
}
public class ProducerConsumerTest {
public static void main(String[] args) {
CubbyHole c = new CubbyHole();
Producer p1 = new Producer(c, 1);
Consumer c1 = new Consumer(c, 1);

p1.start();
c1.start();
}
}

SUN说输出的结果应该是如下形式，但是在我的机器上却不是这样的，做了一些改动才正确，有兴趣的朋友可以运行一下看看结果，欢迎和我讨论一下！

 　　Producer #1 put: 0
Consumer #1 got: 0
Producer #1 put: 1
Consumer #1 got: 1
Producer #1 put: 2
Consumer #1 got: 2
Producer #1 put: 3
Consumer #1 got: 3
Producer #1 put: 4
Consumer #1 got: 4
Producer #1 put: 5
Consumer #1 got: 5
Producer #1 put: 6
Consumer #1 got: 6
Producer #1 put: 7
Consumer #1 got: 7
Producer #1 put: 8
Consumer #1 got: 8
Producer #1 put: 9
Consumer #1 got: 9

如果是rpm.bin文件，则按照下面的方法：先将jdkxxx.bin拷贝到当前目录(/home/hd/java)下，然后执行下面的命令
#chmod a+x jdkxxxx.bin
#./jdkxxxx.bin
然后得到一个rpm文件，继续下面的执行
rpm -i –badreloc –relocate /usr/java=/home/hd/java jdk-1_5_0_10-linux-i586.rpm
执行完后，安装并配置环境变量。

如果直接下载bin的安装包，
则直接进行安装，然后配置环境变量

第三步，环境变量设置，
在终端中输入命令
   vi /etc/profile.d/java.sh
   这样可以在所有的用户中使用
   在新的java.sh中输入以下内容：
   #set java environment
   export JAVA_HOME=/home/hd/java/jdk1.5.0_10;/home/hd/class
   export CLASSPATH=.:$JAVA_HOME/lib:$JAVA_HOME/jre/lib
   export PATH=$JAVA_HOME/bin:$JAVA_HOME/jre/bin:$PATH
  其中，/home/hd/class是即将运行class的位置。

try {
            boolean fail=true;
            URL url = new URL(urlString);
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
           
            int a=conn.getResponseCode();
           
            if(a==200){
                fail=false;
            }else{
                fail=true;
            }
       

        } catch (IOException e) {
            fail=true;
           System.out.println("连接:" + urlString + "  时错误,Cause:" + e.getMessage());
        }

如果返回值不为200，则连接失败，如果不能建立连接也算失败。即不能连接到该页面。
使用了HttpURLConnection的 int getResponseCode()方法。(Gets the status code from an HTTP response message.)
 ***********
以下为PHP的实现方法：
1.安装pear
2.安装pear的类库：
HTTP_Client
3.修改php.ini文件中的include_path，设置include_path =".;C:\PHP\PEAR";
重启Apache
4.代码如下：
$url="http://210.34.4.20";
$client  = new HTTP_Client(array(’allowRedirects’ => false));
$client->head($url);
$res = $client->currentResponse();
echo $res['code'];
从而得到header的返回值，然后判断网页是否连通。

参考资料：
 HTTP 状态码表示什么意思？

但是由于JDOM没有自己的解析器，它使用标准的解析器(如Xerces)来完成这个工作。如果想要进行schema校验必须确保选择了支持这个schema的解析器。
代码如下：
SAXBuilder builder =
  new SAXBuilder("org.apache.xerces.parsers.SAXParser", true);
builder.setFeature(
  "http://apache.org/xml/features/validation/schema", true);
builder.setProperty(
  "http://apache.org/xml/properties/schema/external-schemaLocation",
  "http://www.w3.org/2001/12/soap-envelope soap-envelope.xsd" + " " +
  "http://kevinj.develop.com/weblog/weblog.xsd weblog.xsd");
Document doc = builder.build(xml);

如果你想要使用JAXP来选择解析器，可以跳过指定类到SAXBuilder结构和用"org.apache.xerces.jaxp.SAXParserFactoryImpl"代替" javax.xml.parsers.SAXParserFactory"作为系统属性。这就告诉JAXP使用Xerces的 factory来创建解析器。可以用命令行来指定这个属性：
java -Djavax.xml.parsers.SAXParserFactory=
          org.apache.xerces.jaxp.SAXParserFactoryImpl

以上内容摘自http://www.jdom.org/docs/faq.html   How do I validate against a schema when using JDOM?

使用JAXP进行校验：

代码如下：
    // 1. Lookup a factory for the W3C XML Schema language
        SchemaFactory factory =
            SchemaFactory.newInstance("http://www.w3.org/2001/XMLSchema");
       
        // 2. Compile the schema.
        // Here the schema is loaded from a java.io.File, but you could use
        // a java.net.URL or a javax.xml.transform.Source instead.
        File schemaLocation = new File("/opt/xml/docbook/xsd/docbook.xsd");
        Schema schema = factory.newSchema(schemaLocation);
   
        // 3. Get a validator from the schema.
        Validator validator = schema.newValidator();
       
        // 4. Parse the document you want to check.
        Source source = new StreamSource(args[0]);
       
        // 5. Check the document
        try {
            validator.validate(source);
            System.out.println(args[0] + " is valid.");
        }
        catch (SAXException ex) {
            System.out.println(args[0] + " is not valid because ");
            System.out.println(ex.getMessage());
        } 

如果要使用xml自身指定的xsd进行校验，则使用下面的方法：
SchemaFactory factory = SchemaFactory.newInstance("http://www.w3.org/2001/XMLSchema");
Schema schema = factory.newSchema();
这种方法仅适用于 XSD。

参考文章：
 Java 语言的 XML 验证 API (www.ibm.com/developerworks/cn/xml/x-javaxmlvalidapi.html)
 JAXP 专述(www-128.ibm.com/developerworks/cn/xml/jaxp/)

用JAXP解析xml：
               DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
              DocumentBuilder parser = factory.newDocumentBuilder();
              org.w3c.dom.Document doc = parser.parse("temp.xml");
              //获得根节点元素
              Node record=doc.getFirstChild();

由于对xml没有系统的理解，以上仅为粗糙可用的代码，并不理解其中的原理，有待进一步学习。
具体代码见：http://210.34.4.9:8080/svn/SvnTest/datacheck1.0/

第三章表达式、语句和保留字

使用循环语句的几个建议：

1.   当作数组拷贝操作时，采用System.arraycopy()效率更高。
使用了以下代码段：

发现结果如下：

并非和文章中所提到的一样（2500000，105，45），所以不赞同作者的这个观点。

2.   尽量避免在循环体中调用方法
3.   最好避免在循环体内存取数据元素，比较好的办法是在循环体内采用临时变量，在循环体外更改数组的值。这是因为在循环体内使用变量比存取数组元素要快。

4.   避免在做最终条件时采用方法返回值的方式判断。
如：

…
while(isTrue()){
 …
}
…
应该写作：
boolean isTrue=isTrue();
while(isTrue){
 …
}
…

5.   尽量避免在循环体中使用try-catch 块，最好在循环体外使用。
如:
do{
 try{
  …
 }catch(Exception e){
  …
 }
}while(isTrue);
建议使用下面的方式：
try{
 do{
  …
 }while(isTrue);
}catch(Exception e){
  …
}
6.  在多重循环中，如果有可能，尽量将最长的循环放在最内层，最短的循环放在最外层。

林胜利等编著，电子工业出版社

说明：仅记录自己以前不明白或觉得重要的东西。

第一章Java程序设计风格

关于文件注释头：
需要说明的部分有：该类的功能及特点，该类是否被测试过，@see(与该类相关联的类)，
@author(作者)，@since(该文件所支持的JDK版本)，@version(版本)，@date(开发日期)，最后更改日期，修改人，复审人

命名规则：

1. 包：
   包名应该是独一无二的，通常都是小写，一般是公司域名的倒序，域名后面的部分可以根据习惯命名。
2. 类和接口：
   大写字母开头，尽量由具有实际意义的单词组成。
3. 方法：
   一般来说是动词，第一个字母小写，多个单词混合的情况下，第一个单词后的所有单词的第一个字母大写，
   如：run();runFast();getBackground();
   方法的声明最好采用功能性分组的方式进行排列。
4. 变量：
   和方法的命名规则相同。
5. 常量：
   大写，例如：Static final int MIN_WIDTH=14;

其余的排版问题，只需要在编写代码结束后，按Ctrl+Shift+f排版就可以了。(Eclipse和NetBeans都支持)