BlogJava-JAVA涂鸦-文章分类-J2SE

jdom操作xml

千山鸟飞绝 — Mon, 21 Aug 2006 03:18:00 GMT

JDOM是Breet Mclaughlin和Jason Hunter两大Java高手的创作成果，2000年初，JDOM作为一个开放源代码项目正式开始研发。JDOM是一种解析XML的Java工具包。

JDOM的二进制版本下载：http://www.jdom.org/downloads/index.html

把解压后的jdom.jar文件加到项目的类路径中，另外便于调试，还要下载它的源代码。

一、解析XML
要解析的XML文件：

xml version="1.0" encoding="gb2312"?>
<books>
   <book email="zhoujunhui">
     <name>rjzjhname>
     <price>60.0price>
  book>
books>

解析XML的java文件：

1 package com;
2
3 import java.io.IOException;
4 import java.util.*;
5 import org.jdom.*;
6 import org.jdom.input.SAXBuilder;
7
8 public class Test {
9
10     /**
11      * @param args
12      */
13     public static void main(String[] args) {
14         SAXBuilder sb=new SAXBuilder(false);
15         Document doc = null;
16         try {
17             doc = sb.build("sample.xml");
18         } catch (JDOMException e) {
19             e.printStackTrace();
20         } catch (IOException e) {
21             e.printStackTrace();
22         }
23         Element root=doc.getRootElement(); //获取根元素
24         List list=root.getChildren("book");//取名字为book的所有元素
25         for(int i=0;i<list.size();i++){
26             Element element=(Element)list.get(i);
27             String email=element.getAttributeValue("email");
28             String name=element.getChildText("name");
29             String price=element.getChildText("price");
30             System.out.println("name:"+name);
31             System.out.println("price:"+price);
32             System.out.println("email:"+email);
33         }
34     }
35 }
36
37

二、生成XML：
java文件：

1 package com;
2
3 import java.io.FileWriter;
4 import java.io.IOException;
5 import java.util.*;
6 import org.jdom.*;
7 import org.jdom.input.SAXBuilder;
8 import org.jdom.output.XMLOutputter;
9
10 public class Test {
11
12     /**
13      * @param args
14      */
15     public static void main(String[] args) {
16         //第一步，创建根元素
17
18         Element carElement = new Element("car");
19         Document myDocument = new Document(carElement);
20
21         //因为一个 XML 文档必须一直有一个唯一的根元素，所以 Document 将 Element 放在它的构造器中。
22
23         //第二步，添加一个 Attribute
24
25         carElement.setAttribute(new Attribute("vin", "123fhg5869705iop90"));
26
27         //第三步，添加其它元素
28
29         carElement.addContent(new Element("make").addContent("Toyota"));
30
31         carElement.addContent(new Element("model").addContent("Celica"));
32         carElement.addContent(new Element("year").addContent("1997"));
33         carElement.addContent(new Element("color").addContent("green"));
34         carElement.addContent(new Element("license").addContent("1ABC234").setAttribute("state", "CA"));
35
36         //第四步，添加一条注释
37
38         carElement.addContent(new Comment("Description of a car"));
39
40         //第五步，读一个子元素
41
42         Element yearElement = carElement.getChild("year");
43
44         //第六步，删除子元素
45
46         boolean removed = carElement.removeChild("year");
47
48         //第七步，存盘
49         XMLOutputter outputter = new XMLOutputter();//用于输出jdom 文档
50         FileWriter writer;
51         try {
52             writer = new FileWriter("myFile.xml");
53             outputter.output(myDocument, writer);
54             writer.close();
55         } catch (IOException e) {
56             // TODO 自动生成 catch 块
57             e.printStackTrace();
58         }
59
60
61     }
62 }
63
64

生成的XML:

xml version="1.0" encoding="UTF-8"?>
<car vin="123fhg5869705iop90">
<make>Toyotamake>
<model>Celicamodel>
<color>greencolor>
<license state="CA">1ABC234license>

car>

千山鸟飞绝 2006-08-21 11:18 发表评论

