DOM, and (not) sorting by Attribute name

Question

I'm using XML files to store certian options for a program I'm making. The only problem though is that it seems as though the NamedNodeMap you get from calling node.getAttributes has the attributes in sorted order.
Namely it's sorted alphabetically.
This is not at all what I would like, it's pretty important that the attributes be in the order I wrote them, not sorted.
Is there another way I can do this?
I could always just have a text entry for the Attribute types, like
<?xml version="1.0" encoding="UTF-8"?>
<root>
AttributeType_1, AttributeType_2
<whatever AttributeType_1="whatever" AttributeType_2>
#And so on.
</root>
Or I could do any number of variations on that theme.

Answer 1

Here is some source code.
xmlGenerate.java
This will convert 2D arrays into XML Strings, or vice versa. There's a couple other things it does too, but that's the important part (
//import crap
import java.sql.Savepoint;
import java.util.*;
import java.awt.event.*;
import java.io.*;
import javax.xml.parsers.*;
import javax.swing.*;
import javax.xml.parsers.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.*;
import javax.xml.transform.stream.*;
import org.apache.xml.serialize.*;
import org.w3c.dom.*;
import org.xml.sax.*;
//generates xml files
public class xmlGenerate{
public static final String PATH=SRJava.Constants.PATH+
"\\Editors\\CharacterGenerator\\";
* This method takes in stuff, the kind of stuff,the names of the
* attributes of that stuff, and returns XML
* The input is the stuff, and the output is
* a string which is the stuff in XML.
* Each row of the stuff represents the data of an Object
* Each column represents a specific value, which is specified by
* attrNames
public static String toXML(Object[][] stuff, String[] attrNames,
String type){
try{
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.newDocument();
Element root = document.createElement("root");
document.appendChild(root);
//going thru each equipment to append to root
int entries = stuff.length;
int attributes = attrNames.length;
String tempStr;
for (int entry = 0; entry < entries; entry++){
Element a1 = document.createElement(type);
//set xml document
root.appendChild(a1);
for (int attr =0; attr < attributes; attr++){                   
//this gets the data from the xml
if (stuff[entry][attr] instanceof String){
tempStr=(String)stuff[entry][attr];
}else{
tempStr="";
a1.setAttribute(attrNames[attr],tempStr);
OutputFormat format = new OutputFormat(document, "UTF-8", true);
StringWriter stringOut = new StringWriter();
XMLSerializer serial = new XMLSerializer(stringOut, format);
serial.asDOMSerializer();
serial.serialize(document);
return stringOut.toString();
*fill in components
}catch (Exception e){
e.printStackTrace();
return null;
* From XML , returns the equipmennt
* Input is file and output is the data from the XML document
public static Object[][] fmXML(Node root){
//make double array
try{           
NodeList childNodes = root.getChildNodes();
Vector attrNodeVector= new Vector();
int entries=0;
boolean determined=false;
NamedNodeMap attributeList = null;
for (int index=0; index < childNodes.getLength(); index++){
Node node=childNodes.item(index);
if (node.getNodeType()==Node.ELEMENT_NODE){
entries++;
attrNodeVector.add(node);
if (determined==false){
attributeList=node.getAttributes();
determined=true;
String[] attrNames=getAttrNames(root);
int attributes=attrNames.length;
Object[][] stuff=new Object[entries+1][attributes];
//this value is so new entries can be added.
for (int attr=0; attr < attributes; attr++){
stuff[0][attr]="";
for (int entry = 0; entry < entries; entry++){
Element thenode=(Element)attrNodeVector.get(entry);
//make sure the node being looked at is the right kind.
for (int attr=0; attr < attributes; attr++){
//parseing goes on
stuff[entry+1][attr] = thenode.getAttribute(attrNames[attr]);
return stuff;
}catch (Exception e){
e.printStackTrace();
//there was some kind of error, return nothing useful.
return null;
//sorts the Nodes
private static Node[] sort(NodeList subsequent, String[] tags){
Node[] sorted = new Node[tags.length];
//looking through all the different nodes
for(int x=0; x < subsequent.getLength(); x++){
Node inOrder = subsequent.item(x);
String tag = inOrder.getNodeName();
for(int i=0; i<tags.length; i++){
if(tag.equals(tags)){
sorted[i] = inOrder;
break;
return sorted;
* output the xml document to a file
public static void save(String doc, String name){
try {
PrintWriter oF = new PrintWriter(new FileWriter(name), true);
oF.print(doc);
oF.close();
catch (IOException x){
System.err.println("There was a saving error");
//retreiving some data from an xml file
public static Node open(String file){
try{
//This code came from a guy called Rob Thorndyke.
Document doc = DocumentBuilderFactory.newInstance()
.newDocumentBuilder().newDocument();
File f=new File(file);
System.out.println(f.getPath());
// Step 2 is to get a Transformer object.
Transformer transformer =
TransformerFactory.newInstance().newTransformer();
// Step 3 is to set up Source and Result objects and use the
// Transformer object to do the conversion.
Source source = new StreamSource(new FileReader(file));
Result result = new DOMResult(doc);
transformer.transform(source, result);
//This code did not.
Node root = doc.getDocumentElement();
if (root == null){               
System.out.println("There is no root!");
return null;
return root;
}catch (Exception e){
System.out.println("Error in opening.");
return null;
public static String[] getAttrNames(Node root){
try{           
NodeList childNodes = root.getChildNodes();
Vector attrNodeVector= new Vector();
int entries=0;
boolean determined=false;
NamedNodeMap attributeList = null;
for (int index=0; index < childNodes.getLength(); index++){
Node node=childNodes.item(index);
if (node.getNodeType()==Node.ELEMENT_NODE){
entries++;
attrNodeVector.add(node);
if (determined==false){
attributeList=node.getAttributes();
determined=true;
int attributes=attributeList.getLength();
String[] attrNames = new String[attributes];
//get the names of the attributes
for (int attr=0; attr < attributes; attr++){
attrNames[attr]=attributeList.item(attr).getNodeName();
return attrNames;
}catch(Exception e){
System.out.println("Error in getting column names");
return null;
public static String getType(Node root){
if (root == null){               
System.out.println("There is no root!");
return null;
NodeList childNodes = root.getChildNodes();
Vector attrNodeVector= new Vector();
for (int index=0; index < childNodes.getLength(); index++){
Node node=childNodes.item(index);
if (node.getNodeType()==Node.ELEMENT_NODE){
return node.getNodeName();
return null;
// main method
public static void main(String[] args){
System.out.println("Hello out there");
//file->xml->equpment->object
Node root=open(PATH+"\\Equipment.xml");
Object[][] stuff = fmXML(root);
//frames (GUI)
JFrame aFrame = new JFrame();
aFrame.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
aFrame.addWindowListener(new WindowAdapter(){
public void windowClosed(WindowEvent e){
System.exit(0);
JPanel aPanel = new JPanel();
//set headers
aFrame.getContentPane().add(aPanel);
//create scrollableTable
String[] columnNames=new String[] {
"name",
"conceal",
"cost",
"rating",
"weight",
"street index"
boolean[] columnEditable= new boolean[]{
true,
true,
true,
true,
true,
true
int[][] sliders = new int[][]{
{-1,-1,-1},
{-1,-1,-1},
{-1,-1,-1},
{-1,-1,-1},
{-1,-1,-1},
{-1,-1,-1}
if (stuff== null){
System.out.println("stuff is null");
aPanel.add(new ScrollableTable(null,stuff,columnNames,columnEditable,
sliders,true,0));
aFrame.pack();
aFrame.setLocationRelativeTo(null);
aFrame.show();
This isn't what I'm actually using, but I whipped it up real quick so you could get an idea about how it would be used.
* Test.java
* Created on March 23, 2003, 5:14 PM
package SRJava;
* @author unknown
import org.w3c.dom.*;
import SRJava.Editors.CharacterGenerator.*;
import javax.swing.*;
public class Test extends javax.swing.JFrame {
/** Creates new form Test */
public Test() {
//Replace this with some other XML file, in a table like form.
String fileName = "M:\\Shadowrun\\SRJava\\Editors"
+ "\\CharacterGenerator\\Equipment.xml";
Node root = xmlGenerate.open(fileName);
String[] columnNames = xmlGenerate.getAttrNames(root);
Object[][] data = xmlGenerate.fmXML(root);
//There should be no sliders, and all columns should be editable.
int columns=columnNames.length;
int[][] sliders = new int[columns][3];
boolean[] columnEditable= new boolean[columns];
for (int index=0; index < columns; index++){
sliders[index][0]=-1;
sliders[index][1]=-1;
sliders[index][2]=-1;
columnEditable[index]=true;
Object[][] avail = new Object[][]{
JScrollPane scroll = new JScrollPane();
JTable table=new JTable(data,columnNames);
scroll.setViewportView(table);
getContentPane().add(scroll, java.awt.BorderLayout.CENTER);
addWindowListener(new java.awt.event.WindowAdapter() {
public void windowClosing(java.awt.event.WindowEvent evt) {
exitForm(evt);
pack();
/** This method is called from within the constructor to
* initialize the form.
* WARNING: Do NOT modify this code. The content of this method is
* always regenerated by the Form Editor.
private void initComponents() {
addWindowListener(new java.awt.event.WindowAdapter() {
public void windowClosing(java.awt.event.WindowEvent evt) {
exitForm(evt);
pack();
/** Exit the Application */
private void exitForm(java.awt.event.WindowEvent evt) {
System.exit(0);
* @param args the command line arguments
public static void main(String args[]) {
new Test().show();
// Variables declaration - do not modify
// End of variables declaration
And here's an XML File, call it Equipment.xml
<?xml version="1.0" encoding="UTF-8"?>
<root>
<Equipment conceal="" name="" xloge="Blorg"/>
<Equipment conceal="Bla" name="different sample" xloge="Great southern trendkilling"/>
<Equipment conceal="adsf" name="sample" xloge="Red Crested"/>
</root>