Browsing posts in: Java

## Programming Basics Prep

Programming Basics Prep

Most of the concepts on this page is taken from : Data Structures and Algorithms in Java by Robert Lafore

This is a basic programming concept anyone must know. I will keep this page updated with new code when I have time.

### Linear Search vs Binary Search

Linear Search searches for each item in a list. For ordered,  average number of steps needed to find an item is N/2. For unordered, average number of steps needed to find an item is N.

Binary Search is like a Guess-a-number game where it checks for value in the middle and see if the number is less or more or equal to that middle number  thereby shortening the number of guesses. This can an be applied only to a sorted list.

Guess a number between 1-100 (number 33 guessed)

 Step Number Number Guessed Result Range of Possible Values 0 1-100 1 50 Too High 1-49 2 25 Too Low 26-49 3 37 Too High 26-36 4 31 Too Low 32-36 5 34 Too High 32-33 6 32 Too Low 33-33 7 33 Correct

Binary search provides a significant speed increase over a linear search. If we used linear search it would have took us 33 guesses but in binary search it only took us 7. For small number of items it is not significant but for large items binary is way more faster than linear.

### Logarithms

Comparisions needed in Binary Search

10 -> 4, 100 -> 7, 1000 -> 10, 10,000 -> 14 and so on…

 Steps s Range r Range expressed as power of 2 0 1 2^0 1 2 2^1 2 4 2^2 3 8 2^3 4 16 2^4 5 32 2^5 6 64 2^6 7 128 2^7

As we can see 7 steps cover the range of 100 (128 in total).

Doubling the range each time creates a series that’s the same as raising two to a power. We can express this power as a formula. If s represents the steps and r represents the range, the equation is

r = 2^s

(eg. 128 = 2^7)

The inverse of raising something to the power is logarithm. This equation says that the number of steps (comparisions) is equal to the logarithm to the base 2 of the range.

s = log2(r)

It is usually log to the base 10 but we can convert easily to base 2 by multiplying by 3.322

[ex. log10(100) = 2,  log1(100) = 2*3.322,  which is equal to 6.644 (approx. 7)]

### Big O Notation

Big O Notation is used to measure how efficient a computer algorithm is.

T is time, K is constant

Insertion in unordered array : T = K (Insertion requires a same amount of time no matter how big is the arrray)

Linear Search: T = K * N/2 (The number of comparisions that must be made to find a specified item is, on average, half of the total number of items) We can combine constant with 2 and the new formula is T = K*N where K is the new constant.

Big O Notation dispenses with the constant K. All we want to compare is how T change for different values of N, not what the actual numbers are.

We read O(1) as the order of 1.

Therefore we can say, Linear Search takes O(N) time and Binary Search takes O(log N) time. Insertion into unordered array takes O(1) or constant time which is ideal!

 Algorithm Running Time in Big O Linear Search O(N) Binary Search O(log N) Insertion in unordered array O(1) Insertion in ordered array O(N) Deletion in unordered array O(N) Deletion in ordered array O(N)

Time Complexity

O(1) is excellent, O(log N) is good, O(N) is fair, O(N^2) is poor. Bubble sort is O(N^2).

## Simple Sorting

### Bubble Sort

It is simplest of the sorting algorithms and very slow. You start at the left end of the list and compare the two values in index 0 and 1. If value in 0 is greater than a value in 1 then we swap the positions. If value in 0 is smaller than value in 1 we don’t do anything. We then move over one position and compare values in index 1 and index 2. We do this until all the values are sorted. As the algorithm progresses, the biggest items “bubble up” to the top end of the array. After this first pass through all the data, we’ve made N-1 comparisions and somewhere between 0 and N-1 swaps.

Now, we go back again and start another pass from left end of the array towards the right. However, we stop at N-2 because we know N-1 already contains largest number. On each external iteration/pass we decrease the size of N.

```for(int i =array.length-1; i>1; i--){
for(int j =0; j<= array.length; j++){
//swap if needed
if(array[j] > array[j+1]{
int temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}```

Efficiency of Bubble Sort

In general, where N is the number of items in the array, there are N-1 comparisons on the first pass, N-2 on the second and so on…

(N-1)+(N-2)+(N-3)+…+1 = N*(N-1)/2

Thus, the algorithm makes about N^2/2 comparisions as we get rid of -1 as it makes no difference. We know if data is random, a swap is necessay about half the time on average so there will be N^2/2 * 1/2 = N^2/4 swaps. We can ignore the constant 2 (or 4) thus it gives us the Big O Notation of O(N^2) which is very poor.

