java.fornOObs

How to change JDK in Linux

2010-03-30T08:04:08Z

Linux Mint or Ubuntu may come with the OpenJDK Java compiler and runtime. If you need to work the Sun version of the Java development kit, you will need to download it. You can do this using the Synaptic app or just open a Terminal window, press ALT-F2, then type gnome-terminal

sudo apt-get install sun-java6-jdk

Ideally, the update should have changed the symlinks and paths for your JDK, but just in case the default is still OpenJDK, you can point the Java compiler to point to the newly downloaded Sun JDK.

On a terminal window again, just issue the command.

$ sudo update-alternatives –config java

note: there are 2 dashes before the config.

It will give you an input dialog like this.

Type in the number corresponding to the Sun JDK, then press ENTER. Your JDK should be pointing to Sun JDK now, you can test it by

$ java -version

How to accept input from keyboard

2009-11-26T14:35:11Z

If you need to write interactive text-based application in Java, you will need a way to accept input from the keyboard; sure you can get it from the command line, but at some point, you will need to prompt the user for an input and store that input somewhere in your code for later processing.

There are lots of ways to do that, this is one of them.



import java.io.InputStreamReader;

import java.io.BufferedReader;

import java.io.IOException;
class AcceptInputFromKB {
   public static void main(String []args) throws IOException {  
      InputStreamReader isr = new InputStreamReader (System.in);

      BufferedReader br = new BufferedReader (isr);
      System.out.print(“% “);

      String temp = br.readLine();

      System.out.println(temp);

      System.out.println(“Length of string = ” + temp.length());
   }

}

The captured input from the keyboard is already trimmed, there is no need to call temp.trim(); The last System.out.println(“Length …”) is just for show, you can omit that line–it’s just there for show-and-tell.

The second example is a bit more modularized–in most situations, what you will need is a function in your code that you can call every time you need to prompt the user for input; it would be handy too if this function accepts a String object as parameter which will be displayed as a prompt to the user, and finally, the function should return what the user has typed–here is the code for that.


import java.io.InputStreamReader;

import java.io.BufferedReader;

import java.io.IOException;
class Repl {
   InputStreamReader isr = null;

   BufferedReader br = null;
   Repl() {
      isr = new InputStreamReader(System.in);

      br = new BufferedReader(isr);
   }
   String Prompt(String prompt) {

      System.out.print(“% ” + prompt + ” : “);

      String retval = null;

      try {

         retval =  br.readLine();

      }

      catch(IOException ioe) {

         ioe.printStackTrace();

      }

      finally {

         return retval;

      }

   }
   public static void main(String []args)  {  
      Repl repl = new Repl();

      String fname = repl.Prompt(“Enter your first name”);

      String lname = repl.Prompt(“Enter your last name”);
      System.out.println(“Hello ” + fname + ” ” + lname);
   }

}

This will tie you up if you just need some simple mechanism to display a prompt and get input from the user using text-based interfaces. If you need something more advanced like windowing, positioning the prompts on very specific screen coordinates and coloring the fonts — that will be a bit more involved to code; you’re probably better off using some of CURSES related Java libraries like JCurzez, CHARVA and Java Curses — Note though that I haven’t tried anyone of these 3, but these are the ones I found by quickly Googling ‘java curses’–that seemed like a good search phrase at the time of writing.

Multiplication table using 2 for loops in Java

2009-12-10T13:43:51Z

I saw this search term coming up over and over again in my wp-stats, I would guess that this is a school assignment–for those beginning to get into grips with Java language, this is how to generate the Multiplication table using 2 for loops; you could use another kind of loop, but using ‘for’ is by far the simplest that I can think of.

The size of the multiplication table is determined by the values of rows and columns integer variables, just replace the values according to your need.


class MultiplicationTable {
   public static void main(String []args) {
      int rows=10;

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

         for(int j=1;j<=columns;j++){

            System.out.print(i*j + "\t");

         }

         System.out.print("\n");

      }

   }

}

