Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

1
$ hexo new "My New Post"

More info: Writing

Run server

1
$ hexo server

More info: Server

Generate static files

1
$ hexo generate

More info: Generating

Deploy to remote sites

1
$ hexo deploy

More info: Deployment

Fail-Fast Iterators fail as soon as they realized a thread is iterating over it,Structure of Collection has been changed since iteration has begun

Structural changes like Create,Update,Delete

Fail-Fast collections throw throws ConcurrentModificationException
Whereas,Iterator do not throw any Exception if collection is modified structurally,as they work on clone of collection instead of original collection.

Which all are fail-safe collections?

  • CopyOnWriteArrayList
  • ConcurrentHashMap

  • Collection Interface List allows duplicate values, Set does not allow duplicate values
  • List is ordered collection, Set is an unordered collection
  • List maintains insertion order(First-in is Lower Index), Set does not mantain any order
  • Various List Implementations(ArrayList,Vector,LinkedList)
  • Various Set Implementations(HashSet,TreeSet,LinkedHashSet)

  • ArrayList is implemented using re sizable array whereas,LinkedList is implemented using doubly LinkedList.
  • ArrayList insert needs re-size unlike LinkedList, It also warrants for index update if its not at the end of list.
  • Search Mechanism is Index based search in case of ArrayList which is not for LinkedList.
  • Removal of data is better in LinkedList compared to ArrayList
  • Hence,Insertion ore removal kind of application would be recommended with LinkedList, which does not re-size during the cycle.
  • ArrayList each index holds actual data compared to LinkedList,which holds address of itself,next and previous node,so lesser memory overhead.
  • ArrayList is recommended for random access of data compared to LinkedList, where, we need to traverse entire list.

Prior one is part of Synchronised Collection classes Hashtable and Vector are also Synchronised Wrapper classes

  • Allows NULL values
  • Where,Collections.synchronizedMap and Collections.synchronizedList, provide a basic conditionally thread-safe implementation of Map and List
  • Have to lock single collection wide lock to avoid ConcurrentModificationException and which would impediment to scalability
  • Once the size of Hashtable increases , locking is done for longer duration to iteration, which would degrade the performance
    Later one is introduced for the concept of segmentation ,so

  • Does not allow NULL values

  • Larger it becomes only certain part of it get locked to provide thread safety
  • Used for high volume low latency apps
  • Readers can access map without waiting for iterations to complete

Similarities between Hashtable and Hasbmap

  • Both extend Map Interface
  • Both work on hashing principle
  • Both are part of collection package
  • Both provide constant time performance for put and get methods, if objects are distributed in uniform buckets

Differences between Hashtable and Hasbmap

  • Hashtable - Threadsafe whereas Hashmap - Not Threadsafe
  • Hashtable - Synchronised and not better performance as Hashmap
  • Hashtable - Obselete(No Longer Available) class - Replace it by ConcurrentHashMap



Logo:


Name:


Project Type:


Description:


More Info:


Apache HDFS


Storage


Distributed File System


http://hadoop.apache.org/hdfs/


Apache MapReduce


Framework


Framework for parallel processing


http://hadoop.apache.org/mapreduce


Apache Hbase


Storage


Column oriented database, real-time querying


http://hbase.apache.org/


Apache Hive


Analytics


High-latency data warehousing analytics


http://hive.apache.org/


Apache Pig


Analytics


High level Hadoop programming language


http://pig.apache.org/


Apache Mahout


Analytics


Machine learning for clustering, classification, recommendation, and itemset mining


http://mahout.apache.org/


Apache Zookeeper


Management


Configuration information, naming, providing distributed synchronization, and providing group services.


http://hadoop.apache.org/zookeeper/


Ganglia


Monitoring


Scalable distributed monitoring system for high-performance computing systems


http://ganglia.sourceforge.net/


Nagios


Monitoring


Monitors applications, services, and business processes


http://www.nagios.org/about/


Apache Hadoop Streaming


Analytics


Create and run MapReduce jobs with any executable or script as the mapper and/or the reducer.


http://hadoop.apache.org/common/docs/r0.15.2/streaming.html


Cascading


Storage


Java Query API, Query Planner, and Process Scheduler for Hadoop


http://www.cascading.org/


HadoopDB


Development Environment


Hybrid DBMS and MapReduce technology


http://hadoopdb.sourceforge.net/guide/


Karmasphere


User interface


Development environment


http://www.karmasphere.com/Products-Information/karmasphere-studio.html


HUE


Deployment


Web UI for Hadoop


http://www.cloudera.com/blog/2010/07/whats-new-in-cdh3b2-hue/


Puppet


Configuration


Deployment and configuration management


http://docs.puppetlabs.com/guides/introduction.html


Chef


Management


Configuration management


http://wiki.opscode.com/display/chef/Home


Flume


Data import


Load data into HDFS from a variety of sources


http://www.cloudera.com/blog/2010/07/whats-new-in-cdh3b2-flume/


HOP


Realtime processing


Online aggregation (approximate answers as a job runs), and stream processing (MapReduce jobs that run continuously, processing new data as it arrives)


http://code.google.com/p/hop/


sqoop


Database integration


A database import/export tool for Hadoop


https://github.com/cloudera/sqoop


Ora-Oop


Database integration


Connector between Oracle and Apache Hadoop


http://www.quest.com/Ora-Oop/


 

Case#1:If two interfaces have the two are more same methods, **and then** only one method implementation is enough from both interfaces.

`interface Left { public void m1(); }

interface Right{public void m1();}

class Central implement Left, Right
{
public static void main(String arg[])

{
public void m1(){ }
}
}`

Case#2:The interface having same method name but different arguments. `Interface Inter

{

public void m1();

public void m1(int x);

}`

Case#3:Same method name, same arguments but different written types. `Interface Left{public void m1();}

Interface Right{public int m1();}

class Central implement Left, Right

{

public static void main(String arg[])

{

public void m1() {}// error

public int m1(){}// error

}

}
`
In the above class same method signature m1 is not allow .violation leads to compile time error.

Exceptional case: We can’t provide implementation at a time for two or more interfaces having methods with same signature but different return **type.**

Variable Naming conflicts: `interface Left{int x=10;}

interface Right{int x=100;}

class Central implement Left, Right

{
public static void Main(String arg[])

{

System.out.println(x); // reference to x is ambiguous both variables
System.out.println(Right.x);

System.out.println(Left.x);

}

}`

we can resolve variable naming conflicts using interface name.(i.e instead of x we have to specify left.x or right.x).

  • One of my friend wanted the answers so posted this content