cmd /K "cd /d c:\location"
@Override
public synchronized void run() {
for(int i=0;i<10 args="" auto-generated="" block="" catch="" class="" code="" e.printstacktrace="" e="" even="" evenoddthreaddemo="" for="" i="" if="" implements="" int="" main="" notify="" nterruptedexception="" numbers="" odd="" public="" r1="" r2="" run="" runnable="" static="" synchronized="" system.out.println="" t1.start="" t1="new" t2.start="" t2="new" thread1="" thread2="" thread="" todo="" tring="" try="" verride="" void="" wait="">class Person implements Comparable{
private String empName;
private Integer empId;
public Person(Integer id,String name){
this.empId = id;
this.empName = name;
}
@Override
public int compareTo(Person e){
return (this.empId - e.empId);
}
public String toString(){
return empId+" "+empName;
} }
public class ComparableDemo {
public static void main(String[] args) {
Person e1 = new Person(3,"XXX");
Person e2 = new Person(1,"YYYY");
Person e3 = new Person(2,"ZZZ");
List empList = new ArrayList();
empList.add(e1);
empList.add(e2);
empList.add(e3);
Collections.sort(empList);
for(Person e:empList)
System.out.println(e);
}}
ArrayList and LinkedList both implements List interface and their methods and results are almost identical. However there are few differences between them which make one better over another depending on the requirement.
1) Search: ArrayList search operation is pretty fast compared to the LinkedList search operation. get(int index) in ArrayList gives the performance of O(1) while LinkedList performance is O(n).
Reason: ArrayList maintains index based system for its elements as it uses array data structure implicitly which makes it faster for searching an element in the list. On the other side LinkedList implements doubly linked list which requires the traversal through all the elements for searching an element.
2) Deletion: LinkedList remove operation gives O(1) performance while ArrayList gives variable performance: O(n) in worst case (while removing first element) and O(1) in best case (While removing last element).
Conclusion: LinkedList element deletion is faster compared to ArrayList.
Reason: LinkedList’s each element maintains two pointers (addresses) which points to the both neighbor elements in the list. Hence removal only requires change in the pointer location in the two neighbor nodes (elements) of the node which is going to be removed. While In ArrayList all the elements need to be shifted to fill out the space created by removed element.
3) Inserts Performance: LinkedList add method gives O(1) performance while ArrayList gives O(n) in worst case. Reason is same as explained for remove.
4) Memory Overhead: ArrayList maintains indexes and element data while LinkedList maintains element data and two pointers for neighbor nodes hence the memory consumption is high in LinkedList comparatively.
There are few similarities between these classes which are as follows:
Collections.synchronizedList method.1) As explained above the insert and remove operations give good performance (O(1)) in LinkedList compared to ArrayList(O(n)). Hence if there is a requirement of frequent addition and deletion in application then LinkedList is a best choice.
2) Search (get method) operations are fast in Arraylist (O(1)) but not in LinkedList (O(n)) so If there are less add and remove operations and more search operations requirement, ArrayList would be your best bet.
Java.lang.Object has methods called hasCode() and equals(). These methods play a significant role in the real time application. However its use is not always common to all applications. In some case these methods are overridden to perform certain purpose. In this article I will explain you some concept of these methods and why it becomes necessary to override these methods.
As you know this method provides the has code of an object. Basically the default implementation of hashCode() provided by Object is derived by mapping the memory address to an integer value. If look into the source of Object class , you will find the following code for the hashCode. public native int hashCode(); It indicates that hashCode is the native implementation which provides the memory address to a certain extent. However it is possible to override the hashCode method in your implementation class.
This particular method is used to make equal comparison between two objects. There are two types of comparisons in Java. One is using “= =” operator and another is “equals()”. I hope that you know the difference between this two. More specifically the “.equals()” refers to equivalence relations. So in broad sense you say that two objects are equivalent they satisfy the “equals()” condition. If you look into the source code of Object class you will find the following code for the equals() method.
.png)