"\t" is an escape code for tabs, we'd like each vaulue in our table to have a somewhat uniform spacing, and for this reason too, the System.out.print was used--we don't want to have a new line everytime we print a value, we only want the new line after one complete row (the maximum value of the rows variable, which is the outer for loop) -- which is why the System.out.print("\n") is positioned in the outer for loop.

compile and run using

$ javac MultiplicationTable.java
$ java MultiplicationTable

Starting database programming in Java

2009-11-26T05:35:49Z

Database programming is probably one of the most common tasks that you will encounter in your programming career–in fact, during job interviews, it is an expectation that you know how to deal with the most common databases in use–like for example, MySQL, Oracle, MS SQL Server and many others.

Java database programming can get hairy sometimes when you’re doing really complicated tasks–but understanding the basics is a straightforward process. Most java database programs do the following.

Load the driver for the database you are using — most database makers provide a java database driver, mostly these are jar files where the java libraries needed to talk to the database are packaged.
Get a Connection object – This is the initial handshake with the database, if the database requires that you enter a username and password, this is also the step where you give the database your security credentials. The Connection object is important because you will need it to produce the other objects you will use later in order to send SQL commands to the database. The Connection object is also responsible if you would like to influence the behavior of autocommit–whether you would like to have more control over the rollback and commit activities of the database
Fetching records, Inserting records, modifying records and deleting records — You can use either the Statement object or the PreparedStatement object to perform these tasks.
Closing all connections

After you have successfully created the database, you can now try out the code. So Launch your favorite editor and code away.

Sample java database code

Below is a boiler-plate code for a Java program which accesses a database. It uses sqlite3.

You need to prepare the database first and create sample.db using sqlite, lest the code will fail. Here’s how to quickly prepare our sample database.

