Java

import java.applet.*;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import com.standbysoft.component.date.swing.JDatePicker;

public class GeneralDemo_2 extends Applet
{
	private JDatePicker datePicker;
	public void init() 
	{
		datePicker = new JDatePicker();
		setLayout(new GridBagLayout());
		add(datePicker, new GridBagConstraints(0, 7, 1, 1, 0.0, 0.0, GridBagConstraints.NORTH, GridBagConstraints.HORIZONTAL, new Insets(0, 5, 5, 5), 0, 0));
	}
}

<object
    code="GeneralDemo_2.class"
    type="application/x-java-applet"
    archive="jdatepicker.jar"
    height="300" width="450" 
>
</object>

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
  <display-name>Test_1.1</display-name>
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>
  <servlet>
    <description></description>
    <display-name>DateExample</display-name>
    <servlet-name>DateExample</servlet-name>
    <servlet-class>DateExample</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>DateExample</servlet-name>
    <url-pattern>/DateExample</url-pattern>
  </servlet-mapping>
</web-app>

addKeyListener(new KeyAdapter() 
		{
			public void keyTyped(KeyEvent e) 
			{
				// you can use this e.getKeyChar()
                                // or char c = KeyEvent.VK_(your selection here);
			}
		});

import java.io.FileInputStream;
import java.io.InputStream;
//import java.math.BigInteger;
import java.security.InvalidKeyException;
//import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.SignatureException;
//import java.security.interfaces.DSAParams;
import java.security.interfaces.DSAPrivateKey;
import java.security.interfaces.DSAPublicKey;
//import java.security.spec.DSAPublicKeySpec;
//import java.security.spec.KeySpec;

public class SigningDocument 
{
	public static void main(String[] args) throws Exception 
	{
		InputStream in = new FileInputStream("dcaods.pdf");
		int bytesRead=0;
		int bytesToRead=1024;
		byte[] input = new byte[bytesToRead];
		while (bytesRead < bytesToRead) 
		{
			int result = in.read(input, bytesRead, bytesToRead - bytesRead);
			if (result == -1) break;
			bytesRead += result;
		}

		KeyPairGenerator keyGen = KeyPairGenerator.getInstance("DSA");
		keyGen.initialize(1024);
		KeyPair keypair = keyGen.genKeyPair();
		DSAPrivateKey privateKey = (DSAPrivateKey)keypair.getPrivate();
		DSAPublicKey publicKey = (DSAPublicKey)keypair.getPublic();

		/* Data to be sent
		DSAParams dsaParams = privateKey.getParams();
		BigInteger p = dsaParams.getP();
		BigInteger q = dsaParams.getQ();
		BigInteger g = dsaParams.getG();
		BigInteger y = publicKey.getY();
		KeyFactory keyFactory = KeyFactory.getInstance("DSA");
		KeySpec publicKeySpec = new DSAPublicKeySpec(y, p, q, g);
		PublicKey publicKey2 = keyFactory.generatePublic(publicKeySpec);//rebuild key
		byte[] signature= createSignature(privateKey,input);
		*/

		byte[] signature= createSignature(privateKey,input);

		boolean v = verifySignature(publicKey,input,signature);

		System.out.print(v);
	}
	public static byte[] createSignature(PrivateKey key, byte[] buffer) 
	{
		try 
		{
			Signature sig = Signature.getInstance(key.getAlgorithm());
			sig.initSign(key);
			sig.update(buffer, 0, buffer.length);
			return sig.sign();
		} 
		catch (SignatureException e) {} 
		catch (InvalidKeyException e) {} 
		catch (NoSuchAlgorithmException e) {}
		
		return null;
	}
	public static boolean verifySignature(PublicKey key, byte[] buffer, byte[] signature) 
	{
		try 
		{
			Signature sig = Signature.getInstance(key.getAlgorithm());
			sig.initVerify(key);
			sig.update(buffer, 0, buffer.length);
			return sig.verify(signature);
		} 
		catch (SignatureException e) {}
		catch (InvalidKeyException e) {}
		catch (NoSuchAlgorithmException e) {}
		
		return false;
	}
}

