Free Java Codes!!

xSocket

2009-06-06T01:43:00.001-07:00

License:	GNU Library or Lesser General Public License (LGPL)
URL:	http://www.xsocket.org
Description:	xSocket is a lightweight java nio-based server framework to build high performance, high scalable, multithreaded servers.

QuickServer

2009-06-06T01:41:00.000-07:00

License:	GNU Library or Lesser General Public License (LGPL)
URL:	http://www.quickserver.org/
Description:	QuickServer is a free, open source Java library for quick creation of robust and multi-threaded, multi-client TCP server applications.

JmDNS

2009-06-06T01:40:00.000-07:00

License:	GNU Library or Lesser General Public License (LGPL)
URL:	http://jmdns.sourceforge.net
Description:	JmDNS is a java implementation of the IETF draft RFP multicast extensions for DNS.

JAVA SOCKS Server

2009-06-06T01:38:00.000-07:00

License:	GNU General Public License (GPL)
URL:	http://jsocks.sourceforge.net/
Description:	It is a SOCKS server written entirely in Java, which supports both SOCKS4 and SOCKS5 protocols.

Java Sockets

2009-06-06T01:35:00.000-07:00

License:	GNU General Public License (GPL)
URL:	http://www.alhem.net/jsockets/
Description:	Java Sockets is a class library which wraps the nonblocking network I/O.

Coadunation

2009-06-06T01:33:00.000-07:00

License:	GNU Library or Lesser General Public License (LGPL)
URL:	http://www.coadunation.net
Description:	Coadunation is a Java based daemon server. It enables developers to quickly and easily develop daemons, and supplies them with JNDI, RMI/IIOP, container-based security, threading, Automated Deployment, Clustering, Cosnaming, data sources, and much more.

Writing Text to a Socket

2009-04-26T04:57:00.001-07:00

import java.io.BufferedWriter;

import java.io.OutputStreamWriter;

import java.net.ServerSocket;

import java.net.Socket;

