


Explication détaillée de l'analyse syntaxique DOM de la technologie XML-JAXP
DOM解析的基本思路:
1、将整个XML文件一次性读入内存
2、将整个XML看做一棵树
3、XML中的每一个标签,属性,文本都看做是树上的一个结点
4、然后可以对结点进行增删改查的操作
话不多说,上代码。
1、首先我在D:\ABC中新建了一个文本文件,重命名为stus.xml,以下是文件中的内容
<?xml version = "1.0" encoding = "GBK" ?> <stus class = "S160401A"> <stu num = "001" > <name>张三</name> <age>20</age> <sex>男</sex> </stu> <stu num = "002"> <name>李四</name> <age>21</age> <sex>女</sex> </stu> <stu num = "003"> <name>王五</name> <age>22</age> <sex>男</sex> </stu> </stus>
在第一行是XML声明,version表示版本号,encoding表示编码方式,微软的记事本用的是国标的编码方式,如果要用UTF-8,则要在另存为窗口中修改编码方式为UTF-8。
必须且只能有一对根标签,我写的根标签是
2、这是一个学生类,定义了一些属性和get、set方法
<span style="max-width:90%">public class Student { public static String Class; private String name; private int num; private int age; private char sex; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getNum() { return num; } public void setNum(int num) { this.num = num; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public char getSex() { return sex; } public void setSex(char sex) { this.sex = sex; } }</span>
3、这是用DOM解析的类,看这个类之前还要了解一下。
DocumentBuilderFactory DOM解析器工厂
DocumentBuilder DOM解析器
Document 文档对象
Node 结点【接口】
Element 元素结点【标签结点】
Attr 属性结点
Text 文本结点
Node 是Document,Element,Attr,Text的父接口
NodeList 结点列表
NamedNodeMap 一个结点的所有属性
<span style="font-size: 16px;">import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import org.w3c.dom.Attr; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.w3c.dom.NamedNodeMap; import org.w3c.dom.Node; import org.w3c.dom.NodeList; import bean.Student; public class DOMParser { public static void main(String[] args) throws Exception { // 得到解析器工厂对象 DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); // 生产一个解析器对象 DocumentBuilder builder = factory.newDocumentBuilder(); // 开始解析XML文件,得到解析的结果,是一个Document对象 // Document对象叫做文档树对象 Document dom = builder.parse("D:\\ABC\\stus.xml"); // 通过Document对象提取数据 // Document对象的第一个子节点是根节点[根标签] Node root = dom.getFirstChild(); // 获得标签的名字 String str = root.getNodeName(); // 获得根节点的属性 NamedNodeMap attrs = root.getAttributes(); // 强转成Attr类型 属性类 Attr attr = (Attr) attrs.getNamedItem("class"); // 获得属性里的值 String v = attr.getValue(); System.out.println(v); // 获得所有的学生------------------------------------- NodeList list = root.getChildNodes(); for (int i = 0; i < list.getLength(); i++) { Node node = list.item(i); // 判断是否是标签结点 if (node instanceof Element) { Element e = (Element) node; // 获得标签结点里属性的值 String num = e.getAttribute("num"); System.out.println(num); // 输出标签中的文本 // System.out.println(e.getTextContent()); // 继续获得stu的子节点 NodeList nodeList = e.getChildNodes(); for (int j = 0; j < nodeList.getLength(); j++) { Node n = nodeList.item(j); if (n instanceof Element) { Element ele = (Element) n; // 获得元素结点的标签名字 String nodeName = ele.getNodeName(); // 获得元素结点标签中的文本 String value = ele.getTextContent(); if (nodeName.equals("name")) { System.out.println("姓名:" + value); } else if (nodeName.equals("age")) { System.out.println("年龄:" + value); } else if (nodeName.equals("sex")) { System.out.println("性别:" + value); } } } } } } }</span>
自己在其中总结了一些方法:
DocumentBuilderFactory类:
public static DocumentBuilderFactory newInstance(); //得到解析器工厂对象 public abstract DocumentBuilder newDocumentBuilder(); //生产一个解析器对象
DocumentBuilder类:
public Document parse(String uri); //解析路径为uri的XML文件,得到解析的结果是一个Document对象
Node类:
public Node getFirstChild(); //得到Document对象的第一个子结点,也就是根结点、或者叫根标签,在上面的代码中得到的是stus,看上面的第1点中的XML文件的内容。 public NamedNodeMap getAttributes();//获得结点的属性 public NodeList getChildNodes();//获得所有子结点 public String getNodeName();//获得标签的名字 public String getTextContent() throws DOMException;//获得标签结点中的文本
NamedNodeMap类:
public Node getNamedItem(String name);//返回所有名字为name的结点
Attr类:
public String getValue();//获得属性里的值
NodeList类:
public Node item(int index);//返回第index个结点
Element类:
public String getAttribute(String name);//获得标签结点里属性name的值
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

AI Hentai Generator
Générez AI Hentai gratuitement.

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Les fichiers XML peuvent-ils être ouverts avec PPT ? XML, Extensible Markup Language (Extensible Markup Language), est un langage de balisage universel largement utilisé dans l'échange et le stockage de données. Comparé au HTML, XML est plus flexible et peut définir ses propres balises et structures de données, rendant le stockage et l'échange de données plus pratiques et unifiés. PPT, ou PowerPoint, est un logiciel développé par Microsoft pour créer des présentations. Il fournit un moyen complet de

Utilisation de Python pour fusionner et dédupliquer des données XML XML (eXtensibleMarkupLanguage) est un langage de balisage utilisé pour stocker et transmettre des données. Lors du traitement de données XML, nous devons parfois fusionner plusieurs fichiers XML en un seul ou supprimer les données en double. Cet article explique comment utiliser Python pour implémenter la fusion et la déduplication de données XML, et donne des exemples de code correspondants. 1. Fusion de données XML Lorsque nous avons plusieurs fichiers XML, nous devons les fusionner

Implémentation du filtrage et du tri des données XML à l'aide de Python Introduction : XML est un format d'échange de données couramment utilisé qui stocke les données sous forme de balises et d'attributs. Lors du traitement de données XML, nous devons souvent filtrer et trier les données. Python fournit de nombreux outils et bibliothèques utiles pour traiter les données XML. Cet article explique comment utiliser Python pour filtrer et trier les données XML. Lecture du fichier XML Avant de commencer, nous devons lire le fichier XML. Python possède de nombreuses bibliothèques de traitement XML,

Convertir des données XML en Python au format CSV XML (ExtensibleMarkupLanguage) est un langage de balisage extensible couramment utilisé pour le stockage et la transmission de données. CSV (CommaSeparatedValues) est un format de fichier texte délimité par des virgules couramment utilisé pour l'importation et l'exportation de données. Lors du traitement des données, il est parfois nécessaire de convertir les données XML au format CSV pour faciliter l'analyse et le traitement. Python est un puissant

Python implémente la conversion entre XML et JSON Introduction : Dans le processus de développement quotidien, nous devons souvent convertir des données entre différents formats. XML et JSON sont des formats d'échange de données courants. En Python, nous pouvons utiliser diverses bibliothèques pour réaliser une conversion mutuelle entre XML et JSON. Cet article présentera plusieurs méthodes couramment utilisées, avec des exemples de code. 1. Pour convertir XML en JSON en Python, nous pouvons utiliser le module xml.etree.ElementTree

Gestion des erreurs et des exceptions dans XML à l'aide de Python XML est un format de données couramment utilisé pour stocker et représenter des données structurées. Lorsque nous utilisons Python pour traiter XML, nous pouvons parfois rencontrer des erreurs et des exceptions. Dans cet article, je vais vous présenter comment utiliser Python pour gérer les erreurs et les exceptions dans XML, et fournir un exemple de code pour référence. Utilisez l'instruction try-sauf pour détecter les erreurs d'analyse XML Lorsque nous utilisons Python pour analyser XML, nous pouvons parfois rencontrer des

Python analyse les caractères spéciaux et les séquences d'échappement en XML XML (eXtensibleMarkupLanguage) est un format d'échange de données couramment utilisé pour transférer et stocker des données entre différents systèmes. Lors du traitement de fichiers XML, vous rencontrez souvent des situations contenant des caractères spéciaux et des séquences d'échappement, qui peuvent provoquer des erreurs d'analyse ou une mauvaise interprétation des données. Par conséquent, lors de l’analyse de fichiers XML à l’aide de Python, nous devons comprendre comment gérer ces caractères spéciaux et ces séquences d’échappement. 1. Caractères spéciaux et

La gestion des formats de données XML et JSON dans le développement C# nécessite des exemples de code spécifiques. Dans le développement de logiciels modernes, XML et JSON sont deux formats de données largement utilisés. XML (Extensible Markup Language) est un langage de balisage permettant de stocker et de transmettre des données, tandis que JSON (JavaScript Object Notation) est un format d'échange de données léger. Dans le développement C#, nous devons souvent traiter et exploiter des données XML et JSON. Cet article se concentrera sur la façon d'utiliser C# pour traiter ces deux formats de données et les attacher.