### Selection Sort

This sort reduces the number of swaps necessary from O(N^2) as in bubble sort to O(N). Unfortunately, the number of comparisions remains the same O(N^2).

In this type of sorting, we look for the lowest number in the list and swap it with the index 0 of the one on the left. We then start again from index 1 and look for the lowest number and swap it with the value in index 1. We continue forward until we reach the index N-1. In this algorithm the sorted numbers accumulate on the left side.

```int minVal;
for(int i = 0; i<array.length-1; i++){
minVal = i;
for(int j = i+1; j<array.length; j++){
if(array[j]<array[minVal]){
minVal = j;
int temp = array[i];
array[i] = array[minVal];
array[minVal] = temp;
}
}
}```

Efficiency of Selection Sort

Selection sort performs the same number of comparisions as the bubble sort N*(N-1)/2. But, it is faster because there are so few swaps. For smaller values of N, hte selection sort may in fact be much faster than bubble sort. For large values of N, the comparision times will dominate, so we would have to say that the selection sort runs in O(N^2) time just as bubble sort.

### Insertion Sort

In insertion sort, we divide the unsorted list into two and sort the list on the left (partial sorting).  Then we take the value from the start index of the second list, compare it with first list and put the number in appropriate position while shifting remaining numbers from first list to the right. We continue the process until we go through all the numbers in the second list.

```int i, j;
for(i = 1; i<array.length; i++){ //i is dividing line
int temp = array[i]; //remove marked item
j = i; //start shifts at i
while(j>0 && array[j-1] >= temp){ //until j is smaller,
array[j] = array[j-1]; //shift item to right
--j; //go left one position
}
array[j] = temp; //insert marked item
}```

Efficiency of Insertion Sort

On the first pass, it compares the maximum of 1 item. On second pass 2 and so on up to N-1

1 + 2 + 3 + … + N-1 = N*(N-1)/2

On each pass only 1/2 of the maximum number of items are actually compared before the insertion point is found, we can divide by 2. So, N*(N-1)/4

The insertion sort runs in O(N^2) time for random data and when data is almost sorted it runs at O(N).

## Stacks and Queues

Stacks and Queues are more restricted and abstract as we can only access one data at a time – either on top or on the bottom. We can use Arrays to understand the concept but we can also use Linked Lists and Heap.

### Stacks

A stack allows access to onle one data item: the last item inserted. Think of it as a stack of books on the table. You put a book on top of the stack and, you take a book from the top of the stack. Basically it is Last-In-First-Out(LIFO)Example: Stack  can be used to check whether paranthesesm, braces and brackets are balanced in a computer program. In binary trees, it can be used to traverse the nodes of a tree. In Graphs, it can be used to search the vertices of a graph. Most microprocessors use a stack based architecture. When a method is called, its return address and arguments are pushed onto a stack, and when it returns, they are popped off.

```public class StackX{
//size of stack array
private int maxSize;

//Array
private int[] stackArray;

//top of stack
private int top;

//put an item on a stack
public void push(int j)
{
stackArray[++top] = j;
}

//take item from top of stack
public int pop(){
return stackArray[top--];
}

//peek at the top of the stack
public int peek()
{
return stackArray[top];
}

//check if stack is empty
public boolean isEmpty()
{
return(top == -1);
}

//check if stack is full
public boolean isFull()
{
return(top==maxSize-1);
}
} // end of StackX class

public class StackApp
{
StackX theStack = new StackX(10); // new stack creation

theStack.push(10);

while(!theStack.isEmpty())    //loop through stack to pop and display
{
int value = theStack.pop();
System.out.println(value);
}
}

```

Efficiency of Stack : Constant O(1) time and is not dependent on number of items.

### Queues

It is a data structure that is somewhat like a stack, except that in a queue the first item inserted is the first item to be removed (First-In-First-Out, FIFO). Example: A queue works as a line in an apple store: first person to stand gets the first iPhone, a printer’s queue when you hit that print command and, typing things on a screen, etc.

Circular queue: when you insert an item in a queue, it sits at the back of the line. And, when you remove an item, the spot is empty at the front. You can push all the values to the front to make up that space but it is somewhat inefficient. So, we just circle through the array or spots.

