Techie Notes: Java

Showing posts with label Java. Show all posts

Sunday, September 8, 2013

Steps involved during Execution of a Java Program

JVM startup
Loading – finding binary representation of class/interface then constructing the Class object
Linking – combining class/interface into the run-time state of the JVM so that it can be executed

Verification - semantic/structure validation
Preparation - storage allocation, all static fields are created and initialized with default values
Resolution – optionally resolve symbolic reference to other classes/interfaces

Initialization – static initialization

superclass/superinterface static initialization

superclasses are initialized before subclasses
interface initialization does not initialize superinterfaces
only the class that declares static field is initialized, even though it might be referred to through the name of a subclass, a subinterface, or a class that implements an interface

all static explicit field initializers and static initialization blocks are executed in textual order

Instantiation - creation of object/class instance
All the instance variables, including those declared in superclasses, are initialized to their default values first.

start the constructor
call explicit constructor this() if available

call explicit/implicit super() unless class is Object – process recursively using same steps a. to e.
all non-static field initializers and non-static initialization blocks are executed in textual order
execute the rest of the body of constructor

Finalization – finalize() method is called before storage for object is reclaimed by GC
Unloading – happens if its classloader is reclaimed by GC. Bootstrap loader may not be unloaded.
Program Exit

Ref: http://docs.oracle.com/javase/specs

Tuesday, April 23, 2013

Custom JSP tags

1) Make sure that the library for tags is in your classpath. servlet-api-2.3.jar supports it.
2) Create the tag class
Ex.
public class MyTag extends TagSupport
public class HelloTag extends SimpleTagSupport
3) Create the tag libray descripto file and put anywhere inside WEB-INF directory
Ex. WEB-INF/tld/myApp.tld

<taglib>
  <tlib-version>1.0</tlib-version>
  <jsp-version>2.0</jsp-version>
  <short-name>Example TLD</short-name>
  <tag>
    <name>Hello</name>
    <tag-class>com.tutorialspoint.HelloTag</tag-class>
    <body-content>empty</body-content>
  </tag>
</taglib>

4) Use the tag. You can also set uri in tld and use it as your uri in JSP page.

<%@ taglib prefix="ex" uri="WEB-INF/tld/myApp.tld"%>
<html>
  <head>
    <title>A sample custom tag</title>
  </head>
  <body>
    <ex:Hello message="This is custom tag" />
  </body>
</html>

Wednesday, June 9, 2010

Initialization of list/map in one line

List
ArrayList places = new ArrayList(Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));

ArrayList list = new ArrayList() {{
add("A");
add("B");
add("C");
}}

link

Map
Map m = new HashMap() {
{
put(".jpg", "image/jpeg");
put(".jpeg", "image/jpeg");
}
};

Sunday, April 11, 2010

Java Concurrency/Threads

Process vs Thread
Process - is a running program that runs independently from other processes. It has its own address space and cannot directly access resources of other processes. Each process can have one or more threads.

Thread - is sometimes called lightweight process. Both processes and threads provide an execution environment, but creating a new thread requires fewer resources than creating a new process. Threads share the process's resources, including memory and open files.

2 ways to define a Thread:

implement Runnable interface
- more general, can have many superclass
- starting: (new Thread(new HelloRunnable())).start();
extend Thread class (Thread class itself implements Runnable)
- simpler but limited
- starting: (new HelloThread()).start();

Thread methods:

public void run() - the only method coming from Runnable
public void start() - calls the run() method, can only be called once
public static void sleep(long millis)/(long millis, int nanos) throws InterruptedException - suspend execution for a specified period
- time is not guaranteed
- can be interrupted
public void interrupt() - indicates that thread should stop
public static boolean interrupted() - interrupted status is cleared
public boolean isInterrupted() - has no effect on interrupted status
public final void stop()/suspend()/resume() - deprecated

Object	Thread
notify notifyAll wait	sleep yield

Source: http://java.sun.com/docs/books/tutorial/essential/index.html
http://www.vogella.de/articles/JavaConcurrency/article.html

Thursday, April 1, 2010

Using Resource Bundle

ResourceBundle is a class used for containing locale-specific data. A Locale defines the user's environment particularly its language and region. A certain number in one locale may be written differently in another. Likewise, a label of a "Cancel" button may differ in different locales. Using ResourceBundle will allow you to handle these different locales without having to hard-code the locale-specific data.

