Java exceptions: Common terminology with examples [2019 guide]

The Java programming language comes with advanced exception handling features that help programmers manage exceptional events. In Java, exceptions are either thrown by the compiler or occur during the execution of the program. Exceptions stop the normal flow of the program, so you need to handle them appropriately.

The Java programming language comes with advanced exception handling features that help programmers manage exceptional events. In Java, exceptions are either thrown by the compiler or occur during the execution of the program. Exceptions stop the normal flow of the program, so you need to handle them appropriately.

In this article, we’ll have a look at all the terms and examples you need to know about Java exceptions in 2018.

What are Java exceptions?

Java exceptions are events that disrupt the normal execution of the program. The main goal of exceptions is to separate error-handling from regular code. Exceptions might stem from a wide range of problems such as missing resources, coding errors, memory errors, and others. In Java, there are two kinds of exceptions:

  1. Unchecked exceptions (runtime exceptions)
  2. Checked exceptions (compile-time exceptions)

1. Unchecked exceptions

Unchecked exceptions are issues that occur at runtime. They are also called uncaught or runtime exceptions. As unchecked exceptions aren’t checked at compile time, you aren’t required to specify or handle the exception (although you can if you want). They are usually the results of bad coding practices or logical errors such as data errors, invalid arguments, or missing resources.