import java.io.*;
import java.math.*;
import java.security.*;
import java.security.interfaces.*;
import java.security.spec.*;
import java.util.*;
import java.util.zip.*;
import javax.swing.*;

public class SigningDocument_2 
{
	public static void main(String[] args) throws Exception 
	{
		JFileChooser chooser = new JFileChooser();
		JFrame frame = new JFrame();
		chooser.showOpenDialog(frame);
		File file = chooser.getSelectedFile();
		frame.dispose();

		String FileName = file.getPath();
		InputStream in = new FileInputStream(FileName);

		int bytesRead=0;
		int bytesToRead=(int) new File(FileName).length();
		byte[] input = new byte[bytesToRead];
		while (bytesRead < bytesToRead) 
		{
			int result = in.read(input, bytesRead, bytesToRead - bytesRead);
			if (result == -1) break;
			bytesRead += result;
		}

		byte [] FileNameToByte = FileName.getBytes();

		byte [] DataToSign = new byte[input.length +FileNameToByte.length];

		for (int i = 0; i < input.length; i++)
		{
			DataToSign[i] = input[i];
		}

		int k =0;
		for (int i = input.length; i < DataToSign.length; i++)
		{
			DataToSign[i] = FileNameToByte[k];
			k++;
		}

		KeyPairGenerator keyGen = KeyPairGenerator.getInstance("DSA");
		keyGen.initialize(1024);
		KeyPair keypair = keyGen.genKeyPair();
		DSAPrivateKey privateKey = (DSAPrivateKey)keypair.getPrivate();
		DSAPublicKey publicKey = (DSAPublicKey)keypair.getPublic();

		DSAParams dsaParams = privateKey.getParams();
		BigInteger p = dsaParams.getP();
		BigInteger q = dsaParams.getQ();
		BigInteger g = dsaParams.getG();
		BigInteger y = publicKey.getY();

		byte[] signature= createSignature(privateKey,DataToSign);

		File output = new File("Bytes.txt");
		PrintWriter out = new PrintWriter(output);
		for (int i =0; i < input.length; i++)
		{
			out.println(input[i]);
		}
		out.println(FileName);
		out.close();

		File output2 = new File("Key.txt");
		PrintWriter out2 = new PrintWriter(output2);
		out2.println("DSA");
		out2.println(p);
		out2.println(q);
		out2.println(g);
		out2.println(y);
		out2.close();

		File output3 = new File("Signature.txt");
		PrintWriter out3 = new PrintWriter(output3);
		for (int i =0; i < signature.length; i++)
		{
			out3.println(signature[i]);
		}
		out3.close();

		Zip("Bytes.txt","Key.txt","Signature.txt");
		unZip("Result.zip","checksum.txt");
	}

	public static byte[] createSignature(PrivateKey key, byte[] buffer) 
	{
		try 
		{
			Signature sig = Signature.getInstance(key.getAlgorithm());
			sig.initSign(key);
			sig.update(buffer, 0, buffer.length);
			return sig.sign();
		} 
		catch (SignatureException e) {} 
		catch (InvalidKeyException e) {} 
		catch (NoSuchAlgorithmException e) {}

		return null;
	}

