package in.javatutorials;
public class ReverseNumber {
public static void main(String[] args) {
System.out.println(“The reversed number is ” + reverse(1234));
}public static int reverse(int input) {
int result = 0;
int rem;
while (input > 0) {
rem = input % 10;
input = input / 10;
result = result * 10 + rem;
}
return result;
}
}
There are many different ways to find out the duplicates in a List or count of duplicates in a List object. Three best ways have been implemented in the below sample class. I suggest to go with 2nd sample, when there is a requirement in your project.
package in.javatutorials;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;public class CountOfDuplicatesInList {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add(“a”);
list.add(“b”);
list.add(“c”);
list.add(“d”);
list.add(“b”);
list.add(“c”);
list.add(“a”);
list.add(“a”);
list.add(“a”);// Find out the count of duplicates by passing a String – static way
System.out.println(“\n Output 1 – Count ‘a’ with frequency”);
System.out.println(“a : ” + Collections.frequency(list, “a”));// Find out the count of duplicates using Unique values – dynamic way
System.out.println(“\n Output 2 – Count all with frequency”);
Set<String> uniqueSet = new HashSet<String>(list);
for (String temp : uniqueSet) {
System.out.println(temp + “: ” + Collections.frequency(list, temp));
}// Find out the count of duplicates using Map – Lengthy process
System.out.println(“\n Output 3 – Count all with Map”);
Map<String, Integer> map = new HashMap<String, Integer>();for (String temp : list) {
Integer count = map.get(temp);
map.put(temp, (count == null) ? 1 : count + 1);
}
for (Map.Entry<String, Integer> entry : map.entrySet()) {
System.out.println(“Key : ” + entry.getKey() + ” Value : ”
+ entry.getValue());
}
}
}
Other Useful Links:
Avoid nested loops using Collection Framework in Java
Replace special characters in a String using java
Singleton Design pattern in JAVA
Convert Array to Vector in Java
In Java, a Thread can be created by extending to a Thread class or by implementing the Runnable Interface. In below example, I have tried to create the thread by implementing Runnable interface.
package in.javatutorials;
public class CreateThredByRunnable {
public static void main(String[] args) {
Thread myThreadA = new Thread(new MyThread(), “threadA”);
Thread myThreadB = new Thread(new MyThread(), “threadB”);
// run the two threads
myThreadA.start();
myThreadB.start();try {
Thread.currentThread().sleep(1000);
} catch (InterruptedException e) {
}
// Display info about the main thread
System.out.println(Thread.currentThread());
}}
class MyThread implements Runnable {
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread());
}
}
}
Other Useful Links
Thread concept is the most important topic for all the interviews. This post contains most important interview questions on Thread concepts. The answers for these questions will be covered in further posts.
Below is the sample program to connect to MS SQL Sever using JDBC type 4 driver:
package in.javatutorials;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
/**
* @author JavaTutorials.in
*
*/
public class MSSqlDBConnection {
/**
* initialize the connection object
*/
private static Connection connection = null;
/**
* Create the database connection and return the same
*
* @return connection Connection
*/
public static Connection getDbConnection() {
// if required, below variables can be read from properties file
String username = "sqlusr";
String password = "sqlpasswrd";
String connStr = "jdbc:sqlserver://:1433;instanceName=SQLEXPRESS;databaseName=test";
try {
Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
connection = DriverManager.getConnection(connStr, username,
password);
} catch (ClassNotFoundException classNotFoundExcep) {
classNotFoundExcep.printStackTrace();
} catch (SQLException sqlExcep) {
sqlExcep.printStackTrace();
}
return connection;
}
/**
* Close the connection if exists, this method can be called once
* transaction is completed, so that it will close the connection
*/
public static void closeConnection() {
if (connection != null) {
try {
connection.close();
} catch (SQLException sqlExcep) {
sqlExcep.printStackTrace();
}
}
}
public static void main(String[] args) {
System.out.println("Print the Database conn object : "
+ getDbConnection());
}
}
High performance is essential for any software implemented in any programming language. And, loops plays major role in this regard. This post explains how to avoid the loops using Java’s Collection framework.
Below are the two Java programs to understand how the performance could be increased using the Collection framework.
Using nested loops
package in.javatutorials;
/**
* Finds out the Duplicates is String Array using Nested Loops.
*/
public class UsingNesteadLoops {
private static String[] strArray = { "Cat", "Dog", "Tiger", "Lion", "Lion" };
public static void main(String[] args) {
isThereDuplicateUsingLoops(strArray);
}
/**
* Iterates the String array and finds out the duplicates
*/
public static void isThereDuplicateUsingLoops(String[] strArray) {
boolean duplicateFound = false;
int loopCounter = 0;
for (int i = 0; i < strArray.length; i++) {
String str = strArray[i];
int countDuplicate = 0;
for (int j = 0; j < strArray.length; j++) {
String str2 = strArray[j];
if (str.equalsIgnoreCase(str2)) {
countDuplicate++;
}
if (countDuplicate > 1) {
duplicateFound = true;
System.out.println("Duplicates Found for " + str);
}
loopCounter++;
}// end of inner nested for loop
if (duplicateFound) {
break;
}
}// end of outer for loop
System.out.println("Looped " + loopCounter + " times to find the result");
}
}
If we run the above program, it will be looped 20 times to find out the duplicates in the string array which has the length of 5. Number of loops increases exponentially depending on size of array, hence the performance takes a hit. These are not acceptable to use in applications which require high performance.
Without using nested loops
package in.javatutorials;
import java.util.HashSet;
import java.util.Set;
/**
* Finds out the Duplicates is String Array using Collection.
*/
public class AvoidNesteadLoopsUsingCollections {
private static String[] strArray = { "Cat", "Dog", "Tiger", "Lion", "Lion" };
public static void main(String[] args) {
isThereDuplicateUsingSet(strArray);
}
/**
* Iterates the String array and finds out the duplicates
*/
public static void isThereDuplicateUsingSet(String[] strArray) {
boolean duplicateFound = false;
int loopCounter = 0;
Set setValues = new HashSet();
for (int i = 0; i < strArray.length; i++) {
String str = strArray[i];
if(setValues.contains(str)){
duplicateFound = true;
System.out.println("Duplicates Found for " + str);
}
setValues.add(str);
loopCounter++;
if (duplicateFound) {
break;
}
}// end of for loop
System.out.println("Looped " + loopCounter + " times to find the result");
}
}
Other Useful links:
package in.javatutorials;
/**
* @author javatutorials
* @since version 1.0
*
* Below class replaces the special characters in a string with empty value
*
*/
public class ReplaceSpecialCharacters {
public static final String REG_EXPR = “[!\”#$%&'()*+-./:;<=>?@\\^_{|}~`,.\\[\\]]*”;
/**
* @param args
*/
public static void main(String[] args){
String str = “a – b +c^d!e+f g . h (Pvt) Ltd.”;
//Create class object and call replace special characters method
ReplaceSpecialCharacters rsc = new ReplaceSpecialCharacters();
String afterReplacing = rsc.replaceSpecialChars(str);
System.out.println(“After replacing special characters : “+afterReplacing);
}
/**
* @param string String
* @return string String
*/
public String replaceSpecialChars(String string){
string = string.replaceAll(REG_EXPR, “”);
while(string.indexOf(” “) != -1){
string = string.replaceAll(” “, ” “);
}
return string;
}
}
Below class depicts the Singleton design pattern.
SingletonDesignPattern.java
package in.javatutorials;
/**
* @author JavaTutorials
* @version 1.0
*
*/
public final class SingletonDesignPattern {
/**
* make the class object as private as it is
* not used directly out side the class
*/
private static SingletonDesignPattern singletonObj = null;
/**
* make the constructor as private.
* Object cannot be created using the constructor outside of this class.
*/
private SingletonDesignPattern(){
}
/**
* Create the class object if it is null and
*
* @return singletonObj SingletonDesignPattern
*/
public static SingletonDesignPattern getInstance(){
if(singletonObj == null){
singletonObj = new SingletonDesignPattern();
}
return singletonObj;
}
/**
* Take the user name as parameter and return the welcome message
*
* @param userName String
* @return message String
*/
public String getWelcomeInfo(String userName){
String message = null;
//make method access to synchronized to make thread safe
synchronized (SingletonDesignPattern.class) {
System.out.println(“User Name is : ” + userName);
message = “Hello ” + userName + “!!!”;
}
return message;
}
}
TestSingleton.java
The main() method of below class will get the single ton object and access the other methods using the same.
package in.javatutorials;
public class TestSingleton {
public static void main(String[] args) {
//Get the singleton object
SingletonDesignPattern singletonObj = SingletonDesignPattern.getInstance();
System.out.println(singletonObj.getWelcomeInfo(“Mallik”));
}
}
package com.test;
import java.util.Arrays;
import java.util.Vector;
public class ArrayTest {
public static void main(String[] args) {
ArrayTest arrayTest = new ArrayTest();
arrayTest.arrayToVector();
}
public void arrayToVector() {
String[] arrayToConvert = { “jhony”, “peter”, “don” };
Vector<String> convertedVector = new Vector<String> Arrays.asList(arrayToConvert));
System.out.println(“11111 ” + convertedVector.get(0));
System.out.println(“3” + convertedVector.size());
}
}
Contents of one array can be copied into another array by using the arraycopy() method of the System class in Java.
package com.Test;
public class ArrayCopyTest{
public static void main(String[] args){
int[] src = new int[] {1, 2, 3, 4, 5};
int[] dest = new int[src.length];
System.arraycopy(src, 0, dest, 0, src.length);
for (int i = 0; i < dest.length; i++){
System.out.println(dest[i]);
}
}
}
</> MV Techbytes 