The Top 25 Jakarta Mail Interview Questions To Prepare For

//setup Mail SessionProperties props = new Properties();props.put("mail.smtp.host", "smtp.gmail.com"); //authenticateSession session = Session.getInstance(props, new Authenticator(){...});//construct messageMimeMessage message = new MimeMessage(session);message.setFrom("[email protected]");message.addRecipient(Message.RecipientType.TO, new InternetAddress("[email protected]"));//send Transport.send(message);

Toptal sourced essential questions that the best Java developers and engineers can answer. Driven from our community, we encourage experts to submit questions and offer feedback.

Describe and compare fail-fast and fail-safe iterators. Give examples.

What makes fail-fast and fail-safe iterators different is whether the collection can be changed while it is being iterated. Fail-safe iterators allow this; fail-fast iterators do not.

• Fail-fast iterators operate directly on the collection itself. Fault-fast iterators stop iterating as soon as they notice that the collection has been changed (i.e. e. , if it finds that a member has been added, changed, or removed, it will raise a ConcurrentModificationException. Some examples include ArrayList, HashSet, and HashMap (most JDK1. 4 collections are implemented to be fail-fast).
• Because fail-safe iterates work on a copy of the collection, they don’t throw an error if the collection changes during the iteration. Examples would include iterators returned by ConcurrentHashMap or CopyOnWriteArrayList.

2 .

ArrayList, LinkedList, and Vector are all implementations of the List interface. Which one works best for adding and removing items from the list? Explain your answer, including any other options you may know of.

Of the three, LinkedList is generally going to give you the best performance. Here’s why:

ArrayList and Vector each use an array to store the elements of the list. 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. Vector is synchronized, so if a thread-safe implementation is not needed, it is recommended to use ArrayList rather than Vector.

LinkedList, on the other hand, is implemented using a doubly linked list. As a result, an inserting or removing an element only requires updating the links that immediately precede and follow the element being inserted or removed.

However, it is worth noting that if performance is that critical, it’s better to just use an array and manage it yourself, or use one of the high performance 3rd party packages such as Trove or HPPC. 3 .

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?.

In Java, Strings are immutable and 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. Therefore, even after you’re done processing the string value (e.g., the password), it remains available in memory for an indeterminate period of time thereafter (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.

If you store the value in a mutable object, like a character array, you can be sure that it will not be kept in memory after you set it to “blank.”

Apply to Join Toptals Development Network

and enjoy reliable, steady, remote Freelance Java Developer Jobs

What is the ThreadLocal class? How and why would you use it?

A single ThreadLocal instance can store different values for each thread independently. Each thread that accesses the get() or set() method of a ThreadLocal instance is accessing its own, independently initialized copy of the variable. ThreadLocal instances are typically private static fields in classes that wish to associate state with a thread (e.g., a user ID or transaction ID). The example below, from the ThreadLocal Javadoc, generates unique identifiers local to each thread. A thread’s id is assigned the first time it invokes ThreadId.get() and remains unchanged on subsequent calls.

As long as the thread is alive and the ThreadLocal instance can be reached, each thread has an implicit reference to its copy of a thread-local variable. When a thread ends, all of its copies of thread-local instances are collected, unless there are other references to these copies. 5 .

What is the volatile keyword? How and why would you use it?

In Java, each thread has its own stack, including its own copy of variables it can access. When the thread is created, it copies the value of all accessible variables into its own stack. The volatile keyword basically says to the JVM “Warning, this variable may be modified in another Thread”.

In all versions of Java, the volatile keyword guarantees global ordering on reads and writes to a variable. In other words, every thread that accesses a volatile field will read the variable’s current value instead of (possibly) using a value that has been cached.

In Java 5 or later, volatile reads and writes establish a happens-before relationship, much like acquiring and releasing a mutex.

Using volatile may be faster than a lock, but it will not work in some situations. The range of situations in which volatile is effective was expanded in Java 5; in particular, double-checked locking now works correctly.

Since 64-bit types like long and double are written in two operations, the volatile keyword can also be used for them. Without the volatile keyword you risk stale or invalid values.

One common example for using volatile is for a flag to terminate a thread. If you start a thread and want to be able to safely stop it from another thread, you can tell the thread to check a flag every so often. e. , to stop it, set the flag to true). When you make the flag volatile, the thread that checks its value will know that it has been set to true without the need for a synchronized block. For example:

Compare the sleep() and wait() methods in Java, including when and why you would use one vs. the other.

As you can see, sleep() is a blocking operation that locks and monitors the shared object for a certain amount of time.

Wait(), on the other hand, stops the thread until (a) the number of milliseconds you specify has elapsed or (b) it receives a desired notification from another thread, whichever comes first. It does not hold on to the shared object’s monitor or lock.

sleep() is most commonly used for polling, or to check for certain results, at a regular interval. In multithreaded programs, wait() is often used with notify() or notifyAll() to keep all threads in sync and avoid race conditions. 7 .

Tail recursion is functionally equivalent to iteration. Since Java doesn’t have tail call optimization yet, explain how to turn a simple tail recursive function into a loop and why one is usually better than the other.

Here is an example of a typical recursive function, computing the arithmetic series 1, 2, 3…N. Notice how the addition is performed after the function call. For each recursive step, we add another frame to the stack.

When the recursive call is at the end of its surrounding context, this is called “tail recursion.” This means that after the function calls itself, it doesn’t do any more work. That is, once the base case is complete, the solution is apparent. For example:

Here, you can see that a is the accumulator; we don’t compute the sum on the way down the stack, but on the way up. This means that the return trip isn’t needed because a doesn’t store any more information or do any more calculations. Once we hit the base case, the work is done – below is that same function, “unrolled”.

Many functional languages natively support tail call optimization, however the JVM does not. We need to be aware of this limitation so that we don’t get StackOverflowErrors when we try to use recursive functions in Java. In Java, iteration is almost universally preferred to recursion. 8 .

How can you swap the values of two numeric variables without using any other variables?

You can swap two values a and b without using any other variables as follows:

How can you catch an exception thrown by another thread in Java?

This can be done using Thread.UncaughtExceptionHandler.

Here’s a simple example:

What is the Java Classloader? List and explain the purpose of the three types of class loaders.

The Java Classloader is the part of the Java runtime environment that loads classes on demand (lazy loading) into the JVM (Java Virtual Machine). Classes may be loaded from the local file system, a remote file system, or even the web.

When the JVM is started, three class loaders are used: 1. Bootstrap Classloader: Loads core java API file rt. jar from folder. 2. Extension Classloader: Loads jar files from folder. 3. System/Application Classloader: Loads jar files from path specified in the CLASSPATH environment variable. 11 .

If a try block doesn’t have a catch block, is the finally block run when an exception is thrown from the try block? If so, when?

A finally block is executed even if an exception is thrown or propagated to the calling code block.

Example:

Output can vary, being either:

When designing an abstract class, why should you avoid calling abstract methods inside its constructor?

This is a problem of initialization order. There is no way to make the subclass constructor run before the parent class. It won’t have had a chance to run yet. Consider the following example class:

This looks like a good start for an abstract Widget: it lets subclasses set the width and height and saves their factory values. However, look when you spec out a typical subclass implementation like so:

Now we’ve introduced a subtle bug: Widget. cachedWidth and Widget. cachedHeight will always be zero for SquareWidget instances! This is because the this. size = size assignment occurs after the Widget constructor runs.

Calling abstract methods in the constructors of your abstract classes is not a good idea because it limits how those methods can be used. 13 .

What variance is imposed on generic type parameters? How much control does Java give you over this?

Java’s generic type parameters are invariant. This means for any distinct types A and B, G is not a subtype or supertype of G. As a real world example, List is not a supertype or subtype of List. So even though String extends (i.e. is a subtype of) Object, both of the following assignments will fail to compile:

Java does give you some control over this in the form of use-site variance. On individual methods, we can use ? extends Type to create a covariant parameter. Here’s an example:

Even though longs is a List and not List, it can be passed to sum.

Similarly, ? super Type lets a method parameter be contravariant. Consider a function with a callback parameter:

Callback can be a subtype of forEachNumber. This means that any callback that works with a Number supertype will do:

Keep in mind, though, that trying to give a callback that only works with Long (a subtype of Number) will fail, as it should:

Use-site variance should be used liberally to stop many of the unsafe casts that happen in Java code. This is especially important when designing interfaces that will be used by many developers. 14 .

What are static initializers and when would you use them?

A static initializer lets you run code while a class is being loaded for the first time. It guarantees that this code will only run once and will be finished before your class can be used in any way.

They can be used to set up complex static objects or to register a type with a static registry, which is what JDBC drivers do.

Suppose you want to create a static, immutable Map containing some feature flags. Java doesn’t have a good one-liner for initializing maps, so you can use static initializers instead:

You can declare a static field and immediately initialize it more than once in the same class, since multiple static initializers are allowed. 15 .

If one needs a Set, how do you choose between HashSet vs. TreeSet?

At first glance, HashSet is superior in almost every way: O(1) add, remove and contains, vs. O(log(N)) for TreeSet.

But TreeSet is necessary if you want to keep the inserted elements in order or search for a range of elements in the set.

Consider a Set of timestamped Event objects. They could be stored in a HashSet, with equals and hashCode based on that timestamp. This is a good way to store things and lets you look up events by a specific timestamp. But how would you get a list of all the events that happened on a certain day? That would take O(n) traversals of the HashSet, but it only takes O(log(n)) operations with TreeSet and the tailSet method:

TreeSet lets us pass in our own Comparator if Event is a class that we can’t extend or that doesn’t implement Comparable:

In general, TreeSet is a good choice when order matters and the extra cost of writes is less than the extra cost of reading. 16 .

What are method references, and how are they useful?

Since Java 8, method references have been around and let constructors and methods (static or not) be used as lambdas. They allow one to discard the boilerplate of a lambda when the method reference matches an expected signature.

For example, suppose we have a service that must be stopped by a shutdown hook. Before Java 8, we would have code like this:

With lambdas, this can be cut down considerably:

However, stop matches the signature of Runnable. run has a void return type and no parameters, so we can add a method reference to the SomeBusyService instance’s stop method:

This is terse (as opposed to verbose code) and clearly communicates what is going on.

Also, method references don’t have to be tied to a specific instance. They can be used with any object, which is helpful for Stream operations. Let us say we have a Person class and we only want the lowercase names of a group of people:

You can also put a complex lambda inside a static or instance method and then use a method reference to call it. This makes the code more reusable and testable than if it were “trapped” in the lambda.

So we can see that method references are mainly used to improve code organization, clarity and terseness. 17 .

How are Java enums more powerful than integer constants? How can this capability be used?

Enums are essentially final classes with a fixed number of instances. They can implement interfaces but cannot extend another class.

This flexibility is useful in implementing the strategy pattern, for example, when the number of strategies is fixed. Consider an address book that records multiple methods of contact. We can write these methods as an enum and add fields, like the filename of the icon that will be shown in the UI, and any behavior that goes with them, like how to contact someone using that method:

We can dispense with switch statements entirely by simply using instances of ContactMethod:

This is just the beginning of what can be done with enums. Because enums are safe and flexible, they should usually be used instead of integer constants. Also, if you use abstract methods a lot, you can get rid of switch statements. 18 .

What does it mean for one collection to “back up” another? Name a time when this property comes in handy.

If a collection backs another, it means that changes in one are reflected in the other and vice-versa.

For example, suppose we wanted to create a whitelist function that removes invalid keys from a Map. This is made far easier with Map. keySet, which returns a set of keys that is backed by the original map. When we remove keys from the key set, they are also removed from the backing map:

retainAll writes to the backing map and makes it easy to do things that would normally require going through the entries in the input map, checking them against allowedKey, etc.

Note that you should look at the documentation of the backing collection to find out which changes will work when writing through. In the example above, map. keySet(). add(value) would fail, because we cannot add a key to the backing map without a value. 19 .

What is reflection? Give an example of functionality that can only be implemented using reflection.

Reflection allows programmatic access to information about a Java program’s types. Information that is often used includes the classes’ methods and fields, the interfaces that the classes implement, and the runtime annotations that are stored on the classes, fields, and methods.

Examples given are likely to include:

• A lot of the time, annotation-based serialization libraries use class fields to map to JSON keys or XML elements. These libraries need reflection to look at those fields and their comments, as well as to get to the values while the library is being serialized.
• Model-View-Controller frameworks call controller methods based on routing rules. These frameworks need to reflect to find a method that matches an action name and make sure that its signature matches what the framework wants (e.g. g. finally, call the method (it takes a Request object and returns a Response).
• Dependency injection frameworks lean heavily on reflection. Injecting random beans is one of the things they do with it. They also check fields for annotations like @Inject to see if they need to inject a bean and set those values.
• Object-relational mappers, like Hibernate, use reflection to connect database columns to fields or getter/setter pairs of a class. They can even read class and getter names to figure out the names of the table and column.

A concrete code example could be something simple, like copying an object’s fields into a map:

You can use these kinds of tricks to find bugs or make useful methods, like a toString method that works on any class.

Most of the time, reflection is only used to build generic libraries. It is not often used directly, but it is well to have. Knowledge of reflection is also useful for when these mechanisms fail.

But you should usually stay away from reflection unless you have to, because it can turn simple compiler errors into runtime errors. 20 .

Nested classes can be static or non-static (also called an inner class). How do you decide which to use? Does it matter?.

The main difference is that inner classes can use all of the fields and methods of the class that they are inside. This can be helpful for event handlers, but there is a catch: each instance of an inner class needs and keeps a reference to the class that it is inside.

With this cost in mind, there are many situations where we should prefer static nested classes. When instances of the nested class will live longer than instances of the parent class, the nested class should be static to stop memory leaks. Consider this implementation of the factory pattern:

At first glance, this design seems good. The WidgetParserFactory hides the parser’s implementation details with the WidgetParserImpl class that sits inside it. However, WidgetParserImpl is not static. If WidgetParserFactory is thrown away right after the WidgetParser is created, the factory and all the references it holds will leak.

This class WidgetParserImpl should not change, and any internals of WidgetParserFactory should be passed to its constructor if it needs to use them. This also makes it easier to extract WidgetParserImpl into a separate class should it outgrow its enclosing class.

It’s also harder to use reflection to build inner classes because they have a “hidden” reference to the class that encloses them. This reference can get sucked in during reflection-based serialization, which is probably not what was meant.

It’s clear that choosing whether to make a nested class static or not is important. It’s best to make nested classes static when instances will “escape” the enclosing class or when reflection is used on those nested classes. 21 .

What’s the difference between String s = “Test” and String s = new String(“Test”)? Which is better, and why?

In general, String s = "Test" is more efficient to use than String s = new String("Test").

If you give String s the value “Test,” a String with that value will be added to the String pool. If another String with the same value is then created (e. g. , String s2 = “Test”), it will reference this same object in the String pool.

If you use String s = new String(“Test”), you will not only create a String in the String pool with the value “Test”, but that String object will also be passed to the String Object’s constructor (i.e. e. , new String(“Test”)) and will create another String object (not in the String pool) with that value. Each such call will therefore create an additional String object (e. g. String s2 = new String(“Test”) would make a new String object instead of using the same String object from the String pool.

There is more to interviewing than tricky technical questions, so these are intended merely as a guide. Not every good candidate for the job will be able to answer all of them, and answering all of them doesn’t mean they are a good candidate. At the end of the day, hiring remains an art, a science — and a lot of work.

Tired of interviewing candidates? Not sure what to ask to get you a top hire?

Let Toptal find the best people for you.

Our Exclusive Network of Java Developers

Looking to land a job as a Java Developer?

Let Toptal find the right job for you.

Job Opportunities From Our Network

Submit an interview question

Questions and answers sent in will be looked over and edited by Toptal, LLC, and may or may not be posted, at their sole discretion.

Ultimate Guide to Royal Mail Interview Questions and Answers

FAQ

What is the protocol of Jakarta Mail?

What is the use of Jakarta Mail API?

Is Jakarta mail free?

What type of interview is held by EY (Jakarta)?

The interview type held by EY was HR group interview which you are being interviewed together with several applicants (3-6). You are subjected to answer all questions given alternately between participants. I applied through a recruiter. I interviewed at EY (Jakarta)

What is the latest release of Jakarta Mail?

Note: The latest release of Jakarta Mail at the time of the most recent article update is 2.0.1. The Jakarta Mail API has a wide range of classes and interfaces that can be used for sending, reading, and performing other actions with email messages—just like in a typical mailing system.

What’s new in Jakarta Mail specification?

The 2.1.0 release breaks the tight integration between Jakarta Mail Specification API and the implementation and provides standalone API jar file only. The implementation itself, formerly JakartaMail, is now standalone project – Eclipse Angus . This version of the specification is included in the Jakarta EE 10 Platform.

What packages are used in the Jakarta Mail project?

Although there are several packages in the Jakarta Mail Project, two of the most frequently used ones are javax.mail and javax.mail.internet. The javax.mail package provides classes that model a mail system and the javax.mail.internet package provides classes that are focused on Internet mail systems.