Using Character class

First option is to select a character from string with help of charAt() method and the character position; and use Character class static method isDigit() to return boolean value.

String movie = "101 dalmatians";
System.out.println(movie);
boolean result = Character.isDigit(movie.charAt(0));
System.out.println("Is first letter number? Answer: " + result)

The output will be:

101 dalmatians
Is first letter number? true

If we want to check if several characters are numbers, we can place the isDigit() method call inside the loop.

String movie = "101 dalmatians";
for (int i = 0; i <= movie.length() - 1; i++) {
    System.out.println(movie.charAt(i) + " -> " + Character.isDigit(movie.charAt(i)));
}

The output of the above code will be:

1 -> true
0 -> true
1 -> true
  -> false
d -> false
a -> false
l -> false
m -> false
a -> false
t -> false
i -> false
a -> false
n -> false
s -> false

Using Unicode check

Using Character class static method isDigit() can be used on any Unicode character, not just 0-9 number range. You can use create number check at any Unicode character.

Here is an example of checking a number through a check of Unicode characters:

String movie = "101 dalmatians";
System.out.println(movie);
boolean char c = word.charAt(0);
boolean isDigit = (c >= '0' && c <= '9');
System.out.println(isDigit)

101 dalmatians
true

Using Regex

Alternative way to using Character class static method isDigit() is to use solution based on regex output. However, this will require string to be instance of String class as we can conduct regex pattern search only on String.

Let us show you first regex pattern for searching digit in substring of length 1 on the instance String class named word:

word.substring(0, 1).matches("\\d")

The alternative and equivalent version uses the regex search pattern with the search of digit range.

word.substring(0, 1).matches("[0-9]")

The regex solution should be discouraged as it is an over-engineered solution. While there might be a minor performance hit, we can argue it would not affect simple coding solutions. But be aware that regex brings complexity. A solution implementing regular expression should be used with caution and with a fair amount of tests.

Note: Regular expressions are very strong, but expensive tool. It is valid to use regular expressions for character check if, e.g. the first character is a digit. But performance-wise, it is also like shooting birds with cannon.

Using casting

The last way to check if the character in a string is a number is to use Java casting feature. We will cast string values into one of the numerical object classes. However, this is the worst way how to do it. If you find a code using casting, you should refactor it immediately.

public boolean isNumber(String word) {
    boolean isNumber = true;
    try {
        Integer.valueOf(word.substring(0,1));
    } catch (Exception e) {
        isNumber = false;
    }
    return isNumber;
}

There is a lot that can go wrong with the method above. If the entering argument word is an empty string, casting will throw NumberFormatException and catch it. If the first character is not a digit, e.g. letter or special symbol, casting will also throw NumberFormatException and catch it. But if the first character is a digit, it will return true.

You can place any numerical object class to the code such as Integer, Double, Float or Long. But please do not! Using casting with valueOf() method is wrong for two reason:

• In general, we want to avoid throwing Exceptions, checked or unchecked, as they slow the program and have tremendous performance hit.
• Second reason, we can see above at least 3 different ways which provide shorter, more effective and readable way for solving the same problem.

Conclusion

In the article, we have demonstrated four different ways to find out if the single character or characters from a string is a number or not. The solutions ranged from best to worst, from easiest to most cumbersome. Use as much as possible the first option which use Character class static method isDigit() for determining if the character is a string. Using isDigit() method is, without instantiation of any variables, the most effective and readable solution.

I hope you learned something new and had fun. Thanks for the reading. And if you have any tricks or know a better way how to find out if the character is a string, let us know in the comments below. We would like to hear your ideas.

Developer notes will be an irregular series of articles where I will briefly go through some of my notes to make notes for posterity. The notes themself can be pretty long, yet their length is not enough for writing a meaningful article.

Let’s take a look at a list of content:

• Oracle Error: Value Larger Than Specified Precision Allowed For This Column
• Switch on String with Enum Name in Java 8
• Lombok’s serialization error for Jackson
• Interpunct
• How To Do curl in Postman

Oracle Error: Value Larger Than Specified Precision Allowed For This Column

I was getting errors on inserting data into the Oracle database “ORA-01438: value larger than specified precision allowed for this column.”