学习J2EE所看的书籍

千山鸟飞绝 — Wed, 10 May 2006 01:35:00 GMT

J2EE的学习应该循序渐进，一本好的书能够使你很快上手和深入。在学习J2EE之前，我们要把SQL学好，基本上，程序设计都会跟数据库打交道，如果SQL没学好，就如同房子没有基脚一样，学习SQL需要大量的练习才能真正的体会其中的精髓。
在入门之初，只需要买本一二十元的SQL入门书籍看看，了解数据库和SQL的基础知识。在深入学习SQL时，SQLServer2000的帮助文档是再好不过的教材了，只是内容显得过于庞大。
在这里，我推荐一本书，可以看作是SQLServer2000的帮助文档的浓缩版本，方便平常翻阅查询。
SQL编程实用大全（精华版）
相关联接：
http://www.dearbook.com.cn/book/29898

接下来是java语言的学习。

Java语言程序设计

这是一本很好的Java入门教材，该说的都说了，尽管不是很深入，但对入门而言已经足够了。
相关联接：
http://www.huachu.com.cn/itbook/itbookinfo.asp?lbbh=BB07956476
Java 2核心技术卷I：基础知识（原书第7版）和 Java 2 核心技术卷II：高级特性（原书第7版）
我觉得这两本书可以好好读读，这两本书如同java的“新华字典”。不过刚刚接触java，没必要开始就从这两本书入手，因为太厚了，学习的兴趣可能会因此慢慢消失。不过，以后哪怕熟练掌握了Java，也应该好好读读这两本书。
相关联接：
http://www.dearbook.com.cn/book/104972
http://www.dearbook.com.cn/book/104973
Java编程思想：第3版
不知为什么，很多人都推荐新人看这本书。这本书应该是给有Java工作经验或者以前有C++工作经验的人看的。看名字就应该明白，这不是说基础的书籍，而是在基础上的思想的升华。有了上面的书籍，这本书买不买都无所谓了。如果没有Java基础来看这本书，将会是件非常痛苦的经历。另外，更有甚者，推荐新人看此书的英文版，让我觉得真不可思议。很多高手都从此书中收益不少，但并不是每个人都是高手。
相关联接：
http://www.dearbook.com.cn/book/29060

Java面向对象编程
孙卫琴的最新作品,是一本不错的基础书籍。
http://www.dearbook.com.cn/book/110136

学好了Java，就可以进入J2EE的学习了，J2EE是个很庞大的概念，但最基本的就是为企业服务。刚开始接触J2EE，可能让人摸不着头脑，要学的知识太多了。其实，学习J2EE，可以从Web开发入手，边学边做，慢慢就领会了J2EE。Web开发，说窄点，就是做网站，说宽点，就是B/S开发。

首先要学习的就是jsp和servlet，这两项技术是web开发的基础之基础。
Servlet与JSP核心编程（第2版）
我当时借阅了这本书，感觉在学servlet方面，这可以说得上是比较好的一本书了。
http://www.dearbook.com.cn/book/22890

如果你对servlet有了一定了解，只是想学习一下jsp,你可以看看这本书：
JSP程序设计
尽管这是将一本英文原版拆成两本书来买，但我觉得这本书很适合jsp入门。
http://www.dearbook.com.cn/book/91320

有了一定的jsp和servlet基础，就可以看一些流行的框架技术了。在这里将以目前流行的SSH为例。尽管ejb仍然有市场，但因为学习难度大和工作机会较少，所以初学者学习轻量级框架是进入J2EE的最佳捷径。

首先需要介绍的是Struts,Struts尽管有一定岁月了，但至今它仍是开发人员首选的技术之一。目前还有一些与Struts相似的技术，如Tapestry ,JSF等，可以在学会Struts后再去学习，这样可以事半功倍。

精通Struts：基于MVC的Java Web设计与开发
这本书不用多说了，尽管人们对他的评价有褒有贬，但在我看来这本书可以说得上是孙大姐写得最好的一本书，入门，深入都可以在这本书得到。
http://www.dearbook.com.cn/book/23040