```class Queue{
private int maxSize;
private int[] queArray;
private int front;
private int rear;
private int nItems;

public Queue(int s){
maxSize = s;
queArray = new Int[maxSize];
front = 0;
rear = -1;
nItems = 0;
}

public void insert(int j){
if(rear == (maxSize-1)){
rear = -1;
}
queArray[++rear] = j;
nItems++;
}

public int remove(){
int temp = queArray[front++];
if(front==maxSize){
front=0;
}
nItems--;
return temp;
}

public int peekFront(){
return queArray[front]
}

public boolen isEmpty(){
return (nItems==0);
}

public boolean isFull(){
return (nItems==maxSize);
}

public int size(){
return nItems;
}
}

class QueueApp{
Queue theQueue = new Queue(5);

theQueue.insert(10);
theQueue.insert(30);

theQueue.remove();

theQueue.insert(20);

while(!theQueue.isEmpty()){
int n = theQueue.remove();
System.out.println(n);
}
}
```

Efficiency of Queues: O(1) time as we insert and remove data

### Priority Queues

This is a more specialized form of a queue. Like an ordinary queue, priority queue has a front and a rear, and items are removed from the front. However, in a priority queue, items are ordered by key value so that the item with the lowest key is always at the front. Example: Sorting of letters in order of priorities, minimum spanning trees, weighted graphs.

Efficiency of Priority Queues: Insertion runs in O(N) time as it has to sort the values first. Deletion takes O(1). We can improve insertion time using heaps.

## Arrays

Arrays are the most commonly used data structure. But, it is not always ideal. In an unordered array insert takes O(1) time but searching is slow O(N). In ordered array search is quick O(log N) but insertion takes O(N). For both, deletion takes O(N). Linked Lists is another viable option.

• Important things to understand: Insertion, Searching, Deletion
• Average number of steps needed to find and item is N/2 (worst case N)
• A deletion requires searching through an average of N/2 elements and then moving the remaining elements(N/2) to fill up the resulting hole. Total steps is N.

#### Creating an array:

```//initialization
int[] count = new int[3]; //Integer Array of 3 empty slots.

int[] count2 = new int[]{1, 2, 3};
int[] count3 = {1,2,3};

//initialization
String[] arrayString = new String[8]; //String Array of 8 empty slots.

String[] arrayString2 = new String[]{"a","b"};
String[] arrayString3 = {"a","b"};```

#### Accessing Array:

```int second = count[2];

String third = arrayString[3];```

#### Inserting Values in Array:

```count[2] = 4;

arrayString[3] = "c";```

### Some common examples:

#### Reverse a String

```System.out.println(reverseString("Elephant"));

public String reverseString(String key){
String reversedString = "";
for(int i = key.length();i>=0;i--){
reversedString+=key.charAt(i);
}
return reversedString;
}

//Recursion
String reversedString = reverseRec("elephant", "", "elephant".length());

public String reverseRec(String key, String reversed, int i){
if(i<0){
return reversed;
}
reversed = reversed+key.charAt(i);
return reverseRec(key, reversed, i-1);
}

//Output: tnahpelE```

#### Sorting numbers in an Array

```//Bubble Sort
int[] sortArray = {2,3,1,7,5,9,10,4,7,9};

for (int i = 0; i < sortArray.length; i++) {
for (int j = i + 1; j < sortArray.length; j++) {
int tmp = 0;
if (sortArray[i] > sortArray[j]) {
tmp = sortArray[i];
sortArray[i] = sortArray[j];
sortArray[j] = tmp;
}
}
System.out.println(sortArray[i]);
}```

#### Sum of Numbers in an Array

```int[] sortArray = {2,3,1,7,5,9,10,4,7,9};
int sum = 0;
for(int k:sortArray){
sum+=k;
}```

#### Fibonacci Series with and without Recursion

```//Fibonacci Series
printFibonacci(10, true);//recusrive
printFibonacci(10, false);//non-recursive

static int n1=0,n2=1,n3=0;

static void printFibonacci(int count, boolean recursion){
//using recursion
if(recursion){
if(count>0){
n3=n1+n2;
n1=n2;
n2=n3;
System.out.print(" "+n3);
printFibonacci(count--, true);
}
}else{
//without recursion
System.out.println(n1+" "+n2);
for (int i=2;i<=count;i++){
n3=n1+n2;
n1=n2;
n2=n3;
System.out.print(" "+n3);
}
}
}```

#### Check prime number

```	public boolean findPrime(int value){
boolean isPrime = false;
if(value<2){
isPrime=false;
}else{
isPrime=true;
}
for(int i=2; i<=value/i; i++){
if((value%i)==0){
isPrime = false;
break;
}
}
return isPrime;
}```

#### Binary Search

