Programming

Java

• • Execute an external application via Java

Overview

Java is an object-oriented programming language. Switching to objectoriented programming (OOP) from other programming paradigms can be difficult. Java focuses on creating objects (data structures or behaviors) that can be assessed and manipulated by the program.

Like other programming languages, Java provides support for reading and writing data to and from different input and output devices. Java uses processes that increase the efficiency of input and output, facilitate internationalization, and provide better support for non-UNIX platforms. Java looks over your program as it runs and automatically deallocates memory that is no longer required. This means you do not have to keep track of memory pointers or manually deallocate memory. This feature means a program is less likely to crash and that memory can not be intentionally misused.

Java is related to C++, which is a direct descendent of C. Much of the character of Java is inherited from these two languages. From C, Java derives its syntax. Many of Java's object-oriented features were influenced by C++. In fact, several of Java's defining characteristics come from or are responses to its predecessors. Moreover, the creation of Java was deeply rooted in the process of refinement and adaptation that has been occurring in computer programming languages for the past three decades. For these reasons, this section reviews the sequence of events and forces that led up to Java. As you will see, each innovation in language design was driven by the need to solve a fundamental problem that the preceding languages could not solve. Java is no exception.

Examples

Strings. Parsing comma-separated data.

CSV (comma-separated values) is quite frequently used in different applications. Many MS-Windows-based spreadsheets and some databases use CSV to export data.

CSV is deceptive. It looks simple at first glance, but the values may be quoted or unquoted. Even more, the values may contain escaped quotes. These obstacles are beyond the StringTokenizer capabilities.

provides a set of classes that may easily help us to overcome the problem. The class below will parse a csv file and pop up an alert box with every single value from the file.

			  
import com.Ostermiller.util.CSVParser;
import java.io.InputStreamReader;
import java.io.FileInputStream;
import javax.swing.JOptionPane;

public class CSVExample {
  public static void main(String[] args) throws Exception {
    CSVParser shredder = new CSVParser(
      new InputStreamReader(
        new FileInputStream("source.csv"))
      );
    String t;
    while ((t = shredder.nextValue()) != null) {
      JOptionPane.showMessageDialog(
      null, 
      t, 
      "Value from line " + shredder.getLastLineNumber(), 
        JOptionPane.INFORMATION_MESSAGE
      );
    }
    System.exit(0);
  }
}

Regexp. Pattern matching.

Regular expressions, or REs for short, provide a concise and precise specification of patterns to be matched in text. Java 2 did not include any facilities for describing regular expressions in text. This is mildly surprising given how powerful regular expressions are, how ubiquitous they are on the Unix operating system where Java was first brewed, and how powerful they are in modern scripting languages like sed, awk, Python, and Perl.

Apache Jakarta project has achieved sufficient momentum to become nearly a standard. Apache has, in fact, two regular expressions packages. The second, Oro, provides full Perl5-style regular expressions, AWK-like regular expressions, glob expressions, and utility classes for performing substitutions, splits, filtering filenames, etc.

import org.apache.regexp.*;

public class RegExpTest {
  public static void main(String[] argv) throws RESyntaxException {
    //a patter string that we use to match a line.
    String pattern = "^Q[^u]\\d+\\.";
    //a source string for test.
    String input = "QA777. is the next flight. It is on time.";
    // Construct an RE object
    RE r = new RE(pattern);
    // Use RE to match an input.
    boolean found = r.match(input); 
    System.out.println(pattern + (found ? " matches " : " doesn't match ") + input);
  }
}

Date and time

To find out todays date:

System.out.println(new java.util.Date());

Use formatted date:

Date dNow = new Date();
System.out.println("It is now " + dNow.toString());
// Use a SimpleDateFormat to print the date our way.
SimpleDateFormat formatter = new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");
System.out.println("It is " + formatter.format(dNow));

Computing difference between two dates.

import java.util.*;
	
public class DateDiff {
  public static void main(String[] av) {
    Date d1 = new GregorianCalendar(1999,11,31,23,59).getTime( );
    Date d2 = new Date();
    long diff = d2.getTime() - d1.getTime();
    System.out.println("Difference between " + d2 +
                       "\n" + "\tand Y2K is " + 
                       (diff / (1000*60*60*24)) +" days.");
    }
}

Comparing dates:

import java.util.*;
import java.text.*;