另外，如果你不喜欢这本书，那就购买这本书吧：
实战STRUTS
有人说孙大姐的书就是抄袭了这本书，不管怎么说，都证明了这是一本好书。
http://www.dearbook.com.cn/book/29882

Hibernate是SSH中的H，是一项ORM技术。

Hibernate Quickly中文版
我当初学习hibernate时还没有这本书的中文版，我当时是看着英文版学会了hibernate，在我看来，这本书很适合对hibernate的入门。
http://www.dearbook.com.cn/book/110547

关于hibernate深入的书籍，我认为最好的是hibernate in action。但他没有中文版。不过市面上有几本书都不错，可以自己挑选一本看：《精通Hibernate :Java对象持久化技术详解》、《深入浅出Hibernate》、《Hibernate开发及整合应用大全（珍藏版）》

ORM技术另外还有一个Ibatis,在许多大项目中都可以看到Ibatis的踪影，这是因为Ibatis的仍然是面向SQL的，对SQL的操作有得天独厚的优势。它的学习难度也不大，只要看它的官方文档就足够了。现在《Ibatis in Action》英文版已经出版了。

spring是现在流行的SSH框架中最重要也最难理解的一项技术。
我当初理解spring是看它自带的例子理解的，因为当时市面上并没有什么好的入门书籍。
不过现在有本书倒是值得推荐：
spring 2.0技术手册
这本书我在书店看过，觉得确实是本很好的入门书籍，因为spring的理解确实不是那么好理解，从示例出发能更好的理解spring的魅力。
http://www.dearbook.com.cn/book/175891

spring的提升书籍我推荐：
Spring框架高级编程
这本书是spring的作者参与写的书，里面对技术的描述很到位，只是这本书的中文版的翻译有点生硬，但还过得去，最可惜的是这本书的纸张太差。只能看不能写。
http://www.dearbook.com.cn/book/105486

Spring专业开发指南（Pro Spring中文版）

这也是一本很好的Spring书籍，虽然没有Spring框架高级编程那么全面，但翻译质量却胜于前者。

http://www.dearbook.com.cn/book/108340

今年Struts2.0的推出，看来Struts1.x会慢慢淡出大家的视线了。

Struts2.0其实就是WebWork2.2，在现在没有Struts2.0书籍时候，

WebWork in Action中文版值得大家阅读。

http://www.dearbook.com.cn/book/123018

能很好的看完上面书籍，并掌握60%，你就可以成为一名程序员了。呵呵。

其实做好一名程序员，要求掌握的技术远不止这些，javascript和css都是必备的技术，只是大家似乎认为这只是美工的玩意，都不是很在乎，Ajax的出现，大大改变了大家对这两项技术的看法。
Javascript没有什么好书，唯一一本《Javascript权威指南》还是一本字典工具书，CSS也有一本权威指南，但现在已经绝版了，要学好这两项技术，还是多从网上找例子看，或虚心请教美工。

大家在应用Ajax技术时感到的难度，其实也是因为Javascript的问题，要理解Ajax很简单，网上搜索一下，很多小例子都能很好的理解Ajax。

我买Ajax的书可以算多了，买了三本，《Ajax基础教程》，《征服Ajax--Web 2.0开发技术详解》，《征服Ajax+Lucene--构建搜索引擎》。
《Ajax基础教程》是市面上第一本Ajax中文书籍，当时买回来也没怎么看，直到买了《征服Ajax+Lucene--构建搜索引擎》，我才体会了到什么是Ajax，可以是因为它的登陆例子简单实用吧。尽管不少人认为这本书是个大杂烩，但我却觉得买这本书很值，因为它，我开始使用Ajax，也开始使用Lucene引擎了。可能每个人的看书习惯不同，我更喜欢简单易懂的入门书籍，在我看来，只要入了门，就等于成功了一半。

除了上面这些技术，还有不少技术需要掌握才能真正的做到开发时得心应手：

Lucene IN ACTION 中文版

