dom4j简明教程

使用dom4j需要导入jar包

jar包下载地址：http://pan.baidu.com/s/1o65jWRw

将dom4j-1.6.1.jar包导入Eclipse

book2.xml

[html] view
plain copy

print?

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <书架>
  3. <书>
  4. <书名>JAVA</书名>
  5. <作者>XXXXXX</作者>
  6. <售价>23333</售价>
  7. </书>
  8. <书>
  9. <书名>ANDROID</书名>
  10. <作者>XXXXXX</作者>
  11. <售价>23333</售价>
  12. </书>
  13. </书架>

解析book2.xml这个文件。

方法：

获取文档的根结点：

Element root = document.getRootElement();

获取某个结点的子节点

Element element = root.element();

获取某个结点下的所有子节点：

List elements = root.elements();

遍历该结点下的所有子节点

以递归的方式进行

[html] view
plain copy

print?

  1. public class dom4j {
  2. public static void main(String[] args) throws Exception {
  3. // method_1();
  4. method_2();
  5. }
  6. private static void method_2() throws Exception {
  7. SAXReader reader = new SAXReader();
  8. Document document = reader.read("book2.xml");
  9. Element root = document.getRootElement();
  10. parse(root);
  11. }
  12. private static void parse(Element ele) {
  13. // 处理当前元素包含的所有属性
  14. parseAttribute(ele);
  15. // 获取当前元素包含的所有
  16. List el = ele.elements();
  17. for (Object e : el) {
  18. Element element = (Element) e;
  19. // 如果该元素的内容不是只包含字符串
  20. if (!element.isTextOnly()) {
  21. parse(element);
  22. } else {
  23. // 处理当前 元素的全部属性
  24. parseAttribute(element);
  25. // 获取当前元素的内容
  26. System.out.println(element.getQName().getName() + "-->"
  27. + element.getText());
  28. }
  29. }
  30. }
  31. /**
  32. * 处理元素属性
  33. *
  34. * @param ele
  35. */
  36. private static void parseAttribute(Element ele) {
  37. List attributes = ele.attributes();
  38. for (Object e : attributes) {
  39. Attribute attribute = (Attribute) e;
  40. System.out.println(ele.getQName().getName() + "元素的"
  41. + attribute.getQName().getName() + "属性为"
  42. + attribute.getValue());
  43. }
  44. }
  45. private static void method_1() throws Exception {
  46. // 获取解析器
  47. SAXReader reader = new SAXReader();
  48. // 解析xml获取代表整个文档的dom对象
  49. Document document = reader.read("book2.xml");
  50. // 获取根结点
  51. Element rootElement = document.getRootElement();
  52. // 获取书名
  53. String bookName = rootElement.element("书").element("书名").getText();
  54. System.out.println("bookName--:   " + bookName);
  55. }
  56. }

ML

来自：

W3School

XML 被设计用来传输和存储数据。HTML 被设计用来显示数据。

什么是 XML?

eXtensible Markup Language

  • XML 指可扩展标记语言（EXtensible Markup Language）
  • XML 是一种标记语言，很类似 HTML
  • XML 的设计宗旨是传输数据，而非显示数据
  • XML 标签没有被预定义。您需要自行定义标签。
  • XML 被设计为具有自我描述性。
  • XML 是 W3C 的推荐标准

XML 与 HTML 的主要差异

  • XML 不是 HTML 的替代。
  • XML 和 HTML 为不同的目的而设计：
  • XML 被设计为传输和存储数据，其焦点是数据的内容。
  • HTML 被设计用来显示数据，其焦点是数据的外观。
  • HTML 旨在显示信息，而 XML 旨在传输信息。
<note>
    <to>George</to>
    <from>John</from>
    <heading>Reminder</heading>
    <body>Don‘t forget the meeting!</body>
</note>
  • XML 不是对 HTML 的替代
  • XML 是对 HTML 的补充。
  • XML 不会替代 HTML，理解这一点很重要。在大多数 web 应用程序中，XML 用于传输数据，而 HTML 用于格式化并显示数据。

对 XML 最好的描述是：XML 是独立于软件和硬件的信息传输工具。