The reason why I was getting an error was a too big number. When I looked over UI to database column definition, I saw something like this NUMBER(15,2).

Official Oracle documentation, as for Oracle database v21, depicts NUMBER datatype defined as NUMBER (precision,scale).

NUMBER datatype notation can be rather rewritten to NUMBER (size,precision)) where the first number depicts the total size of the digits in a number, and the second means the decimal point scale.

In other words, for example, for NUMBER(2,2), we can place the column number consisting of 2 digits, both of which will be decimals. i.e. 0.15, 0.45 etc. But if we would like to have a bigger number in the column, we need to upgrade the size of the column reserved for the whole number – NUMBER(5,2) will get us five digits, of which 2 are decimals. i.e 125.40, 18.00.

Switch on String with Enum Name in Java 8

Here is an example of how to use Enum values as strings in a switch case. You can only use the strings which are known at compile time. The compiler cannot determine the result of expression. However, in Java Enum case VALUE1, VALUE2 are static.

String name = ...
switch(CustomEnum.valueOf(name)) {
   case VALUE1:
        ...
        break;
   case VALUE2:
        ...
        break;
    ...
}

Lombok’s serialization error for Jackson

When I created a new aggregated DTO class on my REST output, I got the following error:

Type definition error: [simple type, class CUSTOM_DTO_CLASS_NAME]; nested exception is com.fasterxml.jackson.databind.exc.InvalidDefinitionException: No serializer found for class CUSTOM_DTO_CLASS_NAME and no properties discovered to create BeanSerializer (to avoid exception, disable SerializationFeature.FAIL_ON_EMPTY_BEANS) (through reference chain: CUSTOM_DTO_CLASS_NAME[\"aggregation-class-property\"]->java.util.ArrayList[0])

I am sure this error will be thrown quiet often as the solution on it is very simple. All I was missing on my Custom DTO class was Lombok’s @Getters annotation for serialization. So fix consisted on adding missing @Getters annotation on the top of my custom class for Lombok generating getter methods at compile time.

Interpunct

I was editing my resume this month and wanted to create a nice date range in positions I held in the past. I got this from my LinkedIn profile, where LinkedIn use dates in the form as Jan 2020 – Feb 2020 · 2 mos. But I could not figure out where to take the dot sign as it was an image. However, the character for such sign as little black dot · really exists and its name is Interpunct, or middle dot. So every time you would like to create a nice division of text with the help of ·, think about the Interpunct.

How To Do curl in Postman

Is there a way hot to make a curl command in Postman? What if we would like to import the curl command easily into Postman and make a Postman GUI request from it.
Is it even possible to easily translate all the curl command parameters into the Postman request?

Surely it is. Postman request are eventually nothing else than more fancy curl requests and Postman supports the curl import feature. Importing curl is very simple. Here is simple list of steps which will lead you to success:

1. Open Postman.
2. Go to navigation menu, click File and Import option
3. In Import window select the raw text tab.
4. Paste the raw text e.g. curl --location --request GET "https://www.google.com/", then click continue.
5. Check the name, format and import as.
6. If everything is correct, click Import button.

Following the steps will automatically import the curl command into the Postman on the new tab.

Introduction

I have been recently doing code review on other developer pull-request when I found the piece of code below:

private static final String DOCUMENT_VERSION = "document_version-";

public String getDocumentVersion(int version) {
    String documentVersion = "";
    if (version > 999) {
        throw new IllegalStateException("Version number " + version + " is too large.");
    } else if (version > 99) {
        documentVersion += version;
    } else if (version > 9) {
        documentVersion += "0" + version;
    } else {
        documentVersion += "00" + version;
    }

    return "DOCUMENT_VERSION_" + documentVersion;
}

As you can immediately see, the code is bad and can be surely rewritten to something more simple. Creating a string from a number can not be so declarative, right? There needs to be a simpler way how to do it. And surely it can. Like many other general-purpose programming languages, Java has multiple libraries and functions for processing text. String class itself has a static method format() which can be fully utilized on the text changes like this.

Java String format()

The Java String class format() method returns the formatted string. Let’s look little bit on parameters of format() method.

String.format() signature

There are two type of String format() method:

public static String format(String format, Object... args)

and

public static String format(Locale locale, String format, Object... args)  

Therefore, method parameters are described as:

• locale is specifies the locale to be applied on the format() method.
• format is format of the string.
• args represent arguments for the format string. It may be zero or more.

format() method returns new String. However, it is also good to be prepared for possibility of two unchecked exception:

• NullPointerException is thrown if format is null.
• IllegalFormatException is thrown if format is illegal or incompatible.

String.format() internal implementation

In reality, String.format() method allows usage of multiple Object arguments because internal implementation use nothing else than new instance of Formatter class.

public static String format(String format, Object... args) {
    return new Formatter().format(format, args).toString();
}

Usage of quiet Formatter class explains why we can take multiple arguments depending on the number of elements we want to format inside the string. Formatter class can use several different option of “%” character combination in order to define string formatting. In the table below are all options explained:

format() examples

Let us show you few tricks with format()

System.out.println(String.format("%d", 100)); // Integer
System.out.println(String.format("%s", "Anna Smith")); // String
System.out.println(String.format("%f", 42.42)); // Float
System.out.println(String.format("%x", 100)); // Hexadecimal
System.out.println(String.format("%c", 'a')); // Char
System.out.println("-----");
System.out.println(String.format("number with text: %d", 100)); // number with other text
System.out.println(String.format("%f", 42.12345)); // prints floating number
System.out.println(String.format("%10.10f", 42.12345)); // prints 10 digits for fractions padded with 0
System.out.println("-----");
System.out.println(String.format("|<-%10d->|", 222)); // Align right, padding with empty space
System.out.println(String.format("|<-%-10d->|", 555)); // Align left, padding with empty space
System.out.println(String.format("|<-% d->|", 777)); // Single space between % and conversion type is allowed
System.out.println(String.format("|<-%010d->|", 999)); // Filling space with zeros

100
Anna Smith
42.420000
64
a
-----
number with text: 100
42.123450
42.1234500000
-----
|<-       222->|
|<-555       ->|
|<- 777->|
|<-0000000999->|

Using format() to turn number into formatted string

To take for first exemplary code from code review, all what we needed to do in getDocumentVersion() method was to place custom format of string into the String class format method.

private static final String DOCUMENT_VERSION = "document_version-";

public String getDocumentVersion(int version) {
    return String.format(DOCUMENT_VERSION + "%03d", revisionNumber);
}

If we place number 1 into the method getDocumentVersion() we will get the same result as boilerplate code from code review:

Output

document_version-001

We can still quickly write some custom code to test our beliefs. But be thorough and do not forget edge cases as zero and negative numbers.

System.out.println(String.format("%03d", 999));
System.out.println(String.format("%03d", 99));
System.out.println(String.format("%03d", 9));
System.out.println(String.format("%03d", 0));
System.out.println(String.format("%03d", -9));

999
099
009
000
-09

As you can notice format() takes negative number into account its length with minus sign.

Note : If you have any crazy idea how to use format() method, let us know in comments below.

Conclusion

This article showed us how to turn a number into a string with a specific length where additional space is padded.

Did you find the String.format() method useful? Do you have your trick, or do you know another way how to turn a number into a string of specific length? Let us know in the comments below the article. We would like to hear your ideas and stories.

I had stuck on the problem when I needed to provide private key .pem file type for the OpenSSL command. However, the private key was saved in .der file type, so I needed to convert it.

There is a way to convert .pem file type on the Windows operating system to .der without using command line. Go to the Windows search bar and search for KeyStore Explorer. Open the KeyStore Explorer program. After opening the KeyStore Explorer, you should get the program screen like this:

KeyStore opened

Click on the icon Examine a Certificate. From a system select your .der file. After selecting the .der you should get the KeyStore image like this:

KeyStore – .der file opened

Now all you need to do is to click on the PEM button. It will open you content of the .der file in .pem format.

KeyStore – .der file turned to .pem

You have now two options:

• You can either copy .pem file content into the system memory with Copy option.
• Or you can export .pem file content on you machine disk with Export option.

Note : Never show or publish content of your private keys!

Conclusion

This article has shown how to turn .pem file type into the .der file type on Windows.

Did you find turning files easy? Do you have your trick or know another way how to turn .pem file type into the .der file type? Let us know in the comments below the article. We would like to hear your ideas and stories.

What is Java classpath?

If we want to be wordy, classpath is the path where the Java Virtual Machine looks for user-defined classes, packages, and resources in Java programs. However, plain and straightforward, classpath is the route where the Java Virtual Machine will know where to find your compiled class.

Think of classpath as Java’s version of PATH environment variables – OSes search for executable files on the system environment PATH, Java searches for classes and packages on the classpath.

It would generally be impractical to have the JVM look through every folder on your machine. So you have to provide the JVM with a list of places where to look. Then, when we place folders and jar files on the classpath, we can automatically look up classes.

How to print classpath?

In Java, we can use a single line of code to print out the current project classpath. The only issue is with the system based classpath separator. On Unix based systems (Mac OS, CentOS, etc.), the colon character : is the classpath separator. However, on Windows, the separator is the semicolon ;.

To print classpath at Unix based systems use:

System.out.println(System.getProperty("java.class.path").replace(':', '\n'));

To print classpath at Windows use:

System.out.println(System.getProperty("java.class.path").replace(';', '\n'));

Output

The code will work like a charm in new versions of Java (8, 11, …). However, the Java code snippet will also print library dependencies.

On Windows, the output can look something like the following example:

C:\DEV\programming\interview-preparation\trees\target\test-classes
C:\DEV\programming\interview-preparation\trees\target\classes
C:\Users\computer_user\.m2\repository\junit\junit\4.13.1\junit-4.13.1.jar
C:\Users\computer_user\.m2\repository\org\hamcrest\hamcrest-core\1.3\hamcrest-core-1.3.jar
C:\Users\computer_user\.m2\repository\org\projectlombok\lombok\1.18.12\lombok-1.18.12.jar
...

Note: If you have a better idea for printing classpath, let us know in the comments below.

Conclusion

Concisely, this article summarized what the classpath is and how to print classpath in your current Java project.

Did you find printing classpath easy? Do you have your trick or know another way how to print classpath? Let us know in the comments below the article. We would like to hear your ideas and stories.

• Introduction
• Change Future Commits Author
• Git Config Check
• Git Global Configuration
• Git Local Configuration
• Author Identity For the Next Commit
• Change Past Commits Author
• Git Ammend With Author Flag
• Git Interactive Rebase
• Git filter-branch Command
• Conclusion

Introduction

There are two different needs in the request of changing author for your commits. Let’s make clear what are you really looking for:

• a) Either you want to change the author before making commit.
• b) Or you want to change the author after you have made commit.