	public static void Zip(String Bytes,String Key,String Signature)
	{
		String[] filenames = new String[]{Bytes,Key,Signature};
		byte[] buf = new byte[1024];

		try 
		{
			String outFilename = "Result.zip";
			ZipOutputStream out = new ZipOutputStream(new FileOutputStream(outFilename));

			for (int i=0; i < filenames.length; i++) 
			{
				FileInputStream in = new FileInputStream(filenames[i]);
				out.putNextEntry(new ZipEntry(filenames[i]));

				int len;
				while ((len = in.read(buf)) > 0) 
				{
					out.write(buf, 0, len);
				}
				out.closeEntry();
				in.close();
			}
			out.close();

			CheckedInputStream cis = new CheckedInputStream(
					new FileInputStream(outFilename), new Adler32());
			byte[] tempBuf = new byte[1024];
			while (cis.read(tempBuf) >= 0) {}

			long checksum = cis.getChecksum().getValue();
			PrintWriter checksumout = new PrintWriter(new File("checksum.txt"));
			checksumout.write(checksum+"");
			checksumout.close();
		} 
		catch (IOException e) {}
	}


	public static void unZip(String zip,String checksumfile) throws NoSuchAlgorithmException, InvalidKeySpecException
	{
		try 
		{
			ZipFile zf = new ZipFile(zip);
			CheckedInputStream cis = new CheckedInputStream(
					new FileInputStream(zip), new Adler32());
			byte[] tempBuf = new byte[1024];
			while (cis.read(tempBuf) >= 0) {}
			long checksum = cis.getChecksum().getValue();

			Scanner scan = new Scanner(new File(checksumfile));
			long verifychecksum = scan.nextLong();

			if (verifychecksum == checksum)
			{

				Enumeration<?> e = zf.entries();
				while (e.hasMoreElements()) 
				{
					ZipEntry ze = (ZipEntry) e.nextElement();

					FileOutputStream fout = new FileOutputStream(ze.getName());
					InputStream in = zf.getInputStream(ze);
					for (int c = in.read(); c != -1; c = in.read())
					{
						fout.write(c);
					}
					in.close();
					fout.close();
				}


				ArrayList<String> Bytes = new ArrayList<String>();
				Scanner scanBytes = new Scanner(new File("Bytes.txt"));
				while(scanBytes.hasNext())
					Bytes.add(scanBytes.nextLine());

				ArrayList<String> Key = new ArrayList<String>();
				Scanner scanKey = new Scanner(new File("Key.txt"));
				while(scanKey.hasNext())
					Key.add(scanKey.nextLine());

				String algorithm = Key.get(0);

				BigInteger p = new BigInteger(Key.get(1));
				BigInteger q = new BigInteger(Key.get(2));
				BigInteger g = new BigInteger(Key.get(3));
				BigInteger y = new BigInteger(Key.get(4));

				KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
				KeySpec publicKeySpec = new DSAPublicKeySpec(y, p, q, g);
				PublicKey publicKey = keyFactory.generatePublic(publicKeySpec);

				ArrayList<String> Signature = new ArrayList<String>();
				Scanner scanSignature = new Scanner(new File("Signature.txt"));
				while(scanSignature.hasNext())
					Signature.add(scanSignature.nextLine());

				byte [] sig = new byte[Signature.size()];

				for (int i =0; i < sig.length;i++)
				{
					sig[i] = new Byte(Signature.get(i));
				}

				byte [] bytes = new byte[Bytes.size()];
				for (int i =0; i < bytes.length-1;i++)
				{
					bytes[i] = new Byte(Bytes.get(i));
				}

				String filename = Bytes.get(Bytes.size()-1);

				byte [] FileNameToByte = filename.getBytes();

				byte [] DataToSign = new byte[bytes.length +FileNameToByte.length-1];

				for (int i = 0; i < bytes.length-1; i++)
				{
					DataToSign[i] = bytes[i];
				}

				int k =0;
				for (int i = bytes.length-1; i < DataToSign.length; i++)
				{
					DataToSign[i] = FileNameToByte[k];
					k++;
				}

				boolean bool = verifySignature(publicKey,DataToSign,sig);

				if(bool)
				{
					BuildFile(filename,bytes);
					Runtime.getRuntime().exec("rundll32 url.dll,FileProtocolHandler " + filename);
				}
				else
					JOptionPane.showMessageDialog(null,"Warning", "Warning Message",JOptionPane.WARNING_MESSAGE);
			}
		} 
		catch (IOException e) {}
	}
	public static boolean verifySignature(PublicKey key, byte[] buffer, byte[] signature) 
	{
		try 
		{
			Signature sig = Signature.getInstance(key.getAlgorithm());
			sig.initVerify(key);
			sig.update(buffer, 0, buffer.length);
			return sig.verify(signature);
		} 
		catch (SignatureException e) {}
		catch (InvalidKeyException e) {}
		catch (NoSuchAlgorithmException e) {}

		return false;
	}
	public static void BuildFile(String FileName,byte[] bytes) throws IOException
	{
		FileOutputStream m = new FileOutputStream(FileName);
		m.write(bytes);
		m.close();
	}
}