XML 的用途

XML 应用于 web 开发的许多方面，常用于简化数据的存储和共享。

XML 把数据从 HTML 分离。如果你需要在 HTML 文档中显示动态数据，那么每当数据改变时将花费大量的时间来编辑 HTML。通过 XML，数据能够存储在独立的 XML 文件中。这样你就可以专注于使用 HTML 进行布局和显示，并确保修改底层数据不再需要对 HTML 进行任何的改变。

XML树结构

XML 文档形成了一种树结构，它从“根部”开始，然后扩展到“枝叶”。

XML 文档必须包含根元素。该元素是所有其他元素的父元素。

XML 文档中的元素形成了一棵文档树。这棵树从根部开始，并扩展到树的最底端。所有元素均可拥有子元素：

<root>
  <child>
    <subchild>.....</subchild>
  </child>
</root>

父、子以及同胞等术语用于描述元素之间的关系。父元素拥有子元素。相同层级上的子元素成为同胞（兄弟或姐妹）。

所有元素均可拥有文本内容和属性（类似 HTML 中）。

如：

根元素是 <bookstore>。文档中的所有 <book> 元素都被包含在 <bookstore> 中。<book> 元素有 4 个子元素：<title>、< author>、<year>、<price>。

  <bookstore>
   <book category="COOKING">
     <title lang="en">Everyday Italian</title>
     <author>Giada De Laurentiis</author>
     <year>2005</year>
     <price>30.00</price>
   </book>
   <book category="CHILDREN">
     <title lang="en">Harry Potter</title>
     <author>J K. Rowling</author>
     <year>2005</year>
     <price>29.99</price>
   </book>
   <book category="WEB">
     <title lang="en">Learning XML</title>
     <author>Erik T. Ray</author>
     <year>2003</year>
     <price>39.95</price>
   </book>
</bookstore>

XML 语法规则

  • 所有 XML 元素都须有关闭标签
  • XML 标签对大小写敏感
  • XML 必须正确地嵌套
  • XML 文档必须有根元素
  • XML 的属性值须加引号
  • 实体引用
实体 引用 意义
&lt; < 小于
&gt; > 大于
&amp; & 和号
&apos; ‘ 单引号
&quot; " 引号

- XML 中的注释

在 XML 中编写注释的语法与 HTML 的语法很相似：

<!- - This is a comment - ->

  • 在 XML 中，空格会被保留
  • XML 以 LF 存储换行

XPATH

XPath即为XML路径语言，它是一种用来确定XML（标准通用标记语言的子集）文档中某部分位置的语言

最有用的路径表达式：

表达式 描述
nodename 选取此节点的所有子节点。
/ 从根节点选取。
// 从匹配选择的当前节点选择文档中的节点，而不考虑它们的位置。
. 选取当前节点。
.. 选取当前节点的父节点。
@ 选取属性。
路径表达式 结果
bookstore 选取 bookstore 元素的所有子节点。
/bookstore 选取根元素 bookstore。注释：假如路径起始于正斜杠( / )，则此路径始终代表到某元素的绝对路径！
bookstore/book 选取属于 bookstore 的子元素的所有 book 元素。
//book 选取所有 book 子元素，而不管它们在文档中的位置。
bookstore//book 选择属于 bookstore 元素的后代的所有 book 元素，而不管它们位于 bookstore 之下的什么位置。
//@lang 选取名为 lang 的所有属性。

Java解析XML文件

4种解析方式

来自

http://bbs.csdn.net/topics/290027113/

DOM（Document Object Model JAXP Crimson解析器）

DOM是用与平台和语言无关的方式表示XML文档的官方W3C标准。DOM是以层次结构组织的节点或信息片断的集合。这个层次结构允许开发人员在树中寻找特定信息。分析该结构通常需要加载整个文档和构造层次结构，然后才能做任何工作。由于它是基于信息层次的，因而DOM被认为是基于树或基于对象的。DOM以及广义的基于树的处理具有几个优点。首先，由于树在内存中是持久的，因此可以修改它以便应用程序能对数据和结构作出更改。它还可以在任何时候在树中上下导航，而不是像SAX那样是一次性的处理。DOM使用起来也要简单得多。