Sample of retrieving locale-specific data
list of resource bundles:
ButtonLabel
ButtonLabel_de
ButtonLabel_en_GB
ButtonLabel_fr_CA_UNIX

selecting the locale-specific ButtonLabel resource bundle:
Locale currentLocale = new Locale("fr", "CA", "UNIX");
ResourceBundle introLabels =
ResourceBundle.getBundle("ButtonLabel", currentLocale);

2 Types of ResourceBundle

PropertyResourceBundle - uses a properties file to contain the key-value pairs. The value can only be a String.


properties files for 3 resource bundles:
LabelsBundle.properties
LabelsBundle_de.properties
LabelsBundle_fr.properties

resource bundle sample content:
# This is the LabelsBundle_de.properties file
s1 = Computer
s2 = Platte
s3 = Monitor
s4 = Tastatur

use of resource bundle sample:
      Locale[] supportedLocales = {
         Locale.FRENCH,
         Locale.GERMAN,
         Locale.ENGLISH
      };

      for (int i = 0; i < supportedLocales.length; i ++) {
         ResourceBundle labels = 
            ResourceBundle.getBundle("LabelsBundle",currentLocale);

         String value = labels.getString(key);
         Enumeration bundleKeys = labels.getKeys();
         while (bundleKeys.hasMoreElements()) {
            String key = (String)bundleKeys.nextElement();
            String value  = labels.getString(key);         
         }
      }

ListResourceBundle - uses a list to contain the key-value pairs. The value can be any object.


3 resource bundles:
StatsBundle_en_CA.class
StatsBundle_fr_FR.class
StatsBundle_ja_JP.class

resource bundle sample:
import java.util.*;
public class StatsBundle_ja_JP extends ListResourceBundle {
    public Object[][] getContents() {
 return contents;
    }
    private Object[][] contents = {
 { "GDP", new Integer(21300) },
 { "Population", new Integer(125449703) },
 { "Literacy", new Double(0.99) },
    };
}

use of resource bundle sample:
      Locale[] supportedLocales = {
         new Locale("en","CA"),
         new Locale("ja","JP"),
         new Locale("fr","FR")
      };

      for (int i = 0; i < supportedLocales.length; i ++) {
         ResourceBundle stats = 
            ResourceBundle.getBundle("StatsBundle",currentLocale);

         Integer gdp = (Integer)stats.getObject("GDP");
      }

Notes:
- things to check/consider when internationalizing: http://java.sun.com/docs/books/tutorial/i18n/intro/checklist.html
- numbers, dates, times, or currencies need not be isolated in a ResourceBundle because only the display format of these objects varies with Locale, the objects themselves do not
- it is better to have multiple ResourceBundle by determining related objects and grouping them together
- ResourceBundle.Control class provides a way to control the instantiation and location of resource bundles. You can override its methods to behave differently.
- list of language codes (ISO-639): http://ftp.ics.uci.edu/pub/ietf/http/related/iso639.txt
- list of country codes (ISO-3166): http://userpage.chemie.fu-berlin.de/diverse/doc/ISO_3166.html

Source: http://java.sun.com/docs/books/tutorial/i18n/resbundle/index.html

Tuesday, March 23, 2010

Java Exceptions

Exception Objects

Throwable
'-> Error
  '-> AnnotationFormatError
  '-> AssertionError
  '-> IOError
  '-> ThreadDeath
  '-> ...
'-> Exception
  '-> RuntimeException
      '-> ArithmeticException
      '-> ArrayStoreException
      '-> ClassCastException
      '-> ConcurrentModificationException
      '-> IndexOutOfBoundsException
      '-> NullPointerException
      '-> ...
  '-> ClassNotFoundException
  '-> CloneNotSupportedException
  '-> InterruptedException
  '-> IOException
  '-> NoSuchMethodException
  '-> ...

Kinds of Exceptions

checked - all exceptions that are not RuntimeException
unchecked
- Error
- RuntimeException

Notes
- finally is always executed even if there is a change of control flow like when there is a return statement in try
- can you catch runtime exception? yes, you can catch any Throwable type but since the cost of checking for runtime exceptions exceeds the benefit of catching or specifying them, the compiler does not require that you catch them
- for readable code, it's good practice to append the string Exception to the names of all classes that inherit (directly or indirectly) from the Exception class
- what to use when creating your own exception: If a client can reasonably be expected to recover from an exception, make it a checked exception. If a client cannot do anything to recover from the exception, make it an unchecked exception.