```int[] arrayValues = {1,5,8,10,24,35,44,65,76};
int arraySize = arrayValues.length;
boolean checkBinarySearch = binarySearch(10);
public boolean binarySearch(int key){
int low = 0;
int high = arraySize-1;
while(high>=low){
int middle = (low+high)/2;
if(arrayValues[middle]==key){
return true;
}
if(arrayValues[middle]< key){
low=middle+1;
}
if(arrayValues[middle]>key){
high=middle-1;
}
}
return false;
}```

#### Linear Search

```int[] arrayValues = {1,5,8,10,24,35,44,65,76};
int arraySize = arrayValues.length;
public void linearSearch(int key){
for(int i=0; i<arraySize; i++){
if(arrayValues[i]==key){
System.out.println("Found");
}else if(i==arraySize){
}
}
}```

#### Factorial

```public static int factorial(int key){
int result = 1;
for(int i=1; i<= key; i++){
result = result* i;
}
return result;
}

public int factorialrec (int key){
int result;
if(key==1){
return 1;
}
result = key*factorialrec(key-1);
return result;
}```

#### Palindrome

```	public boolean checkPalindrome(String key){
int i = 0;
int j = key.length()-1;
while(j>i){
if(key.charAt(i)!=key.charAt(j)){
return false;
}
++i;
--j;
}
return true;
}```

#### Shuffle a deck of cards

```	private static final int DECK_SIZE = 52;

//Using Collections Library
public void randomizeCards(){
ArrayList<Integer> deck = new ArrayList<Integer>();
for (int i = 0; i < DECK_SIZE; ++i) {
}
Collections.shuffle(deck);
System.out.println(deck);
}

//Using Arrary List
public void randomizeCardsB(){
ArrayList<Integer> deck = new ArrayList<Integer>();

for (int i = 0; i < DECK_SIZE; ++i) {
}

ArrayList<Integer> shuffledDeck = new ArrayList<Integer>();

while (deck.size() > 0) {
int index = (int) (Math.random() * deck.size());
}
System.out.println(shuffledDeck.toString());
}```

#### Check for Anagrams

```	//check for anagrams
public boolean checkAnagrams(String first, String second){
int lengthf = first.length();
int lengths = second.length();
int j = 0;
if(lengthf==lengths){
char[] charArray1 = first.toCharArray();
char[] charArray2 = second.toCharArray();
Arrays.sort(charArray1);
Arrays.sort(charArray2);
for(int i=0; i<lengthf; i++){
if(charArray1[i]==charArray2[i]){
j++;
}else{
return false;
}
if(lengthf==j){
return true;
}
}

}
return false;
}```

#### Find first non repeating char in a string

```static final int NO_OF_CHARS = 256;
static char count[] = new char[NO_OF_CHARS];
static void getCharCountArray(String str)
{
for (int i = 0; i < str.length();  i++)
count[str.charAt(i)]++;
}
static int firstNonRepeating(String str)
{
getCharCountArray(str);
int index = -1, i;

for (i = 0; i < str.length();  i++)
{
if (count[str.charAt(i)] == 1)
{
index = i;
break;
}
}

return index;
}```

Arrays have certain disadvantages as data storage structures. In an unordered array, searching is slow, whereas in an ordered array, insertion is slow. In both, deletion is slow. Also, the size of an array can’t be changed after it’s created.

Linked Lists can replace an array as the basis for other storage structures such as stacks and queues. In fact, you can use a linked list in many cases in which you use an array, unless you need frequent random access to individual items using an index.

In a linked list, each data item is embedded in a link. A link is an object of a class Link (or something similar). Each link object contains a reference to next link in the list. A field in the list itself contains a reference to the first link. This kind of class definition is sometimes called self-referential because it contains a field (called next) of the same type as itself.

```Class Link{
public int iData;  //similar to index in array
public int dData;  //actual value

//you can also hold an object instead of variable
public objetItem obj;

}```

In Java, a Link object doesn’t really contain another Link object. The next field of type Link is only a reference to another link, not an object.

How Linked List differs from Array

In an array each item occupies a particular position. This position can be directly accessed using an index number.Like a row of houses – once you know the address you know the position. In a List, the only way to find a particular element is to follow along the chain of elements.

• Inserting an item at the beginning of the list
• Deleting the item at the beginning of the list
• Iterating through the list to display contents
```class Link
{
public int iData;
public String dData;

iData = id;
dData = dd;
}

System.out.println(iData+" has "+dData);
}
}

first=null;
}
public boolean isEmpty(){
return (first==null);
}
public void insertFirst(int id, String dd){
}
first = first.next;
return temp;
}
public void displayList(){
while(current!=null){
current = current.next;
}
}
}

public static void main (String[] args){
theList.insertFirst(100, "Hello");
theList.insertFirst(101, "World");

theList.displayList();

while(!theList.isEmpty()){        //until the list is empty
}
}
}```