SAX（Simple API for XML）

SAX处理的优点非常类似于流媒体的优点。分析能够立即开始，而不是等待所有的数据被处理。而且，由于应用程序只是在读取数据时检查数据，因此不需要将数据存储在内存中。这对于大型文档来说是个巨大的优点。事实上，应用程序甚至不必解析整个文档；它可以在某个条件得到满足时停止解析。一般来说，SAX还比它的替代者DOM快许多。

DOM解析器把XML文档转化为一个包含其内容的树，并可以对树进行遍历。用DOM解析模型的优点是编程容易，开发人员只需要调用建树的指令，然后利用navigation APIs访问所需的树节点来完成任务。可以很容易的添加和修改树中的元素。然而由于使用DOM解析器的时候需要处理整个XML文档，所以对性能和内存的要求比较高，尤其是遇到很大的XML文件的时候。由于它的遍历能力，DOM解析器常用于XML文档需要频繁的改变的服务中。

SAX解析器采用了基于事件的模型，它在解析XML文档的时候可以触发一系列的事件，当发现给定的tag的时候，它可以激活一个回调方法，告诉该方法制定的标签已经找到。SAX对内存的要求通常会比较低，因为它让开发人员自己来决定所要处理的tag.特别是当开发人员只需要处理文档中所包含的部分数据时，SAX这种扩展能力得到了更好的体现。但用SAX解析器的时候编码工作会比较困难，而且很难同时访问同一个文档中的多处不同数据。

JDOM http://www.jdom.org

JDOM的目的是成为Java特定文档模型，它简化与XML的交互并且比使用DOM实现更快。由于是第一个Java特定模型，JDOM一直得到大力推广和促进。正在考虑通过“Java规范请求JSR-102”将它最终用作“Java标准扩展”。从2000年初就已经开始了JDOM开发。

JDOM与DOM主要有两方面不同。首先，JDOM仅使用具体类而不使用接口。这在某些方面简化了API，但是也限制了灵活性。第二，API大量使用了Collections类，简化了那些已经熟悉这些类的Java开发者的使用。

DOM4J http://dom4j.sourceforge.net

虽然DOM4J代表了完全独立的开发结果，但最初，它是JDOM的一种智能分支。它合并了许多超出基本XML文档表示的功能，包括集成的XPath支持、XML Schema支持以及用于大文档或流化文档的基于事件的处理。它还提供了构建文档表示的选项，它通过DOM4J API和标准DOM接口具有并行访问功能。

比较

1）DOM4J性能最好，连Sun的JAXM也在用DOM4J.目前许多开源项目中大量采用DOM4J，例如大名鼎鼎的Hibernate也用DOM4J来读取XML配置文件。如果不考虑可移植性，那就采用DOM4J.

2）JDOM和DOM在性能测试时表现不佳，在测试10M文档时内存溢出。在小文档情况下还值得考虑使用DOM和JDOM.虽然JDOM的开发者已经说明他们期望在正式发行版前专注性能问题，但是从性能观点来看，它确实没有值得推荐之处。另外，DOM仍是一个非常好的选择。DOM实现广泛应用于多种编程语言。它还是许多其它与XML相关的标准的基础，因为它正式获得W3C推荐（与基于非标准的Java模型相对），所以在某些类型的项目中可能也需要它（如在JavaScript中使用DOM）。

3）SAX表现较好，这要依赖于它特定的解析方式－事件驱动。一个SAX检测即将到来的XML流，但并没有载入到内存（当然当XML流被读入时，会有部分文档暂时隐藏在内存中）。

dom4j简易教程

获取Document

SAXReader reader = new SAXReader();
Document document = reader.read("bookstore.xml");

Iterator

public void bar(Document document) throws DocumentException
   Element root = document.getRootElement();
   // iterate through child elements of root
   for ( Iterator i = root.elementIterator(); i.hasNext(); ) {
     Element element = (Element) i.next();
     // do something
   }
   // iterate through child elements of root with element name "foo"
   for ( Iterator i = root.elementIterator( "foo" ); i.hasNext(); ) {
     Element foo = (Element) i.next();
     // do something
   }
   // iterate through attributes of root
   for ( Iterator i = root.attributeIterator(); i.hasNext(); ) {
     Attribute attribute = (Attribute) i.next();
     // do something
   }
}