public class CompareDates {
  public static void main(String[] args) throws ParseException {
    DateFormat df = new SimpleDateFormat ("yyyy-MM-dd");
    Date d1 = df.parse(args[0]);
    Date d2 = df.parse(args[1]);
    String relation;
    if (d1.equals(d2))
      relation = "the same date as";
    else if (d1.before(d2))
      relation = "before";
    else
      relation = "after";
    System.out.println(d1 + " is " + relation + ' ' + d2);
  }
}

IO

First of all, here's a small example of how to set up input and output streams.

import java.io.*;
class Streams {
public static void main(String[] args) throws IOException {
  BufferedInputStream in = new BufferedInputStream(
                             new FileInputStream(
                               "test.in"));
  PrintStream out = new PrintStream(
                      new BufferedOutputStream(
                        new FileOutputStream("test.out")));
  System.setIn(in);
  System.setOut(out);
  System.setErr(out);
  BufferedReader br = new BufferedReader(
                        new InputStreamReader(System.in));
  String s;
  while((s = br.readLine()) != null)
    System.out.println(s);
    out.close(); // Remember this!
  }
}

And also the object serialization example could be useful. Object serialization allows to take any object that implements the Serializable interface and turn it into a sequence of bytes that can later be fully restored to regenerate the original object.

To serialize an object, the OutputStream object is created and then wrap it inside an ObjectOutputStream object. After that use writeObject() and the object is serialized and sent to the OutputStream. To restore the object wrap an InputStream inside an ObjectInputStream and call readObject(). What comes back is, as usual, a reference to an upcast Object we have to downcast to set things straight.

//MyClass.java
import java.io.Serializable;
public class MyClass implements Serializable {
  public Integer i = new Integer(10);
}

//ClassSaver.java
import java.io.*;
public class ClassSaver {
  public static void main(String[] args) throws IOException {
    ObjectOutput out = new ObjectOutputStream(
                         new FileOutputStream("file.out"));
    MyClass mc = new MyClass();
    out.writeObject(mc);
  }
}

//ClassRestorer.java
import java.io.*;
public class ThawAlien {
  public static void main(String[] args) throws IOException, ClassNotFoundException {
    ObjectInputStream in = new ObjectInputStream(
                             new FileInputStream("file.out"));
    Object o = in.readObject();
    System.out.println(o.getClass());
  }
}

Files

The File class has a number of "informational" methods. To use any of these, you must construct a File object containing the name of the file it is to operate upon.

import java.io.*;
import java.util.*;
public class Status {
  public static void main(String[] argv) throws IOException {
    if (argv.length == 0) {
      System.err.println("Usage: Status filename");
      System.exit(1);
    }
    for (int i = 0; i < argv.length; i++) { status(argv[i]); }
  }

    public static void status(String fileName) throws IOException {
      System.out.println("File: [" + fileName +"]");
      File f = new File(fileName);
      if (!f.exists()) {
        System.out.println("file not found");
        return;
      }
      System.out.println("Canonical name " + f.getCanonicalPath());
      String p = f.getParent();
      if (p != null) { 
        System.out.println("Parent directory: " + p); 
      }
      if (f.canRead()) { 
        System.out.println("File is readable."); 
      }
      if (f.canWrite()) { 
        System.out.println("File is writable."); 
      }
      Date d = new Date();
      d.setTime(f.lastModified());
      System.out.println("Last modified " + d);
      if (f.isFile()) { 
        System.out.println("File size is " + f.length() + " bytes.");
      } else if (f.isDirectory()) {
        System.out.println("It's a directory");
      } else {
        System.out.println("Unknown type of file.");
      }
      System.out.println( ); 
    }
}

Image processing

Identify animated GIF