In this article, we will look at both ways how to change the commit’s author identity.

Change Future Commits Author

There are three different ways how to change identity for your Git committer. All the procedures only affect future commits and not the past commits made in the development line of your repository (commit history).

Git Config Check

Just a quick tip. To confirm your settings for global and local configuration you can type command:

git config --list

git config --list will show global system git settings. If you run it inside a repository, it will also attach and show you the local configuration.

However, using following command might be more clearer:

git config --list --show-origin

git config --list --show-origin command does all what git config --list does. Git command also attaches a path to the origin file of each config item in the list. Arguably, the attached path makes the settings look more understandable, and you can better connect items and their values for local and global Git settings.

Git Global Configuration

If you want to change your username and email by default for all project on your machine, edit global configuration settings. You can run the git config command with --global flag that will override your default Git settings and apply for all the future commits in your repositories. Git command for it looks like this:

git config --global user.name "FIRST_NAME LAST_NAME"
git config --global user.email "EMAIL@example.com"

Git Local Configuration

However, if you want to change your username and email only for single project, go to your repository and make git config adjustment like this:

git config --local user.name "FIRST_NAME LAST_NAME"
git config --local user.email "EMAIL@example.com"

Simply omit the --global flag and replace it with --local flag. git config --local makes the custom configuration valid only in the repository you made a change.