一本讲述Lucene的权威书籍。

http://www.dearbook.com.cn/book/124684

在掌握的这些技术的时候，也不要忘记理论的学习，这样才能更好的理解这些技术、框架。

Java与模式

这本书就不需要过多的介绍了。

http://www.dearbook.com.cn/book/7401

先写到这里，以后再修改。

千山鸟飞绝 2006-05-10 09:35 发表评论

[转贴]用jdom技术将数据库数据写入读出xml文件

千山鸟飞绝 — Sun, 15 Jan 2006 10:33:00 GMT

用jdom技术将数据库数据写入读出xml文件

//很多时候，为了避免多次访问/查询数据库重的数据或者便于察看，将需要的数据一次取出并写入xml文件

//通过查询条件m_condition 按照xmlMapPath的模式/模板将从库中的数据写到resultXml
//并返回记录条数

public int writeXML(String m_condtion,String xmlMapPath,String resultXml){
int recordNum=0;
String tableName = "table";
String tableCol = "*";
String sql = "select " + tableCol + " from " + tableName + " where " + m_condtion;

Document mapDoc = null;
Document dataDoc = null;
Document newDoc = null;
//开始准备工作
try {
DocumentBuilderFactory dbfactory = DocumentBuilderFactory.newInstance();
//Create the DocumentBuilder
DocumentBuilder docbuilder = dbfactory.newDocumentBuilder();
//Parse the file to create the Document
mapDoc = docbuilder.parse(xmlMapPath);

dataDoc = docbuilder.newDocument();
//Instantiate the new Document
newDoc = docbuilder.newDocument();
} catch (Exception e) {
System.out.println(e.getMassege());
}

//开始读取映射作用的template文件

Element mapRoot = mapDoc.getDocumentElement();
Node dataNode = mapRoot.getElementsByTagName("data").item(0);
Element dataElement = (Element)dataNode;

//Create a new element called "data"
Element dataRoot = dataDoc.createElement("data");

try {
/******** 这里创建一个连接conn,并创建statement
根据不同的数据源创建
********************************/
ResultSet resultset = stmt.query(sql);
//Get the ResultSet information
ResultSetMetaData resultmetadata = resultset.getMetaData();
int numCols = resultmetadata.getColumnCount();
Log.write("db_to_xml:numCols:" + numCols);

while (resultset.next()) {
//Create a new element called "row"
Element rowEl = dataDoc.createElement("row");

//为了便于浏览和读，创建列数,以id为标记
String colName = "id";
String colVal =Integer.toString(++recordNum);
Element dataEl = dataDoc.createElement(colName);
dataEl.appendChild(dataDoc.createTextNode(colVal));

rowEl.appendChild(dataEl);
for (int i=1; i <= numCols; i++) {

colName = resultmetadata.getColumnName(i);
//Get the column value
colVal = resultset.getString(i);

//Determine if the last column accessed was null
if (resultset.wasNull()) {
colVal = "";
}

dataEl = dataDoc.createElement(colName);

dataEl.appendChild(dataDoc.createTextNode(colVal));

rowEl.appendChild(dataEl);
}
//Add the row to the root element
dataRoot.appendChild(rowEl);
}
} catch (Exception e) {
Log.write(e.getMessage());
} finally {
Log.write(" db_to_xml: Closing connections...");

}

//Add the root element to the document
dataDoc.appendChild(dataRoot);

Node node1= mapRoot.getElementsByTagName("root").item(0);
Element newRootInfo =(Element)node1;
Log.write("After got newRootInfo ...");
//Retrieve the root and row information

String newRootName = newRootInfo.getAttribute("name");

String newRowName= newRootInfo.getAttribute("rowName");

NodeList newNodesMap = mapRoot.getElementsByTagName("element");

//Create the final root element with the name from the mapping file
Element newRootElement=null;

newRootElement = newDoc.createElement(newRootName);

NodeList oldRows = dataRoot.getElementsByTagName("row");
for (int i=0; i < oldRows.getLength(); i++){

//Retrieve each row in turn
Element thisRow = (Element)oldRows.item(i);

//Create the new row
Element newRow = newDoc.createElement(newRowName);

for (int j=0; j < newNodesMap.getLength(); j++) {

//For each node in the new mapping, retrieve the information
//First the new information...
Element thisElement = (Element)newNodesMap.item(j);
String newElementName = thisElement.getAttribute("name");

//Then the old information
Element oldElement = (Element)thisElement.getElementsByTagName("content").item(0);
String oldField = oldElement.getFirstChild().getNodeValue();

//Get the original values based on the mapping information
Element oldValueElement = (Element)thisRow.getElementsByTagName(oldField).item(0);
String oldValue = oldValueElement.getFirstChild().getNodeValue();

Element newElement = newDoc.createElement(newElementName);
newElement.appendChild(newDoc.createTextNode(oldValue));

NodeList newAttributes = thisElement.getElementsByTagName("attribute");
for (int k=0; k < newAttributes.getLength(); k++) {
//Get the mapping information
Element thisAttribute = (Element)newAttributes.item(k);
String oldAttributeField = thisAttribute.getFirstChild().getNodeValue();
String newAttributeName = thisAttribute.getAttribute("name");

oldValueElement = (Element)thisRow.getElementsByTagName(oldAttributeField).item(0);
String oldAttributeValue = oldValueElement.getFirstChild().getNodeValue();

newElement.setAttribute(newAttributeName, oldAttributeValue);
}

//Add the new element to the new row
newRow.appendChild(newElement);
}
//Add the new row to the root
newRootElement.appendChild(newRow);
}
//Add the new root to the document
newDoc.appendChild(newRootElement);

//把生成的xml文档（newDoc）写到文件中(路径名为resultXml)
try{
TransformerFactory tFactory = TransformerFactory.newInstance();
Transformer transformer = tFactory.newTransformer();
Properties properties = transformer.getOutputProperties();
properties.setProperty(OutputKeys.ENCODING, "GB2312");//ISO8859_1，GB2312,UTF-8
properties.setProperty(OutputKeys.METHOD, "xml");
properties.setProperty(OutputKeys.VERSION, "1.0");
properties.setProperty(OutputKeys.INDENT, "yes");
transformer.setOutputProperties(properties);

DOMSource source = new DOMSource(newDoc);

StreamResult result = new StreamResult(new java.io.File(resultXml));

transformer.transform(source, result);
//生成XML文件完成
} catch (Exception e) {
System.out.println("XML file write:"+e.getMessage());
}
return recordNum;
}

