Sunday, May 24, 2015

Lambda Expression and Functional Interface

Lambda expressions are one of the major features of Java 8 (Project Lambda). With this, Java adopts a feature of Functional Programming Language. This feature already present in other languages which runs on JVM (If you familiar of Scala, you might have noticed it). Anyway, we will see what is Lambda expression; how to use it and what are the advantages to use it.

Why Lambda Expressions

Lambda expression is a block of code written in a more readable and compact way. This piece of code can be executed later stage one or more times. This means, Lambda expression allows to pass a block of code as an argument to function or to a constructor. So far, we have been using Anonymous classes to do that. I will give you couple of most common examples on this and will convert them into Lambda expression.

Example - I

We write a anonymous thread using Runnable interface like this
        Runnable r = new Runnable() {
            public void run()
            {
                System.out.println("Anonymous Runnable Example");
            }
        };
        
        Thread t = new Thread(r);
        t.start();
If we use lambda expression, then the above code can be written as
        Runnable r2 = () -> System.out.println("Lambda Runnable Example"); 
        
        Thread t2 = new Thread(r2);
        t2.start();

Example - II

To sort list of elements (or an array), we use Collections.sort of Arrays.sort using a comparator like this
        String[] names1 = new String[]{"Java", "Scala", "Lisp"};
        Arrays.sort(names1, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2)
            {
                return o1.compareTo(o2);
            }
        });
        
        for(String s : names1)
        {
            System.out.println(s);
        }
If we use lambda expression, the this code can be changed to
        String[] names2 = new String[]{"Java", "Scala", "Lisp"};
        
        Comparator<String> comparator = (s1, s2) -> { return s1.compareTo(s2);};
        Arrays.sort(names2, comparator); 
        
        for(String s : names1)
        {
            System.out.println(s);
        }
Similarly event listeners in Swing can also be written like this. Example ActionListener interface where you implement the action performed by an event.
Pretty easy, isn't it, now we will see more details on the lambda expression

Syntax

Syntax of lambda expression is also simple (as we saw in above examples).
Syntax: (arguments) -> { Code }
  • Lambda expressions takes one or more arguments separated by comma (,) 
  • Type of the arguments are optional
  • Code and Arguments are separated by the symbol (->).
  • Code is just a set of statements like we write in methods
  • The code needs to end with a return statement (if it needs to return a value). 
  • If there is only one statement in the code, then braces {} are optional 
See some more examples of Lambda expressions
Example : () -> System.out.println("Without arguments");
Example : (event) -> System.out.println("One argument without type");
Example : (String s1, String s2) -> {
            System.out.println("two arguments and return type");
            return s1.compareTo(s2);
          };

By looking at the code, examples and usage we can list the advantages of Lambda expressions as
  • It increase the readability of the code 
  • Reduces unnecessary boiler plate code
  • It also adds to the performance of the code using parallel processing. 

Functional Interface 

To incorporate the lambda expression into Java, designers introduced a new feature called Functional Interface. Functional Interface is an interface with only one method. To make it more semantic, we can add an annotation @FunctionalInterface. If we add more than one method, it will break the contract and it will no more be a functional interface, instead we can add default or static methods. Example of Functional Interfaces are
Examples
//Example 1 - Only one method
@FunctionalInterface
public interface FInterface
{
    public void method();
}

//Example 2 - with default method
@FunctionalInterface
public interface FInterface
{
    public void method();
    