Author Identity For the Next Commit

There is at least one last way how to temporary influence the author identity of the commit. Just right before making the commit, add to commit command --author flag. When making the commit, you can override even local settings.

git commit --author="FIRST_NAME LAST_NAME "

Change Past Commits Author

Changing past commit authors in Git repositories is not so straightforward as it is for future ones. The issue lies in the fundamental idea of Git – its distributed asynchronous nature. You should be aware of one simple fact that you might cause a massive problem with synchronization if you work on the project with many team members.

When you change Git commit author identity, you create an entirely new commit with a new hash; you are rewriting commit history and development branch. And while for a single individual repository user, this might not be a problem, for big teams, this might be a cause of enormous evil.

Therefore, let me give you a piece of good advice: if you are working in a team, a change in Git commit history should be adequately communicated with the rest of the team. It might happen that other team members already based their work on the existing commits, and additional changes would cause huge synchronization problems. Communicate with your team if you feel that commits might be already used as the base for other people work. Eventually, for good or bad, it might be possible even to avoid changing commit author identity, and either do rollback commit with new commit with correct author commit or, better, leave the commit history as it is. Commit change is much more critical in the long term as a person who made it (empirical experience – people come and go from teams, code stays forever).

Git Ammend With Author Flag

git ammend command is used to patch last commit in Git’s commit history. By attaching --author flag to git ammend command you can effectively rewrite commit author identity for the last commit in commit history.

