With in the same class if we want to call one constructor from other we use this() method. Based on the number of parameters we pass appropriate this() method is called.
Restrictions for using this method :
|
1 2 3 4 |
1) Divide the list in two parts - first node and rest of the linked list. 2) Call reverse for the rest of the linked list. 3) Link rest to first. 4) Fix head pointer. |
|
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 |
package com.java2novice.ds.linkedlist; 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; } } } |
Output:
Adding: 3
Adding: 32
Adding: 54
Adding:
89 3 32 54 89
reversing the linked list
89 54 32 3
You are given an array of numbers. Find out the array index or position
where sum of numbers preceeding the index is equals to sum of numbers
succeeding the index.
|
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 |
package com.java2novice.algos; 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()); } } } |
In this method, we use reverse() method of StringBuffer class to reverse the string. Here is the code snippet to reverse the string using reverse() method of StringBuffer class.
|
1 2 3 |
StringBuffer sbf = new StringBuffer("MyJava"); System.out.println(sbf.reverse()); //Output : avaJyM |
In this method, first we convert given string to char array using charArray() method. And then we iterate that
Static blocks or static initializes are used to initialize static fields in java. we declare static blocks when we want to initialize static fields in our class. Static blocks gets executed exactly once when the class is loaded. Static blocks are executed even before the constructors are executed.
Example:-
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
public class Test { static{ System.out.println("Static"); } { System.out.println("Non-static block"); } public static void main(String[] args) { Test t = new Test(); Test t2 = new Test(); } } |
Yes, you can make an array volatile in java but only the reference which is pointing to an array, not the whole array. What I mean, if one thread changes the reference variable to points to another array, that will provide volatile guarantee, but if multiple threads are changing individual
|
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 |
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)); } } |
Singleton class means you can create only one object for the given class. You can create a singleton class by making its constructor as private, so that you can restrict the creation of the object. Provide a static method to get instance of the object, wherein you can handle the
1) Using replaceAll() Method.
In the first method, we use replaceAll() method of String class to remove all white spaces (including tab also) from a string. This is the one of the easiest method to remove all white spaces from a string. This method takes two parameters. One is the string