Once I needed to identify if a GIF encoded picture was animated. The procedure shown below worked quite well for me

  /**
   * Get encoding name, like "GIF" or "JPEG"
   * @param byte[] bytes - source bytes of a picture
   * @return String - returns "GIF" if the set of source bytes represent a gif encoded image,
   *                - returns "JPEG" if the set of source bytes represent a jpeg encoded image 
   *                - throws exception if neither of above
   */
  public static String getSourseFormatName(final byte[] bytes) throws Exception{
    InputStream in = new ByteArrayInputStream(bytes);
    int a = in.read() & 0xff;
    int b = in.read() & 0xff;
       
    if (a==71 && b==73){ //71 = "G" and //74 = "I"
      // this is GIF
      // now we'll find out if it is an animated GIF
      in.skip(8);
      // read Logical Screen Descriptor's packed field
      int k = in.read() & 0xff;
      // no need for the rest two bytes in the Logical Screen Descriptor
      in.skip(2);
      int colorTable = 0;
      //if the first byte is '1' then there's the Global Color Table present
      if (k > 127){
        //calculate number of bytes to be skiped in Global Color Table
        colorTable = k & 0x07;
        int toSkip = 3 * (int)Math.pow(2.0,(double)(colorTable+1));
        in.skip(toSkip);

        // just after the Global Color Table there's the animation descriptor:
        // byte   1       : 33 (hex 0x21) GIF Extension code
        // byte   2       : 255 (hex 0xFF) Application Extension Label
        // byte   3       : 11 (hex (0x0B) Length of Application Block (eleven bytes of data to follow)

        int A = in.read() & 0xff; // mask the most significant byte
        int B = in.read() & 0xff;
        int C = in.read() & 0xff;

        if(A==33 && B==255 && C==11){
          throw new Exception("Animated GIF! I will not process it.");
        }
      }
      return "GIF";
    }else if (a==255 && b==216){// 255="J" and 216="P"
      //this is JPEG
      return "JPEG";
    }else{
      throw new Exception("Unknown format! I will not process it.");   
    }
  }

Writing JPEG image with predefined quality.

The method below shows how to write a JPEG encoded image with predefined quality.

/*need following imports*/				  
import com.sun.image.codec.jpeg.JPEGCodec;
import com.sun.image.codec.jpeg.JPEGEncodeParam;
import com.sun.image.codec.jpeg.JPEGImageEncoder; 
...

  /**
   * Writes JPEG with a given quality a target file.
   * @param BufferedImage im - rendered picture
   * @param float quality - quality of jpeg compression. 0.0 < quality < 1.0
   * @param File toFile - target file to store the picture in.
   * @return void
   */
   public static void writeJPEG(final BufferedImage im, final float quality, final File toFile){
      FileOutputStream out = null;    	   
      try{
          out = new FileOutputStream (toFile);
          JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder ( out );
          JPEGEncodeParam param = encoder.getDefaultJPEGEncodeParam ( im ); 
          param.setQuality ( quality, false );  
          encoder.setJPEGEncodeParam ( param );  
          encoder.encode ( im );   	
          out.close(); 
      }catch ( Exception ex ){
          ex.printStrackTrace();
      }
  } 

Converting array of bytes to a BafferedImage object.

Consider that you have read in an image file and you have now an array of bytes representing this file. To obtain a BufferedImage object for further image processing use javax.imageio.ImageIO class (introdiced in JDK 1.4).

  /**
  * byte[] to BufferedImage
   * @param bytes
   * @return BufferedImage
   * @exception IOException
   */
  public static BufferedImage getBufferedImageFromBytes(final byte[] bytes)
  throws IOException {
    ByteArrayInputStream ba = new ByteArrayInputStream(bytes);
    BufferedImage buf = ImageIO.read(ba);
    ba.close();
    return buf;
  } 

Image dithering

Dithering is a technique for digital haftoning. Dithering can be accomplished by tresholding the image against a dither matrix. The elements of dither matrix are thresholds. The matrix is laid like a tile over the entire image and each pixel is compared to the corresponding threshold. The pixel becomes white if its value exceeds the threshold or black otherwise.

    public static BufferedImage ditherByMatrix(int[][] matrix, BufferedImage sourceImage) {
        // Create binary image to hold result
        int w = sourceImage.getWidth();
        int h = sourceImage.getHeight();
        BufferedImage ditheredImage =
         new BufferedImage(w, h, BufferedImage.TYPE_BYTE_BINARY);

        Raster input = sourceImage.getRaster();
        WritableRaster output = ditheredImage.getRaster();
        int n = matrix.length;
        for (int y = 0; y < h; ++y)
	for (int x = 0; x < w; ++x) {
            int threshold = matrix[y%n][x%n];  // tiles image with the matrix
            if (input.getSample(x, y, 0) > threshold)
              output.setSample(x, y, 0, 1);
      	  }
        return ditheredImage;
    }