Ref: http://java.sun.com/docs/books/tutorial/essential/exceptions/index.html

Synchronized & Unsynchronized Objects

Synchronized	Unsynchronized
StringBuffer	StringBuilder
Vector	ArrayList
Hashtable	HashMap

Monday, March 22, 2010

Setting the CLASSPATH Sys Var

To display the current CLASSPATH variable, use these commands in Windows and Unix (Bourne shell):

In Windows:   C:\> set CLASSPATH
In Unix:      % echo $CLASSPATH

To delete the current contents of the CLASSPATH variable, use these commands:

In Windows:   C:\> set CLASSPATH=
In Unix:      % unset CLASSPATH; export CLASSPATH

To set the CLASSPATH variable, use these commands (for example):

In Windows:   C:\> set CLASSPATH=C:\users\george\java\classes
In Unix:      % CLASSPATH=/home/george/java/classes; export CLASSPATH

From: http://java.sun.com/docs/books/tutorial/java/package/managingfiles.html

Tuesday, March 16, 2010

Declaring Constants

I was contemplating for the best way to declare constants in Java and found that there are several ways to do it. The best article I saw regading this topic is here. It helped me decide clearly as to what I should use plus, one of the comments discussed a very interesting information about inlining constants w/c I will also explain later on this blog.

First, I would like to eradicate suggestions/questions that might come up:

Why not use enums? I am referring here to constants that are not related and may even be of different types so enum is not a good choice.

If these constants are not related, why bother grouping them? This is sometimes necessary because there are constants that belong to the same functionality but are not related to each other. You may also want to group constants shared by different classes, more like global constants. These constants do not belong naturally to a certain class so it needs to be grouped somewhere else.

Why not put constants in the class that they are most related to? Aside from the explanation above, this would also lead to dependencies between classes and the constants will clutter. It's always easier to update just one class or few classes.

So what are the options now?

Interface for Constants
ADV:
- cleaner/shorter code because you can define constants without the public static final keywords since they are implicitly public static final
- a class implementing this can refer to the constants without a qualifying class name
DISADV:
- this is not what interface is designed for. Interface is supposed to specify a contract for its services, not to handle data.
- using constant without a qualifying class name can make code more difficult to understand and maintain
- interfaces promotes constants to the API of the class which means that if MyClass implements MyConstantInterface, you can use MyClass.SAMPLE_CONSTANT instead of MyConstantInterface.SAMPLE_CONSTANT. This breaks inheritance and your Javadoc will be full of repeating constants.

Class for Constants with private constructor
ADV:
- cannot be instantiated and cannot be subclassed like interfaces
- the use of qualifying name can add to the readability of the code
DISADV:
- long name, constants are referred using static references like MyConstantClass.SAMPLE_CONSTANT

static import
ADV:
- allow referring to constants without a qualifying class name
DISADV:
- can make code more difficult to understand and maintain

MY CONCLUSION:
You may choose one over another depending on what you need or what is more convenient for you, but for me the best approach is to use class with private constructor. This will avoid all the disadvantages of using an interface. If you still want to use interfaces because of the shorter name reference for constants, you must use static import of a constant class instead. However, this must be taken with precaution. Use it only if you need frequent access of constants from one or very few classes only. Otherwise, readers of your code may get confused as to where a constant comes from.

Now, is there anything else that can do better? Apparently, according to Kevin Riff, there is. When a field is (1)of type primitive or String, (2)declared final, and (3)was initialized upon declaration, it is called "compile-time constant" and it is in-lined in the consumer classes. This means that all reference of this constant is replaced with its actual value at compile time. So if you change the value of a constant, you must recompile not only the containing class but all its consumer classes in order to update the value of the constant.

What is the solution for this? Using a properties file could be considered but if you really need to hard-code your constants in a Java file, you must prevent your constants to be in-line like this,

public class MyLibrary { 
  public static final String VERSION;  // blank final
  static {
    VERSION = "1.0";  // initialized separately
  }
}

The code would seem odd so don't forget to add comments explaining what's going on.

Personally, I might not apply this design because it makes the code look odd and somehow ugly. I would rather recompile all affected classes. It happens to almost any class anyway that when you make a change on it, there will be some affected classes that must be recompiled too.