public class Main {

public static void main(String[] argv) throws Exception {

int port = 2000;

ServerSocket srv = new ServerSocket(port);

// Wait for connection from client.

Socket socket = srv.accept();

BufferedWriter wr = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

wr.write("aString");

wr.flush();

}

Use Socket to read and write stream

2009-04-26T04:56:00.004-07:00

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.InputStream;

import java.io.OutputStream;

import java.net.Socket;

class SquareClient {

private final static int BUFSIZE = 20;

public static void main(String args[]) throws Exception {

String server = args[0];

int port = Integer.parseInt(args[1]);

double value = Double.valueOf(args[2]).doubleValue();

Socket s = new Socket(server, port);

OutputStream os = s.getOutputStream();

DataOutputStream dos = new DataOutputStream(os);

dos.writeDouble(value);

InputStream is = s.getInputStream();

DataInputStream dis = new DataInputStream(is);

value = dis.readDouble();

System.out.println(value);

s.close();

}

Transfer a file via Socket

2009-04-26T04:56:00.003-07:00

import java.io.BufferedInputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.OutputStream;

import java.net.ServerSocket;

import java.net.Socket;

public class Main {

public static void main(String[] args) throws IOException {

ServerSocket servsock = new ServerSocket(123456);

File myFile = new File("s.pdf");

while (true) {

Socket sock = servsock.accept();

byte[] mybytearray = new byte[(int) myFile.length()];

BufferedInputStream bis = new BufferedInputStream(new FileInputStream(myFile));

bis.read(mybytearray, 0, mybytearray.length);

OutputStream os = sock.getOutputStream();

os.write(mybytearray, 0, mybytearray.length);

os.flush();

sock.close();

}

The client module

import java.io.BufferedOutputStream;

import java.io.FileOutputStream;

import java.io.InputStream;

import java.net.Socket;

public class Main {

public static void main(String[] argv) throws Exception {

Socket sock = new Socket("127.0.0.1", 123456);

byte[] mybytearray = new byte[1024];

InputStream is = sock.getInputStream();

FileOutputStream fos = new FileOutputStream("s.pdf");

BufferedOutputStream bos = new BufferedOutputStream(fos);

int bytesRead = is.read(mybytearray, 0, mybytearray.length);

bos.write(mybytearray, 0, bytesRead);

bos.close();

sock.close();

}

String based communication between Socket

2009-04-26T04:56:00.001-07:00

import java.io.BufferedReader;

import java.io.InputStreamReader;

import java.io.PrintWriter;

import java.net.InetAddress;

import java.net.Socket;

public class BufferedSocketClient {

public static void main(String args[]) throws Exception {

Socket socket1;

int portNumber = 1777;

String str = "initialize";

socket1 = new Socket(InetAddress.getLocalHost(), portNumber);

BufferedReader br = new BufferedReader(new InputStreamReader(socket1.getInputStream()));

PrintWriter pw = new PrintWriter(socket1.getOutputStream(), true);

pw.println(str);

while ((str = br.readLine()) != null) {

System.out.println(str);

pw.println("bye");

if (str.equals("bye"))

break;

}

br.close();

pw.close();

socket1.close();

}

///

import java.io.BufferedReader;

import java.io.InputStreamReader;

import java.io.PrintWriter;

import java.net.ServerSocket;

import java.net.Socket;

public class BufferedSocketServer {

public static void main(String args[]) throws Exception {

int cTosPortNumber = 1777;

String str;

ServerSocket servSocket = new ServerSocket(cTosPortNumber);

System.out.println("Waiting for a connection on " + cTosPortNumber);

Socket fromClientSocket = servSocket.accept();

PrintWriter pw = new PrintWriter(fromClientSocket.getOutputStream(), true);

BufferedReader br = new BufferedReader(new InputStreamReader(fromClientSocket.getInputStream()));

while ((str = br.readLine()) != null) {

System.out.println("The message: " + str);

if (str.equals("bye")) {

pw.println("bye");

break;

} else {

str = "Server returns " + str;

pw.println(str);

}

pw.close();

br.close();

fromClientSocket.close();

}

ServerSocket and Socket for Serializable object

2009-04-26T04:55:00.002-07:00

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.io.Serializable;

import java.net.ServerSocket;

import java.net.Socket;

import java.util.Iterator;

import java.util.Vector;

class ComplexCompany implements Serializable {

private String name;

private ComplexEmployee president;

private Vector departments;

public ComplexCompany(String name) {

this.name = name;

departments = new Vector();

}

public String getName() {

return this.name;

}

public void addDepartment(ComplexDepartment dept) {

departments.addElement(dept);

}

public ComplexEmployee getPresident() {

return this.president;

}

public void addPresident(ComplexEmployee e) {

this.president = e;

}

public Iterator getDepartmentIterator() {

return departments.iterator();

}

public void printCompanyObject() {

System.out.println("The company name is " + getName());

System.out.println("The company president is " + getPresident().getName());

System.out.println(" ");

Iterator i = getDepartmentIterator();

while (i.hasNext()) {

ComplexDepartment d = (ComplexDepartment) i.next();

System.out.println(" The department name is " + d.getName());

System.out.println(" The department manager is " + d.getManager().getName());

System.out.println(" ");

}

class ComplexDepartment implements Serializable {

private String name;

private ComplexEmployee manager;

public ComplexDepartment(String name) {

this.name = name;

}

public String getName() {

return this.name;

}

public ComplexEmployee getManager() {

return this.manager;

}

public void addManager(ComplexEmployee e) {

manager = e;

}

class ComplexEmployee implements Serializable {

private String name;

private int salary;

/** Creates a new instance of ComplexEmployee */

public ComplexEmployee(String name, int salary) {

this.name = name;

this.salary = salary;

}

public String getName() {

return name;

}

public int getSalary() {

return this.salary;

}

public class ComplexSocketServer {

public static void main(String args[]) throws Exception {

ServerSocket servSocket;

Socket fromClientSocket;

int cTosPortNumber = 1777;

String str;

ComplexCompany comp;

servSocket = new ServerSocket(cTosPortNumber);

System.out.println("Waiting for a connection on " + cTosPortNumber);

fromClientSocket = servSocket.accept();

ObjectOutputStream oos = new ObjectOutputStream(fromClientSocket.getOutputStream());

ObjectInputStream ois = new ObjectInputStream(fromClientSocket.getInputStream());

while ((comp = (ComplexCompany) ois.readObject()) != null) {

comp.printCompanyObject();

oos.writeObject("bye bye");

break;

}

oos.close();

fromClientSocket.close();

}

public class ComplexSocketClient {

public static void main(String args[]) throws Exception {

Socket socket1;

int portNumber = 1777;

String str = "";

socket1 = new Socket(InetAddress.getLocalHost(), portNumber);

ObjectInputStream ois = new ObjectInputStream(socket1.getInputStream());

ObjectOutputStream oos = new ObjectOutputStream(socket1.getOutputStream());

ComplexCompany comp = new ComplexCompany("A");

ComplexEmployee emp0 = new ComplexEmployee("B", 1000);

comp.addPresident(emp0);

ComplexDepartment sales = new ComplexDepartment("C");

ComplexEmployee emp1 = new ComplexEmployee("D", 1200);

sales.addManager(emp1);

comp.addDepartment(sales);

ComplexDepartment accounting = new ComplexDepartment("E");

ComplexEmployee emp2 = new ComplexEmployee("F", 1230);

accounting.addManager(emp2);

comp.addDepartment(accounting);

ComplexDepartment maintenance = new ComplexDepartment("Maintenance");

ComplexEmployee emp3 = new ComplexEmployee("Greg Hladlick", 1020);

maintenance.addManager(emp3);

comp.addDepartment(maintenance);

oos.writeObject(comp);

while ((str = (String) ois.readObject()) != null) {

System.out.println(str);

oos.writeObject("bye");

if (str.equals("bye"))

break;

}

ois.close();

oos.close();

socket1.close();

}

Reading Text from a Socket

2009-04-26T04:55:00.001-07:00

import java.io.BufferedReader;

import java.io.InputStreamReader;

import java.net.ServerSocket;

import java.net.Socket;

public class Main {

public static void main(String[] argv) throws Exception {

int port = 2000;

ServerSocket srv = new ServerSocket(port);

// Wait for connection from client.

Socket socket = srv.accept();

BufferedReader rd = new BufferedReader(new InputStreamReader(socket.getInputStream()));

String str;

while ((str = rd.readLine()) != null) {

System.out.println(str);

}

rd.close();

}

Ping a server

2009-04-26T04:54:00.002-07:00

import java.io.DataInputStream;

import java.io.PrintStream;

import java.net.Socket;

public class Main {

public static void main(String[] argv) throws Exception {

Socket t = new Socket("127.0.0.1", 7);

DataInputStream dis = new DataInputStream(t.getInputStream());

PrintStream ps = new PrintStream(t.getOutputStream());

ps.println("Hello");

String str = dis.readUTF();

if (str.equals("Hello"))

System.out.println("Alive!");

else

System.out.println("Dead");

t.close();

}

ObjectInputStream and ObjectOutputStream from Socket

2009-04-26T04:54:00.001-07:00

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.net.InetAddress;

import java.net.Socket;

public class LoopingSocketClient {

public static void main(String args[]) throws Exception {

Socket socket1;

int portNumber = 1777;

String str = "";

socket1 = new Socket(InetAddress.getLocalHost(), portNumber);

ObjectInputStream ois = new ObjectInputStream(socket1.getInputStream());

ObjectOutputStream oos = new ObjectOutputStream(socket1.getOutputStream());

str = "initialize";

oos.writeObject(str);

while ((str = (String) ois.readObject()) != null) {

System.out.println(str);

oos.writeObject("bye");

if (str.equals("bye bye"))

break;

}

ois.close();

oos.close();

socket1.close();

}

Demonstrate Sockets.

2009-04-26T04:53:00.002-07:00

import java.io.InputStream;

import java.io.OutputStream;

import java.net.Socket;

class Whois {

public static void main(String args[]) throws Exception {

int c;

Socket s = new Socket("internic.net", 43);

InputStream in = s.getInputStream();

OutputStream out = s.getOutputStream();

String str = "asdfasdfasdf\n";

byte buf[] = str.getBytes();

out.write(buf);

while ((c = in.read()) != -1) {

System.out.print((char) c);

}

s.close();

}

Create a socket without a timeout

2009-04-26T04:53:00.001-07:00

import java.net.InetAddress;

import java.net.Socket;

public class Main {

public static void main(String[] argv) throws Exception {

InetAddress addr = InetAddress.getByName("java.sun.com");

int port = 80;

Socket socket = new Socket(addr, port);

}

Using the Comparable interface to compare and sort objects

2009-04-26T00:24:00.000-07:00

public class Main {

/**
* Lists the system properties
*/
public void copyArrayExample() {

int[] intArray = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};

int[] arrayCopy = new int[intArray.length];

System.arraycopy(intArray, 0, arrayCopy, 0, intArray.length);

for (int i = 0; i < arrayCopy.length; i++)
System.out.println(arrayCopy[i]);

}

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
new Main().copyArrayExample();
}
}import java.util.Arrays;

/**
*
* @author javadb.com
*/
public class Main {

/**
* Creates objects using the Car class which implements the Comparable
* interface.
* Compares and sorts the objects by mileage.
*/
public void comparableExample() {

//Creating the objects that implements the Comparable interface
Car car1 = new Car("Toyota", 2006, 5000);
Car car2 = new Car("BMW", 2007, 5000);
Car car3 = new Car("Chrysler", 2007, 4000);

//Comparing the objects by calling the compareTo method on one of them
//passing another object as argument.
System.out.println("Car 1 equals Car 2: " + car1.compareTo(car2));
System.out.println("Car 1 equals Car 3: " + car1.compareTo(car3));
System.out.println("Car 2 equals Car 3: " + car2.compareTo(car3));
System.out.println();

//To sort them we create an array which is passed to the Arrays.sort()
//method.
Car[] carArray = new Car[] {car1, car2, car3};
Arrays.sort(carArray);

//Print out the sorted array
for (Car car : carArray)
System.out.println(car.toString());
}

//The Car class used to compare and sort objects.
class Car implements Comparable {

private String make;
private int year;
private int mileage;

public Car(String make, int year, int mileage) {

this.make = make;
this.year = year;
this.mileage = mileage;
}

//Mandatory method when implementing the
//Comparable interface. In this method we
//compare the mileage of the two car objects.
public int compareTo(Object obj) {

if (obj instanceof Car) {

Car car = (Car) obj;
if (this.mileage > car.getMileage())
return 1;
else if (this.mileage < car.getMileage())
return -1;
}
return 0;
}

public void setMake(String make) {
this.make = make;
}

public void setYear(int year) {
this.year = year;
}

public void setMileage(int mileage) {
this.mileage = mileage;
}

public String getMake() {
return make;
}

public int getYear() {
return year;
}

public int getMileage() {
return mileage;
}

public String toString() {

StringBuffer buffer = new StringBuffer();
buffer.append("Make: " + make + "\n");
buffer.append("Year: " + year + "\n");
buffer.append("Mileage: " + mileage + "\n");

return buffer.toString();
}
}

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
new Main().comparableExample();
}
}

The output from the code example above is:

Car 1 equals Car 2: 0
Car 1 equals Car 3: 1
Car 2 equals Car 3: 1

Make: Chrysler
Year: 2007
Mileage: 4000

Make: Toyota
Year: 2006
Mileage: 5000

Make: BMW
Year: 2007
Mileage: 5000

Sorting an Array in Descending (Reverse) Order

2009-04-26T00:23:00.000-07:00

import java.util.Arrays;
import java.util.Collections;

public class Main {

/**
* Example method for sorting an Integer array
* in reverse order.
*/
public void sortIntArrayReverseOrder() {

Integer[] arrayToSort = new Integer[] {
new Integer(48),
new Integer(5),
new Integer(89),
new Integer(80),
new Integer(81),
new Integer(23),
new Integer(45),
new Integer(16),
new Integer(2)
};

Arrays.sort(arrayToSort, Collections.reverseOrder());

for (Integer i : arrayToSort) {
System.out.println(i.intValue());
}

}

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
Main main = new Main();
main.sortIntArrayReverseOrder();
}}

How to copy an array

2009-04-26T00:22:00.002-07:00

public class Main {

/**

* Lists the system properties

public void copyArrayExample() {

int[] intArray = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};

int[] arrayCopy = new int[intArray.length];

System.arraycopy(intArray, 0, arrayCopy, 0, intArray.length);

for (int i = 0; i <>

System.out.println(arrayCopy[i]);

}

/**

* @param args the command line arguments

public static void main(String[] args) {

new Main().copyArrayExample();

}

Extend the size of an array

2009-04-26T00:22:00.001-07:00

public class Main {

/**

* Extends the size of an array.

public void extendArraySize() {

String[] names = new String[] {"Joe", "Bill", "Mary"};

//Create the extended array

String[] extended = new String[5];

//Add more names to the extended array

extended[3] = "Carl";

extended[4] = "Jane";

//Copy contents from the first names array to the extended array

System.arraycopy(names, 0, extended, 0, names.length);

//Ouput contents of the extended array

for (String str : extended)

System.out.println(str);

}

/**

* Starts the program

* @param args the command line arguments

public static void main(String[] args) {

new Main().extendArraySize();

}

Convert an Array to a List

2009-04-26T00:19:00.000-07:00

public class Main {

public void arrayToList() {

String[] cars = {"Dodge", "Chevrolet", "BMW", "Toyota"};
List carList = Arrays.asList(cars);

for (String car : carList) {
System.out.println(car);
}
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
new Main().arrayToList();
}
}

Using a Stack

2009-04-26T00:18:00.002-07:00

//Create the Stack instance and add a couple of elements to it
Stack stack = new Stack();

String s1 = "element 1";
String s2 = "element 2";

stack.push(s1);
stack.push(s2);

Now we have two elements in the stack, and to check what element is at the top of the stack (and will be the first to be removed) we use the peek() method to find out.

System.out.println(stack.peek());

The output is:

element 2

To find out the position of the first element, we use the method search().

//Find position of a certain element
int pos = stack.search("element 1");
System.out.println(pos);

//Code example by www.javadb.com

This will print out the position within the stack.

2

To remove elements from the stack, we use the method pop().

System.out.println(stack.pop());
System.out.println(stack.pop());

This will result in the output:

element 2
element 1

The 'element 2' was added after 'element 1' so that element is removed first.
Now the stack is empty, and to be sure we check with the empty method:

System.out.println(stack.empty());

true

Using a Set (or HashSet)

2009-04-26T00:18:00.001-07:00

import java.util.HashSet;
import java.util.Set;

public class Main {

/**
* Example method for using a Set
*/
public void hashSetExample() {

Set vehicles = new HashSet();

//Declare some string items
String item_1 = "Car";
String item_2 = "Bicycle";
String item_3 = "Tractor";

boolean result;

//Add the items to the Set
result = vehicles.add(item_1);
System.out.println(item_1 + ": " + result);

result = vehicles.add(item_2);
System.out.println(item_2 + ": " + result);

result = vehicles.add(item_3);
System.out.println(item_3 + ": " + result);

//Now we try to add item_1 again
result = vehicles.add(item_1);
System.out.println(item_1 + ": " + result);

//Adding null
result = vehicles.add(null);
System.out.println("null: " + result);

//Adding null again
result = vehicles.add(null);
System.out.println("null: " + result);
}

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
new Main().hashSetExample();
}
}

The output from the code is:

Car: true
Bicycle: true
Tractor: true
Car: false
null: true
null: false

Using a Queue (or LinkedList)

2009-04-26T00:17:00.002-07:00

import java.util.LinkedList;
import java.util.Queue;

public class Main {

/**
* Example method for using a Queue
*/
public void queueExample() {

Queue queue = new LinkedList();

//Using the add method to add items.
//Should anything go wrong an exception will be thrown.
queue.add("item1");
queue.add("item2");

//Using the offer method to add items.
//Should anything go wrong it will just return false
queue.offer("Item3");
queue.offer("Item4");

//Removing the first item from the queue.
//If the queue is empty a java.util.NoSuchElementException will be thrown.
System.out.println("remove: " + queue.remove());

//Checking what item is first in line without removing it
//If the queue is empty a java.util.NoSuchElementException will be thrown.
System.out.println("element: " + queue.element());

//Removing the first item from the queue.
//If the queue is empty the method just returns false.
System.out.println("poll: " + queue.poll());

//Checking what item is first in line without removing it
//If the queue is empty a null value will be returned.
System.out.println("peek: " + queue.peek());

}

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
new Main().queueExample();
}
}

The output from the code below is:

remove: item1
element: item2
poll: item2
peek: Item3

Convert LinkedList to Array

2009-04-26T00:17:00.001-07:00

package com.javadb.examples;

import java.util.LinkedList;

import java.util.List;

public class Main {

public void convertLinkedListToArray() {

List theList = new LinkedList();

theList.add("Apples");

theList.add("Bananas");

theList.add("Oranges");

theList.add("Grapes");

String[] fruits = theList.toArray(new String[0]);

for (int i = 0; i <>

System.out.println(fruits[i]);

}

public static void main(String[] args) {

new Main().convertLinkedListToArray();

}

We could also have done the conversion like this:

String[] fruits = new String[theList.size()];

theList.toArray(fruits);

The output looks like this:

Apples

Bananas

Oranges

Grapes

Convert a List (ArrayList) to an Array

2009-04-26T00:15:00.000-07:00

public class Main {

public void ListToArray() {

List carList = new ArrayList();

carList.add("Dodge");

carList.add("Chevrolet");

carList.add("BMW");

carList.add("Toyota");

String[] carArray = carList.toArray(new String[0]);

for (String car : carArray) {

System.out.println(car);

}

/**

* @param args the command line arguments

public static void main(String[] args) {

new Main().ListToArray();

}

The code above generate the following output (the elements are ordered similarly in the array as in the list):

Dodge

Chevrolet

BMW

Toyota

How to list the contents of a zip file

2009-04-26T00:14:00.002-07:00

import java.io.IOException;

import java.util.Enumeration;

import java.util.zip.ZipEntry;

import java.util.zip.ZipFile;

public class Main {

public void listContentsOfZipFile() {

try {

ZipFile zipFile = new ZipFile("testfile.zip");

Enumeration zipEntries = zipFile.entries();

while (zipEntries.hasMoreElements()) {

//Process the name, here we just print it out

System.out.println(((ZipEntry)zipEntries.nextElement()).getName());

}

} catch (IOException ex) {

ex.printStackTrace();

}

/**

* @param args the command line arguments

public static void main(String[] args) {

new Main().listContentsOfZipFile();

}

How to create a zip file

2009-04-26T00:14:00.001-07:00

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.zip.ZipEntry;

import java.util.zip.ZipOutputStream;

public class Main {

/**

* Creates a zip file

public void createZipFile() {

try {

String inputFileName = "test.txt";

String zipFileName = "compressed.zip";

//Create input and output streams

FileInputStream inStream = new FileInputStream(inputFileName);

ZipOutputStream outStream = new ZipOutputStream(new FileOutputStream(zipFileName));

// Add a zip entry to the output stream

outStream.putNextEntry(new ZipEntry(inputFileName));

byte[] buffer = new byte[1024];

int bytesRead;

//Each chunk of data read from the input stream

//is written to the output stream

while ((bytesRead = inStream.read(buffer)) > 0) {

outStream.write(buffer, 0, bytesRead);

}

//Close zip entry and file streams

outStream.closeEntry();

outStream.close();

inStream.close();

} catch (IOException ex) {

ex.printStackTrace();

}

/**

* @param args the command line arguments

public static void main(String[] args) {

new Main().createZipFile();

}

Extract contents of a zip file

2009-04-26T00:12:00.002-07:00

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.OutputStream;

import java.util.zip.ZipEntry;

import java.util.zip.ZipInputStream;

public class Main {

/**

* Extracts a zip file

public void extractZipFile() {

try {

String zipFileName = "compressed.zip";

String extractedFileName = "extracted.txt";

//Create input and output streams

ZipInputStream inStream = new ZipInputStream(new FileInputStream(zipFileName));

OutputStream outStream = new FileOutputStream(extractedFileName);

ZipEntry entry;

byte[] buffer = new byte[1024];

int nrBytesRead;

//Get next zip entry and start reading data

if ((entry = inStream.getNextEntry()) != null) {

while ((nrBytesRead = inStream.read(buffer)) > 0) {

outStream.write(buffer, 0, nrBytesRead);

}

//Finish off by closing the streams

outStream.close();

inStream.close();

} catch (IOException ex) {

ex.printStackTrace();

}

/**

* @param args the command line arguments

public static void main(String[] args) {

new Main().extractZipFile();

}

Using a database transaction with JDBC

2009-04-26T00:12:00.001-07:00

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.SQLException;

import java.sql.Statement;

public class Main {

/**

* Updates tables using a transaction

public void updateDatabaseWithTransaction() {

Connection connection = null;

Statement statement = null;

try {

Class.forName("[nameOfDriver]");

connection = DriverManager.getConnection("[databaseURL]",

"[userid]",

"[password]");

//Here we set auto commit to false so no changes will take

//effect immediately.

connection.setAutoCommit(false);

statement = connection.createStatement();

//Execute the queries

statement.executeUpdate("UPDATE Table1 SET Value = 1 WHERE Name = 'foo'");

statement.executeUpdate("UPDATE Table2 SET Value = 2 WHERE Name = 'bar'");

//No changes has been made in the database yet, so now we will commit

//the changes.

connection.commit();

} catch (ClassNotFoundException ex) {

ex.printStackTrace();

} catch (SQLException ex) {

ex.printStackTrace();

try {

//An error occured so we rollback the changes.

connection.rollback();

} catch (SQLException ex1) {

ex1.printStackTrace();

}

} finally {

try {

if (statement != null)

statement.close();

if (connection != null)

connection.close();

} catch (SQLException ex) {

ex.printStackTrace();

}

/**

* @param args the command line arguments

public static void main(String[] args) {

new Main().updateDatabaseWithTransaction();

}

Connecting to a Database - Step by Step

2009-04-26T00:11:00.000-07:00

Class.forName("[nameOfDriver]");

//For Microsoft SQL Server that would be

Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");

For the JVM to be able to find that class, you need to make sure the class is in your classpath.

Usually the class is located within a .jar-file that can be downloaded from the database vendor.

Creating the database connection

To create the connection you use the static method getConnection() of the java.sql.DriverManager class.

The method has several overloaded variants, and one of them takes an url, userid and password as arguments.

The database url slightly differs from one type of database to another. For Microsoft SQL Server it looks like this:

//The values within square brackets are the ones to change to suite your environment,

//and the square brackets should thus not be included

Connection con = DriverManager.getConnection("jdbc:sqlserver://[server]:[port];databaseName=[nameofdatabase]",

"[userid]",

"[password]");

Create the Statement object and executing a query

Now that we have established a connection, we want to create a Statement object and execute an sql query.

Statement statement = con.createStatement();

ResultSet rs = statement.executeQuery("SELECT * FROM table");

Now we have retrieved the data from the table called 'table' into a ResultSet and all we have to do now is loop through it.

Assume the table has two columns called id which is of type int, and value which is of type varchar:

//The next() mehtod jumps to the next row in the ResultSet.

//When the last row has been processed, the method returns false.

while (rs.next()) {

System.out.println(rs.getInt("id") + " - " + rs.getString("value"));

}

Cleaning up resources

Now all we have to do is close the connection. Actually we should close all of the instances of Connection, Statement and ResultSet and

it's done in reverse order from which they were created:

if (rs != null)

rs.close();

if (statement != null)

statement.close();

if (con != null)

con.close();

For many of the code statements above it is required to handle an SQLException in case anything goes wrong.

Thus you'll have to enclose much of the code in a try / catch block which were excluded in the example to make it more readable.

// Declare the variables outside the try block to be able to call them

// in a finally block where the closing should take place.

Connection con = null;

Statement stmt = null;

ResultSet rs = null;

try {

//all code here

} catch (SQLException ex) {

ex.printStackTrace();

} finally {

//the code for closing here

}

Connect to database and call stored procedure

2009-04-26T00:10:00.000-07:00

Connection con = null;

CallableStatement proc_stmt = null;

ResultSet rs = null;

try {

Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");

con = DriverManager.getConnection("jdbc:sqlserver://MYSERVER;databaseName=MYDATABASE", "USERID", "PASSWORD");

proc_stmt = con.prepareCall("{ call generateID(?) }");

proc_stmt.setString(1, "employee");

rs = proc_stmt.executeQuery();

if (rs.next()) {

int employeeId = rs.getInt(1);

System.out.println("Generated employeeId: " + employeeId);

} else {

System.out.println("Stored procedure couldn't generate new Id");

}

} catch (ClassNotFoundException ex) {

ex.printStackTrace();

} catch (SQLException ex) {

ex.printStackTrace();

} finally {

try {

rs.close();

proc_stmt.close();

con.close();

} catch (SQLException ex) {

ex.printStackTrace();

}

In the second example we do about just the same as above except that this time we don't provide an argument to the stored procedure and we don't receive any return value.

Connection con = null;

CallableStatement proc_stmt = null;

try {

Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");

con = DriverManager.getConnection("jdbc:sqlserver://MYSERVER;databaseName=MYDATABASE", "USERID", "PASSWORD");

proc_stmt = con.prepareCall("{ call someStoredProc() }");

proc_stmt.executeQuery();

} catch (ClassNotFoundException ex) {

ex.printStackTrace();

} catch (SQLException ex) {

ex.printStackTrace();

} finally {

try {

proc_stmt.close();

con.close();

} catch (SQLException ex) {

ex.printStackTrace();

}

Connect to a database and read from table

2009-04-26T00:05:00.000-07:00

import java.sql.DriverManager;

import java.sql.Statement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Connection;

public class DBTest {

Connection m_Connection = null;

Statement m_Statement = null;

ResultSet m_ResultSet = null;

String m_Driver = "com.microsoft.jdbc.sqlserver.SQLServerDriver";

String m_Url = "jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=MyDatabase";

public DBTest() {

//Load driver

try {

Class.forName(m_Driver);

}

catch (ClassNotFoundException ex) {

ex.printStackTrace();

}

public void doWork() {

String query = "";

try {

//Create connection object

m_Connection = DriverManager.getConnection(m_Url, "userid", "password");

//Create Statement object

m_Statement = m_Connection.createStatement();

query = "SELECT * FROM MyTable";

//Execute the query

m_ResultSet = m_Statement.executeQuery(query);

//Loop through the results

while (m_ResultSet.next()) {

System.out.print(m_ResultSet.getString(1));

System.out.print(", ");

System.out.print(m_ResultSet.getString(2));

System.out.print(", ");

System.out.print(m_ResultSet.getString(3));

System.out.print("\n"); //new line

}

catch (SQLException ex) {

ex.printStackTrace();

System.out.println(query);

}

finally {

try {

if (m_ResultSet != null)

m_ResultSet.close();

if (m_Statement != null)

m_Statement.close();

if (m_Connection != null)

m_Connection.close();

}

catch (SQLException ex) {

ex.printStackTrace();

}

public static void main(String[] args) {

DBTest dbTest = new DBTest();

dbTest.doWork();

}

Convert String to byte array

2009-04-26T00:04:00.002-07:00

public class Main {

* This method converts a String to an array of bytes

public void convertStringToByteArray() {

String stringToConvert = "This String is 76 characters long and will be converted to an array of bytes";

byte[] theByteArray = stringToConvert.getBytes();

System.out.println(theByteArray.length);

}

/**

* @param args the command line arguments

public static void main(String[] args) {

new Main().convertStringToByteArray();

}

When executed, the code will output the length of the array: 76

Convert String to Boolean

2009-04-26T00:04:00.001-07:00

public class Main {

/**

* String to boolean conversion

public void convertStringToBoolean() {

String strBoolean = "true";

//Do the String to boolean conversion

boolean theValue = Boolean.parseBoolean(strBoolean);

System.out.println(theValue);

}

/**

* Starts the program

* @param args the command line arguments

public static void main(String[] args) {

new Main().convertStringToBoolean();

}

Convert byte[ ] array to String

2009-04-26T00:03:00.000-07:00

public class Main {

* This method converts an byte array to a String object.

public void convertByteArrayToString() {

byte[] byteArray = new byte[] {87, 79, 87, 46, 46, 46};

String value = new String(byteArray);

System.out.println(value);

}

/**

* @param args the command line arguments

public static void main(String[] args) {

new Main().convertByteArrayToString();

}

When executed the output of the code above will be:

WOW...

Convert byte to String

2009-04-26T00:02:00.000-07:00

public class Main {

/**

* Example method for converting a byte to a String.

public void convertByteToString() {

byte b = 65;

//Using the static toString method of the Byte class

System.out.println(Byte.toString(b));

//Using simple concatenation with an empty String

System.out.println(b + "");

//Creating a byte array and passing it to the String constructor

System.out.println(new String(new byte[] {b}));

}

/**

* @param args the command line arguments

public static void main(String[] args) {

new Main().convertByteToString();

}

Convert Boolean to String

2009-04-25T23:59:00.002-07:00

public class Main {

/**

* Boolean to String conversion

public void convertBooleanToString() {

boolean theValue = true;

//Do the boolean to String conversion

String theValueAsString = new Boolean(theValue).toString();

System.out.println(theValueAsString);

}

/**

* Starts the program

* @param args the command line arguments

public static void main(String[] args) {

new Main().convertBooleanToString();

}

Using BufferedReader to read input number from user

2009-04-25T23:59:00.001-07:00

package com.javadb.examples;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

public class Main {

public static void main(String[] args) {

try {

BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

String input = reader.readLine();

double number = Double.parseDouble(input);

System.out.println("Square root of input number " + input + " is: " + Math.sqrt(number));

//Not really necessary in this case but since we want to

//write clean code...

reader.close();

} catch (IOException e) {

e.printStackTrace();

} catch (NumberFormatException e) {

System.out.println("Input by user was not a number.");

e.printStackTrace();

}

So if we for example type in 12345, the output from the program looks like:

Square root of input number 12345 is: 111.1080555135405

Remove a line from a text file

2009-04-25T23:58:00.000-07:00

import java.io.BufferedReader;

import java.io.FileReader;

import java.io.File;

import java.io.FileWriter;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.PrintWriter;

public class FileUtil {

public void removeLineFromFile(String file, String lineToRemove) {

try {

File inFile = new File(file);

if (!inFile.isFile()) {

System.out.println("Parameter is not an existing file");

return;

}

//Construct the new file that will later be renamed to the original filename.

File tempFile = new File(inFile.getAbsolutePath() + ".tmp");

BufferedReader br = new BufferedReader(new FileReader(file));

PrintWriter pw = new PrintWriter(new FileWriter(tempFile));

String line = null;

//Read from the original file and write to the new

//unless content matches data to be removed.

while ((line = br.readLine()) != null) {

if (!line.trim().equals(lineToRemove)) {

pw.println(line);

pw.flush();

}

pw.close();

br.close();

//Delete the original file

if (!inFile.delete()) {

System.out.println("Could not delete file");

return;

}

//Rename the new file to the filename the original file had.

if (!tempFile.renameTo(inFile))

System.out.println("Could not rename file");

}

catch (FileNotFoundException ex) {

ex.printStackTrace();

}

catch (IOException ex) {

ex.printStackTrace();

}

public static void main(String[] args) {

FileUtil util = new FileUtil();

util.removeLineFromFile("test.txt", "bbbbb");

}

The file test.txt now looks like this:

aaaaa

ccccc

Read Input From User and Write to File

2009-04-25T23:57:00.002-07:00

package com.javadb.examples;

import java.io.BufferedWriter;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStream;

public class Main {

public void readInputFromUser() {

BufferedWriter bw = null;

try {

InputStream in = System.in;

bw = new BufferedWriter(new FileWriter("output.txt"));

StringBuilder builder = new StringBuilder();

int letter;

while ((letter = in.read()) != -1) {

bw.write((char)letter);

bw.flush();

builder.append((char) letter);

if (builder.toString().endsWith("finished")) {

System.exit(0);

}

} catch (IOException e) {

e.printStackTrace();

} finally {

if (bw != null) {

try {

bw.close();

} catch (IOException ex) {

ex.printStackTrace();

}

public static void main(String[] args) {

new Main().readInputFromUser();

}

Loading configuration parameters from textfile into a program

2009-04-25T23:57:00.001-07:00

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.util.Enumeration;

import java.util.Properties;

public class Main {

Properties config;

/**

* Loads configuration parameters from a textfile and print them out.

public void loadConfigFile() {

//Load configuration file

String filename = "conf/systemconfig.txt";

config = new Properties();

try {

config.load(new FileInputStream(filename));

} catch (FileNotFoundException ex) {

ex.printStackTrace();

return;

} catch (IOException ex) {

ex.printStackTrace();

return;

}

//Print out the configuration parameters

Enumeration en = config.keys();

System.out.println("********** System configuration **********");

while (en.hasMoreElements()) {

String key = (String) en.nextElement();

System.out.println(key + " => " + config.get(key));

}

/**

* Starts the program

* @param args the command line arguments

public static void main(String[] args) {

new Main().loadConfigFile();

}

This is the output after printing out the loaded configuration parameters:

********** System configuration **********

parameter2 => value2

parameter1 => value1

How to rename a file (change file name)

2009-04-25T23:54:00.000-07:00

import java.io.File;

public class Main {

public void renameFile(String file, String toFile) {

File toBeRenamed = new File(file);

if (!toBeRenamed.exists() || toBeRenamed.isDirectory()) {

System.out.println("File does not exist: " + file);

return;

}

File newFile = new File(toFile);

//Rename

if (toBeRenamed.renameTo(newFile)) {

System.out.println("File has been renamed.");

} else {

System.out.println("Error renmaing file");

}

public static void main(String[] args) {

new Main().renameFile("C:\\temp\\file1.txt", "C:\\temp\\file2.txt");

}

Drawing a String using Java 2D Graphics API

2009-04-25T23:53:00.000-07:00

import java.awt.Graphics;

import java.awt.Graphics2D;

/**

* Displays a JFrame and draws text on it using the Java 2D Graphics API

public class Java2DFrame extends javax.swing.JFrame {

/**

* Creates a new instance of Java2DFrame

public Java2DFrame() {

initComponents();

}

/**

* This is the method where the String is drawn.

* @param g The graphics object

public void paint(Graphics g) {

Graphics2D graphics = (Graphics2D) g;

graphics.drawString("Using Java 2D API to draw a String", 20, 100);

}

private void initComponents() {

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

org.jdesktop.layout.GroupLayout layout = new org.jdesktop.layout.GroupLayout(getContentPane());

getContentPane().setLayout(layout);

layout.setHorizontalGroup(

layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)

.add(0, 400, Short.MAX_VALUE)

);

layout.setVerticalGroup(

layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)

.add(0, 300, Short.MAX_VALUE)

);

pack();

}//

/**

* Starts the program

* @param args the command line arguments

public static void main(String args[]) {

java.awt.EventQueue.invokeLater(new Runnable() {

public void run() {

new Java2DFrame().setVisible(true);

}

});

}

Drawing a Ractangle with rounded corners using Java 2D Graphics API

2009-04-25T23:52:00.000-07:00

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.geom.RoundRectangle2D;

/**

* Displays a JFrame and draws a rounded ractangle on it using the Java 2D Graphics API

public class Java2DFrame extends javax.swing.JFrame {

/**

* Creates a new instance of Java2DFrame

public Java2DFrame() {

initComponents();

}

/**

* This is the method where the rounded rectangle is drawn.

* @param g The graphics object

public void paint(Graphics g) {

Graphics2D graphics2 = (Graphics2D) g;

RoundRectangle2D roundedRectangle = new RoundRectangle2D.Float(100, 100, 240, 160, 10, 10);

graphics2.draw(roundedRectangle);

}

private void initComponents() {

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

org.jdesktop.layout.GroupLayout layout = new org.jdesktop.layout.GroupLayout(getContentPane());

getContentPane().setLayout(layout);

layout.setHorizontalGroup(

layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)

.add(0, 400, Short.MAX_VALUE)

);

layout.setVerticalGroup(

layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)

.add(0, 300, Short.MAX_VALUE)

);

pack();

}//

/**

* Starts the program

* @param args the command line arguments

public static void main(String args[]) {

java.awt.EventQueue.invokeLater(new Runnable() {

public void run() {

new Java2DFrame().setVisible(true);

}

});

}

Drawing a Ractangle using Java 2D Graphics API

2009-04-25T23:51:00.000-07:00

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.geom.Rectangle2D;

/**

* Displays a JFrame and draws a ractangle on it using the Java 2D Graphics API

public class Java2DFrame extends javax.swing.JFrame {

/**

* Creates a new instance of Java2DFrame

public Java2DFrame() {

initComponents();

}

/**

* This is the method where the rectangle is drawn.

* @param g The graphics object

public void paint(Graphics g) {

Graphics2D graphics2 = (Graphics2D) g;

Rectangle2D rectangle = new Rectangle2D.Float(100, 100, 240, 160);

graphics2.draw(rectangle);

}

private void initComponents() {

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

org.jdesktop.layout.GroupLayout layout = new org.jdesktop.layout.GroupLayout(getContentPane());

getContentPane().setLayout(layout);

layout.setHorizontalGroup(

layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)

.add(0, 400, Short.MAX_VALUE)

);

layout.setVerticalGroup(

layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)

.add(0, 300, Short.MAX_VALUE)

);

pack();

}//

/**

* Starts the program

* @param args the command line arguments

public static void main(String args[]) {

java.awt.EventQueue.invokeLater(new Runnable() {

public void run() {

new Java2DFrame().setVisible(true);

}

});

}

Drawing a Line using Java 2D Graphics API

2009-04-25T23:48:00.002-07:00

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.geom.Line2D;

/**

* Displays a JFrame and draws a line on it using the Java 2D Graphics API

public class Java2DFrame extends javax.swing.JFrame {

/**

* Creates a new instance of Java2DFrame

public Java2DFrame() {

initComponents();

}

/**

* This is the method where the line is drawn.

* @param g The graphics object

public void paint(Graphics g) {

Graphics2D g2 = (Graphics2D) g;

Line2D lin = new Line2D.Float(100, 100, 250, 260);

g2.draw(lin);

}

private void initComponents() {

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

org.jdesktop.layout.GroupLayout layout = new org.jdesktop.layout.GroupLayout(getContentPane());

getContentPane().setLayout(layout);

layout.setHorizontalGroup(

layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)

.add(0, 400, Short.MAX_VALUE)

);

layout.setVerticalGroup(

layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)

.add(0, 300, Short.MAX_VALUE)

);

pack();

}//

/**

* Starts the program

* @param args the command line arguments

public static void main(String args[]) {

java.awt.EventQueue.invokeLater(new Runnable() {

public void run() {

new Java2DFrame().setVisible(true);

}

});

}

Replace Characters in a String

2009-04-25T23:48:00.001-07:00

public class Main {

/**

* This method replaces characters in a string

public void replaceCharacters() {

String str = "aaa bbb ccc";

str = str.replace('b', 'd');

System.out.println(str);

}

/**

* Starts the program

* @param args the command line arguments

public static void main(String[] args) {

new Main().replaceCharacters();

}

When the code above is executed it will display:

aaa ddd ccc

Get Name of User Currently Logged In to the Computer

2009-04-25T23:47:00.000-07:00

public class Main {

public void getCurrentUser() {

String currentUser = System.getProperty("user.name");

System.out.println("Current user is " + currentUser);

}

/**

* @param args the command line arguments

public static void main(String[] args) {

new Main().getCurrentUser();

}

Convert Characters to Upper Case

2009-04-25T23:46:00.000-07:00

public class Main {

/**

* Converts all lower case characters to upper case

public void stringToUpperCase() {

String str = "All Lower Case Characters In This String Will Be Converted To Upper Case";

str = str.toUpperCase();

System.out.println(str);

}

/**

* Starts the program

* @param args the command line arguments

public static void main(String[] args) {

new Main().stringToUpperCase();

}

The result of the above code when executed:

ALL LOWER CASE CHARACTERS IN THIS STRING WILL BE CONVERTED TO UPPER CASE

Convert Characters to Lower Case

2009-04-25T23:45:00.000-07:00

public class Main {

/**

* Converts all upper case characters to lower case

public void stringToLowerCase() {

String str = "All Upper Case Characters In This String Will Be Converted To Lower Case";

str = str.toLowerCase();

System.out.println(str);

}

/**

* Starts the program

* @param args the command line arguments

public static void main(String[] args) {

new Main().stringToLowerCase();

}

The result of the above code when executed:

all upper case characters in this string will be converted to lower case

Convert a String to Date

2009-04-25T23:44:00.000-07:00

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

public class Main {

public void convertStringToDate(int date, int month, int year) {

SimpleDateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy");

String in = date + "/" + month + "/" + year;

try {

Date theDate = dateFormat.parse(in);

System.out.println("Date parsed = " + dateFormat.format(theDate));

} catch (ParseException e) {

e.printStackTrace();

}

/**

* @param args the command line arguments

public static void main(String[] args) {

new Main().convertStringToDate(01, 01, 2015);

}

The output from the code above looks like:

Date parsed = 01/01/2015

Sending a POST Request with Parameters From a Java Class

2009-04-25T23:42:00.001-07:00

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.net.MalformedURLException;

import java.net.URL;

import java.net.URLConnection;

public class Main {

/**

* Extends the size of an array.

public void sendPostRequest() {

//Build parameter string

String data = "width=50&height=100";

try {

// Send the request

URL url = new URL("http://www.somesite.com");

URLConnection conn = url.openConnection();

conn.setDoOutput(true);

OutputStreamWriter writer = new OutputStreamWriter(conn.getOutputStream());

//write parameters

writer.write(data);

writer.flush();

// Get the response

StringBuffer answer = new StringBuffer();

BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));

String line;

while ((line = reader.readLine()) != null) {

answer.append(line);

}

writer.close();

reader.close();

//Output the response

System.out.println(answer.toString());

} catch (MalformedURLException ex) {

ex.printStackTrace();

} catch (IOException ex) {

ex.printStackTrace();

}

/**

* Starts the program

* @param args the command line arguments

public static void main(String[] args) {

new Main().sendPostRequest();

}

Perform NSLookup with the InetAddress class

2009-04-25T23:41:00.000-07:00

import java.net.InetAddress;

import java.net.UnknownHostException;

public class Main {

* This method performs a NS Lookup

public void performNSLookup() {

try {

InetAddress inetHost = InetAddress.getByName("cnn.com");

String hostName = inetHost.getHostName();

System.out.println("The host name was: " + hostName);

System.out.println("The hosts IP address is: " + inetHost.getHostAddress());

} catch(UnknownHostException ex) {

System.out.println("Unrecognized host");

}

/**

* @param args the command line arguments

public static void main(String[] args) {

new Main().performNSLookup();

}

Downloading a web page using URL and URLConnection classes

2009-04-25T23:39:00.000-07:00

import java.io.BufferedInputStream;

import java.io.IOException;

import java.net.MalformedURLException;

import java.net.URL;

import java.net.URLConnection;

public class Main {

/**

* Reads a web page into a StringBuilder object

* and prints it out to console along with the

* size of the page.

public void getWebSite() {

try {

URL url = new URL("http://www.google.com");

URLConnection urlc = url.openConnection();

BufferedInputStream buffer = new BufferedInputStream(urlc.getInputStream());

StringBuilder builder = new StringBuilder();

int byteRead;

while ((byteRead = buffer.read()) != -1)

builder.append((char) byteRead);

buffer.close();

System.out.println(builder.toString());

System.out.println("The size of the web page is " + builder.length() + " bytes.");

} catch (MalformedURLException ex) {

ex.printStackTrace();

} catch (IOException ex) {

ex.printStackTrace();

}

/**

* Starts the program

* @param args the command line arguments

public static void main(String[] args) {

new Main().getWebSite();

}

weblech

2009-04-25T12:44:00.001-07:00

webharvest

2009-04-25T12:43:00.001-07:00

webeater

2009-04-25T12:42:00.000-07:00

jspider

2009-04-25T12:41:00.000-07:00

jobo

2009-04-25T12:40:00.000-07:00

List methods of a class using Reflection

2009-04-25T12:12:00.001-07:00

import java.lang.reflect.Method;

public class Main {

/**
* Lists the methods of a class using the Reflection api.
*/
public void listMethodsUsingReflection() {

//Obtain the Class instance
Class personClass = Person.class;

//Get the methods
Method[] methods = personClass.getDeclaredMethods();

//Loop through the methods and print out their names
for (Method method : methods) {
System.out.println(method.getName());
}
}

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
new Main().listMethodsUsingReflection();
}

class Person {

private String firstname;
private String lastname;
private String age;

public String getFirstname() {
return firstname;
}

public void setFirstname(String firstname) {
this.firstname = firstname;
}

public String getLastname() {
return lastname;
}

public void setLastname(String lastname) {
this.lastname = lastname;
}

public String getAge() {
return age;
}

public void setAge(String age) {
this.age = age;
}
}
}

If you run the example code above the output will be:

getFirstname
setFirstname
getLastname
setLastname
getAge
setAge

Invoke methods of an object using reflection

2009-04-25T12:11:00.001-07:00

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Main {

/**
* Invokes the methods of an object using the Reflection api.
*/
public void invokeMethodsUsingReflection() {

//Obtain the Class instance
Class computerClass = Computer.class;

//Get the methods
Method[] methods = computerClass.getDeclaredMethods();

//Create the object that we want to invoke the methods on
Computer computer = new Computer();

//Loop through the methods and invoke them
for (Method method : methods) {
Object result;
try {
//Call the method. Since none of them takes arguments we just
//pass an empty array as second parameter.
result = method.invoke(computer, new Object[0]);
} catch (IllegalArgumentException ex) {
ex.printStackTrace();
return;
} catch (InvocationTargetException ex) {
ex.printStackTrace();
return;
} catch (IllegalAccessException ex) {
ex.printStackTrace();
return;
}
System.out.println(method.getName() + ": " + result);
}
}

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
new Main().invokeMethodsUsingReflection();
}

class Computer {

private String brand = "DELL";
private String type = "Laptop";
private int harddiskSize_GB = 300;
private boolean AntiVirusInstalled = true;

public String getBrand() {
return brand;
}

public String getType() {
return type;
}

public int getHarddiskSize_GB() {
return harddiskSize_GB;
}

public boolean isAntiVirusInstalled() {
return AntiVirusInstalled;
}
}
}

The output of the code above is:

getBrand: DELL
getHarddiskSize_GB: 300
isAntiVirusInstalled: true
getType: Laptop

Instantiate unknown class at runtime and call the object's methods

2009-04-25T12:08:00.000-07:00

package com.javadb.examples;

import java.lang.reflect.Method;

public class Main {

public void loadClass() {
try {

Class myclass = Class.forName(getClassName());

//Use reflection to list methods and invoke them
Method[] methods = myclass.getMethods();
Object object = myclass.newInstance();

for (int i = 0; i < methods.length; i++) {
if (methods[i].getName().startsWith("say")) {
System.out.println(methods[i].invoke(object));
}

}

} catch (Exception ex) {
ex.printStackTrace();
}
}

private String getClassName() {

//Do appropriate stuff here to find out the classname

return "com.javadb.examples.MyClass";
}

public static void main(String[] args) {
new Main().loadClass();
}
}

MyClass:

package com.javadb.examples;

/**
*
* @author www.javadb.com
*/
public class MyClass {

public String sayHello() {

return "Hello";
}

public String sayGoodbye() {

return "Goodbye";
}

}

The output from the example will be:

Hello
Goodbye

Redirect Servlet Call to Another URL

2009-04-25T12:06:00.002-07:00

import java.io.*;

import javax.servlet.*;
import javax.servlet.http.*;

public class ExampleServlet extends HttpServlet {

/**
* Processes requests for both HTTP GET and POST methods.
* @param request servlet request
* @param response servlet response
*/
protected void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

//Redirect call to another url
response.sendRedirect("http://www.java.com");
}

}

Get Users IP Address

2009-04-25T12:06:00.001-07:00

import java.io.*;
import java.util.Enumeration;

import javax.servlet.*;
import javax.servlet.http.*;

public class ExampleServlet extends HttpServlet {

/** Processes requests for both HTTP GET and POST methods.
* @param request servlet request
* @param response servlet response
*/
protected void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();

printPageStart(out);

//Print out the IP address of the caller
out.println(request.getRemoteAddr());

printPageEnd(out);
}

/** Prints out the start of the html page
* @param out the PrintWriter object
*/
private void printPageStart(PrintWriter out) {

out.println("");
out.println("");
out.println("Example Servlet of how to display users IP-address");
out.println("");
out.println("");

}

/** Prints out the end of the html page
* @param out the PrintWriter object
*/
private void printPageEnd(PrintWriter out) {

out.println("");
out.println("");
out.close();
}
}

Get Request Parameters in a Servlet

2009-04-25T12:05:00.001-07:00

import java.io.*;
import java.util.Enumeration;

import javax.servlet.*;
import javax.servlet.http.*;

public class ExampleServlet extends HttpServlet {

/** Processes requests for both HTTP GET and POST methods.
* @param request servlet request
* @param response servlet response
*/
protected void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();

printPageStart(out);

Enumeration en = request.getParameterNames();

while (en.hasMoreElements()) {

String paramName = (String) en.nextElement();
out.println(paramName + " = " + request.getParameter(paramName) + "
");

}

printPageEnd(out);
}

/** Prints out the start of the html page
* @param out the PrintWriter object
*/
private void printPageStart(PrintWriter out) {

out.println("");
out.println("");
out.println("Servlet ExampleServlet");
out.println("");
out.println("");

}

/** Prints out the end of the html page
* @param out the PrintWriter object
*/
private void printPageEnd(PrintWriter out) {

out.println("");
out.println("");
out.close();
}
}

So, if the http request looked like this in the browser (assuming we run the servlet on our own computer):

http://localhost/ExampleServlet?color1=blue&color2=red

The output to the page would be:

color1 = blue
color2 = red

Get and Set Session Variables in a Servlet

2009-04-25T12:04:00.000-07:00

import java.io.*;

import javax.servlet.*;

import javax.servlet.http.*;

public class ExampleServlet extends HttpServlet {

/** Processes requests for both HTTP GET and POST methods.

* @param request servlet request

* @param response servlet response

protected void service(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

response.setContentType("text/html;charset=UTF-8");

PrintWriter out = response.getWriter();

printPageStart(out);

//Obtain the session object, create a new session if doesn't exist

HttpSession session = request.getSession(true);

//Check if our session variable is set, if so, get the session variable value

//which is an Integer object, and add one to the value.

//If the value is not set, create an Integer object with the default value 1.

//Add the variable to the session overwriting any possible present values.

Integer param = (Integer) session.getAttribute("MySessionVariable");

if (param != null) {

session.setAttribute("MySessionVariable", new Integer(param.intValue() + 1));

param = (Integer) session.getAttribute("MySessionVariable");

} else {

param = new Integer(1);

session.setAttribute("MySessionVariable", param);

}

out.println("You have displayed this page " + param.intValue() + " times this session.

");

out.println("Hit the browsers refresh button.");

printPageEnd(out);

}

/** Prints out the start of the html page

* @param out the PrintWriter object

private void printPageStart(PrintWriter out) {

out.println("");

out.println("Example Servlet of how to store and retrieve session variables");

out.println("");

}

/** Prints out the end of the html page

* @param out the PrintWriter object

private void printPageEnd(PrintWriter out) {

out.println("");

out.close();

}

This is what the text will look like if you hit the refresh button a few times:

You have displayed this page 16 times this session.

Hit the browsers refresh button.

Forward Call from a Servlet

2009-04-25T12:01:00.000-07:00

import java.io.*;

import javax.servlet.*;

import javax.servlet.http.*;

public class ExampleServlet extends HttpServlet {

/** Processes requests for both HTTP GET and POST methods.

* @param request servlet request

* @param response servlet response

protected void service(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

RequestDispatcher dispatcher = request.getRequestDispatcher("/otherPage.jsp");

dispatcher.forward(request, response);

}

How to find and calculate prime numbers

2009-04-25T12:00:00.000-07:00

public class Main {

private final int UPPER_LIMIT = 10000;

public void calculatePrimeNumbers() {

int i = 0;

int primeNumberCounter = 0;

while (++i <= UPPER_LIMIT) {

int i1 = (int) Math.ceil(Math.sqrt(i));

boolean isPrimeNumber = false;

while (i1 > 1) {

if ((i != i1) && (i % i1 == 0)) {

isPrimeNumber = false;

break;

} else if (!isPrimeNumber) {

isPrimeNumber = true;

}

--i1;

}

if (isPrimeNumber) {

System.out.println(i);

++primeNumberCounter;

}

System.out.println("Nr of prime numbers found: " + primeNumberCounter);

}

/**

* @param args the command line arguments

public static void main(String[] args) {

new Main().calculatePrimeNumbers();

}

The result when running the program looks something like this:

...

9907

9923

9929

9931

9941

9949

9967

9973

Show a message dialog with JOptionPane

2009-04-25T11:59:00.001-07:00

public class myFrame extends JFrame {

//....

public void displayMessage() {

JOptionPane.showMessageDialog(this,
"The message",
"The Title",
JOptionPane.INFORMATION_MESSAGE);
}
}

Set Look and Feel for a Swing application

2009-04-25T11:58:00.000-07:00

public static void main(String[] args) {
try {
UIManager.setLookAndFeel("com.sun.java.swing.plaf.motif.MotifLookAndFeel");
} catch (Exception ex) {
//Just print stacktrace here since it's an example.
ex.printStackTrace();
}
SwingUtilities.invokeLater(new Runnable() {
public void run() {
createTheGUIComponents();
}
});
}

Now if you don't want the same look and feel for every platform but you want the application to adjust to the platform it is currently running on, you can specify that the look and feel for the current system should be used:

public static void main(String[] args) {
try {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
} catch (Exception ex) {
//Just print stacktrace here since it's an example.
ex.printStackTrace();
}
SwingUtilities.invokeLater(new Runnable() {
public void run() {
createTheGUIComponents();
}
});
}

JLabel with more than one row

2009-04-25T11:56:00.000-07:00

JLabel label = new JLabel();

...

label.setText("First row
Second row");

Setting thread priorities

2009-04-25T11:55:00.001-07:00

public class Main {

/**

* Starts two threads and wait for them to finish.

public void setPrioritiesOnThreads() {

Thread thread1 = new Thread(new TestThread(1));

Thread thread2 = new Thread(new TestThread(2));

thread1.start();

thread2.start();

try {

//Wait for the threads to finish

thread1.join();

thread2.join();

} catch (InterruptedException ex) {

ex.printStackTrace();

}

System.out.println("Done.");

}

/**

* Starts the program

* @param args the command line arguments

public static void main(String[] args) {

new Main().setPrioritiesOnThreads();

}

class TestThread implements Runnable {

int id;

public TestThread(int id) {

this.id = id;

}

public void run() {

for (int i = 1; i <= 10; i++) {

System.out.println("Thread" + id + ": " + i);

}

Since both threads have the same priority, the output will be a mix between them and could look like this:

Thread2: 1

Thread1: 1

Thread2: 2

Thread1: 2

Thread2: 3

Thread1: 3

Thread2: 4

Thread1: 4

Thread2: 5

Thread1: 5

Thread2: 6

Thread1: 6

Thread2: 7

Thread2: 8

Thread2: 9

Thread2: 10

Thread1: 7

Thread1: 8

Thread1: 9

Thread1: 10

Done.

The output could look different from on execution to another since we have no control of how the CPU will prioritize them.

If we set the priority on the threads we still haven't got exact control of the execution, but at least we can tell the CPU which one we think is

most important. The next example is identical to the one above except for the lines where the priority of the threads are set:

public class Main {

/**

* Starts two threads, setting priorities on them

* and wait for them to finish.

public void setPrioritiesOnThreads() {

Thread thread1 = new Thread(new TestThread(1));

Thread thread2 = new Thread(new TestThread(2));

//Setting priorities on the Thread objects

thread1.setPriority(Thread.MAX_PRIORITY);

thread2.setPriority(Thread.MIN_PRIORITY);

thread1.start();

thread2.start();

try {

//Wait for the threads to finish

thread1.join();

thread2.join();

} catch (InterruptedException ex) {

ex.printStackTrace();

}

System.out.println("Done.");

}

/**

* Starts the program

* @param args the command line arguments

public static void main(String[] args) {

new Main().setPrioritiesOnThreads();

}

class TestThread implements Runnable {

int id;

public TestThread(int id) {

this.id = id;

}

public void run() {

for (int i = 1; i <= 10; i++) {

System.out.println("Thread" + id + ": " + i);

}

The output from the code looked like this when executed:

Thread1: 1

Thread1: 2

Thread1: 3

Thread1: 4

Thread1: 5

Thread1: 6

Thread1: 7

Thread1: 8

Thread1: 9

Thread1: 10

Thread2: 1

Thread2: 2

Thread2: 3

Thread2: 4

Thread2: 5

Thread2: 6

Thread2: 7

Thread2: 8

Thread2: 9

Thread2: 10

Done.

It is however not certain that the first thread will be prioritized to finish before the second thread starts every time.

It is, as mentioned earlier, up to the CPU to decide.

How to create a thread

2009-04-25T11:54:00.001-07:00

ublic class MyThread extends Thread {

/**

* This method is executed when the start() method is called on the thread

* so here you will put the 'thread code'.

public void run() {

System.out.println("Thread executed!");

}

/**

* @param args the command line arguments

public static void main(String[] args) {

Thread thread = new MyThread();

thread.start();

}

Implementing the Runnable interface:

public class MyRunnable implements Runnable {

/**

* As in the previous example this method is executed

* when the start() method is called on the thread

* so here you will put the 'thread code'.

public void run() {

System.out.println("Thread executed!");

}

/**

* @param args the command line arguments

public static void main(String[] args) {

//create a Thread object and pass it an object of type Runnable

Thread thread = new Thread(new MyRunnable());

thread.start();

}

Increment and Decrement a Date Using the Calendar Class

2009-04-25T11:51:00.001-07:00

import java.util.Calendar;

public class Main {

public void incrementDate(Calendar cal) {

int daysToIncrement = 5;

cal.add(Calendar.DATE, daysToIncrement);

System.out.println("Date after increment: " + cal.getTime());

}

public void decrementDate(Calendar cal) {

int monthsToDecrement = -1;

cal.add(Calendar.MONTH, monthsToDecrement);

System.out.println("Date after decrement: " + cal.getTime());

}

/**

* @param args the command line arguments

public static void main(String[] args) {

Calendar cal = Calendar.getInstance();

System.out.println("Now : " + cal.getTime());

Main main = new Main();

main.incrementDate(cal);

main.decrementDate(cal);

}

Since both the increment and decrement methods are called with the same instance of the Calendar class, the output from the code example showed this when it was executed:

Now : Wed Oct 01 18:15:15 CEST 2008

Date after increment: Mon Oct 06 18:15:15 CEST 2008

Date after decrement: Sat Sep 06 18:15:15 CEST 2008

Getting Currency Symbols

2009-04-25T11:50:00.002-07:00

import java.util.Currency;

import java.util.Locale;

public class Main {

public void displayCurrencySymbols() {

Currency currency = Currency.getInstance(Locale.US);

System.out.println("United States: " + currency.getSymbol());

currency = Currency.getInstance(Locale.UK);

System.out.println("United Kingdom: " + currency.getSymbol());

currency = Currency.getInstance(Locale.FRANCE);

System.out.println("France: " + currency.getSymbol());

}

public static void main(String[] args) {

new Main().displayCurrencySymbols();

}

The output from the code example:

United States: USD

United Kingdom: GBP

France: €

Get Today's Date

2009-04-25T11:50:00.001-07:00

import java.text.SimpleDateFormat;

import java.util.Calendar;

public class Main {

public void convertDateToString() {

Calendar calendar = Calendar.getInstance();

SimpleDateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy");

try {

System.out.println("Today: " + dateFormat.format(calendar.getTime()));

} catch (Exception e) {

e.printStackTrace();

}

/**

* @param args the command line arguments

public static void main(String[] args) {

new Main().convertDateToString();

}

The output from the code above prints the current date.

Get current date and time with the SimpleDateFormat class

2009-04-25T11:49:00.001-07:00

import java.text.SimpleDateFormat;

import java.util.Date;

public class GetDateTime {

public GetDateTime() {

SimpleDateFormat sdfDate = new SimpleDateFormat("dd/MM/yyyy");

SimpleDateFormat sdfTime = new SimpleDateFormat("HH:mm:ss");

Date now = new Date();

String strDate = sdfDate.format(now);

String strTime = sdfTime.format(now);

System.out.println("Date: " + strDate);

System.out.println("Time: " + strTime);

}

public static void main(String[] args) {

GetDateTime getDateTime = new GetDateTime();

}

Create a Date object using the Calendar class

2009-04-25T11:46:00.002-07:00

import java.util.Calendar;

public class DateUtil {

public void createDates() {

int year = 2006;

int month = 0; //January

int date = 1;

Calendar cal = Calendar.getInstance();

//Clear all fields

cal.clear();

cal.set(Calendar.YEAR, year);

cal.set(Calendar.MONTH, month);

cal.set(Calendar.DATE, date);

//Create instance of java.util.Date

java.util.Date utilDate = cal.getTime();

//Create instance of java.sql.Date

java.sql.Date sqlDate = new java.sql.Date(cal.getTimeInMillis());

System.out.println(utilDate);

System.out.println(sqlDate);

}

public static void main(String[] args) {

DateUtil dateutil = new DateUtil();

dateutil.createDates();

}

Using a Message Handler to alter the SOAP Header in a Web Service Client

2009-04-25T11:46:00.001-07:00

import java.util.Set;

import javax.xml.namespace.QName;

import javax.xml.soap.SOAPElement;

import javax.xml.soap.SOAPEnvelope;

import javax.xml.soap.SOAPHeader;

import javax.xml.soap.SOAPMessage;

import javax.xml.ws.handler.MessageContext;

import javax.xml.ws.handler.soap.SOAPHandler;

import javax.xml.ws.handler.soap.SOAPMessageContext;

public class HeaderHandler implements SOAPHandler {

public boolean handleMessage(SOAPMessageContext smc) {

Boolean outboundProperty = (Boolean) smc.get(MessageContext.MESSAGE_OUTBOUND_PROPERTY);

if (outboundProperty.booleanValue()) {

SOAPMessage message = smc.getMessage();

try {

SOAPEnvelope envelope = smc.getMessage().getSOAPPart().getEnvelope();

SOAPHeader header = envelope.addHeader();

SOAPElement security =

header.addChildElement("Security", "wsse", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd");

SOAPElement usernameToken =

security.addChildElement("UsernameToken", "wsse");

usernameToken.addAttribute(new QName("xmlns:wsu"), "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd");

SOAPElement username =

usernameToken.addChildElement("Username", "wsse");

username.addTextNode("TestUser");

SOAPElement password =

usernameToken.addChildElement("Password", "wsse");

password.setAttribute("Type", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordText");

password.addTextNode("TestPassword");

//Print out the outbound SOAP message to System.out

message.writeTo(System.out);

System.out.println("");

} catch (Exception e) {

e.printStackTrace();

}

} else {

try {

//This handler does nothing with the response from the Web Service so

//we just print out the SOAP message.

SOAPMessage message = smc.getMessage();

message.writeTo(System.out);

System.out.println("");

} catch (Exception ex) {

ex.printStackTrace();

}

return outboundProperty;

}

public Set getHeaders() {

//throw new UnsupportedOperationException("Not supported yet.");

return null;

}

public boolean handleFault(SOAPMessageContext context) {

//throw new UnsupportedOperationException("Not supported yet.");

return true;

}

public void close(MessageContext context) {

//throw new UnsupportedOperationException("Not supported yet.");

}

The handler resolver that is to contain the SOAP handler above looks like this:

package com.javadb.ws.example;

import java.util.ArrayList;

import java.util.List;

import javax.xml.ws.handler.Handler;

import javax.xml.ws.handler.HandlerResolver;

import javax.xml.ws.handler.PortInfo;

/**

* @author www.javadb.com

public class HeaderHandlerResolver implements HandlerResolver {

public List getHandlerChain(PortInfo portInfo) {

List handlerChain = new ArrayList();

HeaderHandler hh = new HeaderHandler();

handlerChain.add(hh);

return handlerChain;

}

Finally we need to add the handler resolver to our web service client class.

JavadbWebServiceService service = new JavadbWebServiceService();

HeaderHandlerResolver handlerResolver = new HeaderHandlerResolver();

service.setHandlerResolver(handlerResolver);

JavadbWebService port = service.getJavadbWebServicePort();

//Call web service

String currentTime = port.getTime();

System.out.println("Current time is: " + currentTime);

Create a Web Service Client with JAX-WS

2009-04-25T11:45:00.000-07:00

import com.javadb.ws.example.JavadbWebService;

import com.javadb.ws.example.JavadbWebServiceService;

public class Main {

public void callWebService() {

/* Note, the JavadbWebServiceService class has two constructors.

* The default one that we use here uses the wsdl-location that was

* specified at the time of the generation of the client classes,

* i.e. localhost. If the service is deployed at

* another location you need to use the constructor:

* public JavadbWebServiceService(URL wsdlLocation, QName serviceName)

JavadbWebServiceService service = new JavadbWebServiceService();

JavadbWebService port = service.getJavadbWebServicePort();

String currentTime = port.getTime();

System.out.println("Current time is: " + currentTime);

}

public static void main(String[] args) {

new Main().callWebService();

}

Note that you need the genereated classes and the jax-ws libraries in the classpath when you compile and run the above class.

That is easiest done by pointing them out in your project properties in the IDE.

The output looks something like this:

Current time is: 15:54

Create a simple Web Service

2009-04-25T11:43:00.000-07:00

import java.text.SimpleDateFormat;

import java.util.Calendar;

import javax.jws.WebMethod;

import javax.jws.WebService;

@WebService()

public class JavadbWebService {

@WebMethod

public String getTime() {

Calendar calendar = Calendar.getInstance();

SimpleDateFormat sdf = new SimpleDateFormat("HH:mm");

return (sdf.format(calendar.getTime()));

}

The result of a call to the operation getTime produces something like this:

14:15

This is the SOAP request and response to the web service:

14:15

JavaMail Authenticator

2009-04-25T11:41:00.001-07:00

import java.util.Properties;

import javax.mail.Authenticator;
import javax.mail.Folder;
import javax.mail.Message;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Store;

public class MainClass {

public static void main(String[] args) throws Exception {

Properties props = new Properties();

String host = "yourserver.edu";
String provider = "pop3";

Session session = Session.getDefaultInstance(props, new MailAuthenticator());
Store store = session.getStore(provider);
store.connect(host, null, null);

Folder inbox = store.getFolder("INBOX");
if (inbox == null) {
System.out.println("No INBOX");
System.exit(1);
}
inbox.open(Folder.READ_ONLY);

Message[] messages = inbox.getMessages();
for (int i = 0; i < messages.length; i++) {
System.out.println("Message " + (i + 1));
messages[i].writeTo(System.out);
}
inbox.close(false);
store.close();
}
}

class MailAuthenticator extends Authenticator {

public MailAuthenticator() {
}

public PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication("username", "password");
}
}

Java Mail POP3 Client

2009-04-25T11:40:00.002-07:00

import java.util.Properties;

import javax.mail.Folder;
import javax.mail.Message;
import javax.mail.Session;
import javax.mail.Store;

public class MainClass {

public static void main(String[] args) throws Exception {

Properties props = new Properties();

String host = "yourHost.edu";
String username = "userName";
String password = "mypassword";
String provider = "pop3";

Session session = Session.getDefaultInstance(props, null);
Store store = session.getStore(provider);
store.connect(host, username, password);

Folder inbox = store.getFolder("INBOX");
if (inbox == null) {
System.out.println("No INBOX");
System.exit(1);
}
inbox.open(Folder.READ_ONLY);

Message[] messages = inbox.getMessages();
for (int i = 0; i < messages.length; i++) {
System.out.println("Message " + (i + 1));
messages[i].writeTo(System.out);
}
inbox.close(false);
store.close();
}
}

Get Attachment File Name

2009-04-25T11:40:00.001-07:00

import java.util.Properties;

import javax.mail.Authenticator;
import javax.mail.Folder;
import javax.mail.Message;
import javax.mail.Part;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.URLName;
import javax.mail.internet.InternetAddress;

public class MainClass {

public static void main(String[] args) throws Exception {
URLName server = new URLName("protocol://username@host/foldername");

Session session = Session.getDefaultInstance(new Properties(), new MailAuthenticator());

Folder folder = session.getFolder(server);
if (folder == null) {
System.out.println("Folder " + server.getFile() + " not found.");
System.exit(1);
}
folder.open(Folder.READ_ONLY);

Message[] messages = folder.getMessages();
for (int i = 0; i < messages.length; i++) {
System.out.println(messages[i].getSize() + " bytes long.");
System.out.println(messages[i].getLineCount() + " lines.");
String disposition = messages[i].getDisposition();
if (disposition == null){
; // do nothing
}else if (disposition.equals(Part.INLINE)) {
System.out.println("This part should be displayed inline");
} else if (disposition.equals(Part.ATTACHMENT)) {
System.out.println("This part is an attachment");
String fileName = messages[i].getFileName();
System.out.println("The file name of this attachment is " + fileName);
}
String description = messages[i].getDescription();
if (description != null) {
System.out.println("The description of this message is " + description);
}
}
folder.close(false);
}
}

class MailAuthenticator extends Authenticator {

public MailAuthenticator() {
}

public PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication("username", "password");
}
}

Create a very simple text message and sends it

2009-04-25T11:37:00.000-07:00

import java.util.Date;

import java.util.Properties;

import javax.mail.Address;

import javax.mail.Message;

import javax.mail.MessagingException;

import javax.mail.SendFailedException;

import javax.mail.Session;

import javax.mail.Transport;

import javax.mail.internet.InternetAddress;

import javax.mail.internet.MimeMessage;

// import javax.activation.*;

/**

* msgsendsample creates a very simple text/plain message and sends it.

* usage: java msgsendsample to from smtphost true|false

* where to and from are the destination and origin email

* addresses, respectively, and smtphost is the hostname of the machine

* that has the smtp server running. The last parameter either turns on or turns

* off debugging during sending.

* @author Max Spivak

public class MainClass {

static String msgText = "This is a message body.\nHere's the second line.";

public static void main(String[] args) {

if (args.length != 4) {

usage();

System.exit(1);

}

System.out.println();

String to = args[0];

String from = args[1];

String host = args[2];

boolean debug = Boolean.valueOf(args[3]).booleanValue();

// create some properties and get the default Session

Properties props = new Properties();

props.put("mail.smtp.host", host);

if (debug)

props.put("mail.debug", args[3]);

Session session = Session.getInstance(props, null);

session.setDebug(debug);

try {

// create a message

Message msg = new MimeMessage(session);

msg.setFrom(new InternetAddress(from));

InternetAddress[] address = { new InternetAddress(args[0]) };

msg.setRecipients(Message.RecipientType.TO, address);

msg.setSubject("JavaMail APIs Test");

msg.setSentDate(new Date());

// If the desired charset is known, you can use

// setText(text, charset)

msg.setText(msgText);

Transport.send(msg);

} catch (MessagingException mex) {

System.out.println("\n--Exception handling in msgsendsample.java");

mex.printStackTrace();

System.out.println();

Exception ex = mex;

do {

if (ex instanceof SendFailedException) {

SendFailedException sfex = (SendFailedException) ex;

Address[] invalid = sfex.getInvalidAddresses();

if (invalid != null) {

System.out.println(" ** Invalid Addresses");

if (invalid != null) {

for (int i = 0; i <>

System.out.println(" " + invalid[i]);

}

Address[] validUnsent = sfex.getValidUnsentAddresses();

if (validUnsent != null) {

System.out.println(" ** ValidUnsent Addresses");

if (validUnsent != null) {

for (int i = 0; i <>

System.out.println(" " + validUnsent[i]);

}

Address[] validSent = sfex.getValidSentAddresses();

if (validSent != null) {

System.out.println(" ** ValidSent Addresses");

if (validSent != null) {

for (int i = 0; i <>

System.out.println(" " + validSent[i]);

}

System.out.println();

if (ex instanceof MessagingException)

ex = ((MessagingException) ex).getNextException();

else

ex = null;

} while (ex != null);

}

private static void usage() {

System.out.println("usage: java msgsendsample true|false");

}

Use PasswordTextBox

2009-04-25T11:35:00.001-07:00

package com.java2s.gwt.client;

import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.Button;
import com.google.gwt.user.client.ui.ClickListener;
import com.google.gwt.user.client.ui.RootPanel;
import com.google.gwt.user.client.ui.Widget;
import com.google.gwt.user.client.ui.PasswordTextBox;

public class GWTClient implements EntryPoint {

public void onModuleLoad() {
PasswordTextBox passwordText = new PasswordTextBox();

RootPanel.get().add(passwordText);
}
}

Toggle Image Button

2009-04-25T11:34:00.002-07:00

package com.java2s.gwt.client;

import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.ToggleButton;
import com.google.gwt.user.client.ui.ClickListener;
import com.google.gwt.user.client.ui.RootPanel;
import com.google.gwt.user.client.ui.Widget;

public class GWTClient implements EntryPoint {

public void onModuleLoad() {
ToggleButton b = new ToggleButton("Click me", new ClickListener() {
public void onClick(Widget sender) {
Window.alert("Hello, AJAX");
}
});

RootPanel.get().add(b);
}
}

Hyperlink ClickListener

2009-04-25T11:34:00.001-07:00

package com.java2s.gwt.client;

import com.google.gwt.user.client.*;
import com.google.gwt.user.client.ui.*;
import com.google.gwt.core.client.*;

public class GWTClient implements EntryPoint{
public void onModuleLoad() {
RootPanel.get().add(new ImageButton("images/close.png",16,16));
}
}

class ImageButton extends PNGImage
{

protected final static int ON_STATE = 1;
protected final static int OFF_STATE = -1;
private int state = OFF_STATE;

private String onStyle = "gwl-ImageButton-On";
private String offStyle = "gwl-ImageButton-Off";

private Color backgroundOnColor = Color.NONE;
private Color backgroundOffColor = Color.NONE;

private Color borderOnColor = Color.BLACK;
private Color borderOffColor = Color.NONE;

private int borderOnWidth = 1;
private int borderOffWidth = 0;

private int paddingLeft = 0;
private int paddingRight = 0;
private int paddingTop = 0;
private int paddingBottom = 0;

private BorderStyleConstant borderOnStyle = BorderStyle.BORDER_STYLE_SOLID;
private BorderStyleConstant borderOffStyle = BorderStyle.BORDER_STYLE_NONE;

public ImageButton (String url, int width, int height)
{
super(url, width, height);
setStyleName("gwl-image-button");
setColors();
init();
}

protected void init ()
{
addMouseListener(new MouseListenerAdapter(){

public void onMouseEnter (Widget sender)
{
state = ON_STATE;
setColors();
}

public void onMouseLeave (Widget sender)
{
state = OFF_STATE;
setColors();
}
});
}

public boolean isOn ()
{
return state == ON_STATE;
}

/**
* Updates the colors of the widget based on the state
* and color settings. This is usually only used after
* setting one or more of the colors.
*/
public void setColors ()
{
DOM.setStyleAttribute(getElement(), "paddingTop", getPaddingTopWidth() + "px");
DOM.setStyleAttribute(getElement(), "paddingRight", getPaddingRightWidth() + "px");
DOM.setStyleAttribute(getElement(), "paddingBottom", getPaddingBottomWidth() + "px");
DOM.setStyleAttribute(getElement(), "paddingLeft", getPaddingLeftWidth() + "px");
DOM.setStyleAttribute(getElement(), "borderWidth", getBorderWidth() + "px");
DOM.setStyleAttribute(getElement(), "borderColor", getBorderColor().getHexValue());
DOM.setStyleAttribute(getElement(), "borderStyle", getBorderStyle().getBorderStyleName());
DOM.setStyleAttribute(getElement(), "backgroundColor", getBackgroundColor().getHexValue());
setStyleName(getCssStyleName());
}

private String getCssStyleName ()
{
if (state == ON_STATE)
return onStyle;
else
return offStyle;
}

private Color getBackgroundColor ()
{
if (state == ON_STATE)
return backgroundOnColor;
else
return backgroundOffColor;
}

private BorderStyleConstant getBorderStyle ()
{
if (state == ON_STATE)
return borderOnStyle;
else
return borderOffStyle;
}

private Color getBorderColor ()
{
if (state == ON_STATE)
return borderOnColor;
else
return borderOffColor;
}

private int getBorderWidth ()
{
if (state == ON_STATE)
return borderOnWidth;
else
return borderOffWidth;
}

private int getPaddingLeftWidth ()
{
int max = (borderOnWidth > borderOffWidth) ? borderOnWidth : borderOffWidth;

if (state == ON_STATE) {
return (max - borderOnWidth + paddingLeft);
}
else {
return (max - borderOffWidth + paddingLeft);
}
}

private int getPaddingRightWidth ()
{
int max = (borderOnWidth > borderOffWidth) ? borderOnWidth : borderOffWidth;

if (state == ON_STATE) {
return (max - borderOnWidth + paddingRight);
}
else {
return (max - borderOffWidth + paddingRight);
}
}

private int getPaddingTopWidth ()
{
int max = (borderOnWidth > borderOffWidth) ? borderOnWidth : borderOffWidth;

if (state == ON_STATE) {
return (max - borderOnWidth + paddingTop);
}
else {
return (max - borderOffWidth + paddingTop);
}
}

private int getPaddingBottomWidth ()
{
int max = (borderOnWidth > borderOffWidth) ? borderOnWidth : borderOffWidth;

if (state == ON_STATE) {
return (max - borderOnWidth + paddingBottom);
}
else {
return (max - borderOffWidth + paddingBottom);
}
}

/**
* This method is under consideration for removal,
*
*/
public void setMargin (int px)
{
DOM.setStyleAttribute(getElement(), "margin", px + "px");
}

/**
* This method is under consideration for removal,
*
*/
public void setHorizontalMargin (int px)
{
DOM.setStyleAttribute(getElement(), "marginLeft", px + "px");
DOM.setStyleAttribute(getElement(), "marginRight", px + "px");
}

/**
* This method is under consideration for removal,
*
*/
public void setVerticleMargin (int px)
{
DOM.setStyleAttribute(getElement(), "marginTop", px + "px");
DOM.setStyleAttribute(getElement(), "marginBotom", px + "px");
}

/**
* This method is under consideration for removal,
*
*/
public Color getBackgroundOffColor ()
{
return backgroundOffColor;
}

/**
* This method is under consideration for removal,
*
*/
public void setBackgroundOffColor (Color backgroundOffColor)
{
this.backgroundOffColor = backgroundOffColor;
}

/**
* This method is under consideration for removal,
*
*/
public Color getBackgroundOnColor ()
{
return backgroundOnColor;
}

/**
* This method is under consideration for removal,
*
*/
public void setBackgroundOnColor (Color backgroundOnColor)
{
this.backgroundOnColor = backgroundOnColor;
}

/**
* This method is under consideration for removal,
*
*/
public Color getBorderOffColor ()
{
return borderOffColor;
}

/**
* This method is under consideration for removal,
*
*/
public void setBorderOffColor (Color borderOffColor)
{
this.borderOffColor = borderOffColor;
}

/**
* This method is under consideration for removal,
*
*/
public BorderStyleConstant getBorderOffStyle ()
{
return borderOffStyle;
}

/**
* This method is under consideration for removal,
*
*/
public void setBorderOffStyle (BorderStyleConstant borderOffStyle)
{
this.borderOffStyle = borderOffStyle;
}

/**
* This method is under consideration for removal,
*
*/
public int getBorderOffWidth ()
{
return borderOffWidth;
}

/**
* This method is under consideration for removal,
*
*/
public void setBorderOffWidth (int borderOffWidth)
{
this.borderOffWidth = borderOffWidth;
}

/**
* This method is under consideration for removal,
*
*/
public Color getBorderOnColor ()
{
return borderOnColor;
}

/**
* This method is under consideration for removal,
*
*/
public void setBorderOnColor (Color borderOnColor)
{
this.borderOnColor = borderOnColor;
}

/**
* This method is under consideration for removal,
*
*/
public BorderStyleConstant getBorderOnStyle ()
{
return borderOnStyle;
}

/**
* This method is under consideration for removal,
*
*/
public void setBorderOnStyle (BorderStyleConstant borderOnStyle)
{
this.borderOnStyle = borderOnStyle;
}

/**
* This method is under consideration for removal,
*
*/
public int getBorderOnWidth ()
{
return borderOnWidth;
}

public void setBorderOnWidth (int borderOnWidth)
{
this.borderOnWidth = borderOnWidth;
}

protected int getState ()
{
return state;
}

protected void setState (int state)
{
this.state = state;
}

public String getOffStyle ()
{
return offStyle;
}

public void setOffStyle (String offStyle)
{
this.offStyle = offStyle;
}

public String getOnStyle ()
{
return onStyle;
}

public void setOnStyle (String onStyle)
{
this.onStyle = onStyle;
}

}

class PNGImage extends Image
{
private PNGImageImpl impl;

public PNGImage (String url, int width, int height)
{
impl = (PNGImageImpl) GWT.create(PNGImageImpl.class);

setElement(impl.createElement(url, width, height));
sinkEvents(Event.ONCLICK | Event.MOUSEEVENTS | Event.ONLOAD | Event.ONERROR);
}

public String getUrl ()
{
return impl.getUrl(this);
}

/**
* Should not be used. Throws RuntimeException
*/
public void setUrl (String url)
{
throw new RuntimeException("Not allowed to set url for a PNG image");
}
}

class PNGImageImpl
{

public Element createElement (String url, int width, int height)
{
Element result = DOM.createImg();
DOM.setAttribute(result, "src", url);
DOM.setIntAttribute(result, "width", width);
DOM.setIntAttribute(result, "height", height);
return result;
}

public String getUrl (PNGImage image)
{
return DOM.getAttribute(image.getElement(), "src");
}

}

class PNGImageImplIE6 extends PNGImageImpl
{
private String url;
private boolean isPng;

public Element createElement (String url, int width, int height)
{
this.url = url;

if (url.endsWith(".png") || url.endsWith(".PNG")) {
isPng = true;
}
else {
isPng = false;
}

if (isPng) {
Element div = DOM.createDiv();
DOM.setInnerHTML(div, "");

return DOM.getFirstChild(div);
}
else {
return super.createElement(url, width, height);
}
}

public String getUrl (PNGImage image)
{
if (isPng) {
return url;
}
else {
return super.getUrl(image);
}
}

}
public class BorderStyleConstant
{

private String styleName;

public BorderStyleConstant (String styleName)
{
this.styleName = styleName;
}

public String getBorderStyleName() {
return styleName;
}

}

class BorderStyle
{

final public static BorderStyleConstant BORDER_STYLE_NONE = new BorderStyleConstant("none");

final public static BorderStyleConstant BORDER_STYLE_DOTTED = new BorderStyleConstant("dotted");

final public static BorderStyleConstant BORDER_STYLE_DASHED = new BorderStyleConstant("dashed");

final public static BorderStyleConstant BORDER_STYLE_SOLID = new BorderStyleConstant("solid");

final public static BorderStyleConstant BORDER_STYLE_DOUBLE = new BorderStyleConstant("double");

final public static BorderStyleConstant BORDER_STYLE_GROOVE = new BorderStyleConstant("groove");

final public static BorderStyleConstant BORDER_STYLE_RIDGE = new BorderStyleConstant("ridge");

final public static BorderStyleConstant BORDER_STYLE_INSET = new BorderStyleConstant("inset");

final public static BorderStyleConstant BORDER_STYLE_OUTSET = new BorderStyleConstant("outset");

}

class Color
{
public final static Color WHITE = new Color(255, 255, 255);
public final static Color LIGHT_GRAY = new Color(192, 192, 192);
public final static Color GRAY = new Color(128, 128, 128);
public final static Color DARK_GRAY = new Color(64, 64, 64);
public final static Color BLACK = new Color(0, 0, 0);
public final static Color RED = new Color(255, 0, 0);
public final static Color PINK = new Color(255, 175, 175);
public final static Color ORANGE = new Color(255, 200, 0);
public final static Color YELLOW = new Color(255, 255, 0);
public final static Color GREEN = new Color(0, 255, 0);
public final static Color MAGENTA = new Color(255, 0, 255);
public final static Color CYAN = new Color(0, 255, 255);
public final static Color BLUE = new Color(0, 0, 255);
public static final Color NONE = new Color("");

private int r, g, b;

// only for special cases, like no color, or maybe named colors
private String colorText = null;

private Color (String colorText) {
this.colorText = colorText;
}

public Color (int r, int g, int b)
{
this.r = r;
this.g = g;
this.b = b;
}

public int getRed ()
{
return r;
}

public int getGreen ()
{
return g;
}

public int getBlue ()
{
return b;
}

public String getHexValue ()
{
if (colorText != null) {
return colorText;
}

return "#"
+ pad(Integer.toHexString(r))
+ pad(Integer.toHexString(g))
+ pad(Integer.toHexString(b));
}

private String pad (String in)
{
if (in.length() == 0) {
return "00";
}
if (in.length() == 1) {
return "0" + in;
}
return in;
}

public String toString ()
{
if (colorText != null) {
return colorText;
}
return "red=" + r + ", green=" + g + ", blue=" + b;
}
}

GWT progress bar

2009-04-25T11:29:00.002-07:00

package com.java2s.gwt.client;

import com.google.gwt.user.client.*;

import com.google.gwt.user.client.ui.*;

import com.google.gwt.core.client.*;

public class GWTClient implements EntryPoint{

public void onModuleLoad() {

final ProgressBar progressBar = new ProgressBar(20

,ProgressBar.SHOW_TIME_REMAINING

+ProgressBar.SHOW_TEXT);

progressBar.setText("Doing something...");

RootPanel.get().add(progressBar);

Timer t = new Timer() {

public void run() {

int progress = progressBar.getProgress()+4;

if (progress>100) cancel();

progressBar.setProgress(progress);

}

};

t.scheduleRepeating(1000);

}

/**

A simple progress bar that uses table elements to show progress

* and with a basic time remaining calculation built in.

You can optionally display some text above the progress bar

* and/or display time remaining underneath the progress bar. To

* control the display of those features, set the options in the

* constructor as shown in the following usage example:

* final ProgressBar progressBar = new ProgressBar(20

* ,ProgressBar.SHOW_TIME_REMAINING

* +ProgressBar.SHOW_TEXT);

* progressBar.setText("Doing something...");

* RootPanel.get().add(progressBar);

* Timer t = new Timer() {

* public void run() {

* int progress = progressBar.getProgress()+4;

* if (progress>100) cancel();

* progressBar.setProgress(progress);

* }

* };

* t.scheduleRepeating(1000);

How the time remaining is displayed can be controlled by setting the

* relevant messages using the language of your choice.

The default setting for the messages are as follows:

* setSecondsMessage("Time remaining: {0} Seconds");

* setMinutesMessage("Time remaining: {0} Minutes");

* setHoursMessage("Time remaining: {0} Hours");

To reset the time remaining/set the start time, simply set the

* progress to zero.

Some basic CSS styling is available to control the text, border around the

* progress bar itself and the colour of the progress bar elements.

* .progressbar-text {

* font-weight: bold;

* }

* .progressbar-remaining {

* font-size: 12px;

* font-style: italic;

* }

* .progressbar-outer {

* border: 1px solid black;

* }

* .progressbar-inner {

* border: 1px solid black;

* margin: 1px;

* }

* .progressbar-bar {

* width: 5px;

* height: 15px;

* margin: 1px;

* }

* .progressbar-fullbar {

* background: blue;

* }

* .progressbar-blankbar {

* background: #eee;

* }

You can take advantage of the default style by adding the

* following to the head of your HTML page.

This style sheet also has two additional styles which you can use

* by adding the stye name to the widget. You can use either one of

* these, or use both combined.

* ProgressBar progressBar = new ProgressBar(20);

* progressBar.addStyleName("progressbar-solid");

* progressBar.addStyleName("progressbar-noborder");

* @author Bjarne Matzen - Bjarne[dot]Matzen[at]gmail[dot]com

class ProgressBar extends VerticalPanel {

/**

* Option to show text label above progress bar

public static final int SHOW_TEXT = 2;

/**

* Option to show time remaining

public static final int SHOW_TIME_REMAINING = 1;

/**

* The time the progress bar was started

private long startTime = System.currentTimeMillis();

/**

* The number of bar elements to show

private int elements = 20;

/**

* Time element text

private String secondsMessage = "Time remaining: {0} Seconds";

private String minutesMessage = "Time remaining: {0} Minutes";

private String hoursMessage = "Time remaining: {0} Hours";

/**

* Current progress (as a percentage)

private int progress = 0;

/**

* This is the frame around the progress bar

private FlexTable barFrame = new FlexTable();

/**

* This is the grid used to show the elements

private Grid elementGrid;

/**

* This is the current text label below the progress bar

private Label remainLabel = new Label();

/**

* This is the current text label above the progress bar

private Label textLabel = new Label();

/**

* internal flags for options

private boolean showRemaining = false;

private boolean showText = false;

/**

* Base constructor for this widget

* @param elements The number of elements (bars) to show on the progress bar

* @param options The display options for the progress bar

public ProgressBar (int elements, int options)

{

// Read the options and set convenience variables

if ((options & SHOW_TIME_REMAINING) == SHOW_TIME_REMAINING) showRemaining = true;

if ((options & SHOW_TEXT) == SHOW_TEXT) showText = true;

// Set element count

this.elements = elements;

// Styling

remainLabel.setStyleName("progressbar-remaining");

textLabel.setStyleName("progressbar-text");

// Initialize the progress elements

elementGrid = new Grid(1, elements);

elementGrid.setStyleName("progressbar-inner");

elementGrid.setCellPadding(0);

elementGrid.setCellSpacing(0);

for (int loop = 0; loop <>

Grid elm = new Grid(1, 1);

//elm.setHTML(0, 0, " ");

elm.setHTML(0, 0, "");

elm.setStyleName("progressbar-blankbar");

elm.addStyleName("progressbar-bar");

elementGrid.setWidget(0, loop, elm);

}

// Create the container around the elements

Grid containerGrid = new Grid(1,1);

containerGrid.setCellPadding(0);

containerGrid.setCellSpacing(0);

containerGrid.setWidget(0, 0, elementGrid);

containerGrid.setStyleName("progressbar-outer");

//containerGrid.setBorderWidth(1);

// Set up the surrounding flex table based on the options

int row = 0;

if (showText) barFrame.setWidget(row++, 0, textLabel);

barFrame.setWidget(row++, 0, containerGrid);

if (showRemaining) barFrame.setWidget(row++, 0, remainLabel);

barFrame.setWidth("100%");

// Add the frame to the panel

this.add(barFrame);

// Initialize progress bar

setProgress(0);

}

/**

* Constructor without options

* @param elements The number of elements (bars) to show on the progress bar

public ProgressBar (int elements)

{

this(elements, 0);

}

/**

* Set the current progress as a percentage

* @param percentage Set current percentage for the progress bar

public void setProgress (int percentage)

{

// Make sure we are error-tolerant

if (percentage > 100) percentage = 100;

if (percentage < percentage ="">

// Set the internal variable

progress = percentage;

// Update the elements in the progress grid to

// reflect the status

int completed = elements * percentage / 100;

for (int loop = 0; loop <>

Grid elm = (Grid) elementGrid.getWidget(0, loop);

if (loop <>

elm.setStyleName("progressbar-fullbar");

elm.addStyleName("progressbar-bar");

}

else {

elm.setStyleName("progressbar-blankbar");

elm.addStyleName("progressbar-bar");

}

if (percentage > 0) {

// Calculate the new time remaining

long soFar = (System.currentTimeMillis() - startTime) / 1000;

long remaining = soFar * (100 - percentage) / percentage;

// Select the best UOM

String remainText = secondsMessage;

if (remaining > 120) {

remaining = remaining / 60;

remainText = minutesMessage;

if (remaining > 120) {

remaining = remaining / 60;

remainText = hoursMessage;

}

// Locate the position to insert out time remaining

int pos = remainText.indexOf("{0}");

if (pos >= 0) {

String trail = "";

if (pos + 3 < trail =" remainText.substring(pos">

remainText = remainText.substring(0, pos) + remaining + trail;

}

// Set the label

remainLabel.setText(remainText);

}

else {

// If progress is 0, reset the start time

startTime = System.currentTimeMillis();

}

/**

* Get the current progress as a percentage

* @return Current percentage for the progress bar

public int getProgress ()

{

return (progress);

}

/**

* Get the text displayed above the progress bar

* @return the text

public String getText ()

{

return this.textLabel.getText();

}

/**

* Set the text displayed above the progress bar

* @param text the text to set

public void setText (String text)

{

this.textLabel.setText(text);

}

/**

* Get the message used to format the time remaining text

* for hours

* @return the hours message

public String getHoursMessage ()

{

return hoursMessage;

}

/**

* Set the message used to format the time remaining text

* below the progress bar. There are 3 messages used for

* hours, minutes and seconds respectively.

* The message must contain a placeholder for the value. The

* placeholder must be {0}. For example, the following is

* a valid message:

* "Hours remaining: {0}"

* @param hoursMessage the hours message to set

public void setHoursMessage (String hoursMessage)

{

this.hoursMessage = hoursMessage;

}

/**

* Get the message used to format the time remaining text

* for minutes

* @return the minutesMessage

public String getMinutesMessage ()

{

return minutesMessage;

}

/**

* Set the message used to format the time remaining text

* below the progress bar. There are 3 messages used for

* hours, minutes and seconds respectively.

* The message must contain a placeholder for the value. The

* placeholder must be {0}. For example, the following is

* a valid message:

* "Minutes remaining: {0}"

* @param minutesMessage the minutes message to set

public void setMinutesMessage (String minutesMessage)

{

this.minutesMessage = minutesMessage;

}

/**

* Get the message used to format the time remaining text

* for seconds

* @return the secondsMessage

public String getSecondsMessage ()

{

return secondsMessage;

}

/**

* Set the message used to format the time remaining text

* below the progress bar. There are 3 messages used for

* hours, minutes and seconds respectively.

* The message must contain a placeholder for the value. The

* placeholder must be {0}. For example, the following is

* a valid message:

* "Seconds remaining: {0}"

* @param secondsMessage the secondsMessage to set

public void setSecondsMessage (String secondsMessage)

{

this.secondsMessage = secondsMessage;

}

Deal with browser history

2009-04-25T11:29:00.001-07:00

package com.java2s.gwt.client;

import com.google.gwt.core.client.EntryPoint;

import com.google.gwt.core.client.GWT;

import com.google.gwt.user.client.Window;

import com.google.gwt.user.client.ui.Button;

import com.google.gwt.user.client.ui.ClickListener;

import com.google.gwt.user.client.ui.Grid;

import com.google.gwt.user.client.ui.Label;

import com.google.gwt.user.client.ui.PasswordTextBox;

import com.google.gwt.user.client.ui.RootPanel;

import com.google.gwt.user.client.ui.TextBox;

import com.google.gwt.user.client.ui.Widget;

import com.google.gwt.user.client.ui.Hyperlink;

import com.google.gwt.user.client.History;

import com.google.gwt.user.client.HistoryListener;

public class GWTClient implements EntryPoint,HistoryListener {

private static final String LOGIN_STATE = "login";

private static final String WELCOME_STATE = "welcome";

public void onModuleLoad() {

setupHistory();

}

private void setupHistory() {

History.addHistoryListener(this);

History.onHistoryChanged(LOGIN_STATE);

}

public void onHistoryChanged(String historyToken) {

if (LOGIN_STATE.equals(historyToken)) {

loadLoginView();

}

else

if (WELCOME_STATE.equals(historyToken)) {

loadWelcomeView();

}

private void loadLoginView() {

final Label loginPrompt = new Label("login");

final Grid grid = new Grid(3, 2);

final Label namePrompt = new Label("name");

final TextBox nameTextbox = new TextBox();

final Label passwordPrompt = new Label("password");

final PasswordTextBox passwordTextbox = new PasswordTextBox();

final Button button = new Button("Login");

button.addClickListener(new ClickListener() {

public void onClick(Widget sender) {

History.newItem(WELCOME_STATE);

}

});

loginPrompt.addStyleName("loginPrompt");

nameTextbox.addStyleName("nameField");

passwordTextbox.addStyleName("passwordField");

grid.setWidget(0, 0, namePrompt);

grid.setWidget(0, 1, nameTextbox);

grid.setWidget(1, 0, passwordPrompt);

grid.setWidget(1, 1, passwordTextbox);

grid.setWidget(2, 1, button);

RootPanel.get().clear();

RootPanel.get().add(loginPrompt);

RootPanel.get().add(grid);

}

private void loadWelcomeView() {

final Label welcomeMsg = new Label("welcome");

welcomeMsg.addStyleName("welcomeMsg");

RootPanel.get().clear();

RootPanel.get().add(welcomeMsg);

RootPanel.get().add(new Hyperlink("logoutLink",LOGIN_STATE));

}

Compiling from Memory

2009-04-25T11:25:00.004-07:00

import java.io.IOException;

import java.io.PrintWriter;

import java.io.StringWriter;

import java.lang.reflect.InvocationTargetException;

import java.net.URI;

import java.util.Arrays;

import javax.tools.Diagnostic;

import javax.tools.DiagnosticCollector;

import javax.tools.JavaCompiler;

import javax.tools.JavaFileObject;

import javax.tools.SimpleJavaFileObject;

import javax.tools.ToolProvider;

import javax.tools.JavaCompiler.CompilationTask;

import javax.tools.JavaFileObject.Kind;

public class CompileSourceInMemory {

public static void main(String args[]) throws IOException {

JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

DiagnosticCollector diagnostics = new DiagnosticCollector();

StringWriter writer = new StringWriter();

PrintWriter out = new PrintWriter(writer);

out.println("public class HelloWorld {");

out.println(" public static void main(String args[]) {");

out.println(" System.out.println(\"This is in another java file\");");

out.println(" }");

out.println("}");

out.close();

JavaFileObject file = new JavaSourceFromString("HelloWorld", writer.toString());

Iterable compilationUnits = Arrays.asList(file);

CompilationTask task = compiler.getTask(null, null, diagnostics, null, null, compilationUnits);

boolean success = task.call();

for (Diagnostic diagnostic : diagnostics.getDiagnostics()) {

System.out.println(diagnostic.getCode());

System.out.println(diagnostic.getKind());

System.out.println(diagnostic.getPosition());

System.out.println(diagnostic.getStartPosition());

System.out.println(diagnostic.getEndPosition());

System.out.println(diagnostic.getSource());

System.out.println(diagnostic.getMessage(null));

}

System.out.println("Success: " + success);

if (success) {

try {

Class.forName("HelloWorld").getDeclaredMethod("main", new Class[] { String[].class })

.invoke(null, new Object[] { null });

} catch (ClassNotFoundException e) {

System.err.println("Class not found: " + e);

} catch (NoSuchMethodException e) {

System.err.println("No such method: " + e);

} catch (IllegalAccessException e) {

System.err.println("Illegal access: " + e);

} catch (InvocationTargetException e) {

System.err.println("Invocation target: " + e);

}

class JavaSourceFromString extends SimpleJavaFileObject {

final String code;

JavaSourceFromString(String name, String code) {

super(URI.create("string:///" + name.replace('.','/') + Kind.SOURCE.extension),Kind.SOURCE);

this.code = code;

}

@Override

public CharSequence getCharContent(boolean ignoreEncodingErrors) {

return code;

}

Compile a Java source from inside a Java program

2009-04-25T11:25:00.003-07:00

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import javax.tools.JavaCompilerTool;

import javax.tools.JavaFileObject;

import javax.tools.StandardJavaFileManager;

import javax.tools.ToolProvider;

import javax.tools.JavaCompilerTool.CompilationTask;

public class JDK6JavaCompilerDemo {

public static void main (String[] args) {

String sourceFile = "c:/HelloWorld.Java";

JavaCompilerTool compiler = ToolProvider.getSystemJavaCompilerTool ();

StandardJavaFileManager fileManager =

compiler.getStandardFileManager (null);

// prepare the source file(s) to compile

List sourceFileList = new ArrayList ();

sourceFileList.add (new File (sourceFile));

Iterable compilationUnits =fileManager.getJavaFileObjectsFromFiles (sourceFileList);

CompilationTask task = compiler.getTask (null,fileManager, null, null, null, compilationUnits);

task.run ();

boolean result = task.getResult ();

if (result) {

System.out.println ("Compilation was successful");

} else {

System.out.println ("Compilation failed");

}

try {

fileManager.close ();

} catch (IOException e) {

}

* import Java.util.Date;

public class HelloWorld {

public static void main (String[] args) {

Date date = new Date (1234, 11, 12);

System.out.println ("[" + date + "] Hello World !");

}

Compile a Java file with JavaCompiler

2009-04-25T11:25:00.001-07:00

import java.io.IOException;

import java.util.Arrays;

import javax.tools.DiagnosticCollector;

import javax.tools.JavaCompiler;

import javax.tools.JavaFileObject;

import javax.tools.StandardJavaFileManager;

import javax.tools.ToolProvider;

public class DiagnosticCollectorCompile {

public static void main(String args[]) throws IOException {

JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

DiagnosticCollector diagnostics = new DiagnosticCollector();

StandardJavaFileManager fileManager = compiler.getStandardFileManager(diagnostics, null, null);

Iterable compilationUnits = fileManager

.getJavaFileObjectsFromStrings(Arrays.asList("Foo.java"));

JavaCompiler.CompilationTask task = compiler.getTask(null, fileManager, diagnostics, null,

null, compilationUnits);

boolean success = task.call();

fileManager.close();

System.out.println("Success: " + success);

}

// File: MyClass.java

class MyClass {

public static void main(String args[]) {

System.out.println("Hello, World");

}

Compile a Java code

2009-04-25T11:23:00.000-07:00

import java.io.IOException;

import javax.tools.JavaCompiler;

import javax.tools.ToolProvider;

public class JDK6FirstCompile {

public static void main(String args[]) throws IOException {

JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

int results = compiler.run(null, null, null, "Foo.java");

System.out.println("Success: " + (results == 0));

}

// File: MyClass.java

class MyClass {

public static void main(String args[]) {

System.out.println("Hello, World");

}

Use JDBC Chained Exception

2009-04-25T11:21:00.002-07:00

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

public class ChainedExceptionDemo {

static Connection conn;

public static void main(String[] args) {

String driver = "com.mysql.jdbc.Driver";

String connectionURL = "jdbc:mysql://127.0.0.1:3306/sample";

try {

Class.forName(driver);

} catch (java.lang.ClassNotFoundException e) {

e.printStackTrace();

}

try {

conn = DriverManager.getConnection(connectionURL);

Statement stmt = conn.createStatement();

ResultSet rs = stmt.executeQuery("SELECT * FROM NONEXISTINGTABLE");

rs.next();

rs.close();

} catch (SQLException sx) {

for (Throwable e : sx) {

System.err.println("Error encountered: " + e);

}

Update annotation

2009-04-25T11:21:00.001-07:00

import java.sql.BaseQuery;

import java.sql.DataSet;

import java.sql.Select;

public interface UserQueries extends BaseQuery {

// Delete user

@Update ("DELETE Users WHERE firstName={firstName}" +

"AND lastName={lastName}")

int deleteUser (String firstName, String lastName);

}

JDK6 Splash Screen

2009-04-25T11:19:00.000-07:00

import java.awt.AlphaComposite;

import java.awt.BorderLayout;

import java.awt.Color;

import java.awt.Frame;

import java.awt.Graphics2D;

import java.awt.Menu;

import java.awt.MenuBar;

import java.awt.MenuItem;

import java.awt.SplashScreen;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

public class JDK6SplashTest extends Frame{

static void renderSplashFrame(Graphics2D g, int frame) {

final String[] comps = { "foo", "bar", "baz" };

g.setComposite(AlphaComposite.Clear);

g.fillRect(130, 250, 280, 40);

g.setPaintMode();

g.setColor(Color.BLACK);

g.drawString("Loading " + comps[(frame / 5) % 3] + "...", 130, 260);

g.fillRect(130, 270, (frame * 10) % 280, 20);

}

public JDK6SplashTest() {

super("SplashScreen demo");

setSize(500, 300);

setLayout(new BorderLayout());

Menu m1 = new Menu("File");

MenuItem mi1 = new MenuItem("Exit");

m1.add(mi1);

mi1.addActionListener(new ActionListener(){

public void actionPerformed(ActionEvent e){

System.exit(0);

}

});

MenuBar mb = new MenuBar();

setMenuBar(mb);

mb.add(m1);

final SplashScreen splash = SplashScreen.getSplashScreen();

if (splash == null) {

System.out.println("SplashScreen.getSplashScreen() returned null");

return;

}

Graphics2D g = (Graphics2D) splash.createGraphics();

if (g == null) {

System.out.println("g is null");

return;

}

for (int i = 0; i <>

renderSplashFrame(g, i);

splash.update();

try {

Thread.sleep(200);

} catch (InterruptedException e) {

}

splash.close();

setVisible(true);

toFront();

}

public static void main(String args[]) {

JDK6SplashTest test = new JDK6SplashTest();

}

JDBC Annotations

2009-04-25T11:17:00.000-07:00

import java.sql.BaseQuery;

import java.sql.DataSet;

import java.sql.Select;

public interface UserQueries extends BaseQuery {

// Select all users

@Select (sql ="SELECT userId, firstName, lastName FROM Users",

readOnly=false, connected=false, tableName="Users")

DataSet getAllUsers ();

// Select user by name */

@Select (sql ="SELECT userId, firstName, lastName FROM Users"

+ "WHERE userName=?", readOnly=false, connected=false,

tableName ="Users")

DataSet getUserByName(String userName);

}

Using thread to run JavaScript by Java

2009-04-25T11:14:00.002-07:00

import javax.script.Invocable;

import javax.script.ScriptEngine;

import javax.script.ScriptEngineManager;

import javax.script.ScriptException;

public class InterfaceTest {

public static void main(String args[]) throws Exception{

ScriptEngineManager manager = new ScriptEngineManager();

ScriptEngine engine = manager.getEngineByName("javascript");

engine.eval("function run() {print('www.java2s.com');}");

Invocable invokeEngine = (Invocable) engine;

Runnable runner = invokeEngine.getInterface(Runnable.class);

Thread t = new Thread(runner);

t.start();

t.join();

}