Git Interactive Rebase

Interactive rebase is a powerful feature of Git that allows you to edit Git commit history very effectively.

However, be careful with interactive rebase, it might shoot you in the foot if you will be not careful! Any changes made will affect your Git commit history. I would recommend to study deeper official Git documentation for interactive rebase before making any changes with it over console [7.6 Git Tools – Rewriting History]. Otherwise I can really recommend using interactive rebase with IDE tools such as IntelliJ.

First step, you need to find commit you consider as base for your interactive rebase. Provide to git command commit’s hash like this:

$ git rebase -i -p 9be2477a

git rebase command will open the interactive editor in which you need to mark all the commits you want to change. Selected commits will be marked with the red keyword “edit”.

edit 87bee32a Added new tests
edit 1be09dcb Merge branch with hotfix for DJ-1041
edit 9be2477a Change title tag for homepage
edit c427697c Add images support in gallery

Git will now walk you through each commit. You will have a chance to change every commit individually:

Stopped at 1be09dcb... Merge branch with hotfix for DJ-1041
You can amend the commit now, with

    git commit --amend

Once you are satisfied with your changes, run

    git rebase --continue

Now is your chance to rewrite the commit author identity. Either you will use --amend with --author flag. Or you will continue to next commit in edit mode until you have edited all commits which were marked for edit

$ git commit --amend --author="FIRST_NAME LAST_NAME " --no-edit
$ git rebase --continue

Git filter-branch

Last option is to use Git filter-branch command. filter-branch will allow you to go through a large chunk of commits with the help of simple script. Let us show you a simple script:

$ git filter-branch --env-filter '
OLD_COMMITTER_EMAIL="OLD_EMAIL@example.com"
NEW_COMMITTER_NAME="FIRST_NAME LAST_NAME"
NEW_COMMITTER_EMAIL="NEW_EMAIL@example.com"

if [ "$GIT_COMMITTER_EMAIL" = "$OLD_COMMITTER_EMAIL" ]
then
    export GIT_COMMITTER_NAME="$NEW_COMMITTER_NAME"
    export GIT_COMMITTER_EMAIL="$NEW_COMMITTER_EMAIL"
fi
if [ "$GIT_AUTHOR_EMAIL" = "$OLD_COMMITTER_EMAIL" ]
then
    export GIT_AUTHOR_NAME="$NEW_COMMITTER_NAME"
    export GIT_AUTHOR_EMAIL="$NEW_COMMITTER_EMAIL"
fi
' --tag-name-filter cat -- --branches --tags

However, same as with interactive rebase, it is necessary to be aware that by using filter-branch, you will create entirely new sort of commits and change Git commit history. The new commit history might have severe consequences when synchronizing with your team, so you should do this preferably only on repositories that haven’t been published or shared.

Conclusion

In summary, we divided the methods of changing the commit author identity into two different approaches based on the commit stage. We showed three different ways to change the author information before making a commit, and we explained another three ways to change the author information after making a commit.

Did you find commands easy? Do you have your trick or know another way how to change global and local Git settings? Let us know in the comments below the article. We would like to hear your ideas and stories.

Prerequisites

Let me give you some essential tips for prerequisites to get successful and smooth remote debugging.

Debug same version as on the remote server