Monday, March 15, 2010

Java Generics

introduced in J2SE 5.0
adds robustness/stability on code by making more bugs detectable at compile time

normal way can cause runtime ClassCastException

public class Box {
    private Object object;
    public void add(Object object) {
        this.object = object;
    }
    public Object get() {
        return object;
    }
}
    Box integerBox = new Box();
    integerBox.add("10"); // note how the type is now String
    Integer someInteger = (Integer)integerBox.get();

sample generic version with type variable T

public class Box {
private T t; // T stands for "Type"      
public void add(T t) {
    this.t = t;
}
public T get() {
    return t;
}
}
    Box integerBox = new Box();
    integerBox.add(new Integer(10));
    Integer someInteger = integerBox.get(); // no cast!

generic method/constructor

public static <U> void fillBoxes(U u, List<Box<U>> boxes) {
for (Box<U> box : boxes) {
    box.add(u);
}
}
Crayon red = ...;
List<Box<Crayon>> crayonBoxes = ...;
// normal way
Box.<Crayon>fillBoxes(red, crayonBoxes);
// with type inference
Box.fillBoxes(red, crayonBoxes); // compiler infers that U is Crayon

Bounded Parameter types -> when variables are restricted to certain types, upper bound only
```
<U extends Number & MyInterface> // uses extend for both classes & interfaces
```

Unknown type/wilcard bounds -> represented by wildcard character "?"

3 different flavors of wildcards:

" ? " - the unbounded wildcard. It stands for the family of all types.
" ? extends Type " - a wildcard with an upper bound. It stands for the family of all types that are subtypes of Type , type Type being included.
" ? super Type " - a wildcard with a lower bound. It stands for the family of all types that are supertypes of Type , type Type being included.

// Box<Integer> and Box<Double> are not subtypes of Box<Number>
Box<Number> box = new Box<Integer>(); // compile-time error

// Box<Integer> and Box<Double> are subtypes of Box<? extends Number>
Box<? extends Number> box = new Box<Integer>(); // ok

Integer i = new Integer(1);
Number n = i;
// compile-time error
// Integer is not '? extends Number'
// we are not sure that the instance type of Box is Integer, so we cannot add i
box.add(i); 

// compile-time error
// Number is not '? extends Number'
// we are sure that the type of Box extends a Number but we are not sure of the 
//     instance type of n, so we cannot add n
// what if runtime type of Box is Box<Double> but n is Integer
box.add(n)

// compile-time error
// we are not sure that the type of Box is an Integer
Integer i2 = box.get();

// we are sure that the type of Box is always extends a Number
Number n2 = box.get(); // ok

// sample using upperbound & lowerbound wildcards
public class Collections {
public static <T> void copy
( List<? super T> dest, List<? extends T> src) {  // bounded wildcard parameterized types
   for (int i=0; i<src.size(); i++)
     dest.set(i,src.get(i));
}
}

Type Erasure -> when generic types are instantiated, all generic information are removed leaving only the raw type. Box becomes Box only.

public class MyClass {
    public static void myMethod(Object item) {
        if (item instanceof E) {  //Compiler error
            ...
        }
        E item2 = new E();   //Compiler error
        E[] iArray = new E[10]; //Compiler error
        E obj = (E)new Object(); //Unchecked cast warning
    }
}

Sources:
http://java.sun.com/docs/books/tutorial/java/generics/index.html
http://www.angelikalanger.com/GenericsFAQ/JavaGenericsFAQ.html

Saturday, March 6, 2010

Java Inheritance

Variables

Kinds of variables base on scope: local, instance, class

Hiding/Shadowing Variables
- redeclaring a variable that’s already been declared somewhere else. The closest scope is used when you refer it through simple name.

1) local var hides instance var
- use this to access the instance var

2) instance var hides inherited var
- use super.name or cast the object to its super class, with the syntax ((Superclass)object).name
- when the variable is accessed thru the object containing it, the variable used depends on the type the object it was declared with or casted to, not the runtime type of the object.

Methods

Overloading
- same name, diff arguments, return type doesn't matter

Overriding
- same signature (method name + arguments), same return type diff classes
- instance to instance method only

Hiding
- static to static only
- when the method is called thru the object containing it, the method used depends on the type the object it was declared with or casted to, not the runtime type of the object.