XPath表达式

public static void main(String[] args) throws DocumentException
{
  System.out.println("Hello World!");
  SAXReader sax = new SAXReader();
  Document document = sax.read("bookstore.xml");
  List<Node> list = document.selectNodes( "//book/title" );
  for(Node n : list){
    System.out.println("=======================");
    System.out.println("节点名：" + n.getName());
    System.out.println("节点值：" + n.getText());
    System.out.println("节点XPath：" + n.getPath());
    System.out.println("节点属性lang值：" + n.valueOf("@lang"));
    System.out.println("节点所属的xml文档对象：" +n.getDocument().equals(document));
    System.out.println("节点父亲名字：" + n.getParent().getQName().getName());
    System.out.println("节点类型：" + n.getNodeTypeName());
  }
  Node node = document.selectSingleNode( "/bookstore/book" );
  String name = node.valueOf( "@category" );
  System.out.println(name);
  System.out.println(node.getDocument());
}

快速遍历

public static void main(String[] args) throws DocumentException
{
  System.out.println("Hello World!");
  SAXReader sax = new SAXReader();
  Document document = sax.read("bookstore.xml");
  Element root = document.getRootElement();
  DFS(root);
}
public static void DFS(Element e){
  System.out.println(e.getQName().getName()+"------------"+e.getNodeTypeName());
  for ( int i = 0, size = e.nodeCount(); i < size; i++ ) {
    Node node = e.node(i);
    if ( node instanceof Element ) {
      DFS( (Element) node );
    }
    else {
      if(node.getText().trim().length() > 0){
        System.out.println(node.getNodeTypeName()+"-------------" + node.getText().trim());
      }
    }
  }
}

制作新XML文件

从零开始制作XML

public static void main(String[] args) throws Exception
{
  System.out.println("Hello World!");
  //1. 创建Document对象
  Document document = createDocument();
  //2. 将Document写入文件，两种方式，简洁方式和美观方式
  //2.1 简洁方式，设置OutputFormat为compact
  //2.2 美观方式，设置OutputFormat为pretty
  write(document);
}
public static Document createDocument(){
  Document document = DocumentHelper.createDocument();
  Element root = document.addElement("root");
  Element author1 = root.addElement( "author" )
    .addAttribute( "name", "James" )
    .addAttribute( "location", "UK" )
    .addText( "James Strachan" );
  Element author2 = root.addElement( "author" )
    .addAttribute( "name", "Bob" )
    .addAttribute( "location", "US" )
    .addText( "Bob McWhirter" );
  return document;
}
public static void write(Document document) throws Exception {
  // lets write to a file
  XMLWriter writer = new XMLWriter( new FileWriter( "output.xml" ) );
  writer.write( document );
  writer.close();
  // Pretty print the document to System.out
  OutputFormat format = OutputFormat.createPrettyPrint();
  writer = new XMLWriter( System.out, format );
  writer.write( document );
  writer.close();
  // Compact format to System.out
  format = OutputFormat.createCompactFormat();
  writer = new XMLWriter( System.out, format );
  writer.write( document );
  writer.close();
}

字符串与XML互换

实现字符串和XML文件之间的转换

public static void main(String[] args) throws Exception
{
  System.out.println("Hello World!");
  SAXReader sax = new SAXReader();
  Document document = sax.read("bookstore.xml");
  //将XML文件转成string
  String str = document.asXML();
  System.out.println(str);
  //删除换行
  str = str.replaceAll("[\n]","");
  System.out.println(str);
  //将string转换成document对象，然后写入XML文件
  Document document1 = DocumentHelper.parseText(str);
  XMLWriter writer = new XMLWriter(new FileWriter("stringToXML.xml"));
  writer.write(document1);
  writer.flush();
  writer.close();
}

实例

将一个XML文件转换成类对象1、创建xml文件