千山鸟飞绝 2006-01-15 18:33 发表评论

面试题

千山鸟飞绝 — Fri, 06 Jan 2006 03:02:00 GMT

摘要: JSP方面1、forward 和redirect的区别答：forward是服务器请求资源，服务器直接访问目标地址的URL，把那个URL的响应内容读取过来，然后把这些内容再发给浏览器，浏览器根本不知道服务器发送的内容是从哪儿来的，所以它的地址栏中还是原来的地址。 redirect就是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址，... 阅读全文

千山鸟飞绝 2006-01-06 11:02 发表评论

多线程实现对多个客户端的监听.

千山鸟飞绝 — Mon, 10 Oct 2005 06:04:00 GMT

    这是一个比较简单的例子来说明socket编程，服务器端使用了多线程来监听客户端。

    服务器端的代码：
    package SocketTest;

    import java.io.*;
    import java.net.*;
    import java.util.*;

    class SocketServer{
        public SocketServer(){
            Socket incoming;
            ServerSocket so;
            try{
                so= new ServerSocket(8001);
                System.out.println("等待客户端连接。");

                while(true){
                    try{
                        incoming = so.accept( );
                          System.out.println("已连接客户端。");
                          GetInfo gi=new GetInfo(incoming);//调用线程
                     } catch (IOException e){
                        e.printStackTrace();
                     }
                }
            }catch (IOException e){
               e.printStackTrace();
          }
        }

        public static void main(String[] args){
          new SocketServer();
        }

        private static class GetInfo implements Runnable{   //线程类
            private Socket incoming;
            private String s=null;
            private BufferedReader b;
            Thread t;

            public GetInfo(Socket incoming){
              try{
                  this.incoming=incoming;
                  b=new BufferedReader(new InputStreamReader(incoming.getInputStream()));

                  t=new Thread(this);
                  t.start();
                }catch(IOException e){
                  e.printStackTrace();
              }
          }

            public void run(){
              try{
                  while (true){
                      s=b.readLine();
                      System.out.println(s);
                    if(s.equals("end")){
                        break;
                      }
                  }
                }catch(IOException e){
                e.printStackTrace();
                }
            }
        }

     }

    客户端的代码：
    package SocketTest;

    import java.io.*;
    import java.net.*;
    import java.util.*;

    public class SocketClient{

       public static void main(String[] args){

             try{
              Socket so = new Socket("localhost", 8001);
                  System.out.println("连接服务器。");

                  BufferedReader b=new BufferedReader(new InputStreamReader(System.in));

                  OutputStream outStream = so.getOutputStream();
                PrintWriter out = new PrintWriter(outStream);

              String s=null;
                  while (true){
                    s=b.readLine();
                    out.println("Client:"+s);
                    out.flush();
                    if(s.equals("end")){
                       break;
                    }
                  }
            }catch (IOException e){
              e.printStackTrace();
          }
       }
    }

