Hey there! Welcome to ClearUrDoubt.com. In this post, we will look at a Java program to create a JSON file using JSON-simple API. JSON-simple API is used to create and read JSON files in a simple way. Maven dependency for Read more
Hey there! Welcome to ClearUrDoubt.com. In this post, we will look at the Custom implementation of the Doubly LinkedList class in Java. Before proceeding further, please go through the below post for a better understanding of Doubly LinkedList. Custom Implementation of Read more
Hey there! Welcome to ClearUrDoubt.com. In this post, we will look at the Custom implementation of the Singly LinkedList class in Java. Simple implementation of Singly LinkedList:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 |
package com.clearurdoubt.impl; /** * * @author Sai Gowtham Badvity * SinglyLinkedList Implementation * @param <T> type of the object LinkedList holds. * */ public class MySinglyLinkedList<T> { private class Node { T value; Node next; } private Node head = null, tail = null; /** * Add Node to the List * @param val */ public void add(T val) { addLast(val); } /** * Add Node in the beginning the List * @param val */ public void addFirst(T val) { Node newNode = new Node(); newNode.value = val; newNode.next = head; head = newNode; if(tail == null) tail = newNode; } /** * Add Node at the end of the List * @param val */ public void addLast(T val) { if(head == null) { addFirst(val); return; } Node newNode = new Node(); newNode.value = val; newNode.next = null; tail.next = newNode; tail = newNode; } /** * Remove first node */ public void removeFirst() { if(head == null) return; else { head = head.next; } } /** * Remove last node */ public void removeLast() { Node temp = head; while(temp.next != tail) { temp = temp.next; } temp.next = null; tail = temp; } /** * Print the elements */ @Override public String toString() { StringBuilder builder = new StringBuilder(); Node temp = head; do { builder.append( temp.value + " -> "); temp = temp.next; } while(temp.next != null); builder.append( temp.value ); return builder.toString(); } } |
Let’s see the demo of MySinglyLinkedList class:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
package com.clearurdoubt.impl; /** * * @author Sai Gowtham Badvity * Demo of the usage of MySinglyLinkedList * */ public class MySinglyLinkedListDemo { public static void main(String[] args) { MySinglyLinkedList<Integer> myList = new MySinglyLinkedList<Integer>(); myList.add(10); myList.add(20); myList.add(30); myList.addFirst(40); myList.addLast(50); System.out.println(); System.out.println("Elements in the list: " + myList); myList.removeFirst(); System.out.println(); System.out.println("After removing first node: " + myList); myList.removeLast(); System.out.println(); System.out.println("After removing last node: " + myList); myList.addFirst(40); System.out.println(); System.out.println("After adding a new node in the beginning: " + myList); } } |
Output: Happy Learning :). Read more
Hey there! Welcome to ClearUrDoubt.com. In this post, we will look at a Java program to demonstrate Inter-Thread Communication. I would suggest you go through the below link before proceeding with this post. Core Java program to create multiple threads Inter-Thread communication is Read more
Hey there! Welcome to ClearUrDoubt.com. In this post, we will look at a Core Java program to create multiple threads. We can create threads in two ways as below: By implementing the Runnable interface. By extending the Thread class The user can select Read more
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.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
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
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
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.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
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
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
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:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 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:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 |
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."); } } } |
Output: Happy Learning :). Please leave Read more