<?xml version="1.0" ?>
<root>
    <Book>
      <category>COOKING</category>
      <title>Everyday Italian</title>
      <author>Giada De Laurentiis</author>
      <year>2005</year>
      <price>30.00</price>
    </Book>
    <Book>
      <category>CHILDREN</category>
      <title lang="en">Harry Potter</title>
      <author>J K. Rowling</author>
      <year>2005</year>
      <price>29.99</price>
    </Book>
    <Book>
      <category>WEB</category>
      <title lang="en">Learning XML</title>
      <author>Erik T. Ray</author>
      <year>2003</year>
      <price>39.95</price>
    </Book>
</root>

2、编写java bean文件3、转换类

public class  XMLToClass
{
  public static void main(String[] args)
  {
    System.out.println("Hello World!");
    readXML("classXML.xml");
  }
  public static void readXML(String xmlFileName) {
    SAXReader sax = new SAXReader();
    Document document = null;
    try{
      document = sax.read(xmlFileName);
    }catch(DocumentException dex){
      dex.printStackTrace();
      System.out.println("获取Document对象失败");
      return;
    }
    Element root = document.getRootElement();
    List<Element> objs = root.elements();
    List<Element> properties = null;
    String className = "";
    if(objs.size() > 0){
      //获取类名
      className = objs.get(0).getQName().getName();
      properties = objs.get(0).elements();
    }
    System.out.println("类名：" + className);
    List<String> pros = new ArrayList<String>();
    for(int i = 0 ; i < properties.size(); i ++){
      System.out.println("属性"+i+":"+properties.get(i).getQName().getName());
      pros.add(properties.get(i).getQName().getName());
    }
    System.out.println(pros);
    List<Object> list = createObject(className,objs);
    for(Object o : list){
      System.out.println(o);
    }
  }
  /*
  *   根据类名，属性值构造对象
  */
  public static List<Object> createObject(String className,List<Element> objNodes){
    Class clazz = null;
    try{
      clazz = Class.forName(className);
    }catch(ClassNotFoundException cnfe){
      System.out.println(className + "没有找到！");
    }
    List<Object> objs = new ArrayList<Object>();
    for(int i = 0; i < objNodes.size(); i++){
      List<Element> properties = objNodes.get(i).elements();
      try{
        Object obj = clazz.newInstance();
        for(int j = 0; j < properties.size(); j ++){
          Element e = properties.get(j);
          Field field = clazz.getDeclaredField(e.getQName().getName());
          field.setAccessible(true);
          //获取域的类型，需要选择field的set方法
          String type = field.getType().getName();
          if("int".equals(type)){
            field.setInt(obj,Integer.parseInt(e.getText().trim()));
          }else if("double".equals(type)){
            field.setDouble(obj,Double.parseDouble(e.getText().trim()));
          }else{
            field.set(obj,e.getText().trim());
          }
        }
        objs.add(obj);
      }catch(InstantiationException ie){
        System.out.println("实例化类失败！");
      }catch(NoSuchFieldException nse){
        System.out.println("找不到指定的数据域！");
      }catch(IllegalAccessException iae){
        System.out.println("底层字段是不可访问的！");
      }
    }
    return objs;
  }
}

相关类和接口

Document

实现了Node接口

获取根元素Element getRootElement()

Element

方法 意义
Iterator elementIterator() 返回一个包含子元素的迭代器
List elements() 返回子元素列表
Element element(String name) 根据name获取Element
QName getQName() 获取元素的QName名字
int attributeCount() 获取属性个数
Attribute attribute(int index) 第index个属性
getText() 如果元素有值，则获取值
String elementText(String name) 获取值 
public static void main(String[] args) throws DocumentException
{
  System.out.println("Hello World!");
  SAXReader sax = new SAXReader();
  Document document = sax.read("bookstore.xml");
  //获取xml的根元素
  Element root = document.getRootElement();
  System.out.println(root.getQName().getName());
  //获取指定的元素，根据QName或者name
  Element foo = root.element("foo");
  //获取元素的属性个数
  System.out.println("属性个数：" + foo.attributeCount());
  for(int i = 0; i < foo.attributeCount(); i++){
    //获取元素的属性，三种方式QName，Name，Index
    Attribute a = foo.attribute(i);
    //获取属性值
    System.out.println(a.getQName().getName() + "=" + a.getValue());
  }
  //获取属性列表
  List<Attribute> list = foo.attributes();
  for(Attribute a : list){
    System.out.println(a.getQName().getName() + "=" + a.getValue());
  }
  //获取指定属性名的值
  System.out.println("color:"+foo.attributeValue("color"));
  System.out.println("================================");
  List<Element> list1 = root.elements("book");
  System.out.println();
  for(Element e : list1){
    Element child = e.element("title");
    System.out.println(child.getText());
    System.out.println(e.elementText("title"));
  }
}

