October 2018 – Clear ur Doubt

Oct 29

Spark program to load a table data from Cassandra to Hive using Java

Hey there! Welcome to ClearUrDoubt.com. In this post, we will look at a Spark program to load a table data from Cassandra to Hive using Java. Step 1: Create a table in Cassandra and insert records into it.

cqlsh:clearurdoubt> CREATE TABLE students(
                ... id int PRIMARY KEY,
                ... name text,
                ... marks int);

cqlsh:clearurdoubt> INSERT INTO students (id, name, marks) VALUES (101, 'Sidhu', 92);
cqlsh:clearurdoubt> INSERT INTO students (id, name, marks) VALUES (102, 'Sanju', 90);
cqlsh:clearurdoubt> INSERT INTO students (id, name, marks) VALUES (103, 'Ram', 45) ;
cqlsh:clearurdoubt> INSERT INTO students (id, name, marks) VALUES (105, 'Krishna', 88) ;
cqlsh:clearurdoubt> INSERT INTO students (id, name, marks) VALUES (104, 'Mounika', 90) ;
cqlsh:clearurdoubt>
cqlsh:clearurdoubt> select * from students;

 id  | marks | name
-----+-------+---------
 105 |    88 | Krishna
 104 |    90 | Mounika
 102 |    90 |   Sanju
 101 |    92 |   Sidhu
 103 |    45 |     Ram

(5 rows)
cqlsh:clearurdoubt>

cqlsh:clearurdoubt> CREATE TABLE students(

... id int PRIMARY KEY,

... name text,

... marks int);

cqlsh:clearurdoubt> INSERT INTO students (id, name, marks) VALUES (101, 'Sidhu', 92);

cqlsh:clearurdoubt> INSERT INTO students (id, name, marks) VALUES (102, 'Sanju', 90);

cqlsh:clearurdoubt> INSERT INTO students (id, name, marks) VALUES (103, 'Ram', 45) ;

cqlsh:clearurdoubt> INSERT INTO students (id, name, marks) VALUES (105, 'Krishna', 88) ;

cqlsh:clearurdoubt> INSERT INTO students (id, name, marks) VALUES (104, 'Mounika', 90) ;

cqlsh:clearurdoubt>

cqlsh:clearurdoubt> select * from students;

id | marks | name

-----+-------+---------

105 | 88 | Krishna

104 | 90 | Mounika

102 | 90 | Sanju

101 | 92 | Sidhu

103 | 45 | Ram

(5 rows)

cqlsh:clearurdoubt>

Step 2: Read more

Oct 28

Core Java program to sort the elements of an array.

Hey there! Welcome to ClearUrDoubt.com. In this post, we will look at a Core Java program to sort the elements of an array. We will use the Insertion Sort technique to sort the array elements. Insertion Sort is good for small datasets. Read more

Oct 26

Core Java program to reverse an array of elements

Hey there! Welcome to ClearUrDoubt.com. In this post, we will look at a Core Java program to reverse an array of elements. Let’s take an integer array and try to reverse it.

package com.clearurdoubt;

import java.util.Arrays;

public class ReverseArray {

	public static void main(String[] args) 
	{		
		int[] ints = new int[] {1,2,3,4,5,6,7,8,9,10};
		
		System.out.println("Before reversing the Array: ");
		System.out.println(Arrays.toString(ints));
			
		ints = reverse(ints);
		
		System.out.println();
		System.out.println("After reversing the Array: ");
		System.out.println(Arrays.toString(ints));
	}
	
	
	/**
	 * Method to reverse the elements of an array
	 * @param input is an array of integers
	 * @return the reversed array.
	 */
	public static int[] reverse(int[] input)
	{
		int forwardIndex = 0, backwardIndex = input.length - 1; 
		
		while(forwardIndex < backwardIndex)
		{
			int temp = input[forwardIndex];
			input[forwardIndex++] = input[backwardIndex];    // increment the forwardIndex
			input[backwardIndex--] = temp;                   // decrement the backwardIndex
		}
		
		return input;
	}

}

