Create XML File

import java.io.File;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.ParserConfigurationException;

import javax.xml.transform.Transformer;

import javax.xml.transform.TransformerException;

import javax.xml.transform.TransformerFactory;

import javax.xml.transform.dom.DOMSource;

import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Attr;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

public class CreateXMLFile {

       public static void main(String[] args) throws ParserConfigurationException, TransformerException {

             

              //get the Document Builder Factory instance

              DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();

             

              //create the document Builder from Document Builder

              DocumentBuilder docBuilder = docFactory.newDocumentBuilder();

             

             

              //create the new Document object from Document Builder

              Document doc = docBuilder.newDocument();

             

              //create root Element

              Element rootElement = doc.createElement("company");

             

              //append root element to the document

              doc.appendChild(rootElement);

             

              //create child Element

              Element employee = doc.createElement("Employee");

             

              //append child to root element

              rootElement.appendChild(employee);

             

              //create new Attribute

              Attr attr = doc.createAttribute("id");

              //set the value of the attribute

              attr.setValue("1");

             

              //attach it to element

              employee.setAttributeNode(attr);

             

              //first Element

              Element firstname = doc.createElement("firstname");

              firstname.appendChild(doc.createTextNode("Atul"));

              employee.appendChild(firstname);

             

             

              //last elements

              Element lastname = doc.createElement("lastname");

              lastname.appendChild(doc.createTextNode("vijay"));

              employee.appendChild(lastname);

             

              //create the DOMSource of the doc

              DOMSource source = new DOMSource(doc);

             

              //get the instance of the transformer factory

              TransformerFactory transformerFactory = TransformerFactory.newInstance();

             

              //create the new Transformer Object

              Transformer transformer = transformerFactory.newTransformer();

             

              //create the StreamResult object with File object

              StreamResult result = new StreamResult(new File("C:\\file.xml"));

             

              //create the file now

              transformer.transform(source, result);

       }

}

Sort HashMap by Values or Key

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.LinkedList;

import java.util.List;

import java.util.Map.Entry;

import java.util.Set;

import java.util.ArrayList;

/**

 * Sorting HashMap by key or value

 * 1. Create data for HashMap<Employee, Employee>

 * 2. Get the EntrySet and create an object of ArrayList 

 * 3. Pass this list into Collections.sort and pass a     

 *    Comparator<Entry<Employee,Employee>> of entry set as shown below

 * 4. After sorting, iterate sorted list and put key values in new LinkedHashMap

 * 5. Iterate LinkedHashMap which you get in step 4. Sorted values will be printed.

 */

import classes.Employee;

public class SortHashMap {

      

       public static void main(String[] args) {

              sortByKey();

              sortByValue();

       }

       private static void printUsingIterator(HashMap<Employee,Employee> sortedMap){

              Set<Entry<Employee,Employee>> entrySet = sortedMap.entrySet();

              Iterator<Entry<Employee,Employee>> itr = entrySet.iterator();

              while (itr.hasNext()){

                     Entry<Employee,Employee>  entry = itr.next();

                     System.out.println("Key of Map :: "+entry.getKey().getEmpName()+"   Value of Map :: "+entry.getKey().getEmpName());

              }

       }

       private static void sortByKey(){

              HashMap<Employee,Employee> empMap=prepareData();

              List<Entry<Employee,Employee>> listEntrySet = new ArrayList<Entry<Employee,

                            Employee>>(empMap.entrySet());

              Collections.sort(listEntrySet,new Comparator<Entry<Employee,Employee>>(){

                     @Override

                     public int compare(Entry<Employee, Employee> o1,

                                  Entry<Employee, Employee> o2) {

                           return o1.getKey().getEmpName().compareTo(o2.getKey().getEmpName());

                     }

                    

              });

              HashMap<Employee,Employee> map = new LinkedHashMap<Employee,Employee>();

              for (Entry<Employee,Employee> e: listEntrySet){

                     map.put((Employee)e.getKey(), (Employee)e.getValue());

                    

              }

              printUsingIterator(map);

       }

      

       private static void sortByValue(){

              HashMap<Employee,Employee> empMap=prepareData();

              List<Entry<Employee,Employee>> listEntrySet = new LinkedList<Entry<Employee,

                            Employee>>(empMap.entrySet());

              Collections.sort(listEntrySet,new Comparator<Entry<Employee,Employee>>(){

                     @Override

                     public int compare(Entry<Employee, Employee> o1,

                                  Entry<Employee, Employee> o2) {

                           return o1.getValue().getEmpName().compareTo(o2.getValue().getEmpName());

                     }

                    

              });

              HashMap<Employee,Employee> map = new LinkedHashMap<Employee,Employee>();

              for (Entry<Employee,Employee> e: listEntrySet){

                     map.put((Employee)e.getKey(), (Employee)e.getValue());

                    

              }

              printUsingIterator(map);

       }

      

      

       private static HashMap<Employee,Employee> prepareData(){

              HashMap<Employee,Employee> mapA = new HashMap<Employee,Employee>();

             

              mapA.put(new Employee(new Long(6),"Six"),new Employee(new Long(6),"Six"));

              mapA.put(new Employee(new Long(7),"Seven"),new Employee(new Long(7),"Seven"));

              mapA.put(new Employee(new Long(8),"Eight"),new Employee(new Long(8),"Eight"));

              mapA.put(new Employee(new Long(3),"Third"),new Employee(new Long(3),"Third"));

              mapA.put(new Employee(new Long(4),"Forth"),new Employee(new Long(4),"Forth"));

              mapA.put(new Employee(new Long(5),"Fift"),new Employee(new Long(5),"Fift"));

             

              return mapA;

       }

}