Attribute

方法 意义
QName getQName() 返回属性名QName（）
String getValue() 获取属性值
void setValue(String value) 设置属性值，若是只读则抛出异常UnsupportedOperationException

QName

Namespace getNamespace()String getName()

SAXReader

读取xml文件read

Node

接口类型

最好熟悉XPath语法

方法 意义
Document getDocument()  
String getName() 返回Node名
String getText() 返回节点的文本内容，最好再使用string的trim()方法删除两端的换行符
Element getParent() 返回父节点
short getNodeType() 返回节点类型整数值
String getNodeTypeName() 返回节点类型
List selectNodes(String xpathExpression) 返回Node列表
write(Writer writer)  

Branch

接口类型

定义了节点的共同行为

方法 意义
int indexOf(Node node)  
Node node(int index)  
int nodeCount()  
Iterator nodeIterator()  
void add(Comment comment) Adds the given Comment to this branch.
void add(Element element) Adds the given Element to this branch.
void add(Node node) Adds the given Node or throws IllegalAddException if the given node is not of a valid type.
Element addElement(String name) Adds a new Element node with the given name to this branch and returns a reference to the new node.
boolean remove(Comment comment) Removes the given Comment if the node is an immediate child of this branch.
boolean remove(Element element) Removes the given Element if the node is an immediate child of this branch.
boolean remove(Node node) Removes the given Node if the node is an immediate child of this branch.

XMLWriter

方法 意义
XMLWriter() 默认是简洁输出
XMLWriter(OutputFormat format)  
XMLWriter(OutputStream out)  
XMLWriter(OutputStream out, OutputFormat format)  
XMLWriter(Writer writer)  
XMLWriter(Writer writer, OutputFormat format)  
void write(Document doc) This will print the Document to the current Writer.

OutputFormat

输出样式控制

方法 意义
static OutputFormat createCompactFormat() 简洁输出，没有添加为了美观的换行符，如： <root><author name="James" location="UK">James Strachan</author><author name="Bob" location="US">Bob
McWhirter</author></root>
static OutputFormat createPrettyPrint() 美观输出，如下面所示 
<root>
  <author name="James" location="UK">James Strachan</author>
  <author name="Bob" location="US">Bob McWhirter</author>
</root>

时间： 2025-01-01 08:26:27

dom4j简明教程的相关文章

Lisp简明教程