Not allowed in methods but allowed in variables/fields:
- static to non-static or vice versa
- narrowing visibility
- different return type (but same signature/name) -> compile error in methods

Object
- implicit superclass of all classes
- must be overridden in objects -> equals(), hashCode(), toString()

clone() method
-protected|public Object clone() throws CloneNotSupportedException
aCloneableObject.clone();
- aCloneableObject must implemenet Cloneable interface
- default behavior of Object's clone() -> creates an object of the same class as the original object and initializes the new object's member variables. But if a member variable is an external object, say ObjExternal, ObjExternal is not cloned but shared. A change in ObjExternal made by one object will be visible in its clone also.

equals() method
- uses ==
- if overridden, u must override hashCode() too. If two objects are equal, their hash code must also be equal.
```
public boolean equals(Object obj) {
   if (obj instanceof Book)
       return ISBN.equals((Book)obj.getISBN());
   else
       return false;
}
```
Abstract vs Interface
- http://mindprod.com/jgloss/interfacevsabstract.html
- when to use one over the other:
General rule is if you are creating something that provides common functionality to unrelated classes, use an interface. If you are creating something for objects that are closely related in a hierarchy, use an abstract class.

Tuesday, February 16, 2010

Java Annotations

provides data about a program but do not directly affect the program semantics

defined similar to interface
@interface Author {
String author();
String date();
String[] reviewers(); // Note use of array
}

sample use:
@Author(
name = "Benjamin Franklin",
date = "3/27/2003",
reviewers = {"Alice", "Bob", "Cindy"} // Note array notation
)
class MyClass() { }

3 Predefined Annotation Types:
1) @Deprecated - should also be documented using the Javadoc @deprecated tag
/**
* @deprecated
* explanation of why it was deprecated
*/
@Deprecated

2) @Override

3) @SuppressWarnings
@SuppressWarnings("deprecation") //deprecation warning - suppressed
@SuppressWarnings({"unchecked", "deprecation"}) // legacy code & deprecation warning - suppressed

Detailed explanation here: http://java.sun.com/j2se/1.5.0/docs/guide/language/annotations.html

Tuesday, September 22, 2009

Java Enum Type

How do you represent enumerated constants in your java code? It probably will look something like this:
public static final int STATUS_ACTIVE = 0;
public static final int STATUS_PENDING = 1;
public static final int STATUS_CLOSED = 2;

This way of representation poses some problems. So in Java 5.0 Enum Type is introduced. Now you can write your code as,
public enum Status { ACTIVE, PENDING, CLOSED }
and refer to it by Status.ACTIVE, Status.PENDING and Status.CLOSED. The reserved word enum is used like class.

The links below are some discussions on what, how and when they should be used.

http://java.sun.com/j2se/1.5.0/docs/guide/language/enums.html
http://java.sun.com/docs/books/tutorial/java/javaOO/enum.html
http://www.ajaxonomy.com/2007/java/making-the-most-of-java-50-enum-tricks

Monday, July 27, 2009

Java nested classes

I usually get confused with nested classes so I'll note some important points here.

Nested classes
- is also a member of enclosing class like variables and methods
- can use all access modifiers like variables and methods

Types of nested classes
1) static
- like a static method, it is not associated to any instance of enclosing class and has access only to all the static members
- syntax: Outer.Inner i = new Outer.Inner();

2) non-static / inner
- has access to other members of enclosing class even if declared private
- like non-static methods, it cannot define any static members as static members only belong to the (outer) class
- syntax: Outer.Inner i = new Outer().new Inner();

3) local inner - declared and known only within the body of method/block

4) anonymous inner - no name and known only within the statement in w/c they are defined

Thursday, July 9, 2009

Java modifiers summary

Modifier	Class	Interface	Inner Class	Inner Interface	Variable	Method	Constructor	Free-Floating Block
public	yes	yes	yes	yes	yes	yes	yes	no
protected	no	no	yes	yes	yes	yes	yes	no
none or package or default	yes	yes	yes	yes	yes	yes	yes	yes
private	no	no	yes	yes	yes	yes	yes	no
final	yes	no	yes	no	yes	yes	no	no
abstract	yes	yes/no	yes	yes/no	no	yes	no	no
static	no	no	yes	yes	yes	yes	no	yes
native	no	no	no	no	no	yes	no	no
transient	no	no	no	no	yes	no	no	no
volatile	no	no	no	no	yes	no	no	no
synchronized	no	no	no	no	no	yes	no	yes
strictfp	yes	yes	yes	yes	no	yes	yes	no

Points:

all access modifiers can be used to classes and members except for protected and private which cannot be used to outer classes and interfaces

free-floating block cannot have access modifiers. it can only use static or synchronized

constructors can only use access modifiers and strictfp

native is only for methods

transient and volatile are only for variables. Transient indicates that it is not serializable. Volatile indicates that it can be modified simultaneously by many threads.

synchronized can only be used on methods or free-floating blocks

strictfp can't be used on variables or free-floating blocks

Using strictfp ensures that you get the same result of floating-point expressions across multiple platforms. But it may also result to overflow or underflow hence the expression, "Write-Once-Get-Equally-Wrong-Results-Everywhere". If you don't use strictfp, JVM can calculate floating-point expressions however it want and thus could produce more accurate results.

Thursday, July 2, 2009

Getting started with Java

1) download the Java EE Software Development Kit (SDK)
- download link: http://www.oracle.com/technetwork/java/javaee/downloads/index.html

What Java Do I Need?
You must have a copy of the JRE (Java Runtime Environment) on your system to run Java applications and applets. To develop Java applications and applets, you need the JDK (Java Development Kit), which includes the JRE.

What's the difference between J2SE and J2EE?
J2SE has access to all of the SE libraries. However, EE adds a set of libraries for dealing with enterprise applications such as Servlets, JSP and Enterprise
Javabeans.

2) install JDK
- Windows instructions/troubleshooting: http://java.sun.com/javase/6/webnotes/install/jdk/install-windows.html

Why shouldn't I install in "C:\Program Files\Java"?
Some apps (e.g. maven, plugins) uses your Java path without considering potential whitespace on the path causing "C:\Program Files\Java" to become "C:\Program" w/c leads to errors. So either use a path w/out whitespace or set you path to JAVA_HOME=C:\Progra~1\Java not JAVA_HOME=C:\Program Files\Java

3) update environment variables (NOT case-sensitive under Windows)
PATH
- defines the search paths for executable programs (with file extension of ".exe", ".bat" or ".com" for Windows systems) invoked from a command shell ("cmd.exe")
- allows the use of javac and java
- if not set, you need to specify the full path to the executable every time you run it, such as: C:\Program Files\Java\jdk1.6.0\bin\javac MyClass.java
- so add here the JDK binary (bin) directory (e.g., "c:\jdk1.6\bin")
- Note: The JDK binary directory should be listed before "c:\windows\system32" and "c:\windows" in the PATH. This is because some Windows systems provide their own Java runtime (which is often outdated) in these directories (try search for "java.exe" in your computer!).

CLASSPATH
- defines the directories and Java's jar-files for searching for the Java classes referenced in a Java program
- normally, no explicit CLASSPATH setting is required
- if not set, default is current working directory (since JDK 1.3)
- if set, include the current working directory '.'
- link: How Classes are found

JAVA_HOME
- needed for running Tomcat and many Java applications
- set here the JDK installation directory, e.g., "c:\jdk1.6

How to set environment variables in Mac/Unix
1. Set environment variables for your user in ~/.bash_profile (will affect bash shells only).
Create the file if it does not exist:

touch ~/.bash_profile

Open the file:

open ~/.bash_profile

Add environment variables in the file:

export JAVA_HOME=$(/usr/libexec/java_home)
export JRE_HOME=$(/usr/libexec/java_home)

2. Set temporary environment variables for the current bash shell. Just type the same command in 1. to the current bash shell.

Ref: http://www3.ntu.edu.sg/home/ehchua/programming/howto/environment_variables.html

Monday, February 16, 2009

Java Pointers / Links

strength and limitations of for each loop (for( : ))
http://today.java.net/article/2006/11/03/nuances-java-50-each-loop

Loading properties/configurationfiles

Java 5 New Features
http://java.sun.com/j2se/1.5.0/docs/relnotes/features.html
http://java.sun.com/developer/technicalArticles/releases/j2se15/
http://download.oracle.com/javase/1.5.0/docs/guide/language/index.html

Increase Java Performance
http://java.sun.com/developer/technicalArticles/Programming/Performance/