千山鸟飞绝 2005-10-10 14:04 发表评论

简单的四则计算器

千山鸟飞绝 — Tue, 20 Sep 2005 09:31:00 GMT

效果图:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;

//定义了一个面板存放控件
class MyPanel extends JPanel implements ActionListener
{
   //定义了19个按钮（有两个还没实现），一个文本框
   JButton jb1=new JButton("1");
   JButton jb2=new JButton("2");
   JButton jb3=new JButton("3");
   JButton jb4=new JButton("4");
   JButton jb5=new JButton("5");
   JButton jb6=new JButton("6");
   JButton jb7=new JButton("7");
   JButton jb8=new JButton("8");
   JButton jb9=new JButton("9");
   JButton jb10=new JButton("0");
   JButton jb11=new JButton("+");
   JButton jb12=new JButton("-");
   JButton jb13=new JButton("*");
   JButton jb14=new JButton("/");
   JButton jb15=new JButton("+/-");
   JButton jb16=new JButton("清零");
   JButton jb17=new JButton("");   //留着给以后加按钮
   JButton jb18=new JButton(".");//起符号作用的按钮，还没实现
   JButton jb19=new JButton("=");
   JTextField jtf=new JTextField(20);
   String type;//定义了一个字符串存放算术运算符
   double a=0D,b=0D;//定义两个数字（算术运算符两边的数字）