e-mail

import java.io.IOException;
import java.io.PrintStream;
import sun.net.smtp.*;

public class HelloMail {
public static void main(String[] args){
    String smtpServer; // assign your smtp 
    String fromAddr;   // from
    String toAddr;     // to
    try {
      SmtpClient sc = new SmtpClient(smtpServer);
      sc.from(fromAddr);
      sc.to(toAddr);
      PrintStream ps = sc.startMessage();
      ps.println("Subject: this is a test");
      ps.println();
			
      ps.println("Hello there!");
      sc.closeServer();
    }catch (IOException e){
      System.err.println(e);
      System.out.println("Sorry, your mail can't be sent."); 
    }
  }
}

Make an SQL query to database

import java.sql.*;
import java.io.*;
import java.util.*;

/** Load a driver and connect to a database and return connection.*/
public class Connect {
  public static Connection getConnection() {
    String dbURL = "jdbc:odbc:Companies"; //any database URL
    try {
      // Load the jdbc-odbc bridge driver
      Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
      // Enable logging
      DriverManager.setLogStream(System.err);
      System.out.println("Getting Connection");
      Connection conn = DriverManager.getConnection(dbURL, "user", "password"); // set user and password
      SQLWarning warn = conn.getWarnings();
      while (warn != null) {
        System.out.println("SQLState: " + warn.getSQLState());
        System.out.println("Message: " + warn.getMessage());
        System.out.println("Vendor: " + warn.getErrorCode());
        System.out.println("");
        warn = warn.getNextWarning();
      }

      PreparedStatement stmt = conn.prepareStatement("SELECT user_name, full_name from userdb where id=?");
      stmt.setInt(1, 12345);
      ResultSet rs = stmt.executeQuery();
      
      // Now retrieve (all) the rows that matched the query
      while (rs.next()) {
        String name = rs.getString(1);
        String fullName = rs.getString(2);
        System.out.println("User " + name + " is named " + fullName);
      }
      
    } catch (ClassNotFoundException e) {
      System.out.println("Can't load driver " + e);
    } catch (SQLException e) {
      System.out.println("Database access failed " + e);
    } finally {
      try {
        rs.close(); // All done with that resultset
      } finally {
        try {
          stmt.close(); // All done with that statement
        } finally {
	  conn.close(); // All done with that DB connection
	}
      }
    }
  }
}

XML

Here's an example of simple XML tree construction using DOM.

/*need some special imports*/				  
import org.apache.crimson.tree.AttributeNode;
import org.apache.crimson.tree.XmlDocument;
import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.Node; 
...

public static void itemList(HashSet items, File out) 
throws IOException{
  FileOutputStream fs = new FileOutputStream(out);
  XmlDocument xmlDoc = new XmlDocument();
  Node root = xmlDoc.createElement("root");
  xmlDoc.appendChild(root);
  for(Iterator i = items.iterator(); i.hasNext();){
    String item = (String)i.next();
    Node item = xmlDoc.createElement("item");
            
    Attr itemId = xmlDoc.createAttribute("id");
    itemId.setValue(item);
    item.getAttributes().setNamedItem(itemId);
            
    xmlDoc.write(fs);
    fs.close();
  }
} 

Execute an external application via Java

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Executor {
	public static void main(String[] args) throws java.io.IOException {
	    Process p = Runtime.getRuntime().exec(args[0]);
	   
	    // uncomment the following code in case you'd like to read 
	    // the output from executed application
	    /*
            String line;
	    BufferedReader is = new BufferedReader(new InputStreamReader(p.getInputStream()));
	    while ((line = is.readLine( )) != null) {
	      System.out.println(line);
	    }
	    */  
	}
}

Obtain class info

import java.lang.reflect.*;
public class ListMethods {
  public static void main(String[] argv) throws ClassNotFoundException {
    if (argv.length == 0) {
      System.err.println("Usage: ListMethods className");
      return;
    }
    Class c = Class.forName(argv[0]);
    Constructor[] cons = c.getConstructors();
    printList("Constructors", cons);
    Method[] meths = c.getMethods( );
    printList("Methods", meths);
  }
  static void printList(String s, Object[] o) {
    System.out.println("*** " + s + " ***");
    for (int i=0; i      System.out.println(o[i].toString( ));
    }
  }    
}

by ant