Grabbing Files from Remote Server

I have written a helpful method to grab files from remote server and save them into a local folder. This example works as follow:
[1] The input file will be read line by line
[2] The resource names will be appended to the URL of the remote server
[3] Resources that are found in the remote server will be written to the local folder
[4] Otherwise, show error messages if the resources are not found<br />import java.io.BufferedInputStream;<br />import java.io.BufferedOutputStream;<br />import java.io.BufferedReader;<br />import java.io.File;<br />import java.io.FileNotFoundException;<br />import java.io.FileOutputStream;<br />import java.io.FileReader;<br />import java.io.IOException;<br />import java.net.MalformedURLException;<br />import java.net.URL;<br /><br />public class FileDownloader {<br /> private final static String templatePath = FileDownloader.class.getResource("").getPath().replaceAll("%20", " ");<br /><br /> private static final String folderStr = templatePath + "/pics";<br /> <br /> private static void readText() {<br /> File folder = new File(folderStr);<br /> if (!folder.exists()) {<br /> folder.mkdir();<br /> }<br /> BufferedReader br;<br /> FileReader fr;<br /> String line;<br /> try {<br /> fr = new FileReader(YOUR_FILE_NAME);<br /> br = new BufferedReader(fr);<br /> while ((line = br.readLine()) != null) {<br /> grabFile(line, folderStr);<br /> }<br /> } catch (FileNotFoundException e) {<br /> System.err.println("File not found!");<br /> e.printStackTrace();<br /> }catch (IOException e) {<br /> System.err.println("Error reading file");<br /> e.printStackTrace();<br /> }<br /> }<br /><br /> private static void grabFile(String input, String folder){<br /> byte[] bytes = new byte[4096];<br /> BufferedInputStream in;<br /> BufferedOutputStream out;<br /> URL URLsource = null;<br /> try {<br /> URLsource = new URL(REMOTE_SERVER_URL + input.trim());<br /> in = new BufferedInputStream (URLsource.openStream());<br /> out = new BufferedOutputStream(new FileOutputStream( new File( folder + "/" + input.trim() )));<br /> int pos = in.read( bytes );<br /> while ( pos != -1 ){<br /> out.write( bytes, 0, pos );<br /> pos = in.read( bytes );<br /> }<br /> out.close();<br /> System.out.println("Downloaded: " + input);<br /> } catch (MalformedURLException e) {<br /> e.printStackTrace();<br /> } catch (IOException e) {<br /> System.err.println("Fail to download: " + input);<br /> e.printStackTrace();<br /> } catch (InterruptedException e) {<br /> e.printStackTrace();<br /> }<br /> }<br /><br /> public static void main(String[] args) {<br /> readText();<br /> }<br />}Happy coding everyone :)

Replacing whitespace characters in a string

Here is an example of method overloading - same method name with different number of parameters. The complexity of this algorithm is O(n) because the input string is scanned character by character.

But what if there is a input with a massive size? I would want to partition out the string into several portion depending on the size threshold which can be set in the method and the hash the partitioned texts into a hashmap. Threading is possible in this context because the texts will be processed synchronously instead of sequentially.

public static StringBuffer removeSpace(String input){
  return removeSpace(input, "%20");
}

public static StringBuffer removeSpace(String input, String fillerString){
  StringBuffer sb = new StringBuffer();
  int strLength = input.length();
  int index = 0;
  while(index != (strLength)){
    if (input.charAt(index) != ' ') {
      sb.append(input.charAt(index));
    } else {
      sb.append(fillerString);
    }
    index++;
  }
  return sb;
}

You may test this code with this sample method calls:

System.out.println(removeSpace("Hello World, I am Nicholas Key"));
System.out.println(removeSpace("Hello World, I am Nicholas Key", "[SPACE]"));

Usefulness of BigInteger

It's way much better than Integer, the primitive type; simply because we won't be restricted with arithmetic overflow issue. An example is in this method to compute factorial.

public static BigInteger factorial(int n){
  BigInteger result = BigInteger.ONE;
  for (int count = 1; count <= n; count++) {
    result = result.multiply(BigInteger.valueOf(count));
  }
  return result;
}