package com.clearurdoubt;

import java.util.Arrays;

public class ReverseArray {

public static void main(String[] args)

{

int[] ints = new int[] {1,2,3,4,5,6,7,8,9,10};

System.out.println("Before reversing the Array: ");

System.out.println(Arrays.toString(ints));

ints = reverse(ints);

System.out.println();

System.out.println("After reversing the Array: ");

System.out.println(Arrays.toString(ints));

}

/**

* Method to reverse the elements of an array

* @param input is an array of integers

* @return the reversed array.

public static int[] reverse(int[] input)

{

int forwardIndex = 0, backwardIndex = input.length - 1;

while(forwardIndex < backwardIndex)

{

int temp = input[forwardIndex];

input[forwardIndex++] = input[backwardIndex]; // increment the forwardIndex

input[backwardIndex--] = temp; // decrement the backwardIndex

}

return input;

}

Output: Happy Learning :). Please leave a reply Read more

Oct 26

Core Java program to remove duplicates from an array of Strings

Hey there! Welcome to ClearUrDoubt.com. In this post, we will look at a Core Java program to remove duplicates from an array of Strings. Here is the program:

package com.clearurdoubt;

import java.util.Arrays;

public class RemoveDups {

	public static void main(String[] args) {
		
		String[] dups = new String[] {"ONE", "TWO", "THREE", "TWO", "ONE",}; 

		String[] nodups = new String[dups.length];
		
		System.out.println("Before removing duplicates: ");
		System.out.println(Arrays.toString(dups));
		
		// Loop through the elements of dups array
		for(int i=0, j=0; i < dups.length; i++)
		{
			boolean isDuplicate = false; 
			
			// Check if the current element in dups exists in nodups array.
			for(int k=0; k < nodups.length; k++)
			{
				if(nodups[k] == null)				
					break;
				
				
				if(nodups[k].equals(dups[i]))
				{
					isDuplicate = true;
					break;
				}
				
			}
			
			// If the current element is not a duplicate, add to nodups array
			if(!isDuplicate)
			{
				nodups[j++] = dups[i];
			}
		}
		
		// Let's find the true size of the nodups array 
		int size = 0;

		// Remove nulls so that nodups array contains only the non-null elements		
		for(int i = 0; i < nodups.length; i++)
		{
			if( nodups[i] == null)
			{
				size = i;
				break;
			}
		}
		
		// Create a new array with the "size" elements and copy the values so that nulls will be truncated 
		nodups = Arrays.copyOf(nodups, size); 
		
		System.out.println();
		System.out.println("After removing duplicates: ");
		System.out.println(Arrays.toString(nodups));
	}

}

package com.clearurdoubt;

import java.util.Arrays;

public class RemoveDups {

public static void main(String[] args) {

String[] dups = new String[] {"ONE", "TWO", "THREE", "TWO", "ONE",};

String[] nodups = new String[dups.length];

System.out.println("Before removing duplicates: ");

System.out.println(Arrays.toString(dups));

// Loop through the elements of dups array

for(int i=0, j=0; i < dups.length; i++)

{

boolean isDuplicate = false;

// Check if the current element in dups exists in nodups array.

for(int k=0; k < nodups.length; k++)

{

if(nodups[k] == null)

break;

if(nodups[k].equals(dups[i]))

{

isDuplicate = true;

break;

}

// If the current element is not a duplicate, add to nodups array

if(!isDuplicate)

{

nodups[j++] = dups[i];

}

// Let's find the true size of the nodups array

int size = 0;

// Remove nulls so that nodups array contains only the non-null elements

for(int i = 0; i < nodups.length; i++)

{

if( nodups[i] == null)

{

size = i;

break;

}

// Create a new array with the "size" elements and copy the values so that nulls will be truncated

nodups = Arrays.copyOf(nodups, size);

System.out.println();

System.out.println("After removing duplicates: ");

System.out.println(Arrays.toString(nodups));

}

Output: Happy Learning :). Please leave a reply in case of any Read more

Oct 24

Java Program to Handle Exceptions while reading User Input from Console

Hey there! Welcome to ClearUrDoubt.com. In this post, we will look at a Java Program to handle exceptions while reading user input from the console. Exceptions are unexpected events that occur during the execution of a program. An exception might Read more

Oct 16

Custom Implementation of ArrayList class in Java

Hey there! Welcome to ClearUrDoubt.com. In this post, we will look at the Custom implementation of the ArrayList class in Java. Custom ArrayList Implementation:

package com.clearurdoubt;

import java.util.Arrays;

public class MyArrayList {
	
	private Object[] arrayObjs;
	private int idx;
	
	
	// Constructors
	public MyArrayList()
	{
		this(10);
	}
	
	public MyArrayList(int initialcapacity)
	{	
		arrayObjs = new Object[initialcapacity];
	}
	
	/**
	 * 
	 * @return size of the List
	 */
	public int size()
	{
		return idx;
	}
	
