Program9573776838: How to reverse Singly

Linked List?

public class SinglyLinkedListImpl<T> {

private Node<T> head;

public void add(T element){

Node<T> nd = new Node<T>();

nd.setValue(element);

System.out.println("Adding: "+element);

Node<T> tmp = head;

while(true){

if(tmp == null){

//since there is only one element, both head and

//tail points to the same object.

head = nd;

break;

} else if(tmp.getNextRef() == null){

tmp.setNextRef(nd);

break;

} else {

tmp = tmp.getNextRef();

public void traverse(){

 Node<T> tmp = head;

while(true){

if(tmp == null){

break;

System.out.print(tmp.getValue()+"\t");

tmp = tmp.getNextRef();

public void reverse(){

System.out.println("\nreversing the linked list\n");

Node<T> prev = null;

Node<T> current = head;

Node<T> next = null;

while(current != null){

next = current.getNextRef();

current.setNextRef(prev);

prev = current;

current = next;

head = prev;

public static void main(String a[]){

 SinglyLinkedListImpl<Integer> sl = new SinglyLinkedListImpl<Integer>();

sl.add(3);

sl.add(32);

sl.add(54);

sl.add(89);

System.out.println();

sl.traverse();

System.out.println();

sl.reverse();

sl.traverse();

class Node<T> implements Comparable<T> {

private T value;

private Node<T> nextRef;

public T getValue() {

return value;

public void setValue(T value) {

this.value = value;

public Node<T> getNextRef() {

 return nextRef;

public void setNextRef(Node<T> ref) {

this.nextRef = ref;

@Override

public int compareTo(T arg) {

if(arg == this.value){

return 0;

} else {

return 1;

Program: Find out duplicate number

between 1 to N numbers.

package com.java2novice.algos;

import java.util.ArrayList;

import java.util.List;

public class DuplicateNumber {

public int findDuplicateNumber(List<Integer> numbers){

int highestNumber = numbers.size() - 1;

int total = getSum(numbers);

int duplicate = total - (highestNumber*(highestNumber+1)/2);

return duplicate;
 }

public int getSum(List<Integer> numbers){

int sum = 0;

for(int num:numbers){

sum += num;

return sum;

public static void main(String a[]){

List<Integer> numbers = new ArrayList<Integer>();

for(int i=1;i<30;i++){

numbers.add(i);

//add duplicate number into the list

numbers.add(22);

DuplicateNumber dn = new DuplicateNumber();

System.out.println("Duplicate Number: "+dn.findDuplicateNumber(numbers));

Program: Find out middle index where sum

of both ends are equal.

public class FindMiddleIndex {

public static int findMiddleIndex(int[] numbers) throws Exception {

int endIndex = numbers.length - 1;

int startIndex = 0;
int sumLeft = 0;
 int sumRight = 0;
while (true) {
if (sumLeft > sumRight) {
sumRight += numbers[endIndex--];
} else {
sumLeft += numbers[startIndex++];
}
if (startIndex > endIndex) {
if (sumLeft == sumRight) {
break;
} else {
throw new Exception(
"Please pass proper array to match the
requirement");
}
}
}
return endIndex;
}

public static void main(String a[]) {

int[] num = { 2, 4, 4, 5, 4, 1 };
try {
System.out.println("Starting from index 0, adding numbers till index "
+ findMiddleIndex(num) + " and");
System.out.println("adding rest of the numbers can be equal");
} catch (Exception ex) {
System.out.println(ex.getMessage());
}
}
}

Output:
Starting from index 0, adding numbers till index 2 and
adding rest of the numbers can be equal

Program: Write a singleton class.

public class MySingleton {

private static MySingleton myObj;

static{

myObj = new MySingleton();

private MySingleton(){
 }

public static MySingleton getInstance(){

return myObj;

public void testMe(){

System.out.println("Hey.... it is working!!!");

public static void main(String a[]){

MySingleton ms = getInstance();

ms.testMe();

Program: Write a program to create

deadlock between two threads.

package com.java2novice.algos;

public class MyDeadlock {

String str1 = "Java";

String str2 = "UNIX";

Thread trd1 = new Thread("My Thread 1"){

public void run(){

while(true){

synchronized(str1){
 synchronized(str2){

System.out.println(str1 + str2);

};

Thread trd2 = new Thread("My Thread 2"){

public void run(){

while(true){

synchronized(str2){

synchronized(str1){

System.out.println(str2 + str1);

};

public static void main(String a[]){

MyDeadlock mdl = new MyDeadlock();

mdl.trd1.start();

mdl.trd2.start();

}
Program: Write a program to reverse a
string using recursive algorithm.

package com.java2novice.algos;

\public class StringRecursiveReversal {

String reverse = "";

public String reverseString(String str){

if(str.length() == 1){

return str;

} else {

reverse += str.charAt(str.length()-1)

+reverseString(str.substring(0,str.length()-1));

return reverse;

public static void main(String a[]){

StringRecursiveReversal srr = new StringRecursiveReversal();

System.out.println("Result: "+srr.reverseString("Java2novice"));

Program: Write a program to reverse a

number.

package com.java2novice.algos;

public class NumberReverse {

public int reverseNumber(int number){

 int reverse = 0;

while(number != 0){

reverse = (reverse*10)+(number%10);

number = number/10;

return reverse;

public static void main(String a[]){

NumberReverse nr = new NumberReverse();

System.out.println("Result: "+nr.reverseNumber(17868));

Program: Write a program to convert

decimal number to binary format.

package com.java2novice.algos;

public class DecimalToBinary {

public void printBinaryFormat(int number){

int binary[] = new int[25];

int index = 0;

while(number > 0){

binary[index++] = number%2;

number = number/2;

}
 for(int i = index-1;i >= 0;i--){

System.out.print(binary[i]);

public static void main(String a[]){

DecimalToBinary dtb = new DecimalToBinary();

dtb.printBinaryFormat(25);

Program: Write a program to find perfect

number or not.

package com.java2novice.algos;

public class IsPerfectNumber {

public boolean isPerfectNumber(int number){

int temp = 0;

for(int i=1;i<=number/2;i++){

if(number%i == 0){

temp += i;

if(temp == number){

System.out.println("It is a perfect number");

return true;

} else {
 System.out.println("It is not a perfect number");

return false;

public static void main(String a[]){

IsPerfectNumber ipn = new IsPerfectNumber();

System.out.println("Is perfect number: "+ipn.isPerfectNumber(28));

28
It is a perfect number
Is perfect number: true

Program: Write a program to implement

ArrayList.

package com.java2novice.algos;

import java.util.Arrays;

public class MyArrayList {

private Object[] myStore;

private int actSize = 0;

public MyArrayList(){

myStore = new Object[10];

public Object get(int index){

if(index < actSize){

return myStore[index];

} else {

throw new ArrayIndexOutOfBoundsException();

public void add(Object obj){

if(myStore.length-actSize <= 5){

increaseListSize();

myStore[actSize++] = obj;

public Object remove(int index){

if(index < actSize){

Object obj = myStore[index];

myStore[index] = null;

int tmp = index;

while(tmp < actSize){

 myStore[tmp] = myStore[tmp+1];

myStore[tmp+1] = null;

tmp++;

actSize--;

return obj;

} else {

throw new ArrayIndexOutOfBoundsException();

public int size(){

return actSize;

private void increaseListSize(){

myStore = Arrays.copyOf(myStore, myStore.length*2);

System.out.println("\nNew length: "+myStore.length);

public static void main(String a[]){

MyArrayList mal = new MyArrayList();

mal.add(new Integer(2));

mal.add(new Integer(5));
 mal.add(new Integer(1));

mal.add(new Integer(23));

mal.add(new Integer(14));

for(int i=0;i<mal.size();i++){

System.out.print(mal.get(i)+" ");

mal.add(new Integer(29));

System.out.println("Element at Index 5:"+mal.get(5));

System.out.println("List size: "+mal.size());

System.out.println("Removing element at index 2: "+mal.remove(2));

for(int i=0;i<mal.size();i++){

System.out.print(mal.get(i)+" ");

Output:
2 5 1 23 14
New length: 20
Element at Index 5:29
List size: 6
Removing element at index 2: 1
2 5 23 14 29

Program: Write a program to find

maximum repeated words from a file.
public class MaxDuplicateWordCount {

public Map<String, Integer> getWordCount(String fileName){

FileInputStream fis = null;

DataInputStream dis = null;

BufferedReader br = null;

Map<String, Integer> wordMap = new HashMap<String, Integer>();

try {

fis = new FileInputStream(fileName);

dis = new DataInputStream(fis);

br = new BufferedReader(new InputStreamReader(dis));

String line = null;

while((line = br.readLine()) != null){

StringTokenizer st = new StringTokenizer(line, " ");

while(st.hasMoreTokens()){

String tmp = st.nextToken().toLowerCase();

if(wordMap.containsKey(tmp)){

wordMap.put(tmp, wordMap.get(tmp)+1);

} else {

wordMap.put(tmp, 1);

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();
 } finally{

try{if(br != null) br.close();}catch(Exception ex){}

return wordMap;

public List<Entry<String, Integer>> sortByValue(Map<String, Integer> wordMap){

Set<Entry<String, Integer>> set = wordMap.entrySet();

List<Entry<String, Integer>> list = new ArrayList<Entry<String, Integer>>(set);

Collections.sort( list, new Comparator<Map.Entry<String, Integer>>()

public int compare( Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2 )

return (o2.getValue()).compareTo( o1.getValue() );

} );

return list;

public static void main(String a[]){

MaxDuplicateWordCount mdc = new MaxDuplicateWordCount();

Map<String, Integer> wordMap = mdc.getWordCount("C:/MyTestFile.txt");

List<Entry<String, Integer>> list = mdc.sortByValue(wordMap);

for(Map.Entry<String, Integer> entry:list){

 System.out.println(entry.getKey()+" ==== "+entry.getValue());

Output:
one ==== 3
the ==== 3
that ==== 3
of ==== 2
in ==== 2
some ==== 2
to ==== 1
summary ==== 1
but ==== 1
have ==== 1
common ==== 1
least ==== 1
simplest ==== 1

Program: Write a program to find out

duplicate characters in a string.

public class DuplicateCharsInString {

public void findDuplicateChars(String str){

Map<Character, Integer> dupMap = new HashMap<Character, Integer>();

char[] chrs = str.toCharArray();
for(Character ch:chrs){
if(dupMap.containsKey(ch)){
dupMap.put(ch, dupMap.get(ch)+1);
} else {
dupMap.put(ch, 1);
}
}
Set<Character> keys = dupMap.keySet();
for(Character ch:keys){
if(dupMap.get(ch) > 1){
System.out.println(ch+"--->"+dupMap.get(ch));
}
}
}

public static void main(String a[]){

 DuplicateCharsInString dcs = new DuplicateCharsInString();
dcs.findDuplicateChars("Java2Novice");
}
}

Output:
v--->2
a--->2

Program: Write a program to find top two

maximum numbers in a array.

package com.java2novice.algos;

public class TwoMaxNumbers {

public void printTwoMaxNumbers(int[] nums){

int maxOne = 0;

int maxTwo = 0;

for(int n:nums){

if(maxOne < n){

maxTwo = maxOne;

maxOne =n;

} else if(maxTwo < n){

maxTwo = n;

}
 System.out.println("First Max Number: "+maxOne);

System.out.println("Second Max Number: "+maxTwo);

public static void main(String a[]){

int num[] = {5,34,78,2,45,1,99,23};

TwoMaxNumbers tmn = new TwoMaxNumbers();

tmn.printTwoMaxNumbers(num);

Program: Write a program to sort a map by

value.

package com.java2novice.algos;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.Map.Entry;

public class OrderByValue {

 public static void main(String a[]){

Map<String, Integer> map = new HashMap<String, Integer>();

map.put("java", 20);

map.put("C++", 45);

map.put("Java2Novice", 2);

map.put("Unix", 67);

map.put("MAC", 26);

map.put("Why this kolavari", 93);

Set<Entry<String, Integer>> set = map.entrySet();

List<Entry<String, Integer>> list = new ArrayList<Entry<String, Integer>>(set);

Collections.sort( list, new Comparator<Map.Entry<String, Integer>>()

public int compare( Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2 )

return (o2.getValue()).compareTo( o1.getValue() );

} );

for(Map.Entry<String, Integer> entry:list){

System.out.println(entry.getKey()+" ==== "+entry.getValue());

Output:
Why this kolavari ==== 93
Unix ==== 67
C++ ==== 45
MAC ==== 26
java ==== 20
 Java2Novice ==== 2

Program: Write a program to find common

elements between two arrays.

public class CommonElementsInArray {

public static void main(String a[]){

int[] arr1 = {4,7,3,9,2};

int[] arr2 = {3,2,12,9,40,32,4};

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

for(int j=0;j<arr2.length;j++){

if(arr1[i]==arr2[j]){

System.out.println(arr1[i]);

Output:
4
3
9
2
Program: How to swap two numbers
without using temporary variable?

package com.java2novice.algos;

public class MySwapingTwoNumbers {

public static void main(String a[]){

int x = 10;

int y = 20;

System.out.println("Before swap:");

System.out.println("x value: "+x);

System.out.println("y value: "+y);

x = x+y;

y=x-y;

x=x-y;

System.out.println("After swap:");

System.out.println("x value: "+x);

System.out.println("y value: "+y);

Output:
Before swap:
x value: 10
y value: 20
After swap:
x value: 20
y value: 10
Program: Write a program to print
fibonacci series.

package com.java2novice.algos;

public class MyFibonacci {

public static void main(String a[]){

int febCount = 15;

int[] feb = new int[febCount];

feb[0] = 0;

feb[1] = 1;

for(int i=2; i < febCount; i++){

feb[i] = feb[i-1] + feb[i-2];

for(int i=0; i< febCount; i++){

System.out.print(feb[i] + " ");

Output:
 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

Program: Write a program to find sum of

each digit in the given number using
recursion.
package com.java2novice.algos;

public class MyNumberSumRec {

int sum = 0;

public int getNumberSum(int number){

if(number == 0){

return sum;

} else {

sum += (number%10);

getNumberSum(number/10);

return sum;

public static void main(String a[]){

MyNumberSumRec mns = new MyNumberSumRec();

System.out.println("Sum is: "+mns.getNumberSum(223));

 }

Sum is: 7

Program: Write a program to check the

given number is a prime number or not?
package com.java2novice.algos;

public class MyPrimeNumCheck {

public boolean isPrimeNumber(int number){

for(int i=2; i<=number/2; i++){

if(number % i == 0){

return false;

return true;

public static void main(String a[]){

MyPrimeNumCheck mpc = new MyPrimeNumCheck();

System.out.println("Is 17 prime number? "+mpc.isPrimeNumber(17));

System.out.println("Is 19 prime number? "+mpc.isPrimeNumber(19));

System.out.println("Is 15 prime number? "+mpc.isPrimeNumber(15));

}
}

Output:
Is 17 prime number? true
Is 19 prime number? true
Is 15 prime number? false

Program: Write a program to find the

given number is Armstrong number or not?

package com.java2novice.algos;

public class MyArmstrongNumber {

public boolean isArmstrongNumber(int number){

int tmp = number;

int noOfDigits = String.valueOf(number).length();

int sum = 0;

int div = 0;

while(tmp > 0)

div = tmp % 10;

int temp = 1;

for(int i=0;i<noOfDigits;i++){

temp *= div;

sum += temp;
 tmp = tmp/10;

if(number == sum) {

return true;

} else {

return false;

public static void main(String a[]){

MyArmstrongNumber man = new MyArmstrongNumber();

System.out.println("Is 371 Armstrong number? "+man.isArmstrongNumber(371));

System.out.println("Is 523 Armstrong number? "+man.isArmstrongNumber(523));

System.out.println("Is 153 Armstrong number? "+man.isArmstrongNumber(153));

Output:
Is 371 Armstrong number? true
Is 523 Armstrong number? false
Is 153 Armstrong number? true

Program: Write a program to convert

binary to decimal number.
package com.java2novice.algos;

public class BinaryToDecimal {

 public int getDecimalFromBinary(int binary){

int decimal = 0;

int power = 0;

while(true){

if(binary == 0){

break;

} else {

int tmp = binary%10;

decimal += tmp*Math.pow(2, power);

binary = binary/10;

power++;

return decimal;

public static void main(String a[]){

BinaryToDecimal bd = new BinaryToDecimal();

System.out.println("11 ===> "+bd.getDecimalFromBinary(11));

System.out.println("110 ===> "+bd.getDecimalFromBinary(110));

System.out.println("100110 ===> "+bd.getDecimalFromBinary(100110));

}
 Output:
11 ===> 3
110 ===> 6
100110 ===> 38

Program: Write a program to check the

given number is binary number or not?

public class MyBinaryCheck {

public boolean isBinaryNumber(int binary){

boolean status = true;

while(true){

if(binary == 0){

break;

} else {

int tmp = binary%10;

if(tmp > 1){

status = false;

break;

binary = binary/10;

return status;
 }

public static void main(String a[]){

MyBinaryCheck mbc = new MyBinaryCheck();

System.out.println("Is 1000111 binary? :"+mbc.isBinaryNumber(1000111));

System.out.println("Is 10300111 binary? :"+mbc.isBinaryNumber(10300111));

Output:
Is 1000111 binary? :true
Is 10300111 binary? :false

Program: Write a program for Bubble Sort

in java.

public class MyBubbleSort {

// logic to sort the elements

public static void bubble_srt(int array[]) {

int n = array.length;

int k;

for (int m = n; m >= 0; m--) {

for (int i = 0; i < n - 1; i++) {

k = i + 1;

if (array[i] > array[k]) {

 swapNumbers(i, k, array);

printNumbers(array);

private static void swapNumbers(int i, int j, int[] array) {

int temp;

temp = array[i];

array[i] = array[j];

array[j] = temp;

private static void printNumbers(int[] input) {

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

System.out.print(input[i] + ", ");

System.out.println("\n");

public static void main(String[] args) {

int[] input = { 4, 2, 9, 6, 23, 12, 34, 0, 1 };

 bubble_srt(input);

Output:
2, 4, 6, 9, 12, 23, 0, 1, 34,

2, 4, 6, 9, 12, 0, 1, 23, 34,

2, 4, 6, 9, 0, 1, 12, 23, 34,

2, 4, 6, 0, 1, 9, 12, 23, 34,

2, 4, 0, 1, 6, 9, 12, 23, 34,

2, 0, 1, 4, 6, 9, 12, 23, 34,

0, 1, 2, 4, 6, 9, 12, 23, 34,

0, 1, 2, 4, 6, 9, 12, 23, 34,

0, 1, 2, 4, 6, 9, 12, 23, 34,

0, 1, 2, 4, 6, 9, 12, 23, 34,

Program: Write a program for Insertion

Sort in java.

package com.java2novice.algos;

public class MyInsertionSort {

public static void main(String[] args) {

int[] input = { 4, 2, 9, 6, 23, 12, 34, 0, 1 };

 insertionSort(input);

private static void printNumbers(int[] input) {

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

System.out.print(input[i] + ", ");

System.out.println("\n");

public static void insertionSort(int array[]) {

int n = array.length;

for (int j = 1; j < n; j++) {

int key = array[j];

int i = j-1;

while ( (i > -1) && ( array [i] > key ) ) {

array [i+1] = array [i];

i--;

array[i+1] = key;

printNumbers(array);

}
 Output:
2, 4, 9, 6, 23, 12, 34, 0, 1,

2, 4, 9, 6, 23, 12, 34, 0, 1,

2, 4, 6, 9, 23, 12, 34, 0, 1,

2, 4, 6, 9, 23, 12, 34, 0, 1,

2, 4, 6, 9, 12, 23, 34, 0, 1,

2, 4, 6, 9, 12, 23, 34, 0, 1,

0, 2, 4, 6, 9, 12, 23, 34, 1,

0, 1, 2, 4, 6, 9, 12, 23, 34,

Program: Write a program to implement

hashcode and equals.

package com.java2novice.algos;

import java.util.HashMap;

public class MyHashcodeImpl {

public static void main(String a[]){

HashMap<Price, String> hm = new HashMap<Price, String>();

hm.put(new Price("Banana", 20), "Banana");

hm.put(new Price("Apple", 40), "Apple");

hm.put(new Price("Orange", 30), "Orange");

 //creating new object to use as key to get value

Price key = new Price("Banana", 20);

System.out.println("Hashcode of the key: "+key.hashCode());

System.out.println("Value from map: "+hm.get(key));

class Price{

private String item;

private int price;

public Price(String itm, int pr){

this.item = itm;

this.price = pr;

public int hashCode(){

System.out.println("In hashcode");

int hashcode = 0;

hashcode = price*20;

hashcode += item.hashCode();

return hashcode;

}
public boolean equals(Object obj){

System.out.println("In equals");

if (obj instanceof Price) {

Price pp = (Price) obj;

return (pp.item.equals(this.item) && pp.price == this.price);

} else {

return false;

public String getItem() {

return item;

public void setItem(String item) {

this.item = item;

public int getPrice() {

return price;

public void setPrice(int price) {

this.price = price;

public String toString(){

return "item: "+item+" price: "+price;

 }

Output:
In hashcode
In hashcode
In hashcode
In hashcode
Hashcode of the key: 1982479637
In hashcode
In equals
Value from map: Banana

Program: How to get distinct elements

from an array by avoiding duplicate
elements?

package com.java2novice.algos;

public class MyDisticntElements {

public static void printDistinctElements(int[] arr){

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

boolean isDistinct = false;

for(int j=0;j<i;j++){

if(arr[i] == arr[j]){

isDistinct = true;

break;

}
 }

if(!isDistinct){

System.out.print(arr[i]+" ");

public static void main(String a[]){

int[] nums = {5,2,7,2,4,7,8,2,3};

MyDisticntElements.printDistinctElements(nums);

Output:
527483

Program: Write a program to get distinct

word list from the given file.

package com.java2novice.algos;

import java.io.BufferedReader;

import java.io.DataInputStream;

import java.io.FileInputStream;

import java.io.FileNotFoundException;
import java.io.IOException;

import java.io.InputStreamReader;

import java.util.ArrayList;

import java.util.List;

import java.util.StringTokenizer;

public class MyDistinctFileWords {

public List<String> getDistinctWordList(String fileName){

FileInputStream fis = null;

DataInputStream dis = null;

BufferedReader br = null;

List<String> wordList = new ArrayList<String>();

try {

fis = new FileInputStream(fileName);

dis = new DataInputStream(fis);

br = new BufferedReader(new InputStreamReader(dis));

String line = null;

while((line = br.readLine()) != null){

StringTokenizer st = new StringTokenizer(line, " ,.;:\"");

while(st.hasMoreTokens()){

String tmp = st.nextToken().toLowerCase();

if(!wordList.contains(tmp)){

wordList.add(tmp);
 }

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

} finally{

try{if(br != null) br.close();}catch(Exception ex){}

return wordList;

public static void main(String a[]){

MyDistinctFileWords distFw = new MyDistinctFileWords();

List<String> wordList = distFw.getDistinctWordList("C:/sample.txt");

for(String str:wordList){

System.out.println(str);

Program: Write a program to get a line

with max word count from the given file.

package com.java2novice.algos;
import java.io.BufferedReader;

import java.io.DataInputStream;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.InputStreamReader;

import java.util.ArrayList;

import java.util.List;

public class MaxWordCountInLine {

private int currentMaxCount = 0;

private List<String> lines = new ArrayList<String>();

public void readMaxLineCount(String fileName){

FileInputStream fis = null;

DataInputStream dis = null;

BufferedReader br = null;

try {

fis = new FileInputStream(fileName);

dis = new DataInputStream(fis);

br = new BufferedReader(new InputStreamReader(dis));

 String line = null;

while((line = br.readLine()) != null){

int count = (line.split("\\s+")).length;

if(count > currentMaxCount){

lines.clear();

lines.add(line);

currentMaxCount = count;

} else if(count == currentMaxCount){

lines.add(line);

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

} finally{

try{

if(br != null) br.close();

}catch(Exception ex){}

public int getCurrentMaxCount() {

return currentMaxCount;
}

public void setCurrentMaxCount(int currentMaxCount) {

this.currentMaxCount = currentMaxCount;

public List<String> getLines() {

return lines;

public void setLines(List<String> lines) {

this.lines = lines;

public static void main(String a[]){

MaxWordCountInLine mdc = new MaxWordCountInLine();

mdc.readMaxLineCount("/Users/ngootooru/MyTestFile.txt");

System.out.println("Max number of words in a line is: "+mdc.getCurrentMaxCount());

System.out.println("Line with max word count:");

List<String> lines = mdc.getLines();

for(String l:lines){

System.out.println(l);

}
}

Output:
Max number of words in a line is: 13
Line with max word count:
true, false, and null might seem like keywords, but they are actually literals.

Program: Write a program to convert

string to number without using
Integer.parseInt() method.

package com.java2novice.algos;

public class MyStringToNumber {

public static int convert_String_To_Number(String numStr){

char ch[] = numStr.toCharArray();

int sum = 0;

//get ascii value for zero

int zeroAscii = (int)'0';

for(char c:ch){

int tmpAscii = (int)c;

sum = (sum*10)+(tmpAscii-zeroAscii);

return sum;

}
 public static void main(String a[]){

System.out.println("\"3256\" == "+convert_String_To_Number("3256"));

System.out.println("\"76289\" == "+convert_String_To_Number("76289"));

System.out.println("\"90087\" == "+convert_String_To_Number("90087"));

Output:
"3256" == 3256
"76289" == 76289
"90087" == 90087

Program: Write a program to find two

lines with max characters in descending
order.

package com.longest.lines;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.IOException;

import java.util.Comparator;

import java.util.Set;

import java.util.TreeSet;
public class Main {

public static void main(String[] args) {

BufferedReader br = null;

String filePath = args[0];

int topList = 0;

Set<Entries> liSet = new TreeSet<Entries>(new MyComp());

try {

br = new BufferedReader(new FileReader(new File(filePath)));

String line = br.readLine();

topList = Integer.parseInt(line.trim());

while((line = br.readLine()) != null){

line = line.trim();

if(!"".equals(line)){

liSet.add(new Entries(line.length(), line));

int count = 0;

for(Entries ent:liSet){

System.out.println(ent.line);

if(++count == topList){

break;

}
 }

} catch (FileNotFoundException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

public static class Entries{

Integer length;

String line;

public Entries(Integer l,String line){

length = l;

this.line = line;

public static class MyComp implements Comparator<Entries>{

@Override

public int compare(Entries e1, Entries e2) {

if(e2.length > e1.length){

return 1;
 } else {

return -1;

Sample input file:

3
Java2novice
My Test line 123

Java world
I know java language

This is a test program

java is simple

Output:
This is a test program
I know java language
My Test line 123

Program: Write a program to find the sum

of the first 1000 prime numbers.

package com.primesum;

public class Main {

public static void main(String args[]){

 int number = 2;

int count = 0;

long sum = 0;

while(count < 1000){

if(isPrimeNumber(number)){

sum += number;

count++;

number++;

System.out.println(sum);

private static boolean isPrimeNumber(int number){

for(int i=2; i<=number/2; i++){

if(number % i == 0){

return false;

return true;

Output:
 3682913

Program: Find longest substring without

repeating characters.

package com.java2novice.algos;

import java.util.HashSet;

import java.util.Set;

public class MyLongestSubstr {

private Set<String> subStrList = new HashSet<String>();

private int finalSubStrSize = 0;

public Set<String> getLongestSubstr(String input){

//reset instance variables

subStrList.clear();

finalSubStrSize = 0;

// have a boolean flag on each character ascii value

boolean[] flag = new boolean[256];

int j = 0;

char[] inputCharArr = input.toCharArray();

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

 char c = inputCharArr[i];

if (flag[c]) {

extractSubString(inputCharArr,j,i);

for (int k = j; k < i; k++) {

if (inputCharArr[k] == c) {

j = k + 1;

break;

flag[inputCharArr[k]] = false;

} else {

flag[c] = true;

extractSubString(inputCharArr,j,inputCharArr.length);

return subStrList;

private String extractSubString(char[] inputArr, int start, int end){

StringBuilder sb = new StringBuilder();

for(int i=start;i<end;i++){

sb.append(inputArr[i]);

String subStr = sb.toString();

 if(subStr.length() > finalSubStrSize){

finalSubStrSize = subStr.length();

subStrList.clear();

subStrList.add(subStr);

} else if(subStr.length() == finalSubStrSize){

subStrList.add(subStr);

return sb.toString();

public static void main(String a[]){

MyLongestSubstr mls = new MyLongestSubstr();

System.out.println(mls.getLongestSubstr("java2novice"));

System.out.println(mls.getLongestSubstr("java_language_is_sweet"));

System.out.println(mls.getLongestSubstr("java_java_java_java"));

System.out.println(mls.getLongestSubstr("abcabcbb"));

Output:
[a2novice]
[uage_is]
[_jav, va_j]
[cab, abc, bca]
Program: Write a program to remove
duplicates from sorted array.

1
2
3
package com.java2novice.algos;
4
5 public class MyDuplicateElements {
6
7 public static int[] removeDuplicates(int[] input){
8
9 int j = 0;
10 int i = 1;
//return if the array length is less than 2
11 if(input.length < 2){
12 return input;
13 }
14 while(i < input.length){
15 if(input[i] == input[j]){
i++;
16 }else{
17 input[++j] = input[i++];
18 }
19 }
20 int[] output = new int[j+1];
for(int k=0; k<output.length; k++){
21 output[k] = input[k];
22 }
23
24 return output;
25 }
26
public static void main(String a[]){
27
int[] input1 = {2,3,6,6,8,9,10,10,10,12,12};
28 int[] output = removeDuplicates(input1);
29 for(int i:output){
30 System.out.print(i+" ");
31 }
}
32 }
33
34
35

Output:
2 3 6 8 9 10 12
Program: How to sort a Stack using a
temporary Stack?

package com.java2novice.algo;

import java.util.Stack;

public class StackSort {

public static Stack<Integer> sortStack(Stack<Integer> input){

Stack<Integer> tmpStack = new Stack<Integer>();

System.out.println("=============== debug logs ================");

while(!input.isEmpty()) {

int tmp = input.pop();

System.out.println("Element taken out: "+tmp);

while(!tmpStack.isEmpty() && tmpStack.peek() > tmp) {

input.push(tmpStack.pop());

tmpStack.push(tmp);

System.out.println("input: "+input);

System.out.println("tmpStack: "+tmpStack);

System.out.println("=============== debug logs ended ================");

return tmpStack;
 }

public static void main(String a[]){

Stack<Integer> input = new Stack<Integer>();

input.add(34);

input.add(3);

input.add(31);

input.add(98);

input.add(92);

input.add(23);

System.out.println("input: "+input);

System.out.println("final sorted list: "+sortStack(input));

input: [34, 3, 31, 98, 92, 23]

=============== debug logs ================
Element taken out: 23
input: [34, 3, 31, 98, 92]
tmpStack: [23]
Element taken out: 92
input: [34, 3, 31, 98]
tmpStack: [23, 92]
Element taken out: 98
input: [34, 3, 31]
tmpStack: [23, 92, 98]
Element taken out: 31
input: [34, 3, 98, 92]
tmpStack: [23, 31]
Element taken out: 92
input: [34, 3, 98]
tmpStack: [23, 31, 92]
Element taken out: 98
input: [34, 3]
tmpStack: [23, 31, 92, 98]
Element taken out: 3
input: [34, 98, 92, 31, 23]
tmpStack: [3]
Element taken out: 23
input: [34, 98, 92, 31]
tmpStack: [3, 23]
Element taken out: 31
input: [34, 98, 92]
tmpStack: [3, 23, 31]
Element taken out: 92
input: [34, 98]
tmpStack: [3, 23, 31, 92]
Element taken out: 98
input: [34]
tmpStack: [3, 23, 31, 92, 98]
Element taken out: 34
input: [98, 92]
tmpStack: [3, 23, 31, 34]
Element taken out: 92
input: [98]
tmpStack: [3, 23, 31, 34, 92]
Element taken out: 98
input: []
tmpStack: [3, 23, 31, 34, 92, 98]
=============== debug logs ended ================
final sorted list: [3, 23, 31, 34, 92, 98]