$ sqlite3 sample.db
SQLite version 3.6.12
Enter “.help” for instructions
Enter SQL statements terminated with a “;”
sqlite> CREATE TABLE user(username varchar(50), email varchar(200), password varchar(20));
sqlite> insert into user values(‘ted’, ‘ted@fornoobs.info’,'I wont tell you’);
sqlite> select * from user;
ted|ted@fornoobs.info|I wont tell you
sqlite> .quit
$



import java.sql.DriverManager;

import java.sql.Connection;

import java.sql.Statement;

import java.sql.ResultSet;

import java.sql.SQLException;
class DBSample {
   public static void main(String []args){
      Connection cn = null;

      Statement st = null;

      ResultSet rs = null;
      try {
         Class.forName(“org.sqlite.JDBC”);

         cn = DriverManager.getConnection(“jdbc:sqlite:sample.db”);

         st = cn.createStatement();

         rs = st.executeQuery(“SELECT * FROM user;”);
         while(rs.next()) {

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

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

            System.out.println(rs.getString(3));

         }
      }

      catch(ClassNotFoundException ce) {

         ce.printStackTrace();

      }

      catch(SQLException sqle) {

         sqle.printStackTrace();

      }

      finally {

         try {

            rs.close();

            st.close();

            cn.close();

         }

         catch(SQLException sqle) {

            sqle.printStackTrace();

         }

      }

   }

}

Class.forName(“org.sqlite.JDBC”) – The reason we are calling this is so that we can load the methods of sqlite database functions, specifically the JDBC class found in org/sqlite package (folder). The JDBC class contains the necessary CLI (Command Level Interface) for the sqlite database, we don’t have to call them natively because org.sqlite.JDBC class is already acting as a wrapper for those calls. You could actually load the sqlite Java driver as well by just calling ‘new org.sqlite.JDBC();’

DriverManager.getConnection() – the getConnection() method returns Connection interface (a Connection type). The Connection object is the one responsible for, well, the connection to the database. It is also via the Connection object that you can adjust how database writes are performed, whether it commits automatically or otherwise.

jdbc:sqlite:sample.db – The parameter for the getConnection() method is the database URL, the database URL is composed of 3 parts and each part is separated by a colon (:). Most java database URLs start with jdbc, the second part will vary depending on which database you are using–you will need to look at the documentation of each jdbc driver for the URL, it will be different if you will use say, MySQL or MS SQL or Oracle.

“SELECT * FROM user;” – This is a standard SQL command which will select all records from the user database defined in sample.db, it’s a good idea to test out the command in the command line of sqlite first before writing it here, especially if the SQL command becomes a bit more complicated than simple selects. You will write the SQL statements as parameter to the executeQuery() method of the Statement object. The .executeQuery() returns a ResultSet object which we can use to process the returned CURSOR–a CURSOR means CURrent Set Of Records, it’s a database term, but for now just imagine that they are pretty much like Excel worksheets, they are composed of rows and columns which contains the user information.

rs.next() – The next() method returns actually does 2 things, first, it moves the location of our database pointer (if you can imagine it) so that it fetches the next row, then it returns true if there are more records to process; when you have reached the last record or there are no more records to process, the .next() method will return false–this is the reason I placed it inside a while loop, the loop will be processed only as long as there are records to process. When there are no more records to read, our while loop will exit.

getString() – The getString() method extracts the the contents of the current record. The numbered parameter inside the getString() indicates which column you would like to fetch. The column count for ResultSet objects actually starts at 1–not zero, you need to remember this because it can be confusing sometimes that array counting starts at zero, that is true for arrays, not true for ResultSet objects–always start counting at 1. You can actually use the field name if you like, so instead of writing getString(1), you can write getString(“username”). One more important thing to mention, I only used getString() because the data type of what I’m trying to read from the database is String (varchar actually, which is a String type), if you were reading a numeric value like an integer, you should use getInt() instead–you need to read the java.sql.ResultSet documentation to have a feel of what kinds of data types you can use.

The example is a bit verbose, but it’s representative of most database programming codes that we do Java.

Notes on exception handling blocks

The methods forName(), getConnection(), createStatement(), executeQuery() and next() throws ClassNotFoundException and SQLException(s) respectively. This is a reason why they are inside a try-catch-finally block, Java won’t allow you to compile if Exceptions are not handled properly.

How to peek quickly inside the .class files using javap

2009-11-26T14:42:20Z

If you need just need to quickly see the name of the methods of a specific Java class or you want to take a look at a disassembled code, you can use javap. If your JDK is properly installed and you have setup your PATH and CLASSPATH properly, then you can already use javap–it’s executable file is located in /Path/To/YourJDK/Installation/bin.

Basic use of javap

$ javap java.lang.String

This will print out (to the standard output, your monitor) all the method signatures of java.lang.String, pretty much what you will find in the JDK documentation, only without the brief explanations–although not as complete as the JDK documentation, it’s at a quick way to just look at at the method signatures of specific classes. This is a handy technique to have while coding because you can quickly access the exact definitions for method signatures.

If you want to learn more about javap, all you’ve got to do is to type javap -help in the command line so that you can see all of it’s options. I’m including it here for your reference.

$ javap -help
Usage: javap
 ...

where options include:
   -c                        Disassemble the code
   -classpath
     Specify where to find user class files
   -extdirs            Override location of installed extensions
   -help                     Print this usage message
   -J                  Pass  directly to the runtime system
   -l                        Print line number and local variable tables
   -public                   Show only public classes and members
   -protected                Show protected/public classes and members
   -package                  Show package/protected/public classes
                             and members (default)
   -private                  Show all classes and members
   -s                        Print internal type signatures
   -bootclasspath
 Override location of class files loaded
                             by the bootstrap class loader
   -verbose                  Print stack size, number of locals and args for methods
                             If verifying, print reasons for failure

java.fornOObs

How to change JDK in Linux

Related Posts:

How to accept input from keyboard

Related Posts:

Multiplication table using 2 for loops in Java

Related Posts:

Starting database programming in Java

Sample java database code

Notes on exception handling blocks

Related Posts:

How to peek quickly inside the .class files using javap

Basic use of javap

Related Posts: