Thursday, 28 April 2016

Ways to copy array in Java ? Which one is better ?

 There are  mainly  three ways : 

1) Using Loop

2) System.arrayCopy();

3) Arrays.copyOf() &&  Arrays.copyOfRange() 

    Lets go in brief with array copy.

1. Using Loop
  • We all know array start with index 0,so using loop you can initialize variable and put condition with array size like     array_name.length (Be remember its property not method).
  • Now iterate loop and copy one by one element into another array.
  •  Following is example for array Copy using for loop. 

class Array_Loop{
public int[] copyArrayByLoop (int[] myArray){
int length = myArray.length;
int[] copy = new int [length];
for(int i=0;i<length;i++){
copy [i] = myArray[i];
return copy;

2. System.arrayCopy()

  • It depends on the virtual machine, but it looks as if it copies blocks of memory instead of copying single array elements. 
  • This would absolutely increase performance. It's always preferred over loops when performance is an issue.
  • System.arraycopy() uses JNI (Java Native Interface) to copy an array (or parts of it), so it is amazingly fast.

public static native void arraycopy(Object src,  int  srcPos,Object dest, int destPos,int length);

  • If dest is null, then a NullPointerException is thrown.
  • If src is null, then a NullPointerException is thrown and the destination array is not modified.
  • Otherwise, if any of the following is true, an ArrayStoreException is thrown and the destination is not modified:

  • The src argument refers to an object that is not an array.
  • The dest argument refers to an object that is not an array.
  • The src argument and dest argument refer to arrays whose component types are different primitive types.
  • The src argument refers to an array with a primitive component type and the dest argument refers to an array with a reference component type.
  • The src argument refers to an array with a reference component type and the dest argument refers to an array with a primitive component type.
  • Otherwise, if any of the following is true, an IndexOutOfBoundsException is thrown and the destination is not modified:
  • The srcPos argument is negative.
  • The destPos argument is negative.
  • The length argument is negative.
  • srcPos+length is greater than src.length, the length of the source array.
  • destPos+length is greater than dest.length, the length of the destination array.

 3. Arrays.copyOf() &&  Arrays.copyOfRange()

int []return  = Arrays.copyOf(int[] array,int newLength)

  • Copies the specified array, truncating or padding with false (if necessary) so the copy has the specified length. 
  • For all indices that are valid in both the original array and the copy, the two arrays will contain identical values. 
  • For any indices that are valid in the copy but not the original, the copy will contain false. 
  • Such indices will exist if and only if the specified length is greater than that of the original array.
  • Arrays.copyOf(T[], int) is easier to read. Internaly it uses System.arraycopy() which is a native call.
  • NegativeArraySizeException - if newLength is negative
  • NullPointerException - if array is null

byte []return  = Arrays.copyOfRange(byte[] array,int from,int to)

  • Copies the specified range of the specified array into a new array. 
  • The initial index of the range (from) must lie between zero and original.length, inclusive. 
  • The value at array[from] is placed into the initial element of the copy (unless from == original.length or from == to). 
  • Values from subsequent elements in the original array are placed into subsequent elements in the copy. The final index of the range (to), which must be greater than or equal to from, may be greater than original.length, in which case null is placed in all elements of the copy whose index is greater than or equal to original.length - from. 
  • The length of the returned array will be to - from.
  • ArrayIndexOutOfBoundsException - if from < 0 or from > original.lengt
  • IllegalArgumentException - if from > to
  • NullPointerException - if original is null

Thursday, 14 April 2016

What is the output for following String Literals

  • Literal strings within the same class  in the same package  represent references to the same String object.

  • Literal strings within different classes in the same package represent references to the same String object.

  •  Literal strings within different classes in different packages likewise represent references to the same String object.

  • Strings computed by constant expressions are computed at compile time and then treated as if they were literals.

  • Strings computed by concatenation at run time are newly created and therefore distinct.

  •  The result of explicitly interning a computed string is the same string as any pre-existing literal string with the same contents.

package testPackage;
class Test {
    public static void main(String[] args) {
       String hello = "Hello", lo = "lo";
       System.out.print((hello == "Hello") + " ");
       System.out.print((Other.hello == hello) + " ");
       System.out.print((other.Other.hello == hello) + " ");
       System.out.print((hello == ("Hel"+"lo")) + " ");
       System.out.print((hello == ("Hel"+lo)) + " ");
       System.out.println(hello == ("Hel"+lo).intern());
class Other { static String hello = "Hello"; }

and the compilation unit: 

package other; 
public class Other { public static String hello = "Hello"; } 
produces the output:

true   true    true    true   false   true

Command Line Arguments In Java

A Java application can accept any number of arguments from the command line. This allows the user to specify configuration information when the application is launched.

The user enters command-line arguments when invoking the application and specifies them after the name of the class to be run.

class Test { 
 public static void main(String[] args) {
      for (int i = 0; i < args.length; i++)
          System.out.println( args[i]);

On a machine with the Oracle JDK installed, this class, stored in the file,
can be compiled and executed by giving the commands:


java Test Drink Hot Java

producing the output:


To have Drink, Hot, and Java interpreted as a single argument, the user would join them by enclosing them within quotation marks.

java Test "Drink Hot Java"

Drink Hot Java

Parsing Numeric Command-Line Arguments

 It must convert a String argument to respective types.Here is a code snippet that converts a command-line argument to respective types:

Class ParseCommandLine{
   public static void main(String args[]){
     String str = args[0]
     int i  = Integer.parseInt(args[1]);
     float f  = Integer.parseFloat(args[2]);
     double d  = Integer.parseDouble(args[3]);
     boolean b  = Integer.parseBoolean(args[4]);


How To Compile & Run : 

javac ParseCommandLine 

java ParseCommandLine MyJava 15   2.4   5.67  true

Output :

5.67 true

Tuesday, 11 August 2015

How To Store UTF-8 Character in MySql

What is UTF-8 ?

  • UTF-8 & UTF 16 are Unicode Character Sets.
  • UTF-8 is the preferred encoding for e-mail and web pages. 
  • UTF-8 is variable-length and uses 8-bit code units.
  • UTF-8 is backwards compatible with ASCII.

How to handle with mysql?

First of all check character set and collation of  your database,to execute following query :

SHOW VARIABLES LIKE "character_set_database";

Variable_name                 Value
character_set_database      latin1

SHOW VARIABLES LIKE "collation_database";

Variable_name                     Value          
collation_database            latin1_swedish_ci

OR you can also execute this query : SHOW VARIABLES LIKE  'char%';

As a result you get result like this:

  • So here default character set is UTF 8 so no big bloom..if not then whenever you create table set CHARSET=utf8 and Collation = utf8_general_ci

Let us create one table :

CREATE TABLE product (
  id bigint(20) NOT NULL AUTO_INCREMENT,
  name varchar(50) NOT NULL,

If you have already created table then execute following alter query

ALTER TABLE product 

Now you can insert or update utf-8 character easily..enjoy..lots..!!!!

Tuesday, 4 August 2015

Java Collection Set : Difference between Hashset and Treeset

Java Collection

  • A collection is a group of data manipulate as a single object. 
  • Collections are primarily defined through a set of interfaces.
  • Interfaces are used of flexibility reasons
    • Programs that uses an interface is not tightened to a specific implementation of a collection.
    • It is easy to change or replace the underlying collection class with another (more efficient) class that implements the same interface.
  • HashSet and TreeSet implement the interface Set.
  • HashSet is much faster than TreeSet (constant-time versus log-time for most operations like add, remove and contains) but offers no ordering guarantees like TreeSet.
  • HashSet
    • Class offers constant time performance for the basic operations (add, remove, contains and size).
    • It does not guarantee that the order of elements will remain constant over time.
    • Iteration performance depends on the initial capacity and the load factor of the HashSet.
    • It's quite safe to accept default load factor but you may want to specify an initial capacity that's about twice the size to which you expect the set to grow.
  • TreeSet
    • Guarantees log(n) time cost for the basic operations (add, remove and contains) .
    • Guarantees that elements of set will be sorted (ascending, natural, or the one specified by you via its constructor) (implements SortedSet).
    • Doesn't offer any tuning parameters for iteration performance
    • Offers a few handy methods to deal with the ordered set like first(), last(), headSet(), and tailSet() etc.
  • Important points:
    •  Both guarantee duplicate-free collection of elements.
    •  It is generally faster to add elements to the HashSet and then convert the collection to a TreeSet for a duplicate-free sorted traversal.
    •  None of these implementation are synchronized. That is if multiple threads access a set concurrently, and at least one of the threads modifies the set, it must be synchronized externally.
    • LinkedHashSet is in some sense intermediate between HashSet and TreeSet. Implemented as a hash table with a linked list running through it, however it provides insertion-ordered iteration which is not same as sorted traversal guaranteed by TreeSet.
  • So choice of usage depends entirely on your needs but I feel that even if you need an ordered collection then you should still prefer HashSet to create the Set and then convert it into TreeSet.
  • e.g. SortedSet<String> s = new TreeSet<String>(hashSet);

Monday, 3 August 2015

Big Oh notation

  • For run time complexity analysis we use big Oh notation extensively so it is vital that you are familiar with the general concepts to determine which is the best algorithm for you in certain scenarios. 
  • We have chosen to use big Oh notation for a few reasons, the most important of which is that it provides an abstract measurement by which we can judge the performance of algorithms without using mathematical proofs.
The following list explains some of the most common big Oh notations : 

  • O(1) constant: the operation doesn't depend on the size of its input, e.g. adding a node to the tail of a linked list where we always maintain a pointer to the tail node.

  •  O(n) linear: the run time complexity is proportionate to the size of n

  •  O(log nlogarithmic: normally associated with algorithms that break the problem into smaller chunks per each invocation, e.g. searching a binary search tree.

  • O(n log njust n log n : usually associated with an algorithm that breaks the problem into smaller chunks per each invocation, and then takes the results of these smaller chunks and stitches them back together, e.g. quick sort.
  • (n^2quadratic: e.g. bubble sort.
  • O(n^3) cubic: very rare.
  • O(2n) exponential: incredibly rare.

  • If you encounter either of the latter two items (cubic and exponential) this is really a signal for you to review the design of your algorithm. 
  • While prototyping algorithm designs you may just have the intention of solving the problem irrespective of how fast it works. We would strongly advise that you always review your algorithm design and optimize where possible|particularly loops recursive calls|so that you can get the most efficient run times for your algorithms.
  • Taking a quantitative approach for many software development properties will make you a far superior programmer - measuring one's work is critical to success.

Thursday, 16 July 2015

In Java to encode Base64 in Java

  • Base64 is a straight forward encoding for binary data into readable characters.
  • The Java class is the javax.xml.bind.DatatypeConverter, which is part of the XML package (JAXB) and has a method called printBase64Binary() that takes in a byte array and returns a encoded BASE64 string.
  • The following is a code snippet that encoding the user name and password for BASIC Authentication for Web applications.
  • It combines a user name and corresponding password with “:” as delimiter, and converts it to an byte array that can be feed into the printBase64Binary(). Once the encoded string is ready, just set it as value to the Authorization header. 

The following code is how to do the encoding and set it as a HTTP header in request to server:
import javax.xml.bind.DatatypeConverter;

String encoding = 
DatatypeConverter.printBase64Binary((username + ":" + password).getBytes("UTF-8"));
urlConn.setRequestProperty("Authorization", "Basic " + encoding);

Depending the client library, your API to set the header could be different. For example, if you use Apache Thrift’s HTTP transport, the code may look like the following:

import org.apache.thrift.transport.THttpClient;
transport.setCustomHeader("Authorization", "Basic " + encoding);