Mocking is an essential part of unit testing, and the Mockito library makes it easy to write clean and intuitive unit tests for your Java code.
Get started with mocking and improve your application tests using our Mockito guide:
Handling concurrency in an application can be a tricky process with many potential pitfalls. A solid grasp of the fundamentals will go a long way to help minimize these issues.
Get started with understanding multi-threaded applications with our Java Concurrency guide:
Spring 5 added support for reactive programming with the Spring WebFlux module, which has been improved upon ever since. Get started with the Reactor project basics and reactive programming in Spring Boot:
Since its introduction in Java 8, the Stream API has become a staple of Java development. The basic operations like iterating, filtering, mapping sequences of elements are deceptively simple to use.
But these can also be overused and fall into some common pitfalls.
To get a better understanding on how Streams work and how to combine them with other language features, check out our guide to Java Streams:
Explore Spring Boot 3 and Spring 6 in-depth through building a full REST API with the framework:
Yes, Spring Security can be complex, from the more advanced functionality within the Core to the deep OAuth support in the framework.
I built the security material as two full courses - Core and OAuth, to get practical with these more complex scenarios. We explore when and how to use each feature and code through it on the backing project.
You can explore the course here:
Spring Data JPA is a great way to handle the complexity of JPA with the powerful simplicity of Spring Boot.
Get started with Spring Data JPA through the guided reference course:
Refactor Java code safely — and automatically — with OpenRewrite.
Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.
Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.
Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.
Regression testing is an important step in the release process, to ensure that new code doesn't break the existing functionality. As the codebase evolves, we want to run these tests frequently to help catch any issues early on.
The best way to ensure these tests run frequently on an automated basis is, of course, to include them in the CI/CD pipeline. This way, the regression tests will execute automatically whenever we commit code to the repository.
In this tutorial, we'll see how to create regression tests using Selenium, and then include them in our pipeline using GitHub Actions:, to be run on the LambdaTest cloud grid:
1. Overview
Comments can be useful when we need additional notes in our code. They can help us make our code more understandable. Additionally, they can be especially useful in methods that perform complex operations.
In this tutorial, we’ll explore cases where comments in our code can become executable. Or at least it may appear like they can.
2. Comments
Before we dive in, let’s revisit comments in Java. They are part of the Java syntax and come in two basic formats:
- Single-line comments
- Multiline comments
The text from the “//” characters to the end of the line represents a single-line comment:
// This is a single-line comment.Additionally, a multiple-line comment (also known as a multiline comment) starts with the “/*” and ends with the “*/” symbol. Everything in between is treated as a comment:
/* This is a
* multiline
* comment.
*/3. Comments and Unicode
Now, let’s start with an example. The following code prints “Baeldung” in the standard output:
// \u000d System.out.println("Baeldung");Because the line begins with the “//”, which represents the start of a single-line comment, we might conclude the “System.out.println(“Baeldung”);” statement is part of that comment as well.
However, this isn’t accurate. It’s important to note Java doesn’t allow comment execution.
With that in mind, let’s examine our example in detail and see the reasons why the code prints “Baeldung” in the console.
3.1. Unicode Escapes
The code from the example isn’t treated as a comment because of the “\u000d” Unicode escape sequence we placed before it.
All Java programs use the ASCII character set. However, due to the non-Latin characters, we can’t represent using ASCII codes, Java allows Unicode to appear in comments, identifiers, keywords, literals, and separators.
Furthermore, to be able to use all non-ASCII characters in our code, we need to embed them through Unicode escape sequences. They start with a backslash (“\”) followed by the letter “u” which is then followed by a four-digit hexadecimal code of a specific character.
Using this convention, the CR (or Carriage return) becomes “\u000d“.
Additionally, the Unicode escape sequences are transformed into ASCII code using the lexical translation defined in the Java Language Specification.
Moving forward, let’s take a closer look at how Java performs the lexical transformation.
3.2. Lexical Translation
When executing the lexical translation, the Unicode encoding takes precedence over any other encoding, even if it’s part of the comment. To put it differently, Java will first encode all Unicode escape sequences and then move forward with other translations.
Simply put, during the transformation, the Unicode escape is translated into the Unicode character. Then, the result of the previous step is translated into the ASCII code.
As a side effect, our code won’t compile if we put an invalid Unicode escape inside the comment. Java treats everything that starts with the “\u” as a Unicode escape.
Thanks to this transformation, we can use Unicode escapes to include any Unicode characters using only ASCII characters. This way, ASCII-based programs and tools can still process the code written in Unicode.
Now, back to our example. We used the Unicode escape sequence “\u000d“, which represents a new line.
When we compile our code, the lexical translation will happen first. Therefore, the “\u000d” will translate to the new line. Since, by definition, a single-line comment ends at the end of the line, the code we put after the Unicode escape won’t be part of the comment anymore.
As a result of the transformation, our code will appear in the new line:
//
System.out.println("Baeldung");3.3. Unicode and IDEs
Nowadays, we often use an IDE as a development tool. Additionally, we frequently rely on it and expect it’ll warn us if something in our code seems suspicious.
However, when it comes to IDEs and Unicode characters, depending on the IDE we’re using, it sometimes displays the code in the wrong way. It might not interpret Unicode escape sequences correctly and, thus, displays incorrect code highlighting.
Since we can use Unicode escapes instead of ASCII characters, nothing prevents us from substituting other parts of the code with Unicode escapes:
\u002f\u002f This is a comment
\u0053ystem.out.println("Baeldung");Here, we replaced the “//” and the letter “S” with Unicode escapes. The code still prints “Baeldung” in the console.
4. Conclusion
In this tutorial, we learned how comments and Unicode escape sequences work together.
To sum up, Java doesn’t allow executable comments. When using Unicode escapes in our code, Java translates them to ASCII before any other transformation.
Being able to write Unicode characters is useful when we’d like to use non-Latin characters we can’t represent in any other way in our program. Although it’s perfectly legal to write an entire codebase using just Unicode escapes, we should avoid them and use them only when necessary.