```public Link find(int key){
while(current.iData != key){
if(current.next == null){
return null;
}else{
current = current.next;
}
}
return current;
}

while(current.iData != key){
if(current.next == null){
return null;
}else{
previous = current;
current = current.next;
}
}
if(current == first){
first = first.next;
}else{
previous.next = current.next;
}
return current;
}```

#### Double-Ended Lists

A double-ended list is similar to an ordinary linked list, but it has one additional feature: a reference to the last link as well as to the first. The reference to the last link permits you to insert a new link directly at the end of the list as well as at the beginning. You can also do this with Linked List but you will have to traverse through the whole list and then insert it which is inefficient.

Linked List Efficiency: Insertion and deletion at the very beginning of a linked list are very fast – O(1). Finding, deleting, or inserting next to a specific item requires searching through an average of half the items in the list. This requires O(N) comparisions. An array is also O(N) for these operations but linked list is nevertheless faster because nothing needs to be moved when an item is inserted or deleted. Linked List uses exactly as much memory as it needs and can expand to fill all of available memory. The size of an array is fixed (except vector, but is still inefficient).

## Getting started with Twilio Phone Services

Today I am going to talk about how to create a simple phone application using the popular Twilio API. If you don’t know what Twilio is all about then I recommend you go through their “What is Cloud Communications” section.

Twilio

When I was working for Infofree I was given a task to come up with a basic SMS and Voice Authentication system using any available services out there. My two options back then was either Corvisa (now Shoretel) or Twilio. I tried to work with Corvisa and their API but, it lacked a lot of features that Twilio has. So ultimately, I decided to build the feature using Twilio. Sadly, because of economic reasons for my company my code was never live. But, in my free time I went further and used Twilio’s service to test different features.

In this tutorial I will show you how to setup basic twilio service using JAVA.

These are some of the things you will need in order for yor app to work.

1. Twilio Account SID `TWILIO_ACCOUNT_SID`
2. Twilio Authentication Token `TWILIO_AUTH_TOKEN`
3. Twilio Number `TWILIO_NUMBER`
4. Twilio Application SID (Optional)
5. Twilio Agent Number (Optional)

## Get API Key

Go to twilio and click on the “Get a Free API Key button”.

Get a Free API Key – Twilio

Go through the general registration process (should be easy). You need to verify using your phone number.

After you are done, go to Home-> Settings-> General

You should see your  `TWILIO_ACCOUNT_SID` and `TWILIO_AUTH_TOKEN`

## Get Phone Number

If you plan to use your number then you do not need to get `TWILIO_NUMBER` else click here and get a phone number. For trial purposes you can only use verified phone numbers.

Get a new phone number

You should see this number in your Manage Numbers section.

## Things you’ll need for JAVA

If you use maven, you need to add this dependency in your pom.xml file:

```<dependency>
<groupId>com.twilio.sdk</groupId>
<artifactId>twilio</artifactId>
<version>(7.0,7.9)</version>
</dependency>```

If you don’t use maven, use this jar file instead: twilio-7.x.x-with-dependencies.jar

Here I will be using a properties file (db.properties) to store all my API credentials

```#mysql DB properties
DB_DRIVER_CLASS=com.mysql.jdbc.Driver
DB_URL=jdbc:mysql://localhost:3306/test

TWILIO_ACCOUNT_SID=ACed9da74780242eded3a2fb674a*****
TWILIO_AUTH_TOKEN=fac36407eb1bf66f207d2763671*****
TWILIO_NUMBER=+14023789330
TWILIO_APPLICATION_SID=```

Once you have everything setup, we can use Twilio’s API library to do various tasks.

I also created a Phone Verification system where you could verify phone using either a SMS or a Voice Call. But because it was part of my company project, I cannot share the code with you. But here is the screenshot of how it looks like.

Phone Verification using Twilio

Following are some of the examples:

## Send SMS

SendSMS

