Java

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();
				}
			}
		}
	}
}

import java.io.File;
import java.util.*;

public class RegularExpression 
{
	public static void main(String[] args) throws Exception 
	{
		Scanner scan = new Scanner(System.in);
		
		System.out.println("Enter HTML file Name:");
		
		File HtmlFile = new File(scan.next());
		
		Scanner scan2 = new Scanner(HtmlFile);
		
		int FirstIndex =0,LastIndex =0;
		
		ArrayList<String> Bold = new ArrayList<String>();
		
		ArrayList<String> Italics = new ArrayList<String>();
		
		while(scan2.hasNext())
		{
			String q = scan2.nextLine();

			for (int i =0; i <q.length(); i++)
			{
				if (i+3<=q.length())
				{
					if (q.substring(i, i+3).equalsIgnoreCase("<b>"))
					{
						FirstIndex = i+3;

						for (int j = FirstIndex; j <q.length(); j++)
						{
							if (j+4<=q.length())
							{
								if (q.substring(j, j+4).equalsIgnoreCase("</b>"))
								{
									LastIndex = j;
									Bold.add(q.substring(FirstIndex,LastIndex));
									break;
								}
							}
						}
					}
					else
						if (q.substring(i, i+3).equalsIgnoreCase("<i>"))
						{
							for (int j = FirstIndex; j <q.length(); j++)
							{
								if (j+4<=q.length())
								{
									if (q.substring(j, j+4).equalsIgnoreCase("</i>"))
									{
										LastIndex = j;
										Italics.add(q.substring(FirstIndex,LastIndex));
										break;
									}
								}
							}
						}
				}
			}
		}
		
		System.out.println("Bold:");
		
		for (int i =0; i <Bold.size(); i++)
		{
			System.out.println(Bold.get(i));
		}
		
		System.out.println("Italics:");
		
		for (int i =0; i <Bold.size(); i++)
		{
			System.out.println(Italics.get(i));
		}
	}
}