All posts by programmingashish

/* Sorting was performed in non-ascending order on “name” of person class */
public class SortByValueObjectMap {
public static void main(String[] args) {

// Filling the map
Map<Integer, Person> map = new HashMap<Integer, Person>();
map.put(1, new Person(21, “ashish”));
map.put(2, new Person(42, “aman”));
map.put(3, new Person(03, “vishal”));
map.put(4, new Person(19, “pradeep”));

// Creating a list of Map.entry
List<Map.Entry<Integer, Person>> l = new ArrayList<Map.Entry<Integer, Person>>(map.entrySet());

// printing map entry before sorting
for (Map.Entry<Integer, Person> entry : l) {
System.out.println(“No: ” + entry.getKey() + ” Person’s Id: ” + entry.getValue().getId() + ” Person’s Name:”
+ entry.getValue().getName());
}

// Implementing sorting code
Collections.sort(l, new Comparator<Map.Entry<Integer, Person>>() {
public int compare(Map.Entry<Integer, Person> o1, Map.Entry<Integer, Person> o2) {
return ((String) o2.getValue().getName()).compareTo((String) o1.getValue().getName());
}
});

System.out.println(“==============================================================”);
// printing map after sorting
for (Map.Entry<Integer, Person> entry : l) {
System.out.println(“No: ” + entry.getKey() + ” Person’s Id: ” + entry.getValue().getId() + ” Person’s Name:”
+ entry.getValue().getName());
}
}
}

Sort Map By Value(Integer)

June 28, 2017 programmingashish Leave a comment

package javaCollectionsAndMaps;

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());
}*/
Set<Entry<String, Integer>> s=map.entrySet();
List<Entry<String,Integer>> l=new ArrayList<Entry<String,Integer>>(s);
Collections.sort(l,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:l){
System.out.println(entry.getKey()+” “+entry.getValue());
}
}
}

maps of object

June 28, 2017 programmingashish Leave a comment