for (int i = 0; i < ar.length - 1; i++)

1. for (int i = 0; i < ar.length; i++)
2. for (int j = i+1; j < ar.length; j++)

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

public class Validate extends JFrame
{
	TextField t;
	public Validate()
	{
		t= new TextField(10);
		add(t);
		t.addKeyListener(new KeyAdapter() 
		{
			public void keyPressed(KeyEvent e) 
			{
				int key = e.getKeyCode();
				if ((key == KeyEvent.VK_0))
				{
					JOptionPane.showMessageDialog(null,"0 Was Clicked", "Note",JOptionPane.INFORMATION_MESSAGE);
				}
				else
					if((key == KeyEvent.VK_1)||(key == KeyEvent.VK_2)||(key == KeyEvent.VK_3)||(key == KeyEvent.VK_4)||(key == KeyEvent.VK_5)||(key == KeyEvent.VK_6||(key == KeyEvent.VK_7)||(key == KeyEvent.VK_8)||(key == KeyEvent.VK_9)))
					{
						return;
					}
					else
					{
						JOptionPane.showMessageDialog(null,"Invalid Input", "Note",JOptionPane.WARNING_MESSAGE);
						String s = t.getText();
						t.setText(s.replaceAll(e.getKeyChar()+"",""));
						
					}
			}
		}
		);
		setTitle("Validate");
		setLocationRelativeTo(null);
		pack();
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setVisible(true);
	}
	public static void main(String[] args) 
	{
		new Validate();
	}
}

public Validate() 
	{
		Text.addKeyListener(new KeyAdapter() 
		{
			public void keyTyped(KeyEvent e) 
			{
				char c = e.getKeyChar();
				if (!(Character.isDigit(c) ||(c == KeyEvent.VK_BACK_SPACE) ||(c == KeyEvent.VK_DELETE))) 
				{
					getToolkit().beep();
					e.consume();
				}
				if( c == KeyEvent.VK_0)
				{
					Label.setText("0 entered");
					Label.setForeground(Color.red);
				}
				else
				{        	   
					Label.setText("ok");
					Label.setForeground(Color.black);
				}
			}
		});

public class Validate()
{
DoubleValidate dv = new DoubleValidate();
public Validate() 
	{
		Text.setDocument(dv);
		add(Text);
	}

	static class DoubleValidate extends PlainDocument 
	{
		public void insertString(int offset,String string, AttributeSet attributes)throws BadLocationException 
		{
			if (string == null) 
			{
				return;
			} 
			else 
			{
				String newValue;
				int length = getLength();
				
				if (length == 0) 
				{
					newValue = string;
				} 
				else 
				{
					String currentContent = getText(0, length);
					StringBuffer currentBuffer = new StringBuffer(currentContent);
					currentBuffer.insert(offset, string);
					newValue = currentBuffer.toString();
				}
				try 
				{
					Double.parseDouble(newValue);
					super.insertString(offset, string,attributes);
				} 
				catch (NumberFormatException exception) 
				{
					Toolkit.getDefaultToolkit().beep();
				}
			}
		}
	}
}