   public MyPanel()
   {
       jtf.setText("0");
       jtf.setHorizontalAlignment(JTextField.RIGHT);
       setLayout(null);//定义面板布局为空型
       jb1.setBounds(new Rectangle(125, 148, 45, 25));
       jb2.setBounds(new Rectangle(70, 148, 45, 25));
       jb3.setBounds(new Rectangle(15, 148, 45, 25));
       jb4.setBounds(new Rectangle(125, 115, 45, 25));
       jb5.setBounds(new Rectangle(70, 115, 45, 25));
       jb6.setBounds(new Rectangle(15, 115, 45, 25));
       jb7.setBounds(new Rectangle(125, 80, 45, 25));
       jb8.setBounds(new Rectangle(70, 80, 45, 25));
       jb9.setBounds(new Rectangle(15, 80, 45, 25));
       jb10.setBounds(new Rectangle(15, 180, 45, 25));
       jb11.setBounds(new Rectangle(185, 148, 60, 25));
       jb12.setBounds(new Rectangle(185, 180, 60, 25));
       jb13.setBounds(new Rectangle(185, 115, 60, 25));
       jb14.setBounds(new Rectangle(185, 80, 60, 25));
       jb15.setBounds(new Rectangle(185, 45, 60, 25));
       jb16.setBounds(new Rectangle(15, 45, 70, 25));
       jb17.setBounds(new Rectangle(96, 45, 70, 25));
       jb18.setBounds(new Rectangle(70, 180, 45, 25));
       jb19.setBounds(new Rectangle(125, 180, 45, 25));
       jtf.setBounds(new Rectangle(15, 9, 231, 28));
       add(jtf);
       jb1.addActionListener(this);
       jb2.addActionListener(this);
       jb3.addActionListener(this);
       jb4.addActionListener(this);
       jb5.addActionListener(this);
       jb6.addActionListener(this);
       jb7.addActionListener(this);
       jb8.addActionListener(this);
       jb9.addActionListener(this);
       jb10.addActionListener(this);
       jb11.addActionListener(this);
       jb12.addActionListener(this);
       jb13.addActionListener(this);
       jb14.addActionListener(this);
       jb15.addActionListener(this);
       jb16.addActionListener(this);
       jb17.addActionListener(this);
       jb18.addActionListener(this);
       jb19.addActionListener(this);

       add(jb1);
       add(jb2);
       add(jb3);
       add(jb4);
       add(jb5);
       add(jb6);
       add(jb7);
       add(jb8);
       add(jb9);
       add(jb10);
       add(jb11);
       add(jb12);
       add(jb13);
       add(jb14);
       add(jb15);
       add(jb16);
       add(jb17);
       add(jb18);
       add(jb19);
   }


   public void actionPerformed(ActionEvent e)
   {
       if(e.getSource()==jb1)
       {
           if(type=="equal")
               jtf.setText("1");
           else if(jtf.getText().equals("0"))

               jtf.setText("1");
           else
               jtf.setText(jtf.getText()+'1');

       }
       else if(e.getSource()==jb2)
       {
           if(type=="equal")
               jtf.setText("2");
           else if(jtf.getText().equals("0"))

               jtf.setText("2");
           else
               jtf.setText(jtf.getText()+'2');
       }
       else if(e.getSource()==jb3)
       {
           if(type=="equal")
               jtf.setText("3");
           else if(jtf.getText().equals("0"))

               jtf.setText("3");
           else
               jtf.setText(jtf.getText()+'3');
       }
       else if(e.getSource()==jb4)
       {
           if(type=="equal")
               jtf.setText("4");
           else if(jtf.getText().equals("0"))

               jtf.setText("4");
           else
               jtf.setText(jtf.getText()+'4');
       }
       else if(e.getSource()==jb5)
       {
           if(type=="equal")
               jtf.setText("5");
           else if(jtf.getText().equals("0"))

               jtf.setText("5");
           else
               jtf.setText(jtf.getText()+'5');
       }
       else if(e.getSource()==jb6)
       {
           if(type=="equal")
               jtf.setText("6");
           else if(jtf.getText().equals("0"))

               jtf.setText("6");
           else
               jtf.setText(jtf.getText()+'6');
       }
       else if(e.getSource()==jb7)
       {
           if(type=="equal")
               jtf.setText("7");
           else if(jtf.getText().equals("0"))

               jtf.setText("7");
           else
               jtf.setText(jtf.getText()+'7');
       }
       else if(e.getSource()==jb8)
       {
           if(type=="equal")
               jtf.setText("8");
           else if(jtf.getText().equals("0"))

               jtf.setText("8");
           else
               jtf.setText(jtf.getText()+'8');
       }
       else if(e.getSource()==jb9)
       {
           if(type=="equal")
               jtf.setText("9");
           else if(jtf.getText().equals("0"))

               jtf.setText("9");
           else
               jtf.setText(jtf.getText()+'9');
       }
       else if(e.getSource()==jb10)
       {
           if(type=="equal")
               jtf.setText("0");
           else if(jtf.getText().equals("0"))

               jtf.setText("0");
           else
               jtf.setText(jtf.getText()+'0');
       }
       else if(e.getSource()==jb18)
       {
           if(jtf.getText().indexOf(".")<1)
           {
               jtf.setText(jtf.getText()+'.');
           }
           else
           {
               jtf.setText(jtf.getText());
           }

       }
       else if(e.getSource()==jb18)
       {
           if(jtf.getText().equals("0"))
               jtf.setText("0");

       }
       else if(e.getSource()==jb16)
       {
           jtf.setText("0");
       }
       else if(e.getSource()==jb11)
       {
           if(jtf.getText().equals("0"))
                   jtf.setText("0");
           else
           {
               type="add";
               a=Double.parseDouble(jtf.getText());
               jtf.setText("");
           }
       }
       else if(e.getSource()==jb12)
       {
           if(jtf.getText().equals("0"))
                   jtf.setText("0");
           else
           {
               type="subtract";
               a=Double.parseDouble(jtf.getText());
               jtf.setText("");
           }
       }
       else if(e.getSource()==jb13)
       {
           if(jtf.getText().equals("0"))
                   jtf.setText("0");
           else
           {
               type="multiply";
               a=Double.parseDouble(jtf.getText());
               jtf.setText("");
           }
       }
       else if(e.getSource()==jb14)
       {
           if(jtf.getText().equals("0"))
                   jtf.setText("0");
           else
           {
               type="divide";
               a=Double.parseDouble(jtf.getText());
               jtf.setText("");
           }
       }
       else if(e.getSource()==jb19)
       {
           if(type=="add")
           {
               b=Double.parseDouble(jtf.getText());
               jtf.setText(Double.toString(a+b));
               type="equal";
           }
           else if(type=="subtract")
           {
               b=Double.parseDouble(jtf.getText());
               jtf.setText(Double.toString(a-b));
               type="equal";
           }
           else if(type=="multiply")
           {
               b=Double.parseDouble(jtf.getText());
               jtf.setText(Double.toString(a*b));
               type="equal";
           }
           else if(type=="divide")
           {
               b=Double.parseDouble(jtf.getText());
               jtf.setText(Double.toString(a/b));
               type="equal";
           }
       }

   }
}