To debug a remote server-side application in your IntelliJ IDEA, you need to have the same version of your application or component on your side in IntelliJ IDEA as on the server-side. To do so, you shall first finish all the changes you want to test on the remote server. Then build your application and deploy it to the remote server. Only then you should run remote debug mode against your remote environment.

In reverse, if you can not change what is on the server, rebase your code repository on the commit of the JAR or WAR file set on the server. Then, build the application with the build tool of your choice (Maven/Gradle), and only then can you remotely debug.

Don’t make any additional changes before remote debug

Writing the following note might be unnecessary, yet it is better to say it aloud as a reminder. If you make any changes in your code between deployment on the remote server and running the application in remote debug mode, remote debug will not work. Even on the slightest change, remote debug will not decompile your breakpoint on the desired code line because Java bytecode will be different.

Build faster without tests

Just a tip – for a fast Maven build you can use mvn clean install -DskipTests.

For more information regarding running a Maven build without tests, check the article about how to build Java application with Maven without running tests.

Coordination your work with the rest of the team

If you are working in a team and want to be a good team player (or working on something very sensitive), let your teammates know you want to deploy and remotely debug your application. First, ask your colleagues, e.g. in Slack publicly, if it is OK to occupy test instance for a while. Then, coordinate your debugging according to the response or your organization’s policy. For example, let’s say you are clear to go if nobody responds in 15 minutes.

Adjustment of other parts

For more complex changes through the stack, changing and adjusting different system parts might be necessary. E.g., if you are working on the monolith, you might need to adjust the front-end client for testing purposes. In other cases, it might be necessary to change the database.

Adjusting other parts of the system might be necessary for the system to work and for you to be able to test changes through the whole stack.

In every case, do not forget to clean after yourself when leaving (check the last point of this tutorial for more info).

1. In IntelliJ IDEA, create new Run/Debug Configuration for Remote JVM Debug

Example of setup in IntelliJ IDEA

You can change host and port configurations based on the remote environment you want to debug.

If using a multi-module project, select a module in Use module classpath.

2. Run remote debug configuration in debug mode

Connecting to the host should be nearly instant. So now, all you need to do is place the breakpoints in your code.

Then, when the application code executes in a connected environment, the line you set as the breakpoint should be reached, and IntelliJ IDEA will show you the stack trace. That is it, simple as that.

3. Do not forget to close your debug session

Do not forget to close your debug session. Unclosed sessions cause port/socket exhaustion and lead to server restart. Also, try not to keep the session open and be stuck on the breakpoint for too long. TimeOutException and other exceptions might occur which will lead to further server resource consumption.

4. Clean up

After successful testing, returning the testing environment to its original state might be necessary. For example, build your current master/develop branch and place it back in the test environment. Then, if your colleagues do not notice that the testing environment does not work as it should, you did a good job cleaning after yourself and placing the project back in a stable state.

If you are on your own, I highly recommend cleaning after yourself too. You will never know when you will need to return to your projects again, and you might not remember why the testing environment is in a different state at that time.

As I am a software developer, IntelliJ IDE is, for me, a must. IDE is in front of me opened all the time. Therefore it is a chance for me to write a lot of content in the IDE. It is a better choice to use IDE instead of switching to another text editor or using another means of word processing.

Since I am also aiming to work on several articles or documents simultaneously, every decrease in ambiguity and complexity counts towards faster results. The creative process is not possible to automatize. But what it is possible to automatize are redundant tasks during text handling and editing.

Why turn IntelliJ Idea IDE into your word processor?

First of all, IntelliJ Idea IDE already comes in its 2020 version with very, very good support for English vocabulary. So writing in English in IDE was never easier than now.

Plus, when implementing the advantage of multiple IntelliJ shortcuts, the word processing is swift. Especially if you write your text in .html, .adoc or .md format.

Overall, IntelliJ IDE comes in all versions with Git support, which is an additional advantage against traditional word processors. You can easily version your articles’ state and keep a history of your edits in one place. Article versioning is a feature that is available only in very advanced mode in cloud SaaS.

