\n
\nQ:<\/b> ArrayList<\/code>, LinkedList<\/code>, and Vector<\/code> are all implementations of the List<\/code> interface. \nWhich of them is most efficient for adding and removing elements from the list? \n<\/label> \n<\/p>\n
\nOf the three, LinkedList<\/code><\/a> is generally going to give you the best performance.  Here\u2019s why:<\/p>\n
ArrayList<\/code><\/a> and
\n\t\tVector<\/code><\/a> each use an array to store the elements of the list.
\n\t\t As a result, when an element is inserted into (or removed from) the middle of the list, the elements that follow must all be shifted accordingly.
\n\t\t Vector<\/code> is synchronized, so if a thread-safe implementation is
\n\t\tnot<\/em> needed, it is recommended to use ArrayList<\/code> rather than Vector.<\/p>\n<\/p><\/div>\n<\/div>\n
\n
\nQ:<\/b> Why would it be more secure to store sensitive data (such as a password, social security number, etc.) in a character array rather than in a String?
\n<\/label>
\n<\/p>\n\nIn Java, Strings are immutable<\/a>
\n\t\tand are stored in the String pool.  What this means is that, once a String is created, it stays in the pool in memory until being garbage collected.
\n\t\tTherefore, even after you\u2019re done processing the string value (e.g., the password), it remains available in memory for an indeterminate period of time thereafter
\n\t\t(again, until being garbage collected) which you have no real control over.  Therefore, anyone having access to a memory dump can potentially extract the sensitive data and exploit it.<\/p>\n<\/p><\/div>\n<\/div>\n
\n
\nQ:<\/b> What is the ThreadLocal<\/code> class? How and why would you use it?
\n<\/label>
\n<\/p>\n\nA single ThreadLocal<\/code><\/a>
\n\t\tinstance can store different values for each thread independently.  Each thread that accesses the get()<\/code> or set()<\/code> method of a
\n\t\tThreadLocal<\/code> instance is accessing its own, independently initialized copy of the variable.  ThreadLocal<\/code> i
\n\t\tnstances are typically private static fields in classes that wish to associate state with a thread (e.g., a user ID or transaction ID).
\n\t\tThe example below, from the ThreadLocal<\/code> Javadoc<\/a>,
\n\t\tgenerates unique identifiers local to each thread. A thread\u2019s id is assigned the first time it invokes ThreadId.get()<\/code> and remains unchanged on subsequent calls.<\/p>\n
public class ThreadId {\r\n\t\t\t\/\/ Next thread ID to be assigned\r\n\t\t\tprivate static final AtomicInteger nextId = new AtomicInteger(0);\r\n\t\t\t\t\/\/ Thread local variable containing each thread's ID\r\n\t\t\tprivate static final ThreadLocal<Integer> threadId =\r\n\t\t\t\tnew ThreadLocal<Integer>() {\r\n\t\t\t\t\t@Override protected Integer initialValue() {\r\n\t\t\t\t\t\treturn nextId.getAndIncrement();\r\n\t\t\t\t}\r\n\t\t\t};\r\n\r\n\t\t\t\/\/ Returns the current thread's unique ID, assigning it if necessary\r\n\t\t\tpublic static int get() {\r\n\t\t\t\treturn threadId.get();\r\n\t\t\t}\r\n\t\t}\r\n\t\t<\/code><\/pre>\n<\/p><\/div>\n<\/div>\n\n
\nQ:<\/b> What is the volatile<\/code> keyword? How and why would you use it?
\n<\/label>
\n<\/p>\n\nIn Java, each thread has its own stack, including its own copy of variables it can access.
\n\tWhen the thread is created, it copies the value of all accessible variables into its own stack.  The volatile<\/code>
\n\tkeyword basically says to the JVM \u201cWarning, this variable may be modified in another Thread\u201d.<\/p>\n
In all versions of Java, the volatile<\/code> keyword guarantees global ordering on reads and writes
\n\tto a variable.  This implies that every thread accessing a volatile field will read the variable\u2019s current value instead of (potentially) using a cached value.<\/p>\nIn Java 5 or later, volatile<\/code> reads and writes establish a happens-before<\/a>
\n\trelationship, much like acquiring and releasing a mutex.<\/p>\n
Using volatile<\/code> may be faster than a lock, but
\n\tit will not work in some situations.  The range of situations in which volatile is
\n\teffective was expanded in Java 5; in particular, double-checked locking<\/a> now works correctly.<\/p>\n
One common example for using volatile<\/code> is for a flag to terminate a thread.  If you\u2019ve started a thread, and you want to be able to safely interrupt it from a different thread, you can have the thread periodically check a flag (i.e., to stop it, set the flag to true<\/code>).  By making the flag volatile, you can ensure that the thread that is checking its value will see that it has been set to true<\/code> without even having to use a synchronized block.  For example:<\/p>\n
\n
public class Foo extends Thread {\r\n\t\tprivate volatile boolean close = false;\r\n\t\tpublic void run() {\r\n\t\t\twhile(!close) {\r\n\t\t\t\t\/\/ do work\r\n\t\t\t}\r\n\t\t}\r\n\t\tpublic void close() {\r\n\t\t\tclose = true;\r\n\t\t\t\/\/ interrupt here if needed\r\n\t\t}\r\n\t}\r\n\t<\/code><\/pre>\n<\/p><\/div>\n<\/div>\n\n
\nQ:<\/b> Compare the sleep()<\/code> and wait()<\/code> methods in Java, including when and why you would use one vs. the other.
\n<\/label>
\n<\/p>\n\nsleep()<\/code> is a blocking operation that keeps a hold on the monitor \/ lock of the shared object for the specified number of milliseconds.<\/p>\n
wait()<\/code>, on the other hand, simply pauses<\/em> the thread until either<\/em> (a) the specified number of milliseconds have elapsed or<\/em>
\n\t\t(b) it receives a desired notification from another thread (whichever is first), without<\/em> keeping a hold on the monitor\/lock of the shared object.<\/p>\n
sleep()<\/code> is most commonly used for polling, or to check for certain results, at a regular interval.  wait()<\/code> is generally used in
\n\t\tmultithreaded applications, in conjunction with notify()<\/code> \/ notifyAll()<\/code>, to achieve synchronization and avoid race conditions.<\/p>\n<\/p><\/div>\n<\/div>\n\n
\nQ:<\/b> Tail recursion is functionally equivalent to iteration. Since Java does not yet support tail call optimization,
\ndescribe how to transform a simple tail recursive function into a loop and why one is typically preferred over the other
\n<\/label>
\n<\/p>\n\nHere is an example of a typical recursive function, computing the arithmetic series 1, 2, 3\u2026N. Notice how the addition is performed after
\n\tthe function call. For each recursive step, we add another frame to the stack.<\/p>\npublic int sumFromOneToN(int n) {\r\n\t  if (n < 1) {\r\n\t\treturn n;\r\n\t  }\r\n\r\n\t  return n + sumFromOneToN(n - 1);\r\n\t}\r\n\t<\/code><\/pre>\nTail recursion occurs when the recursive call is in the tail position within its enclosing context –
\n\tafter the function calls itself, it performs no additional work. That is, once the base case is complete,
\n\tthe solution is apparent. For example:<\/p>\npublic int sumFromOneToN(int n, int a) {\r\n\t  if (n < 1) {\r\n\t\treturn a;\r\n\t  }\r\n\r\n\t  return sumFromOneToN(n - 1, a + n);\r\n\t}\r\n\t<\/code><\/pre>\nHere you can see that a<\/code> plays the role of the accumulator – instead of computing the sum on
\n\tthe way down the stack, we compute it on the way up, effectively making the return trip unnecessary,
\n\tsince it stores no additional state and performs no further computation. Once we hit the base case, the work is done – below is that same function, \u201cunrolled\u201d.<\/p>\npublic int sumFromOneToN(int n) {\r\n\t  int a = 0;\r\n\r\n\t  while(n > 0) {\r\n\t\ta += n--;\r\n\t  }\r\n\t  \r\n\t  return a;\r\n\t}\r\n\t<\/code><\/pre>\nMany functional languages natively support tail call optimization, however the JVM does not. In order
\n\tto implement recursive functions in Java, we need to be aware of this limitation to avoid
\n\tStackOverflowError<\/code>s. In Java, iteration is almost universally preferred to recursion.<\/p>\n<\/p><\/div>\n<\/div>\n\n
\nQ:<\/b> How can you catch an exception thrown by another thread in Java?
\n<\/label>
\n<\/p>\n\nThis can be done using Thread.UncaughtExceptionHandler<\/a>.<\/p>\n
Here\u2019s a simple example:<\/p>\n
\/\/ create our uncaught exception handler\r\n\tThread.UncaughtExceptionHandler handler = new Thread.UncaughtExceptionHandler() {\r\n\t\tpublic void uncaughtException(Thread th, Throwable ex) {\r\n\t\t\tSystem.out.println(\"Uncaught exception: \" + ex);\r\n\t\t}\r\n\t};\r\n\r\n\t\/\/ create another thread\r\n\tThread otherThread = new Thread() {\r\n\t\tpublic void run() {\r\n\t\t\tSystem.out.println(\"Sleeping ...\");\r\n\t\t\ttry {\r\n\t\t\t\tThread.sleep(1000);\r\n\t\t\t} catch (InterruptedException e) {\r\n\t\t\t\tSystem.out.println(\"Interrupted.\");\r\n\t\t\t}\r\n\t\t\tSystem.out.println(\"Throwing exception ...\");\r\n\t\t\tthrow new RuntimeException();\r\n\t\t}\r\n\t};\r\n\r\n\t\/\/ set our uncaught exception handler as the one to be used when the new thread\r\n\t\/\/ throws an uncaught exception\r\n\totherThread.setUncaughtExceptionHandler(handler);\r\n\r\n\t\/\/ start the other thread - our uncaught exception handler will be invoked when\r\n\t\/\/ the other thread throws an uncaught exception\r\n\totherThread.start();\r\n\t<\/code><\/pre>\n<\/p><\/div>\n<\/div>\n<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"The Toptal Engineering Blog has published a great post called “ 8 Essential Java Interview Questions” on there you can submit your Java interview questions, answers and hire freelancers, and they were happy to share with us these questions. If you would like to like them on Facebook click on the link Toptal on Facebook […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[11,7],"tags":[],"jetpack_featured_media_url":"","_links":{"self":[{"href":"https:\/\/smartvania.com\/wp-json\/wp\/v2\/posts\/590"}],"collection":[{"href":"https:\/\/smartvania.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/smartvania.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/smartvania.com\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/smartvania.com\/wp-json\/wp\/v2\/comments?post=590"}],"version-history":[{"count":11,"href":"https:\/\/smartvania.com\/wp-json\/wp\/v2\/posts\/590\/revisions"}],"predecessor-version":[{"id":638,"href":"https:\/\/smartvania.com\/wp-json\/wp\/v2\/posts\/590\/revisions\/638"}],"wp:attachment":[{"href":"https:\/\/smartvania.com\/wp-json\/wp\/v2\/media?parent=590"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/smartvania.com\/wp-json\/wp\/v2\/categories?post=590"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/smartvania.com\/wp-json\/wp\/v2\/tags?post=590"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}