	/**
	 * 
	 * @param index 
	 * @return status of the operation
	 */
	public boolean add(Object obj)
	{
		return add(idx, obj);
	}
	
	/**
	 * 
	 * @param index of the new object
	 * @param obj to be added to the List
	 * @return status of the operation
	 */
	public boolean add(int index, Object obj)
	{
		// check for the index out of bounds condition
		if(index < 0 || index > idx)
		{
			throw new ArrayIndexOutOfBoundsException();
		}
		
		// increase the size of the list if idx reaches the maximum limit
		if(idx > arrayObjs.length - 1)
		{
			increaseSize();
		}
		
		if(index < idx)
		{
			// Prior to inserting the new element, move all the elements to next positions
			for(int temp = idx+1; temp > index; temp--)
			{
				arrayObjs[temp] = arrayObjs[temp-1];
			}
			
			// insert the element
			arrayObjs[index] = obj;
			
			// as the new element is added, increment the idx value.
			idx++;
		}
		else
		{
			// insert the element at the idx position
			arrayObjs[idx++] = obj;
		}	
		
		return true;
	}

	/**
	 * 
	 * @param obj 
	 * @return status of the operation
	 */
	public boolean remove(Object obj)
	{	
		// Find the index of the obj in the array and call remove(index) method
		for(int i = 0; i < idx; i++)
		{
			if(arrayObjs[i].equals(obj))
			{
				return remove(i);
			}
		}
		
		return true;
	}
	

	/**
	 * 
	 * @param index 
	 * @return status of the operation
	 */
	public boolean remove(int index)
	{
		if(index < 0 || index > idx)
		{
			throw new ArrayIndexOutOfBoundsException();
		}
		
		for(int i = index; i < idx - 1; i++)
		{
			arrayObjs[i] = arrayObjs[i+1];
		}
		
		// as the new element is deleted, decrement the idx value.
		arrayObjs[idx-1] = null;
		idx--;
		
		return true;
	}
	
	private void increaseSize() 
	{
		int newcapacity = (arrayObjs.length * 3/2) + 1;
		
		arrayObjs = Arrays.copyOf(arrayObjs, newcapacity);		
	}

	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		
		for(int i = 0; i < idx; i++)
		{
			sb.append(arrayObjs[i].toString() + ",");
		}
		
		return "[" + sb.toString().substring(0, sb.length() - 1) + "]";
	}
	

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

package com.clearurdoubt;

import java.util.Arrays;