Java Language Best Practices
http://docs.oracle.com/cd/A97688_16/generic.903/bp/java.htm

Code Conventions for the Java Programming Language
http://www.oracle.com/technetwork/java/codeconv-138413.html

ThreadLocal - http://java.dzone.com/articles/java-thread-local-%E2%80%93-how-use

String Concatenation
- use plus operator(+) only if all operands are constants
```
    1) String temp = “alpha” + “beta”;
         '-> String temp = “alphabeta”; (compile time translation)
    2) String temp = x + “beta”;
         '-> String temp = (new StringBuilder()).append(x).append(“beta”).toString();
```
- concat using plus operator uses StringBuilder and String behind the scenes:
```
    “alpha” + “beta” = new StringBuilder(String.toString(“alpha”)).append(“beta”).toString()
```
- use String.concat if concatenating only 2 or few strings
- use StringBuilder(unsynchronized)/StringBuffer(synchronized) for more than 2 strings, specially in a loop
- in a loop, SB is better than concat is better than +
- always initialize SB with initial capacity to greatly improve performance
```
new SB() has 16 char initial capacity by default
```
- best explanation is here: http://www.znetdevelopment.com/blogs/2009/04/06/java-string-concatenation/

character set conversion

String stringToConvert = bmText;
byte[] convertStringToByte = stringToConvert.getBytes("UTF-8");
bmText = new String(convertStringToByte, "ISO-8859-1");
options.add(new SelectOption(bmValue, new String(bmText)));

creating pdf

  public void doHeader() throws Exception {
      Image logoImage = PDFUO.getLogoImage();
      //logoImage.setAbsolutePosition(ReportConstantsIF.ITEXT_POINTS/2, length - ReportConstantsIF.ITEXT_POINTS);
      logoImage.setAlignment(Image.ALIGN_TOP | Image.TEXTWRAP);
    
      Paragraph p = new Paragraph();
      p.add(logoImage);
      p.add(new Phrase("BEAR, STEARNS SECURITIES CORP." + "\n\n", new Font(Font.TIMES_ROMAN, 6, Font.BOLD)));
p.add(new Phrase(
        "ONE METROTECH CENTER NORTH" + "\n" +
  "BROOKLYN, NEW YORK 11201-3859" + "\n" +
  "(212) 272-1000", smallFont));
      p.setLeading(9f);
    
      HeaderFooter header = new HeaderFooter(p, false);
      header.setAlignment(Element.ALIGN_RIGHT);
      header.setBorder(PdfTable.NO_BORDER);

      document.setHeader(header);
  }

Deep copy of Java objects

The class Object's clone method only performs a shallow copy. This means that it creates a new instance of the object but the fields of both the new and original object end up referencing the same objects because only the reference of the fields is copied to the new object. To make deep copies of an object, we can use this class:


import java.io.IOException;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;

/**
 * Utility for making deep copies (vs. clone()'s shallow copies) of
 * objects. Objects are first serialized and then deserialized. Error
 * checking is fairly minimal in this implementation. If an object is
 * encountered that cannot be serialized (or that references an object
 * that cannot be serialized) an error is printed to System.err and
 * null is returned. Depending on your specific application, it might
 * make more sense to have copy(...) re-throw the exception.
 *
 * A later version of this class includes some minor optimizations.
 */
public class ObjectCloner {

    // so that nobody can accidentally create an ObjectCloner object
    private ObjectCloner() {
    }

    /**
     * Returns a copy of the object, or null if the object cannot
     * be serialized.
     */
    public static Object deepCopy(Object orig) {
        Object obj = null;
        try {
            // Write the object out to a byte array
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream out = new ObjectOutputStream(bos);
            out.writeObject(orig);
            out.flush();
            out.close();

            // Make an input stream from the byte array and read
            // a copy of the object back in.
            ObjectInputStream in = new ObjectInputStream(
                new ByteArrayInputStream(bos.toByteArray()));
            obj = in.readObject();
        }
        catch(IOException e) {
            e.printStackTrace();
        }
        catch(ClassNotFoundException cnfe) {
            cnfe.printStackTrace();
        }
        return obj;
    }
}

Sample call: Object clone = ObjectCloner.deepCopy(oldObject);
A more optimized version can be found here: http://javatechniques.com/blog/faster-deep-copies-of-java-objects/

Techie Notes