```package com.twilioAPI;

import com.twilio.sdk.resource.instance.Account;
import com.twilioAPI.exceptions.UndefinedEnvironmentVariableException;
import com.twilioAPI.lib.AppSetup;
import com.twilio.sdk.TwilioRestClient;
import com.twilio.sdk.TwilioRestException;
import com.twilio.sdk.resource.factory.MessageFactory;
import com.twilio.sdk.resource.instance.Message;
import java.util.ArrayList;
import java.util.List;
import org.apache.http.NameValuePair;
import org.apache.http.message.BasicNameValuePair;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
* Servlet implementation class sendSMS
*/
@WebServlet("/sendSMS")
public class SendSMS extends HttpServlet {
private static final long serialVersionUID = 1L;
private AppSetup appsetup;
/**
* @see HttpServlet#HttpServlet()
*/
public SendSMS() {
super();
// TODO Auto-generated constructor stub
}

/**
* @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
*/
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
response.getWriter().append("Served at: ").append(request.getContextPath());
}

/**
* @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
doGet(request, response);
this.appsetup = new AppSetup();
try {
String accountSid = this.appsetup.getAccountSid();
String authToken = this.appsetup.getAuthToken();
String fromNumber = this.appsetup.getTwilioNumber();
TwilioRestClient client = new TwilioRestClient(accountSid, authToken);
String pNumber = request.getParameter("phoneSMS");
String pMessage = request.getParameter("testSMS");
Account account = client.getAccount();
MessageFactory messageFactory = account.getMessageFactory();
List<NameValuePair> params = new ArrayList<NameValuePair>();
params.add(new BasicNameValuePair("To", pNumber)); // Replace with a valid phone number for your account.
params.add(new BasicNameValuePair("From", fromNumber)); // Replace with a valid phone number for your account.
Message sms = messageFactory.create(params);
System.out.println("Sending SMS...: To:" + pNumber + "From:"+ fromNumber+ "and Message:" +pMessage);
} catch (UndefinedEnvironmentVariableException | TwilioRestException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

}```

## Click-to-Call

Click-to-Call

```package com.twilioAPI;

import com.twilioAPI.exceptions.UndefinedEnvironmentVariableException;
import com.twilioAPI.lib.AppSetup;
import com.twilio.sdk.TwilioRestClient;
import com.twilio.sdk.TwilioRestException;
import org.json.simple.JSONObject;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap;
import java.util.Map;
/**
* Servlet implementation class Call
*/
@WebServlet("/Call")
public class Call extends HttpServlet {
private static final long serialVersionUID = 1L;
AppSetup appSetup;
TwilioRestClient client;

public Call() {}

public Call(AppSetup appSetup, TwilioRestClient client) {
this.appSetup = appSetup;
this.client = client;
}
/**
* @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
*/
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
response.getWriter().append("Served at: ").append(request.getContextPath());
}

/**
* @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String phoneNumber = request.getParameter("phone");
if(phoneNumber==null||phoneNumber==""){
phoneNumber = request.getParameter("phoneNumber");
}
boolean record = request.getParameter( "record" ) != null;
String CallRecord = "false";
if (record == true){
CallRecord = "true";
}
request.getServletContext().setAttribute("record", CallRecord);

if (phoneNumber != null) {
if (this.appSetup == null || this.client == null) {
appSetup = new AppSetup();
client = null;
try {
client = new TwilioRestClient(appSetup.getAccountSid(), appSetup.getAuthToken());
} catch (UndefinedEnvironmentVariableException e) {
response.getOutputStream().write(getJSONResponse(e.getMessage()).getBytes());
return;
}
}

Map<String, String> params = new HashMap<>();
String twilioNumber;
try {
twilioNumber = appSetup.getTwilioNumber();
} catch (UndefinedEnvironmentVariableException e) {
response.getOutputStream().write(getJSONResponse(e.getMessage()).getBytes());
return;
}

// Full path to the end point that will respond with the call TwiML
//String path = request.getRequestURL().toString().replace(request.getRequestURI(), "") + "/CorvisaAPI/connect?record="+CallRecord;
String path = request.getRequestURL().toString().replace(request.getRequestURI(), "") + "/CorvisaAPI/connect";
params.put("From", twilioNumber);
params.put("To", phoneNumber);
params.put("Url", path);
try {
client.getAccount().getCallFactory().create(params);
} catch (TwilioRestException e) {
String message = "Twilio rest client error: " + e.getErrorMessage() +
"\nRemember not to use localhost to access this app, use your ngrok URL";
response.getOutputStream().write(getJSONResponse(message).getBytes());
return;
}
response.getOutputStream().write(getJSONResponse("Phone call incoming!").getBytes());
} else {
response.getOutputStream()
.write(getJSONResponse("The phone number field can't be empty").getBytes());
}
}
private String getJSONResponse(String message) {
JSONObject obj = new JSONObject();
obj.put("message", message);
obj.put("status", "ok");

return obj.toJSONString();
}

}```