However, what I have found very tedious was text formatting in IntelliJ. As expected, I was using IntelliJ Idea IDE for coding, mostly Java, and thus the text was supposed to be wrapped automatically after 120 characters. When I then copied my articles to other word processors in my pipelines, such as Microsoft Word or Grammarly, I always needed painfully deleted every single break line to make a single continuous line of text. That was also one of the most common mistakes I had after publishing articles through WordPress – linebreaks were always in places where they should not be.

After enough time spent doing this pointless work, fixing many wrong break lines, I have decided to end it and figure out how to speed up the process. Because every second I spend editing an article is second, I could use it towards another article’s creative process.

How to turn IntelliJ Idea into text editor?

First of all, go to Settings > Editor > General and check all checkboxes in Soft Wraps section.

Then go to Settings > Code Style and select Scheme Project. Here unselect the checkbox “Wrap on typing”.

I would recommend this change be saved under the current project scheme, not under the IDE scheme. If you are using the same IntelliJ for coding, wrapping will conflict with your code clarity if you save the change under the IDE scheme.

Hit Apply button to apply all the changes.

Initialize soft-wrap in IntelliJ code editor

In the active editor tab, on the left side of the text line panel, after the right-click, there is an option soft-wrap to initiate the wrapping. Soft-wrap is not initialized automatically on every new file open. Therefore you will need to initialize soft-wrap on every new file open.

Tip for shortcut

When you open a new file, the text is, by default, unwrapped. You can either right-click on the newly opened line meter on the left side and hit Soft-Wrap from the menu option. Or you can set up a special shortcut for soft-wrapping, while the shortcut is not set by default.

To set up your shortcut, go to File > Settings > Keymap and search for “Soft-Wrap” in Main Menu > View > Active Editor. Add to action key shortcut. I personally use Alt + P key shortcut. That is not a conflicting key shortcut with keys combinations easy to remember.

Whether you want to build your SpringBoot app into the executable JAR file or build classes for a package, remember to use the single Maven flag parameter mvn install -DskipTests, and in the most cases, you will be fine.

However, the rabbit might run deeper, so it will be better to write a bit more info.

-DskipTests option only works from Surefire 2.4. Unfortunately, there are no error messages if you do try to use it with Surefire 2.3 or lower. Therefore, your first task is to check your version of Surefire. For this, run mvn -X test and look for a line that mentions surefire. It should look like this: maven-surefire-plugin: resolved to version 2.3 from repository central. If you use pre-Surefire-2.4 start using -Dmaven.test.skip=true.

Fortunately beyond 2020 older version usage shrinks and you should remember to always favor a -DskipTests above -Dmaven.test.skip=true.

Surefire itself is the intermediate plugin between Maven and JUnit/TestNG for which while -DskipTests works and -Dmaven.test.skip=true works for compiler.

You can find (not really much more) additional info about shortening the build time trough skipping the project tests at maven skipping tests site.

You can add this plugin configuration to your pom if you do not want to set command line arguments:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <configuration>
        <skipTests>true</skipTests>
    </configuration>
</plugin>

Or you can also set skipping tests in you POM file over property:

<properties>
    <maven.test.skip>true</maven.test.skip>
</properties>

Bonus

You can also skip tests in IntelliJ Idea. Just go to Maven tool tab and hit ‘Skip Test’ mode.

How to convert int to long in Java?

When we want to convert primitive int datatype to primitive long data type, all we need to do is just assign primitive int to primitive long variable. Nothing else is necessary. Converting primitive data type from higher to lower data type is implicit.

Let’s look on the example how to convert int to long in Java:

public class Main {
    public static void main(String args[]) {
        int primitiveInt = 1000;
        long primitiveLong = primitiveInt;
        System.out.println(primitiveLong);
    }
}

Output

1000

How to convert int to Long in Java?

When we want to convert primitive int datatype to a Long object, there are two different ways to do it.

We can:

• instantiate new Long class over int constructor.
• use a static method to extract primitive int and create a new Long object (calling Long.valueOf() method).

Let’s look on the example how to convert int to long in Java:

public class Main {
    public static void main(String args[]) {
        int primitiveInt = 1000;

        // Option #1 - constructor initiation
        final Long objectLong = new Long(primitiveInt);
        // Option #2 - use static method
        final Long objectLongOther = Long.valueOf(primitiveInt);

        System.out.println(objectLong);
        System.out.println(objectLongOther);
    }
}

Output

1000
1000