The precision is still well maintained even if you iterate through the first 38 numbers. Give it a try if you are not convinced :)
UPDATE: there is a fundamental flaw in this loop. In the previous code, I demonstrated for (int count = 1; count < n; count++). It has changed to for (int count = 1; count <= n; count++)

Numbers with commas

Here's a simple method to include commas after every third digit from the right:

public class Utilities{
  private static int startingPivot;
  private static final int INDENT = 3;

  public static StringBuffer decimalize(int input){
    String conv = Integer.toString(input);
    StringBuffer sb = new StringBuffer();

    int commaIndex = conv.length() / INDENT ; 
    int strLength = conv.length();

    startingPivot = (strLength) - (commaIndex * INDENT );
    if (startingPivot == 0) {
      startingPivot = INDENT ;
    }

    for (int index = 0; index < strLength; index++) {
      if (index == startingPivot) {
        sb.append(",");
        startingPivot = startingPivot + INDENT;
      }
      sb.append(conv.charAt(index));
    }
    return sb;
  }
}

You may try this code by making this method call

System.out.println(Utilities.decimalize(1234567890));

and the output is 1,234,567,890
NEAT :D

String tokenizer by hand

I was thinking of implementing my custom "StringTokenizer" and here it is. The complexity is O(n) which means it depends on the size of the string.

public static ArrayList tokenizer(String input){
  ArrayList tokenizedStr = new ArrayList();
  StringBuffer str = new StringBuffer();
  int strLength = input.length();
  int index = 0;
  while (index < strLength) {
    char curr = input.charAt(index);
    if (curr != ' '){
      str.append(curr);
    } else {
      tokenizedStr.add(str);
      str = new StringBuffer();
    } 
    if ((index == strLength-1 ) && (curr != ' ')) {
      tokenizedStr.add(str);
    }
    index++;
  }
  return tokenizedStr;
}

The most interesting part of this method if the condition to check if we have reached the last character of the string and to make sure if it is also not a whitespace character.

UPDATE:
On a second thought, the algorithm in this method is not perfect because it will still retain inline whitespace characters. This is a much better way to tokenize the strings

  while (index < strLength) {
    char curr = input.charAt(index);
    if (curr != ' '){
      str.append(curr);
    } else {
      if (str.length() != 0) {
        tokenizedStr.add(str);
      }
      str = new StringBuffer();
    } 
    if ((index == strLength-1 ) && (curr != ' ')) {
      tokenizedStr.add(str);
    }
    index++;
  }

An example of solving this in recursion is at "Tokenizing String Recursively".

Screencast of my iPhone App

Fibonacci Sequence

Here's an interesting usage of "memoization". According to Wikipedia, "In computing, memoization is an optimization technique used primarily to speed up computer programs by having function calls avoid repeating the calculation of results for previously-processed inputs.".

There is actually a drawback if we are using plain and simple recursion to compute the Fibonacci sequence using long datatype (because we are only limited to hold the first 48 Fibonacci numbers). Memoization helps to speed up the computation time by saving already computed values into memory (and we can use BigInteger datatype). An example implementation is as below:

import java.math.BigInteger;
import java.util.ArrayList;

public class Fibonacci {

  /** Variables for memoization **/
  private static ArrayList fibMemoized = new ArrayList();
  static {
    fibMemoized.add(BigInteger.ZERO);
    fibMemoized.add(BigInteger.ONE);
  }

  /** Memoized method to retrieve stored computed values **/
  public static BigInteger fibonacci(int n) {
    if (n >= fibMemoized.size()) {
      fibMemoized.add(n, fibonacci(n-1).add(fibonacci(n-2)));
    }
    return fibMemoized.get(n);
  }

  /** Old school recursion **/
  public static long fib(int n) {
    if (n <= 1) return n;
    else return fib(n-1) + fib(n-2);
  }

  /** Driver **/
  public static void main(String[] args) {
    int N = 45;
    System.out.println(fibonacci(N));
    System.out.println(fib(N));
  }

}

You may try copying the codes and run it locally to observe the difference in performance. The typical recursive method runs slower because it computes the Fibonnaci numbers from scratch many times. Unlike the memoized method, the ArrayList is used to store the previously computed values. While memoized method is more superior in terms of speed, we are actually sacrificing space in order to achieve greater speed.