    public default String printName()
    {
        return "Functional Interface";
    }
    
}
All the famous java interfaces like Runnable, Callable, Comparator etc.. are now functional interfaces. If you open the JavaDoc or code of these interfaces, you will see that these are annotated with @FunctionalInterface. See the samples below
//Comparator
@FunctionalInterface
public interface Comparator<T> {
...

//Runnable
@FunctionalInterface
public interface Runnable {
As i mentioned earlier in the post, lambdas are the most important and prominent feature of Java 8 which attracts most the developers, hope for you as well.

Thanks for reading and Happy Leaning!!!

Monday, May 18, 2015

Programming using VIM editor

There would be some cases, where we need to change source on the host machines and run them. For those instances, VIM (VI - improved) is very good editor to make use of. As we are most used to modern GUI editors, we may find it difficult to use the terminal. We can make best use of terminal using some tips and tricks. I will try to explain what i generally use.

Syntax Highlighting

We do make mistakes/typos when typing, so better to use syntax highlighting to make sure that we are typing the right command/keyword/phrase etc. Syntax highlighting is simple enough in VIM. Use the following commands to set that. Open VIM (empty or with any java/c file) and type
:syntax on
VIM detects the language automatically, but if you would like to change the language, use syn variable to set the preference (java or xml etc). See some samples below on how to use
:set syn=java
:set syn=xml
If you are using a terminal, syntax highlighting may not work for you, unless you set your term variable to ansi
:set term=ansi
You may need to add this in your .vimrc file (exists in $HOME directory. If not exists, create it) to default it for all the files opened by VIM.

Color-Schemes

Syntax highlighting will be shown with default color schemes. There are few color schemes available by vim by default, you can switch the color shown on the highlighting. use colorscheme keyword.
:colorscheme <color-scheme-name>
You can download the color schemes available on web and place in your vim colors directory. Generally it will be at $HOME/.vim/colors. You can download the color-schemes from from github, and install. Copy the downloaded files into .vim/colors (in $HOME), if not exists - create it, and copy all the colors to colors folder.
If want to default the syntax highlighting and color schemes defaulted when you open VIM, simply put all the commands into .vimrc files in your home directory.
See one sample below
set term=ansi
syntax on

colorscheme eclipse

Compile and Run

To run your program, you can use the compile or execute command prefixed with :! inside VIM editor. See sample below. Open vim and write the code and compile using
:!javac Sample.java
When you run the command, a new screen will be opened with the javac command output (Compilation errors/success of compilation). Once the compilation is successful, run the program using the following command.
:!java Sample
  • Note: Just a point to note, javac and java should be in PATH variable to be recognized. 
But it will be too cumbersome to type the same command multiple times, if any compilation errors, you have two options to make it simple and easy. 

QuickRun plugin

As VIM allows to add plugins, there is a plugin QuickRun which compiles and run a program in one go. Download the plugin at github. Follow the installation instructions (just copy the mentioned files to your vim plugins directory - $HOME/.vim/plugins). Once installed, you can run your program by the command QucikRun. Open your program and execute the command
:QuickRun
This will compile and run the program and output will be shown by splitting the screen. QuickRun supports few programming languages by default and it recognizes based on the file type (See documentation for more details).

MakePrg command

If you wouldn't like to install a plugin, or if the plugin doesn't support the programming language that you are working on, then you can use makeprg command to compile your program.
Edit .vimrc file in your $HOME directory to include the following lines (I am giving an example on how to use javac command in makeprg)
"Compiling Java Code
autocmd Filetype java set makeprg=javac\ %
set errorformat=%A%f:%l:\ %m,%-Z%p^,%-C%.%#
map <F9> :make<Return>:copen<Return>
map <F10> :cprevious<Return>
map <F11> :cnext<Return>
By doing this, you are mapping some of the control characters to default compile command (i.e. make). What we are doing in the above lines are
  • Setting the detault make program to use the command javac
  • Mapping F9 (Function-9) key to compile the java code and return to the current window without any prompt.
  • If any compilation error,
    • use F11 to see the next error message (printed in the given error-format).
    • use F10 to see the previous error message (printed in the given error-format).
How to use
Open the program using vim, write the code and compile using by pressing F9. To navigate through the errors, use F10 and F11.
Using this, you can only compile your code, it doesn't execute (Of course javac doesn't execute your java program). Use :!java command from the vim editor to execute the compiled program (as mentioned in the starting of the post), or instead use the java command on the command line (after exiting from vim editor). 

Hope this post helped you with the commands. Happy Learning!!!