## Web Phone

WebPhone

```package com.twilioAPI;

import com.twilioAPI.exceptions.UndefinedEnvironmentVariableException;
import com.twilioAPI.lib.AppSetup;
import com.twilio.sdk.TwilioRestClient;
import com.twilio.sdk.TwilioRestException;
import org.json.simple.JSONObject;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap;
import java.util.Map;
/**
* Servlet implementation class Call
*/
@WebServlet("/Call")
public class Call extends HttpServlet {
private static final long serialVersionUID = 1L;
AppSetup appSetup;
TwilioRestClient client;

public Call() {}

public Call(AppSetup appSetup, TwilioRestClient client) {
this.appSetup = appSetup;
this.client = client;
}
/**
* @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
*/
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
response.getWriter().append("Served at: ").append(request.getContextPath());
}

/**
* @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String phoneNumber = request.getParameter("phone");
if(phoneNumber==null||phoneNumber==""){
phoneNumber = request.getParameter("phoneNumber");
}
boolean record = request.getParameter( "record" ) != null;
String CallRecord = "false";
if (record == true){
CallRecord = "true";
}
request.getServletContext().setAttribute("record", CallRecord);

if (phoneNumber != null) {
if (this.appSetup == null || this.client == null) {
appSetup = new AppSetup();
client = null;
try {
client = new TwilioRestClient(appSetup.getAccountSid(), appSetup.getAuthToken());
} catch (UndefinedEnvironmentVariableException e) {
response.getOutputStream().write(getJSONResponse(e.getMessage()).getBytes());
return;
}
}

Map<String, String> params = new HashMap<>();
String twilioNumber;
try {
twilioNumber = appSetup.getTwilioNumber();
} catch (UndefinedEnvironmentVariableException e) {
response.getOutputStream().write(getJSONResponse(e.getMessage()).getBytes());
return;
}

// Full path to the end point that will respond with the call TwiML
//String path = request.getRequestURL().toString().replace(request.getRequestURI(), "") + "/CorvisaAPI/connect?record="+CallRecord;
String path = request.getRequestURL().toString().replace(request.getRequestURI(), "") + "/CorvisaAPI/connect";
params.put("From", twilioNumber);
params.put("To", phoneNumber);
params.put("Url", path);
try {
client.getAccount().getCallFactory().create(params);
} catch (TwilioRestException e) {
String message = "Twilio rest client error: " + e.getErrorMessage() +
"\nRemember not to use localhost to access this app, use your ngrok URL";
response.getOutputStream().write(getJSONResponse(message).getBytes());
return;
}
response.getOutputStream().write(getJSONResponse("Phone call incoming!").getBytes());
} else {
response.getOutputStream()
.write(getJSONResponse("The phone number field can't be empty").getBytes());
}
}
private String getJSONResponse(String message) {
JSONObject obj = new JSONObject();
obj.put("message", message);
obj.put("status", "ok");

return obj.toJSONString();
}

}```

Other uses are Phone Verification system, Conference Call, etc.

## Array Splitting using PHP’s and Java’s in-built Array Funtion

Today, I am going to talk about something simple and useful in programming. For people who are professional programmers this might seem relatively easy but for someone who is trying to learn PHP or Java having a knowlege of how arrays work might be really useful. Especially when you have a large set of data and you need to display it in multiple columns.

So let’s talk about how to use PHP’s and Java’s inbuilt array funtion to slice a large array into smaller parts. For this tutorial, I am assuming you have some knowledge of how PHP and Java works. If not, there are hundreds of websites and books available to get basic understanding.

Scenario: I was given a task to list all the 52 US states in a page so that only the ones that are flagged as active in a table inside database is shown on the page. I had to show this in 3 columns.

 # State Name Active Flag 1 Alabama 1 2 Alaska 1 3 Arizona 0 4 Arkansas 1 5 … 1

Result: The result should look something like this.

 Alabama Alaska Arkansas California … Kentucky Louisiana Maine Maryland … North Dakota Ohio Oklahoma Oregon …

Now, the question might seem relatively easy. And we don’t necessarily need PHP or JAVA to solve this. We could also use something on client side like JavaScript. But, I’ll show how it’s done on the server side.

#### Query Database for Results:

We can get the list of active states from the database as follows:

`SELECT * FROM states where active_flag = 1 order by state_id asc;`

For PHP you get the data as follows:

```<?php
\$servername = "localhost";
\$dbname = "myDB";

// Create connection
// Check connection
if (\$conn->connect_error) {
die("Connection failed: " . \$conn->connect_error);
}

\$sql = "SELECT * FROM states WHERE active_flag = 1 ORDER BY state_id ASC;";
\$result = \$conn->query(\$sql);
\$states = array();
if (\$result->num_rows > 0) {
// output data of each row
while(\$row = \$result->fetch_assoc()) {
\$states[] = \$row;
}
} else {
}

\$conn->close();
?>```

The above code connects to the database and quries the result and puts it inside the \$states[] array.

In Java, you can do the same utilizing Java’s inbuilt database connection library:

```Connection conn = null;
CallableStatement stmt = null;
ResultSet result = null;
ArrayList<String> states = new ArrayList<String>();

try {
conn = getConnection();
stmt = conn.prepareCall("SELECT * FROM states WHERE active_flag = 1 ORDER BY state_id ASC;");

result = stmt.executeQuery();

while (result.next()) {

String state_name = result.getString("state_name");
}

} catch (SQLException e) {
LOG.log(Level.SEVERE, e.getMessage(), e);

} finally {
result.close();
stmt.close();
conn.close();
}```

The above code puts the result inside states array. Here, getConnection() actually connects to the database. You can google and read about how to connect to database in Java to understand it much better. But, the idea is simple. We utilize Java’s SQL library to automatically connect to the database. You just define all the required connection settings in a properties file (below is just an example).

```protected static Connection getConnection() throws SQLException {
return DriverManager.getConnection("**** Database Name ****");
}```

Now that we have our results in an array. Let’s see how we can split the array into three sub arrays.

#### Array Count or Length

Before we do the actual splitting, we need to know the count of the total states in the array so that we can split the array evenly across the three arrays.

To do this, in PHP we use the inbuilt function count(\$array).

`\$states_count=count(\$states);`

In Java we simply we utilize array.length property of an array.

`int states_count = states.length;`

#### Divisible by 3

Now that we know the array length, we need to know how to evenly distribute the states into three sets of list. The logic here is to make the length (or count) of the list divisible by 3 so that we can evenly distribute the states among three sets.

The concept of modulus is very helpful here. The modulo operation (or simply modulus) finds the remainder after division of one number by another. To check if a number is divisible by 3 or not we do the following:

• First, we check to see if the number is even or odd.
• If even, we add +1 and do the modulo operand on the length. This is done as number % divisor. If this outputs a number, besides 0, then we know the number is not divisible by divisor. Here we know length or count is even as \$states_count % 2 gives us 0. If so, we loop and keep on adding 1 (\$states_count++;) until we get a number that is divisible by 3 (loop until \$states_count % 3 is not 0).
• If odd, we test and see if this odd number is divisible by 3 (\$states_count % 3 == 0). If the number is not divisible by 3 we keep adding 1 until we get a number that is divisible by 3.

In PHP

```if(\$states_count % 2 == 0){
do {
\$states_count++;
}while(\$states_count % 3 != 0);
}else{
if(\$states_count % 3 == 0){
//do nothing
}else{
do {
\$states_count++;
}while(\$states_count % 3 != 0);
}
}```

In Java

```if(states_count % 2 == 0){
do {
states_count++;
}while(states_count % 3 != 0);
}else{
if(states_count % 3 == 0){
//do nothing
}else{
do {
states_count++;
}while(states_count % 3 != 0);
}
}```

#### Split Array in 3

Now that we have an array length that is divisible by 3, we can do the following to split the array.

In PHP we will use array_slice() method to slice into three parts. The syntax for array_slice() is

array_slice(array, starting index, length);

```\$states_first = array_slice(\$states, 0, \$states_count/3);
\$states_second = array_slice(\$states, \$states_count/3, \$states_count/3);
\$states_third = array_slice(\$states, (\$states_count/3)*2, \$states_count/3);```

In Java we will use Arrays.copyOfRange method to make a copy of or split an array. The syntax for copyOfRange() is

int[] newArray = Arrays.copyOfRange(array, starting index, ending index);

```ArrayList<String> states_first = new ArrayList<String>();
ArrayList<String> states_second = new ArrayList<String>();
ArrayList<String> states_third = new ArrayList<String>();

states_first = Arrays.copyOfRange(states, 0, states_count/3);
states_second = Arrays.copyOfRange(states, states_count/3, (states_count/3)*2);
states_third = Arrays.copyOfRange(states, (states_count/3)*2, states_count);```

And there you go! That’s how you split an array. You can split into any number using the same concept. Let me know what you think or if you have an even better way.