package javaCollectionsAndMaps;package javaCollectionsAndMaps;import java.util.*;
/* Provide input: 2 10 4 4 2 2 2 2 0 0 0 0149 9 0 0 2 2 2 2 4 4 4 5 5 6*/public class SortByFrequency { public static void main(String[] args) { Scanner scan = new Scanner(System.in);
// no. of test Cases int T = scan.nextInt(); // System.out.println(“before Sorting:”); // for (int i = 0; i < a.length; i++) { // System.out.print(a[i]+” “); // } while (T– > 0) { int a[] = inputArray(scan); // Sorting the array as per frequency sortByFreq(a); System.out.println(“After Sorting:”); for (int i = 0; i < a.length; i++) { System.out.print(a[i] + ” “); } } }
static int[] inputArray(Scanner scan) { // No of elements in the array int n = scan.nextInt(); int[] a = new int[n]; for (int i = 0; i < n; i++) { a[i] = scan.nextInt(); } return a; }
static <T> void sortByFreq(int[] a) { Map<Integer, Integer> map = new TreeMap<Integer, Integer>(); for (int i = 0; i < a.length; i++) { if (map.get(a[i]) == null) { map.put(a[i], 1); } else { Integer frequency = map.get(a[i]); map.put(a[i], frequency + 1); } }
List<Map.Entry<Integer, Integer>> l = new LinkedList<Map.Entry<Integer, Integer>>(map.entrySet()); Collections.sort(l, new Comparator<Map.Entry<Integer, Integer>>() {
@Override public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) { return (o1.getValue()).compareTo(o2.getValue()); }
});
int count = 0; for (Iterator it = l.iterator(); it.hasNext();) { Map.Entry<Integer, Integer> me = (Map.Entry<Integer, Integer>) it.next(); int key = me.getKey(); int value = me.getValue(); for (int i = 0; i < value; i++) { a[count] = key; count++; } } /* * for(Map.Entry<Integer,Integer> entry:map.entrySet()){ * System.out.println(“key: “+entry.getKey()+”value: “+entry.getValue()) * ; } */ }}

maps array ex

June 28, 2017 programmingashish Leave a comment

Equals and hashcode

May 31, 2017 programmingashish Leave a comment

original equals check equality by this==obj. So it checks by using the reference.
hashcode just implements a logic that returns hashcode as per the hashcode contract.
if we use hash based collection, then it checks the equality comparing hashcode value, if values are equal then it checks using original equals method (this==obj) by reference. If we have also overridden equals method then it will check using our own overridden method.
if we override just hashcode using default eclipse way(it will generate same hashcode for those object who have same value like (0,”ashish”) and (0,”ashish”). The hashcode will be same but, since we are not overriding original equals, the objects reference will be considered different and it will store both object.
If we also override equals as per eclipse. It doesnt check equality using this==obj or using reference . Both the objects with same values will be considered equal.
if we just override equals then since we are using original hashcode method, equal will be true but since hashcode is different only one object will get stored.
WRAPPER CLASSES: in wrapper class, autoboxing convert int to Integer and vice versa. also when we check wrapper object:

Integer i1=new Integer(10);
Integer i2=new Integer(10);
System.out.println(i1.equals(i2));

System.out.println(i1==i2);

It will return true for both.

Sorting custom object List in java

May 30, 2017 programmingashish Leave a comment

package SortingEx;

import java.util.*;

class Person {
private int id;
private String name;

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public Person(int id, String name) {
super();
this.id = id;
this.name = name;
}

}

class reverseComparator implements Comparator {

@Override
public int compare(Object p1, Object p2) {
Integer i1 = ((Person) p1).getId();
Integer i2 = ((Person) p2).getId();
return i2.compareTo(i1);

}
}

class reverseValueComparator implements Comparator {

@Override
public int compare(Object p1, Object p2) {
String i1 = ((Person) p1).getName();
String i2 = ((Person) p2).getName();
return i2.compareTo(i1);

}
}

class checkComparator implements Comparator {

@Override
public int compare(Object p1, Object p2) {
String i1 = ((Person) p1).getName();
String i2 = ((Person) p2).getName();
if (i2.compareTo(i1)==0){
return new reverseComparator().compare(p1, p2);
};
return i2.compareTo(i1);
}
}
public class ListSortEx {
public static void main(String[] args) {
List<Person> l = new ArrayList();
Person p1 = new Person(1, “k”);
Person p2 = new Person(2, “p”);
Person p3 = new Person(3, “p”);
Person p4 = new Person(4, “b”);
System.out.println(p1);
System.out.println(p2);
l.add(p1);
l.add(p2);
l.add(p3);
l.add(p4);
Collections.sort(l, new checkComparator());
ListIterator itr = l.listIterator();
while (itr.hasNext()) {
Person p = (Person) itr.next();
System.out.println(p.getId()+” “+p.getName());
}
}
}

Maven configuration

May 11, 2017 programmingashish Leave a comment

PATH=”/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/usr/java/jdk1.8.0_121/jre/bin:/opt/apache-maven-3.3.9/bin”
JAVA_HOME=”/usr/java/jdk1.8.0_121″
M2_HOME=”/opt/apache-maven-3.3.9″
M2=”/opt/apache-maven-3.3.9/bin”

Questions on Spring MVC/REST

April 15, 2017 programmingashish Leave a comment

Spring MVC

Spring MVC flow
Configuring dispatcher servlet/web.xml, using xml and java config both
What is AbstractAnnotationConfigDispatcherServletInitializer,SpringServletContainerInitializer and its use.
defining multiple beans using ContextLoaderListener(
```
org.springframework.web.context.ContextLoaderListener
```
) in xml.
enable support for annotation-based controllers. using RequestMappingHandlerMapping and RequestMappingHandlerAdapter. How to use less xml using <mvc:annotation-driven>
```
@EnableWebMvc
```

use and purpose of

@RequestMapping(value = "/welcome", method=RequestMethod.GET)

How to use constructor autowiring and using that in web MVC.

What will happen if there is no return from controller:

@RequestMapping(method = RequestMethod.GET)
    public void setupForm() {
    }

How to take request parameter as input using @RequestParam(“name”) String name declaration

Defining Model model in method and using

model.addAttribute("reservations", reservations);

Configuring InternalResourceViewResolver bean.
creating jsp/jstl views and how model to view works.
Deploying application
using
```
@ComponentScan
```
What is bydefault value of method attribut in @RequestMapping
how to user
```
redirect:
```
Different ways of using @RequestMapping, like (“add”),(value={remove,delete}),(“display/user”)
why we dont use .jsp and .html kind of URI.
Define interceptors using HandleInterceptor interface and HandleInterceptorAdapter class.
How to resolve user’s locale.
Using Locale sensitive texts
Different types of view resolvers
What is ContentNegotiatingViewResolver , how is it used for content negotiation
Why ContentNegotiatingViewResolver has highest priority.
handling exceptions and using HandlerExceptionResolver and @ExceptionHandler and @ControllerAdvice.

Java definetions

February 23, 2017 programmingashish Leave a comment

Inheritance can be defined as the process where one class acquires the properties (methods and fields) of another. With the use of inheritance the information is made manageable in a hierarchical order.The class which inherits the properties of other is known as subclass (derived class, child class) and the class whose properties are inherited is known as superclass (base class, parent class).
The benefit of overriding is: ability to define a behavior that’s specific to the subclass type, which means a subclass can implement a parent class method based on its requirement.In object-oriented terms, overriding means to override the functionality of an existing method.
Polymorphism is the ability of an object to take on many forms. The most common use of polymorphism in OOP occurs when a parent class reference is used to refer to a child class object.Any Java object that can pass more than one IS-A test is considered to be polymorphic. In Java, all Java objects are polymorphic since any object will pass the IS-A test for their own type and for the class Object.It is important to know that the only possible way to access an object is through a reference variable. A reference variable can be of only one type. Once declared, the type of a reference variable cannot be changed.The reference variable can be reassigned to other objects provided that it is not declared final. The type of the reference variable would determine the methods that it can invoke on the object.A reference variable can refer to any object of its declared type or any subtype of its declared type. A reference variable can be declared as a class or interface type.
As per dictionary, abstraction is the quality of dealing with ideas rather than events. For example, when you consider the case of e-mail, complex details such as what happens as soon as you send an e-mail, the protocol your e-mail server uses are hidden from the user. Therefore, to send an e-mail you just need to type the content, mention the address of the receiver, and click send.Likewise in Object-oriented programming, abstraction is a process of hiding the implementation details from the user, only the functionality will be provided to the user. In other words, the user will have the information on what the object does instead of how it does it.In Java, abstraction is achieved using Abstract classes and interfaces.
Encapsulation is one of the four fundamental OOP concepts. The other three are inheritance, polymorphism, and abstraction.Encapsulation in Java is a mechanism of wrapping the data (variables) and code acting on the data (methods) together as a single unit. In encapsulation, the variables of a class will be hidden from other classes, and can be accessed only through the methods of their current class. Therefore, it is also known as data hiding.To achieve encapsulation in Java −
- Declare the variables of a class as private.
- Provide public setter and getter methods to modify and view the variables values.

iEvolve

TCS Gems

TCS IPMS

softMart

BGC

PRM

GESS

IDEAMAX

KNOWMAX

Software Installations

Safari Books Online

KNOME

Allocation & Utilization

My Documents

TCS Timesheets

Global Helpdesk IT

Global Helpdesk for Ultimatix Services (Finance & Other Services)

I9 Form for US Associates

Impact Link:

Enterprise Search Homepage

GSPEED : Appraisal

GSPEED : Career Hub

Visa Tracker

Conference Room Booking

iTalent

Ultimatix Recommends

Mediassist Links (HIS Claims)

Global Recruitment System

Recruitment Dashboard

TQAS

TCS MS Relationship Sharepoint link:

BFS Demand Tracker

Profile Tracker :

Allocation Tracker:

Global Procurement System Link :

TCS-WebEx:

TCS Corporate Learning / Talent Development

TCS Project Workbench

TCS Mindworks

TCS iON Learning Exchange

MS Password Reset for New joiners

TCS GBAMs –

Enterprise Reporting – PMR Report Link

Shift Rostering:

eTMS:

IWMS(For raising RGS IDs):

TCS IRC

Enterprise Analytics Portal

Workforce Management

Learning and Collaboration – Lynda

Spring MVC

A place for Programmers.