此教程是我花了一点时间和功夫整理出来的,希望能够帮到喜欢Lisp(Common Lisp)的朋友们.本人排版很烂还望多多海涵! <Lisp简明教程>PDF格式下载 <Lisp简明教程>ODT格式下载 具体的内容我已经编辑好了,想下载的朋友可以用上面的链接.本人水平有限,如有疏漏还望之处(要是有谁帮我排排版就好了)还望指出!资料虽然是我整理的,但都是网友的智慧,如果有人需要转载,请至少保留其中的“鸣谢”页(如果能有我就更好了:-)). Lisp简明教程 整理人:Chaobs 邮箱:[

Linux防火墙iptables简明教程

前几天微魔部落再次遭受到个别别有用心的攻击者的攻击,顺便给自己充个电,复习了一下linux下常见的防火墙iptables的一些内容,但是无奈网上的很多教程都较为繁琐,本着简明化学习的目的,微魔为大家剔除了许多冗余的内容,提取出尽量多的精华部分成文,和大家共同学习,本文涉及的内容包括如下 Linux防火墙iptables简明教程 1.安装iptables 2.查看现有的iptables规则 3.删除某iptables规则 4.清除现有iptables规则 5.创建规则 6.设置开机启动 7.保存i

Markdown简明教程4-Markdown UML图

1. 前言 Markdown是一种轻量级的标记语言,把作者从繁杂的排版工作中解放出来,实现易读易写的文章写作,已经逐渐成为事实上的行业标准.CSDN博客支持Markdown可以让广大博友更加专注于博客内容,大赞.但是,不少博友可能对Markdown比较生疏,本博接下来用一个系列文章<Markdown简明教程>扼要介绍Markdown,希望可以对大家有所帮助. 系列教程目录 关于Markdown Markdown基本使用 Markdown表格和公式 Markdown UML图 CSDN Mark

JSP 简明教程（二）：JSP基本语法

基本语法 JSP只是在html的基础上嵌入一些动态的元素.下面是HelloWorld代码: <html> <% out.println("hello world"); %> </html> 以上代码中的<% %>就是动态元素.JSP中所有的特殊语法如下: <% %>:用于表示一段Java代码.这段代码在编译之后会放在_jspService()方法中. <%! %>:多了一个叹号,也用于表示一段Java代码,但是这段

第一课 C语言简明教程

1序言: 1与Java.C#等高级语言相比,C语言却非常简单,学习简单,使用也简单,但是也非常重要,到目前为止基本上操作系统的内核代码超过百分之九十使用C语言完成,因此学好C语言是学好计算机这门课程的基础,特别是进入系统编程尤为明显. 今天是本人复习C语言课程的第一课,主要重新记录一下C语言的基础知识,这节课涉及到C语言的结构.变量以及类型.输入输出.条件判断以及循环知识. 2知识点: 2.1 C语言的结构 2.1.1 通常情况下C语言程序是由: 1.相关的代码注释,使用/* ··· */可注释

Vbs 脚本编程简明教程之一

-为什么要使用 Vbs ? 在 Windows 中,学习计算机操作也许很简单,但是很多计算机工作是重复性劳动,例如你每周也许需要对一些计算机文件进行复制.粘贴.改名.删除,也许你每天启动 计算机第一件事情就是打开 WORD ,切换到你喜爱的输入法进行文本编辑,同时还要播放优美的音乐给工作创造一个舒心的环境,当然也有可能你经常需要对文本中的某 些数据进行整理,把各式各样的数据按照某种规则排列起来--.这些事情重复.琐碎,使人容易疲劳. 第三方软件也许可以强化计算机的某些功能,但是解决这些重复劳动往

Smarty教程1.引擎定义2.主要优点3.简明教程4.使用判断5.循环数组6.常见问题8.解释程序

Smarty是一个php模板引擎.更准确的说,它分开了逻辑程序和外在的内容,提供了一种易于管理的方法.可以描述为应用程序员和美工扮演了不同的角色,因为在大多数情况下 ,他们不可能是同一个人.例如,你正在创建一个用于浏览新闻的网页,新闻标题,标签栏,作者和内容等都是内容要素,他们并不包含应该怎样去呈现.在Smarty的程序里,这些被忽略了.模板设计者们编辑模板,组合使用html标签和模板标签去格式化这些要素的输出(html表格,背景色,字体大小,样式表,等等).有一天程序员想要改变文章检索的方式(

《Python简明教程》总结

Python经典教程<Python简明教程> 目录: 为什么Python 安装Python 体验Python Python数据类型 运算符与表达式 控制流 函数 模块 数据结构 解决问题 面向对象 输入输出 异常 标准库 更多的内容

Java泛型简明教程

Java泛型简明教程 博客分类: Java综合 JavaApple数据结构CC++ Java泛型简明教程 本文是从 Java Generics Quick Tutorial 这篇文章翻译而来. 泛型是Java SE 5.0中引入的一项特征,自从这项语言特征出现多年来,我相信,几乎所有的Java程序员不仅听说过,而且使用过它.关于Java泛型的教程,免费的,不免费的,有很多.我遇到的最好的教材有: The Java Tutorial Java Generics and Collections ,