class Calculator extends JFrame
{
   public Calculator()
   {
       this.setTitle("计算器");
       this.getContentPane().add(new MyPanel());
       this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
       setSize(300,250);
       setVisible(true);
   }

   public static void main(String args[])
   {
       new Calculator();
   }
}

千山鸟飞绝 2005-09-20 17:31 发表评论

如何在TreeSet中添加两个不具可比性的对象！

千山鸟飞绝 — Tue, 20 Sep 2005 09:29:00 GMT

import java.util.TreeSet;

class treeset{
   public static void main(String[] args){
       TreeSet ts=new TreeSet();
       stud s1=new stud("张三");
       stud s2=new stud("李四");
       ts.add(s1);
       ts.add(s2);
       System.out.println(ts);
   }
}

class stud implements Comparable{
   private String name;

   public stud(String name){
      this.name=name;
   }

   public int compareTo(Object o){
      stud s=(stud)o;
      int i=name.compareTo(s.name);
      return i;
   }

   public String toString(){
       return name;
   }

}

千山鸟飞绝 2005-09-20 17:29 发表评论

千山鸟飞绝 — Tue, 20 Sep 2005 09:28:00 GMT

import java.io.*;

class home3
{
   public static void main(String[] args)
   {
      // 判断是否提供了命令行参数。没有就用默认的。
       if (args.length == 0) args = new String[] { "C:/Flexlm" };

       try
       {
          File f = new File(args[0]);
          String[] s = f.list();

          // 迭代所有目录里面的文件。
          for (int i = 0; i < s.length; i++)
          {
             File fl = new File(f.getPath(), s[i]);

             // 如果文件是目录，则继续调用主方法。
             if (fl.isDirectory())
             {
                System.out.println(fl.getCanonicalPath());
                main(new String [] { fl.getPath() });
             }
          }
       }
       catch(IOException e)
       {
          e.printStackTrace();
       }
    }
}

千山鸟飞绝 2005-09-20 17:28 发表评论