Basic arithmetic errors such as divide by zero are the easiest example of unchecked exceptions. For instance, here’s a code example that throws [ArithmeticException](https://docs.oracle.com/javase/9/docs/api/java/lang/ArithmeticException.html "ArithmeticException") at runtime:

public class ArithmeticException {

	public static void main(String[] args) {

	    int a = 0;
	    int b = 100;
	    int c = b/a;

	    System.out.println("Result: " + c);
	}

}

Of course, divide by zero is an operation that’s impossible to execute. The console output is:

Exception in thread "main" java.lang.ArithmeticException: / by zero
at arithmetic.ArithmeticException.main(ArithmeticException.java:9)

Wanting to access non-existent data is another typical example of unchecked exceptions. Say, you have an array of six elements and try to print out the item at index 10:

public class InvalidArrayIndex {

	public static void main(String[] args) {
		int myArray[] = {0, 1, 2, 3, 4, 5};

		System.out.println(myArray[10]);

	}

}

As there’s nothing at index 10, the above code example throws [ArrayIndexOutOfBoundsException](https://docs.oracle.com/javase/9/docs/api/java/lang/ArrayIndexOutOfBoundsException.html "ArrayIndexOutOfBoundsException"):

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 10
	at invalidarrayindex.InvalidArrayIndex.main(InvalidArrayIndex.java:8)

There are more complicated examples of unchecked exceptions as well. The most frequent unchecked exception is called [NullPointerException](https://docs.oracle.com/javase/9/docs/api/java/lang/NullPointerException.html "NullPointerException"). It’s also among the top 4 Java exceptionsRaygun users encounter. NullPointerException happens when your app tries to use null where an object is required. This can be caused by different reasons such as accessing an uninitialized variable or calling the instance method of a null object.

2. Checked exceptions

Checked exceptions are also called compile-time exceptions, as they arise at compile time. Java code containing any checked exceptions won’t compile. When you try to run such code, the compiler warns you about the presence of the checked exception. If you still choose to compile the code you’ll encounter the “unresolved compilation problems” message.

[IOException](https://docs.oracle.com/javase/9/docs/api/java/io/IOException.html "IOException") is one of the most common checked exceptions in Java. It’s caused by different input-output problems such as invalid file access or networking errors.

Here’s an example. The following code intends to access a non-existent file, then write something into it:

import java.io.FileWriter;

public class FileNotFound {

   public static void main(String args[]) {		
      FileWriter myWriter = new FileWriter("C://filenotfound.txt");

      myWriter.write("Hi, I'm trying to write something.");
      myWriter.close();
   }
}

Needless to say, it’s not possible to write anything into a file that doesn’t exist. My Eclipse IDE informs me about the presence of IOException and asks if I still want to compile the code.

Remember that the compiler had no complaints in the case of unchecked exceptions, as they will be thrown only at runtime.

If I proceed with the unhandled exception the compiler returns the following error message:

Exception in thread "main" java.lang.Error: Unresolved compilation problems:
	Unhandled exception type IOException
	Unhandled exception type IOException
	Unhandled exception type IOException

	at fileNotFound.FileNotFound.main(FileNotFound.java:8)

To solve the compilation problem, the method in which the checked exception occurs needs to either handle or at least specify it. Before showing how to do that, let’s have a look at Java’s Exception class hierarchy.

3. Exception classes

Exception classes are Java classes that include all checked and unchecked exceptions. The exceptions I mentioned before such as ArithmeticException and IOException are all represented by an exception class. In fact, Java has an extensive hierarchy of parent and child classes that cover most issues that may occur during compilation or at runtime.

The classification of Java exceptions is a bit confusing, however. The [Throwable](https://docs.oracle.com/javase/9/docs/api/java/lang/Throwable.html "Throwable") class is the superclass of all Java exceptions and errors. It has two subclasses, [Error](https://docs.oracle.com/javase/9/docs/api/java/lang/Error.html "Error") and [Exception](https://docs.oracle.com/javase/9/docs/api/java/lang/Exception.html "Exception") but they don’t represent checked and unchecked exceptions. The Exception class has a subclass called [RuntimeException](https://docs.oracle.com/javase/9/docs/api/java/lang/RuntimeException.html "RuntimeException") that contains most unchecked exceptions. All other subclasses of Exceptionare handled as checked exceptions. Besides runtime exceptions, errors also count as unchecked exceptions.

So: - Subclasses of Exception except for the subclasses of RuntimeException are regarded as checked exceptions. - Subclasses of Error and RuntimeException are regarded as unchecked exceptions.

ErrorException, and RuntimeException all have several subclasses. For example, IOException is a subclass of Exception and NullPointerException is a subclass of RuntimeException.

You may have noticed that Java differentiates errors from exceptions.

Why is that so?

In Java, errors indicate abnormal conditions such as stack overflow that applications shouldn’t try to catch. They are mostly caused by the environment, as opposed to exceptions that are caused by the program itself.

Exceptions are caught either at compile time or at runtime. Errors terminate the program for sure and they cannot be handled in any way. However, exceptions can be recovered by certain programming techniques.

4. Handling exceptions

Exception handling in Java happens with the trycatch, and finally blocks. You can use them to define how you want to handle exceptions when they occur. The try block should include the code that may or may not throw an exception. Each catch block is an exception handler that deals with an exception thrown by the try block. The finally block executes in any case, whether an exception has been thrown or not.

You can include as many catch blocks as you want. However, you can add only one finally to each try block. Programmers usually use finally blocks to do the cleanup after the try and catch blocks have been executed.

Here’s the general syntax of Java’s exception handling:

try {

   // Code that might throw exceptions.

} catch (Exception e1) {


   // Catch block 1. Executes if try block throws e1.


} catch (Exception e2) {


   // Catch block 2. Executes if try block throws e2.


} catch (Exception e3) {


   // Catch block 3. Executes if try block throws e3.


} finally {


   // Cleanup code. Always executes.


}

Handling checked exceptions

Here’s how you can handle the IOException example we have discussed above, using a try-catchblock. We enclose the sensitive code that might throw an IOException with a try block. The catchblock only fires if the try block throws an IOException.

public class FileNotFound {

   public static void main(String args[]) {	    
FileWriter myWriter;

		try {

			myWriter = new FileWriter("C://filenotfound.txt");

			myWriter.write("Hi, I'm trying to write something.");
		    myWriter.close();

		} catch (IOException e) {

			System.out.println("Exception thrown: " + e);

		} finally {

			System.out.println("End of execution.");

		}

   }

}

Now, the console output changes from the system-generated message to the instructions we’ve given inside the catch block. The code throws [FileNotFoundException](https://docs.oracle.com/javase/9/docs/api/java/io/FileNotFoundException.html "FileNotFoundException") instead of IOException, which is a subclass of IOException and provides the closest description of the issue.

Exception thrown: java.io.FileNotFoundException: C:\filenotfound.txt (Access is denied)
End of execution.

Handling unchecked exceptions

You can also use try-catch blocks to handle an unchecked exception. Although handling unchecked exceptions is not obligatory, it’s a good idea to use a try-catch block for logging and monitoring purposes. The following example is from the Java Programming Wikibook and it demonstrates how logging an unchecked exception can be useful in servlet programming:

public long getLastModified(HttpServletRequest req) {


 try {


   ...


   return getTimeStamp();


   ...


 } catch(RuntimeException e) {


   log.error("Error during handling post request", e);


   throw e;


 }


}

The above code is called when an application server makes a request to the server. First, it catches runtime exceptions for logging purposes. Then, it throws them back to the server so that it can handle them. This way the application has its own logging system separate from the server logging and can detect all runtime exceptions on its own.

Throwing exceptions

Throwing exceptions is a specific programming technique in Java. You can only catch an exception that was thrown before, either by the Java platform or custom code. Exception throwing in Java happens with the [throw](https://docs.oracle.com/javase/tutorial/essential/exceptions/throwing.html "throw") statementArithmeticExceptionArrayIndexOutOfBoundsExceptionNullPointerException, and IOException in our examples were all thrown automatically by the Java platform.

The throw statement

The throw statement can be used with any throwable object that inherits from the Throwable class. It explicitly throws an exception from any block of code. Each throw statement inside a try block needs to be handled by a corresponding catch block.

For instance, our IOException example could also be written this way:

public class FileNotFound {

   public static void main(String args[]) {	    

	   FileWriter myWriter;

		try {

			myWriter = new FileWriter("C://filenotfound.txt");

			myWriter.write("Hi, I'm trying to write something.");
			myWriter.close();

			throw new IOException();

		} catch (IOException e) {

			System.out.println("Exception thrown: " + e);

		} finally {

			System.out.println("End of execution.");

		}

   }

}

You can add as many throw statements to a try block as you want, however, each has to have its own corresponding catch block.

Besides, catch blocks can also include their own throw statement. You could have seen that in the HttpServletRequest example before. When a catch statement throws an exception it needs to be further handled by the code calling the method. This technique is also referred to as rethrowing an exception.

The throws statement

Besides throw, Java also has a throws statement. It can be used in the signature of any method that might throw a checked exception. Say, you have a checked exception that would prevent the code from compiling but you don’t want to or can’t handle it within the current method. Using the throws keyword, you can indicate that the caller has to handle this exception with its own try-catch block.

This is how our IOException example looks like when we don’t handle it directly but delegate it to the caller method:

public class FileNotFound {

public static void main(String args[]) throws IOException {	    	    

	FileWriter myWriter;

	myWriter = new FileWriter("C://filenotfound.txt");

	myWriter.write("Hi, I'm trying to write something.");
	myWriter.close();		

}

}

As you can see, there’s no handling with a try-catch block. We just indicate the presence of the exception in the method signature so that the caller can decide how it wants to handle it.

You can add as many exceptions after the throws keyword in the method signature as you want. For example:

public static void main(String args[]) throws IOException, IllegalAccessException

Grouping exceptions

Grouping exceptions is a programming shortcut that allows you to handle multiple exceptions in a single catch block. This technique is available since Java 7. It’s a great solution when you want to run the same code on different exceptions. As you don’t have to handle each exception in a separate catch clause, you will have a much cleaner code base.

For example, you can handle IOException and IllegalAccessException in the same catch block:

catch (IOException | IllegalAccessException e) {

System.out.println("Exception thrown: " + e);

}

There’s one important rule, however. You can only group exceptions that are unrelated to each other. It’s not allowed to group exceptions that have a parent-child relationship. For example, the following code won’t compile, as FileNotFoundException is a subclass of IOException:

catch (IOException | FileNotFoundException e) {

System.out.println("Exception thrown: " + e);

}

The compiler returns an “unresolved compilation problem” message:

Exception in thread "main" java.lang.Error: Unresolved compilation problem:
	The exception FileNotFoundException is already caught by the alternative IOException

	at fileNotFound.FileNotFound.main(FileNotFound.java:22)

Nesting exceptions

Exception nesting happens in Java when one exception results in a second exception which results in a third exception, etc. As you deal with a whole chain of exceptions, nested exceptions are also called chained exceptions. The stack trace of an exception contains the chain of exceptions that have lead to the final exception.

You can nest a Java exception into another one using of the catch clause. Nested exceptions can help you identify why an exception has been thrown.

For instance, this is how exception nesting works with our IOException example:

public class FileNotFound {

   public static void main(String args[]) throws Exception {	    

	   FileWriter myWriter;

	    try {

			myWriter = new FileWriter("C://filenotfound.txt");

			myWriter.write("Hi, I'm trying to write something.");
		    myWriter.close();

		} catch (IOException e1) {

			Exception e2 = new Exception("Couldn't write into a non-existent file.", e1);

			throw e2;

		}

   }

}

As you can see the catch block creates a second exception called e2 that specifies the reason of e2and refers e1 as the cause of the exception. Then, it rethrows the new exception so that the caller method can handle it (or rethrow it again).

The Exception class has five possible constructors; the above example uses the following one:

public Exception(String message, Throwable cause)

If you run the example code, the console prints the whole stack trace:Exception in thread "main" java.lang.Exception: Couldn't write into non-existent file.
	at fileNotFound.FileNotFound.main(FileNotFound.java:21)
Caused by: java.io.FileNotFoundException: C:\filenotfound.txt (Access is denied)
	at java.base/java.io.FileOutputStream.open0(Native Method)
	at java.base/java.io.FileOutputStream.open(Unknown Source)
	at java.base/java.io.FileOutputStream.<init>(Unknown Source)
	at java.base/java.io.FileOutputStream.<init>(Unknown Source)
	at java.base/java.io.FileWriter.<init>(Unknown Source)
	at fileNotFound.FileNotFound.main(FileNotFound.java:14)

The stack trace starts with the custom message we defined as the first argument of e2. This shows that the new exception has been nested properly. The e2 exception also keeps a reference to e1, its nesting exception.

Note that we added e2 to the method signature using the throws keyword. So, the code that calls the main() method will have to handle e2 with a try-catch block. This kind of exception conversion can happen as long as a caller method is willing to handle it, instead of just re-throwing it to the next caller.

Need help discovering Java exceptions?

Java exceptions can be difficult to discover in the first place. Raygun Crash Reporting surfaces the stack trace where the error occurred so you can resolve issues quickly. Target Java errors with Raygun.

Java to C# – C# to Java

Java to C# – C# to Java

In this post, we bring you a much needed Rosetta Stone — an explanatory bridge between these two technologies

Originally published by Andy Macdonald at https://medium.com
Java and C# are incredibly similar. Both languages are somewhat derived from C++ and from similar first principles.

Java was developed in 1995 to create a language with a simpler programming model than C++ while still preserving some of the same syntax of the language to facilitate developers transitioning to it.

C# was developed in 2000 by Microsoft as part of its .NET drive in order to develop a language and set of technologies that could address some of the perceived weaknesses of the C++ language. It was also developed with quite heavy “inspiration” from the Java language.

Despite the similarities between the languages and sharing some common ground, transitioning from one technology to the other for a developer well-practised in one technology can be quite tricky.

Innovation happens best when there is collaboration between people of different mindsets — yet users of C# and Java can be somewhat tribalistic.

To that end, I thought it would be useful to put together a sort of guide to help people thinking about or starting to transition between these two technologies. It would also be nice in some way to facilitate a bit more collaboration between these two worlds — hopefully to do my bit to reduce the needless gulf that exists between them.

Some of the similarities right off the bat:

Java is a language that runs in a virtual machine environment (JVM) and runs bytecode that the Java compiler generates.

For C#, the situation is similar. It is a language that runs on the .NET framework and the CLR runtime. It uses a similar intermediary language to Java bytecode called MSIL which gets run via CLR.

Naming and Conventions

Some of the key and most immediately obvious differences in nomenclature, syntax, and conventions are:

  • “Projects” (Java) — “Solutions” (C#)
  • In Java, methods use lowerCamelCase (bar.doAThing()), whilst in C# public methods use PascalCase (bar.DoAThing())
  • In C#, interfaces are always prefixed with an I, as in IUserService<T>, instead of UserService<T>** **in Java
  • In Java, a string is a String** **— in C# a string is a string
  • “POJO” (Java) — “POCO” (C#)
  • Packages (Java) — Namespaces (C#)

Package (Java)

package dev.andymacdonald;

// Code goes here

Namespace (C#)

namespace Dev.AndyMacdonald 
{
  // Code goes here
}

Syntax

**Java has <strong>final</strong> variables — C# has **<strong>readonly</strong>

A key difference here is that Java final variables can be assigned once anywhere in the class, whereas C#’s readonly variables can only be assigned in the constructor.

C# has <strong>out</strong> and <strong>ref</strong> parameters to allow passing arguments by reference — Java doesn’t

It can manipulate objects and variables by reference, but in a method, these arguments are passed by a value. With C#, we can override this behaviour with the out and ref keywords.

Annotations (Java) — attributes (C#)

These are basically equivalent concepts and just differ in actual syntax. Both annotations and attributes can be accessed via each language’s respective Reflection API implementation.

Java annotation:

@PersonallyIdentifiable
private String fullName;

C# attribute:

[PersonallyIdentifiable]
private string fullName;

Getters and setters or Project Lombok (Java) — C# properties

C# really overtakes Java here with its built-in properties* *feature. In the standard JDK, there isn’t an equivalent to this, and instead, in Java, getters and setters must be written for each field requiring an accessor.

These are often just generated by the developer with their IDE as a cheat … still a bit tedious, though.

Java getters and setters:


public class Element 
{
   
  private String symbol;   
  private String name;   
  private int atomicNumber;
  public int getAtomicNumber() 
  {
    return this.atomicNumber;
  }
  public String getSymbol() 
  {
    return this.symbol;
  }
  public String getName() 
  {
    return this.name; 
  }
  public void setAtomicNumber(int atomicNumber) 
  {
    this.atomicNumber = atomicNumber;
  }
  public void setName(String name) 
  {
    this.name = name;
  }
  public void setSymbol(String symbol) 
  {
    this.symbol = symbol;
  }
}

Many Java projects incorporate Project Lombok, which adds getters, setters, equals, and hash code (plus other useful boilerplates) at compile time.

Project Lombok — not part of the standard library:

@Getter @Setter
public class Element 
{
   
  private String symbol;   
  private String name;   
  private int atomicNumber;
}

C# built-in properties feature:

public class Element 
{

  public string Symbol { get; set; }     
  public string Name { get; set; }     
  public int AtomicNumber { get; set; }
}

Loops

Java for each loop:

List<Integer> fibNumbers = Arrays.asList(0, 1, 1, 2, 3, 5, 8, 13);
int count = 0;
for (int element: fibNumbers)
{
    count++;
    System.out.println(String.format("Element #%s: %s", count, element));
}
System.out.println(String.format("Number of elements: %s", count));

C# for each loop:

var fibNumbers = new List<int> { 0, 1, 1, 2, 3, 5, 8, 13 };
int count = 0;
foreach (int element in fibNumbers)
{
    count++;
    Console.WriteLine($"Element #{count}: {element}");
}
Console.WriteLine($"Number of elements: {count}");

Implementing interfaces/inheritance

Inheritance and implementing interfaces isn’t drastically different between the two languages. Java uses the extends or implements keywords; C# uses C++ syntax (derivation declaration) B : A for defining inheritance.

Defining and implementing an interface with methods in Java:

package dev.andymacdonald;


import java.util.ArrayList;
import java.util.List;

interface Fish
{
   void swim();
}

class Salmon implements Fish
{

   public void swim()
   {
      System.out.println("Salmon.Fish");
   }
}

class Cod implements Fish
{
   public void swim()
   {
      System.out.println("Cod.Swim");
   }
}

public class Program
{
   public static void main()
   {
      List<Fish> fishes = new ArrayList<>();
      fishes.add(new Salmon());
      fishes.add(new Cod());

      for (Fish fish : fishes)
      {
         fish.swim();
      }
   }
}

Defining and implementing an interface with methods in C#:

using System;
using System.Collections.Generic;

namespace Dev.AndyMacdonald 
{
    interface Fish
    {
        void Swim();
    }
    class Salmon : Fish
    {
        public void Swim()
        {
            Console.WriteLine("Salmon.Fish");
        }
    }
    class Cod : Fish
    {
        public void Swim()
        {
            Console.WriteLine("Cod.Swim");
        }
    }
    class Program
    {
        static void Main()
        {
            List<Fish> fishes = new List<Fish>();
            fishes.Add(new Salmon());
            fishes.Add(new Cod());
            foreach (Fish fish in fishes)
            {
                fish.Swim();
            }
        }
    }
}

Pointers

Quite simply, Java just doesn’t do pointers, whereas in C# it is possible to do pointer arithmetic and manipulation.

 unsafe {
  int a = 25;
  int * ptr = &a;
  Console.WriteLine($"Value of pointer is {*ptr}");
}

IDE

Visual Studio

C# developers traditionally and typically use the Visual Studio IDE. This is a situation borne out of the origins of .NET being a closed-source technology. Microsoft developed Visual Studio** **to be a one-stop shop for all things .NET.

Java went down a different route, offering much more developer choice in tooling from the outset. That’s why there’s a much greater range of IDEs for Java development (e.g., IntelliJ, Eclipse, NetBeans). Gradually the landscape for .NET developers has shifted, and more IDEs and developer choice has been offered over the years.

IntelliJ (Java) — Rider (C#)

Users of JetBrains IDEs will find the transition from one IDE to another very smooth if they choose to make a switch to the respective JetBrains IDE in the technology they are targeting. Keyboard shortcuts, IDE layout, and even some plugins are equivalent or comparable — virtually the same IDE.

Dependency Management

Maven (Java) — NuGet and dotnet CLI (C#)

Maven is a tool responsible for dependency management and the life cycle of the building of typically Java and JVM applications. That said, it is pretty flexible, has 1000s of plugins, and can be used to build applications of other languages, such as PHP and JavaScript.

The configurable unit of maven is a pom.xml file that every maven project has. For a project’s submodules, it is possible to have a pom file per submodule which inherits from a parent. Maven uses a remote server or repository of some kind to host and retrieve packages.

Maven pom.xml file (Java):

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>dev.andymacdonald</groupId>
    <artifactId>fish-app</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

At the simplest level, you can test and build a Maven project with the following command:

mvn clean install

And create a package with this:

mvn clean package

And finally, deploy a package like this:

mvn clean deploy

NuGet fulfills a similar, though not identical role in .NET to Maven. NuGet can use a few different configuration files but commonly uses .csproj*. *As with Maven, NuGet uses a server/repository that can host packages.

NuGet .csproj file:

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <AssemblyName>MSBuildSample</AssemblyName>
    <OutputPath>Bin\</OutputPath>
  </PropertyGroup>
  <ItemGroup>
    <Compile Include="helloworld.cs" />
  </ItemGroup>
  <ItemGroup>
    <PackageReference Include="MyDependency" version="1.0.0" />
  </ItemGroup>  
  <Target Name="Build">
    <MakeDir Directories="$(OutputPath)" Condition="!Exists('$(OutputPath)')" />
    <Csc Sources="@(Compile)" OutputAssembly="$(OutputPath)$(AssemblyName).exe" />
  </Target>
</Project>

NuGet’s primary role is package management, construction, and deployment. Java developers will notice that it doesn’t really have the same concept of build phases as Maven does. Additionally, .NET developers don’t tend to edit their build files manually as Java developers do with pom.xml files, preferring to manipulate them in their IDE instead.

Packages can be built, packaged, and deployed to NuGet with the following nuget commands:

nuget spec
nuget pack {nuspec file}
nuget push {package file} {apikey} -Source {host url}

If you want to run the tests for your .NET application, you can run the following dotnet CLI command:

dotnet test

The dotnet CLI can also be used as a wrapper around nuget commands.

Application Servers

Apache Tomcat (Java) — IIS (ASP.NET)

Tomcat is an open-source web server and servlet container from the Apache Foundation. Though there are many other application servers used widely in Java, it is a pretty common choice for most enterprise-software companies. It works across pretty much every operating system (e.g., Windows, Unix, Linux, and Mac OS).

.NET projects are typically deployed on IIS, a web server that only runs on Windows. While its portability is limited, it’s a pretty popular choice for Windows developers because of its ease of use and simplicity while still offering some advanced configuration options.

… But Wait!

For .NET Core web applications, you can package them to run as standalone web applications — allowing you to run them like this:

dotnet <app_assembly>.dll

In the same way you can run a Java Spring Boot web*** ***application (which has a self-contained Tomcat server):

java -jar <my-application>.jar

And visit your shiny new web app like this:

http://<serveraddress>:<port>

Libraries and Frameworks

Spring Framework (Java) — ASP.NET (C#)

The Spring Framework is a framework and IoC container for Java. In short, the Spring framework is responsible for instantiating objects (beans) and managing the life cycle of these beans in memory.

Create an ApplicationContext* *(similar to the concept of a Startup in ASP.NET). This example uses Spring Boot:

@SpringBootApplication
public class HumanApplication
{
   public static void main(String[] args) 
   {
      SpringApplication.run(HumanApplication.class, args);
   }
}

Create an interface:

public interface Organ<T>
{  
   void function();
}

Implement the Organ<T> interface:

@Component
public class Heart implements Organ<Heart>
{
    public Heart() {}
    public void function() 
    {
        System.out.println("Buh-dump");
    }
}

Constructor injection of Organ dependencies list into a Human service:

@Service
public class Human 
{
    private static final int MAX_SECONDS_OF_LIFE = 3000;
    private List<Organ> organs;
    public Human(List<Organ> organs) 
    {
        this.organs = organs;
    }
    @PostConstruct
    public void live() 
    {
        for (int i = 0; i < MAX_SECONDS_OF_LIFE; i++) 
        {
            organs.forEach(organ -> organ.function());
        }
    }
}

Run the application …

It’s aliiiiiiive:

Buh-dump
Buh-dump
Buh-dump
Buh-dump
...

Spring also ships with a handy suite of modules and packages.

In the core Spring packages, and in the convention-over-configuration extension to the framework, Spring Boot, useful combinations of existing and bespoke technologies are provided for developers wanting access to common libraries to kickstart a project with all that they may need, rather than having to write or track down these utilities themselves:

  • RestTemplate (spring-web — for constructing REST and HTTP requests)
  • JdbcTemplate (spring-data — for constructing JDBC queries and statements)
  • Spring Security (for creating and managing application security models)
  • ObjectMapper (spring-core — useful utility for mapping POJOs from Jackson)
  • etc.

ASP.NET fulfills a similar role in the world of C#, providing IoC functionality, commonly used technologies, and utilities in a single framework. However, ASP.NET generally only provides IoC functionality for web applications, whereas the Spring Framework provides this for any application type.

In terms of dependency inversion, it is possible to do very similar things in ASP.NET as in Spring.

As before, define the needed interface and concrete implementation:

public interface Organ<T>
{  
   void Function();
}
public class Heart : Organ<Heart>
{
    public Heart() {}
    public void Function() 
    {
        Console.WriteLine("Buh-dump");
    }
}

Invoke functions of injected dependencies:

public class Human
{

   private List<IOrgan> _organs;
 
   public Human(List<IOrgan> organs)
   {
      _organs = organs;
      this.Live();
   }
   public void Live()
   {
      organs.ForEach(organ =>
      {
         organ.Function();
      });
   }
}

Define a Startup and register services:

public class Startup  
{    
  public void ConfigureServices(IServiceCollection services)
  {    
    services.AddTransient<IList<IOrgan>>(p => p.GetServices<IOrgan>().ToList());
  }
}

ASP.NET also fulfills the role of providing many useful libraries and utilities to accelerate development of your project.

Streams (Java) — LINQ (C#)

Both Java and C# have mechanisms to simplify the reduction of data sets — Streams and LINQ.

There are some differences and gaps between the two technologies but if you have familiarity with one, you’ll be able to get up and running fairly quickly with the other.

Java Streams:

List<Student> studentList = Arrays.asList( 
    new Student(1, "John", 18, 1),
    new Student(2, "Steve", 21, 1),
);
List<String> studentNames = studentList.stream()
    .filter(s -> s.getAge() > 18)
    .filter(s -> s.getStandardID() > 0)
    .map(s -> s.getName()).collect(Collectors.toList());
studentNames.forEach(name -> System.out.println(name));

LINQ Query (C#):

IList<Student> studentList = new List<Student>() { 
    new Student() { StudentID = 1, StudentName = "John", Age = 18, StandardID = 1 } ,
    new Student() { StudentID = 2, StudentName = "Steve",  Age = 21, StandardID = 1 }
};
var studentNames = studentList.Where(s => s.Age > 18)
                        .Where(st => st.StandardID > 0)
                        .Select(s => s.StudentName);
foreach(var name in studentNames) {   
    Console.WriteLine(name);
}

Apache Commons (Java) — CommonLibrary.NET (C#)

Apache Commons*** ***provides Java developers with a collection of several independently released, useful components and utilities for the purposes of accelerating development.

If you’re in need of a utility to work with ZIP files or a set of utilities for working with mathematical expressions and formulae, then Apache Commons has you covered.

In a similar way, CommonLibrary.NET covers these bases too — there are some key differences in naming of some components and modules, but for the most part, they are pretty much equivalent in their purpose.

That said, unlike Apache Commons, CommonLibrary.NET is quite old and isn’t very commonly used in projects anymore. If you’re after a continuously updated, curated list of libraries for each respective technology, I highly recommend these two lists:

akullpp/awesome-java

quozd/awesome-dotnet

Testing Libraries

JUnit (Java) — NUnit (C#)

Java’s ever-dependable JUnit library has a direct equivalent in C#.

NUnit has almost equivalent functionality to JUnit and is a popular choice for C# developers.

JUnit:

@Test
public void complexNumberTest()
{
    ComplexNumber result = someCalculation();
    Assert.assertEquals("Real", 5.2, result.getRealPart());
    Assert.assertEquals("Imaginary" 3.9, result.getImaginaryPart());
}

NUnit:

[Test]
public void ComplexNumberTest()
{
    ComplexNumber result = SomeCalculation();
    Assert.Multiple(() =>
    {
        Assert.AreEqual(5.2, result.RealPart, "Real");
        Assert.AreEqual(3.9, result.ImaginaryPart, "Imaginary");
    });
}

(Rumour has it NUnit started life as the JUnit source code modified to run in C#.)

Mockito (Java) — Moq (C#)

As with JUnit and NUnit, comparable functionality exists between Java’s Mockito and C#’s Moq library.

Mockito:

Foo mockFoo = mock(Foo.class);
when(mockFoo.doSomething("ping")).thenReturn(true);

Moq:

var mock = new Mock<IFoo>();
mock.Setup(foo => foo.DoSomething("ping")).Returns(true);

That’s It

Thanks for Reading!

I obviously couldn’t fit every difference, similarity, and detail in this article —* *it’s already far too long.

I hope at least I’ve covered enough ground to make you feel confident to make a switch and see how the other half lives.

If you liked this post, share it with all of your programming buddies!

Follow us on Facebook | Twitter

Further reading

Java Tutorial for Absolute Beginners

100+ Java Interview Questions and Answers In 2019

Python vs Java: Understand Object Oriented Programming

Angular 7 + Spring Boot CRUD Example

Build a Simple CRUD App with Spring Boot and Vue.js

Java String – String Functions In Java With Examples

Java String – String Functions In Java With Examples

In this post, we will be discussing about a new concept, Java String. String is a sequence of characters. But in Java, a string is an object that represents a sequence of characters. The java.lang.String class is used to create string object.

Originally published by Aayushi Johari at https://www.edureka.co
There are two ways to create a String object:
By string literal : Java String literal is created by using double quotes. For Example: String s=“Welcome”; By new keyword : Java String is created by using a keyword “new”. For example: String s=new String(“Welcome”); It creates two objects (in String pool and in heap) and one reference variable where the variable ‘s’ will refer to the object in the heap.
Now, let us understand the concept of Java String pool.

**Java String Pool: **Java String pool refers to collection of Strings which are stored in heap memory. In this, whenever a new object is created, String pool first checks whether the object is already present in the pool or not. If it is present, then same reference is returned to the variable else new object will be created in the String pool and the respective reference will be returned. Refer to the diagrammatic representation for better understanding:

In the above image, two Strings are created using literal i.e “Apple” and “Mango”. Now, when third String is created with the value “Apple”, instead of creating a new object, the already present object reference is returned. That’s the reason Java String pool came into the picture.

Before we go ahead, One key point I would like to add that unlike other data types in Java, Strings are immutable. By immutable, we mean that Strings are constant, their values cannot be changed after they are created. Because String objects are immutable, they can be shared. For example:

   String str =”abc”;

is equivalent to:

char data[] = {‘a’, ‘b’, ‘c’};
     String str = new String(data);

Let us now look at some of the inbuilt methods in String class.

Java String Methods

Java String length(): The Java String length() method tells the length of the string. It returns count of total number of characters present in the String. For example:

public class Example{
public static void main(String args[]{
String s1="hello";
String s2="whatsup";
System.out.println("string length is: "+s1.length()); 
System.out.println("string length is: "+s2.length());
}}

Here, String length() function will return the length 5 for s1 and 7 for s2 respectively.
Java String compareTo(): The Java String compareTo() method compares the given string with current string. It is a method of* ‘Comparable’* interface which is implemented by String class. Don’t worry, we will be learning about String interfaces later. It either returns positive number, negative number or 0. For example:

public class CompareToExample{
public static void main(String args[]){
String s1="hello";
String s2="hello";
String s3="hemlo";
String s4="flag";
System.out.println(s1.compareTo(s2)); // 0 because both are equal
System.out.println(s1.compareTo(s3)); //-1 because "l" is only one time lower than "m"
System.out.println(s1.compareTo(s4)); // 2 because "h" is 2 times greater than "f"
}} 

This program shows the comparison between the various string. It is noticed that

if s1 > s2, it returns a positive number

if s1 < s2, it returns a negative number

if s1 == s2, it returns 0
**Java String concat() : **The Java String concat() method combines a specific string at the end of another string and ultimately returns a combined string. It is like appending another string. For example:

public class ConcatExample{
public static void main(String args[]){
String s1="hello";
s1=s1.concat("how are you");
System.out.println(s1);
}}

The above code returns “hellohow are you”.
Java String IsEmpty() : This method checks whether the String contains anything or not. If the java String is Empty, it returns true else false. For example:

public class IsEmptyExample{
public static void main(String args[]){
String s1="";
String s2="hello";
System.out.println(s1.isEmpty());      // true
System.out.println(s2.isEmpty());      // false
}}

  • Java String Trim() : The java string trim() method removes the leading and trailing spaces. It checks the unicode value of space character (‘u0020’) before and after the string. If it exists, then removes the spaces and return the omitted string. For example:
public class StringTrimExample{ 
public static void main(String args[]){ 
String s1="  hello   "; 
System.out.println(s1+"how are you");        // without trim() 
System.out.println(s1.trim()+"how are you"); // with trim() 
}}  

In the above code, the first print statement will print “hello how are you” while the second statement will print “hellohow are you” using the trim() function.

  • Java String toLowerCase() : The java string toLowerCase() method converts all the characters of the String to lower case. For example:
public class StringLowerExample{
public static void main(String args[]){
String s1="HELLO HOW Are You?”;
String s1lower=s1.toLowerCase();
System.out.println(s1lower);}
}

The above code will return “hello how are you”.

  • Java String toUpper() : The Java String toUpperCase() method converts all the characters of the String to upper case. For example:
public class StringUpperExample{ 
public static void main(String args[]){ 
String s1="hello how are you"; 
String s1upper=s1.toUpperCase(); 
System.out.println(s1upper); 
}}

The above code will return “HELLO HOW ARE YOU”.
Java String ValueOf(): This method converts different types of values into string.Using this method, you can convert int to string, long to string, Boolean to string, character to string, float to string, double to string, object to string and char array to string. The signature or syntax of string valueOf() method is given below: public static String valueOf(boolean b) public static String valueOf(char c) public static String valueOf(char[] c) public static String valueOf(int i) public static String valueOf(long l) public static String valueOf(float f) public static String valueOf(double d) public static String valueOf(Object o)
Let’s understand this with a programmatic example:

public class StringValueOfExample{
public static void main(String args[]){
int value=20;
String s1=String.valueOf(value);
System.out.println(s1+17);       //concatenating string with 10
}}

In the above code, it concatenates the Java String and gives the output – 2017.
Java String replace(): The Java String replace() method returns a string, replacing all the old characters or CharSequence to new characters. There are 2 ways to replace methods in a Java String.

public class ReplaceExample1{
public static void main(String args[]){
String s1="hello how are you";
String replaceString=s1.replace('h','t');
System.out.println(replaceString); }}

In the above code, it will replace all the occurrences of ‘h’ to ‘t’. Output to the above code will be “tello tow are you”. Let’s see the another type of using replace method in java string:

**Java String replace(CharSequence target, CharSequence replacement) method **:

public class ReplaceExample2{
public static void main(String args[]){
String s1="Hey, welcome to Edureka";
String replaceString=s1.replace("Edureka","Brainforce");
System.out.println(replaceString);
}}

In the above code, it will replace all occurrences of “Edureka” to “Brainforce”. Therefore, the output would be “ Hey, welcome to Brainforce”.
Java String contains() :The java string contains() method searches the sequence of characters in the string. If the sequences of characters are found, then it returns true otherwise returns false. For example:

class ContainsExample{
public static void main(String args[]){
String name=" hello how are you doing";
System.out.println(name.contains("how are you"));  // returns true
System.out.println(name.contains("hello"));        // returns true 
System.out.println(name.contains("fine"));         // returns false 
}}

In the above code, the first two statements will return true as it matches the String whereas the second print statement will return false because the characters are not present in the string.
Java String equals() : The Java String equals() method compares the two given strings on the basis of content of the string i.e Java String representation. If all the characters are matched, it returns true else it will return false. For example:

public class EqualsExample{
public static void main(String args[]){
String s1="hello";
String s2="hello";
String s3="hi";
System.out.println(s1.equalsIgnoreCase(s2));   // returns true
System.out.println(s1.equalsIgnoreCase(s3));   // returns false
}
}

  • **JavaString equalsIgnoreCase(): **This method compares two string on the basis of content but it does not check the case like equals() method. In this method, if the characters match, it returns true else false. For example:
public class EqualsIgnoreCaseExample{
public static void main(String args[]){
String s1="hello";
String s2="HELLO";
String s3="hi";
System.out.println(s1.equalsIgnoreCase(s2));   // returns true
System.out.println(s1.equalsIgnoreCase(s3));   // returns false
}}

In the above code, the first statement will return true because the content is same irrespective of the case. Then, in the second print statement will return false as the content doesn’t match in the respective strings.
**Java String toCharArray(): **This method converts the string into a character array i.e first it will calculate the length of the given Java String including spaces and then create an array of char type with the same content. For example:

StringToCharArrayExample{
public static void main(String args[]){
String s1="Welcome to Edureka";
char[] ch=s1.toCharArray();
for(int i=0;i<ch.length;i++){
System.out.print(ch[i]);
}}}

The above code will return “Welcome to Edureka”.
Java StringGetBytes() : The Java string getBytes() method returns the sequence of bytes or you can say the byte array of the string. For example:

public class StringGetBytesExample {
public static void main(String args[]){
String s1="ABC";
byte[] b=s1.getBytes();
for(int i=0;i<b.length;i++){
System.out.println(b[i]);
}
}}

In the above code, it will return the value 65,66,67.
Java String IsEmpty() : This method checks whether the String is empty or not. If the length of the String is 0, it returns true else false. For example:

public class IsEmptyExample{
public static void main(String args[]) {
String s1="";
String s2="hello";
System.out.prinltn(s1.isEmpty());     // returns true
System.out.prinltn(s2.isEmpty());     // returns false
}}

In the above code, the first print statement will return true as it does not contain anything while the second print statement will return false.
Java String endsWith() : The Java String endsWith() method checks if this string ends with the given suffix. If it returns with the given suffix, it will return true else returns false. For example:

public class EndsWithExample{
public static void main(String args[]) {
String s1="hello how are you”;
System.out.println(s1.endsWith("u"));       // returns true
System.out.println(s1.endsWith("you"));     // returns true  
System.out.println(s1.endsWith("how"));     // returns false
}}

This is not the end. There are more Java String methods that will help you make your code simpler.

Moving on, Java String class implements three interfaces, namely – Serializable, Comparable and CharSequence.

Since, Java String is immutable and final, so a new String is created whenever we do String manipulation. As String manipulations are resource consuming, Java provides two utility classes: StringBuffer and StringBuilder.

Let us understand the difference between these two utility classes:
StringBuffer and StringBuilder are mutable classes. StringBuffer operations are thread-safe and synchronized whereas StringBuilder operations are not thread-safe.StringBuffer is to be used when multiple threads are working on same String and StringBuilder in the single threaded environment.StringBuilder performance is faster when compared to StringBuffer because of no overhead of synchronized.
I hope you guys are clear with Java String, how they are created, their different methods and interfaces. I would recommend you to try all the Java String examples. Do read my next blog on Java Interview Questions which will help you set apart in the interview process.

Thanks for reading

If you liked this post, share it with all of your programming buddies!

Follow us on Facebook | Twitter

Further reading

Top 4 Spring Annotations for Java Developer in 2019

Java Tutorial for Absolute Beginners

100+ Java Interview Questions and Answers In 2019

Python vs Java: Understand Object Oriented Programming

Java Enum Tutorial - Enumeration in Java Explained

Java Enum Tutorial - Enumeration in Java Explained

This video on Java Enum Tutorial will provide you with detailed knowledge about Enumeration in Java along with real times examples for better understanding.

Java Enum Tutorial | Enumeration in Java Explained | Java Tutorial For Beginners

This informative video will include the following.

00:21 Agenda

00:55 What is Enum?

01:22 Why we need Enum?

06:45 Differences between Class and Enum

07:26 Syntax of Enum

07:43 Practical Examples of Enum

15:40 Advantages of using Enum

16:10 Enum Usecase: Rock Paper Scissor Game