public class MyArrayList {

private Object[] arrayObjs;

private int idx;

// Constructors

public MyArrayList()

{

this(10);

}

public MyArrayList(int initialcapacity)

{

arrayObjs = new Object[initialcapacity];

}

/**

* @return size of the List

public int size()

{

return idx;

}

/**

* @param index

* @return status of the operation

public boolean add(Object obj)

{

return add(idx, obj);

}

/**

* @param index of the new object

* @param obj to be added to the List

* @return status of the operation

public boolean add(int index, Object obj)

{

// check for the index out of bounds condition

if(index < 0 || index > idx)

{

throw new ArrayIndexOutOfBoundsException();

}

// increase the size of the list if idx reaches the maximum limit

if(idx > arrayObjs.length - 1)

{

increaseSize();

}

if(index < idx)

{

// Prior to inserting the new element, move all the elements to next positions

for(int temp = idx+1; temp > index; temp--)

{

arrayObjs[temp] = arrayObjs[temp-1];

}

// insert the element

arrayObjs[index] = obj;

// as the new element is added, increment the idx value.

idx++;

}

else

{

// insert the element at the idx position

arrayObjs[idx++] = obj;

}

return true;

}

/**

* @param obj

* @return status of the operation

public boolean remove(Object obj)

{

// Find the index of the obj in the array and call remove(index) method

for(int i = 0; i < idx; i++)

{

if(arrayObjs[i].equals(obj))

{

return remove(i);

}

return true;

}

/**

* @param index

* @return status of the operation

public boolean remove(int index)

{

if(index < 0 || index > idx)

{

throw new ArrayIndexOutOfBoundsException();

}

for(int i = index; i < idx - 1; i++)

{

arrayObjs[i] = arrayObjs[i+1];

}

// as the new element is deleted, decrement the idx value.

arrayObjs[idx-1] = null;

idx--;

return true;

}

private void increaseSize()

{

int newcapacity = (arrayObjs.length * 3/2) + 1;

arrayObjs = Arrays.copyOf(arrayObjs, newcapacity);

}

@Override

public String toString() {

StringBuilder sb = new StringBuilder();

for(int i = 0; i < idx; i++)

{

sb.append(arrayObjs[i].toString() + ",");

}

return "[" + sb.toString().substring(0, sb.length() - 1) + "]";

}

Let’s see the demo of MyArrayList class:

package com.clearurdoubt;

public class MyArrayListDemo {

	public static void main(String[] args) {
		
		MyArrayList myAL = new MyArrayList();
		
		// add elements to the List
		myAL.add("A");
		myAL.add("B");
		myAL.add("C");		
		System.out.println(myAL + " @@@ " + myAL.size()); // print elements and size
		
		myAL.add(1, "D");
		myAL.add(2, "E");		
		System.out.println(myAL + " @@@ " + myAL.size()); // print elements and size
		
		myAL.add(5, "F");		
		System.out.println(myAL + " @@@ " + myAL.size()); // print elements and size
		
		for(int i = 0; i < 10; i++)
		{
			myAL.add(i);
		}
		System.out.println(myAL + " @@@ " + myAL.size()); // print elements and size
		
		// Lets check the remove operations
		// remove the object 
		myAL.remove("F");
		System.out.println("After removing \"F\": ");
		System.out.println(myAL + " @@@ " + myAL.size()); // print elements and size
		
		// remove the object at index
		myAL.remove(5);
		System.out.println("After removing element at index 5: ");
		System.out.println(myAL + " @@@ " + myAL.size()); // print elements and size
		
		// remove element which is not in the ArrayList
		myAL.remove("F");
		System.out.println("After removing \"F\": ");
		System.out.println(myAL + " @@@ " + myAL.size()); // print elements and size
		
		
		// remove last element in the ArrayList
		myAL.remove(new Integer(9));
		System.out.println("After removing \"9\": ");
		System.out.println(myAL + " @@@ " + myAL.size()); // print elements and size
		
		try 
		{
			myAL.add(40, "Z"); //this will throw an exception
		} 
		catch(ArrayIndexOutOfBoundsException ex)
		{
			System.out.println("ArrayIndexOutOfBoundsException raised.");
		}
		
	}

}

package com.clearurdoubt;

public class MyArrayListDemo {

public static void main(String[] args) {

MyArrayList myAL = new MyArrayList();

// add elements to the List

myAL.add("A");

myAL.add("B");

myAL.add("C");