<h2 id="introduction">Introduction</h2>
The Random Forest algorithm is a tree-based supervised learning algorithm that uses an ensemble of predictions of many decision trees, either to classify a data point or determine its approximate value. This means it can either be used for classification or regression.
When applied for classification, the class of the data point is chosen based on the class that was most voted by the trees; and when applied for regression, the value of the data point is the average of all the values output by the trees.
<blockquote>
An important thing to remember when using Random Forests is that the number of trees is a hyperparameter and it will be defined before running the model.
</blockquote>
When working in data science, one of the reasons why a Random Forest model was chosen for a specific project might have to do with the ability to look at ensembled trees and understand why a classification was made, or why a value was given - this is called explainability.
Considering tree based algorithms, attempting to explain a model can done in several ways, by displaying and looking at each tree (can be hard if the model has 200 trees or more), using <a target="_blank" rel="nofollow noopener noreferrer" href="https://shap.readthedocs.io/en/latest/index.html">Shapley (or SHAP) values</a>, looking at the features that were most taken into consideration by the model, using <a target="_blank" rel="nofollow noopener noreferrer" href="https://github.com/marcotcr/lime">LIME</a> to investigate the relationships between model input and output, etc. Usually, a combination of all methods is employed.
<blockquote>
In this quick guide, we will focus on creating a chart of the features that were considered important for the model to make a decision when classifying penguins. This is known as investigating the feature importance, and can be conveyed to other members of the team (technical and non-technical) to offer a glimpse into how decisions are made.
</blockquote>

 <div class="alert alert-reference">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-link-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Advice: If you'd like to read an in-depth guide to Random Forest, read our <a target="_blank" href="https://stackabuse.com/random-forest-algorithm-with-python-and-scikit-learn/">&quot;Guide to Random Forest Algorithm with Python and Scikit-Learn&quot;</a>!

 </div>
 </div>
 </div>
 To do this, let's import the necessary libraries, load the Palmer Penguins dataset, split the data, create the model, obtain the feature importances, and use Seaborn to plot them! We won't delve much on the data, EDA, or the model itself - those are the topic of the dedicated guide.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: You can download the dataset from <a target="_blank" href="https://gist.github.com/cassiasamp/197b4e070f5f4da890ca4d226d088d1f">GitHub</a> or directly from the code.

 </div>
 </div>
 </div>
 <h2 id="importinglibraries">Importing Libraries</h2>
Let's start by importing a few libraries that we'll be using:
<pre><code class="hljs"># Importing libraries
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier

# Loading the dataset
raw_data_url = &quot;https://gist.githubusercontent.com/cassiasamp/197b4e070f5f4da890ca4d226d088d1f/raw/38c9d4906ed121481b4dc201fa2004f2b3d0065f/penguins.csv&quot;
df = pd.read_csv(raw_data_url)
</code></pre>
<h2 id="splittingthedata">Splitting the Data</h2>
Let's split the data for training and testing:
<pre><code class="hljs"># Removing NaN values, and duplicated index column `rowid`
df = df.dropna().drop(&quot;rowid&quot;, axis=1)

# Splitting data into X (features) and y (target)
y = df[&quot;species&quot;]
X = df[[&quot;bill_length_mm&quot;, &quot;bill_depth_mm&quot;, &quot;flipper_length_mm&quot;]]

# Splitting data into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
</code></pre>
<h2 id="obtainingfeatureimportances">Obtaining Feature Importances</h2>
Finally - we can train a model and export the feature importances with:
<pre><code class="hljs"># Creating Random Forest (rf) model with default values
rf = RandomForestClassifier()

# Fitting model to train data
rf.fit(X_train, y_train)

# Obtaining feature importances
rf.feature_importances_
</code></pre>
This outputs:
<pre><code class="hljs">array([0.41267633, 0.30107056, 0.28625311])
</code></pre>
Those are the feature values, to see feature names, run:
<pre><code class="hljs"># Obtaining feature names
rf.feature_names_in_
</code></pre>
This results in the corresponding name of each feature:
<pre><code class="hljs">array([&#x27;bill_length_mm&#x27;, &#x27;bill_depth_mm&#x27;, &#x27;flipper_length_mm&#x27;],
 dtype=object)
</code></pre>
This means that the most important feature for deciding penguin classes for this particular model was the <code>bill_length_mm</code>!
The importance is relative to the measure of how well the data is being separated in each node split - in this case, the measure is given by the Gini Index - the Gini value is then weighted by how many rows have been split when using the <code>bill_length_mm</code> feature and averaged over the 100 trees in the ensemble. The result of those steps account for <code>0.41267633</code>, or more than 40% in this case.
<h2 id="visualizingfeatureimportance">Visualizing Feature Importance</h2>
A common way of representing importance values is by using bar charts. Let's first create a dataframe with the feature names and their corresponding importances, and then visualize them using Seaborn's <code>barplot()</code>:
<pre><code class="hljs"># Creating importances_df dataframe
importances_df = pd.DataFrame({&quot;feature_names&quot; : rf.feature_names_in_, 
 &quot;importances&quot; : rf.feature_importances_})
 
# Plotting bar chart, g is from graph
g = sns.barplot(x=importances_df[&quot;feature_names&quot;], 
 y=importances_df[&quot;importances&quot;])
g.set_title(&quot;Feature importances&quot;, fontsize=14); 
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/feature-importances-chart-1.png" alt="">

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Advice: A good practice when presenting information is to order values either in ascending or descending order. In this case, the data is already ordered, with the first value being the first we want to know. When this isn't the case, you can order the dataframe with <code>sort_values</code>. This can be done on any column in ascending or descending order: <code>importances_df.sort_values(by=&quot;importances&quot;, ascending=False)</code>.

 </div>
 </div>
 </div>
 When looking at this first plot, it's harder to interpret the value of each feature's importance. It is obvious that the bill length is larger than the other two bars, but not exactly that the <code>bill_depth_mm</code> is equivalent to <code>0.30107056</code>, and that the <code>flipper_length_mm</code> is 0.28625311. So, this first chart can be improved by displaying the value of each bar. This can be done by accessing Seaborn's <code>containers</code> object. It stores each bar information and passing the values as bar labels:
<pre><code class="hljs">g = sns.barplot(data=importances_df, 
 x=&quot;importances&quot;, 
 y=&quot;feature_names&quot;)
g.set_title(&quot;Feature importances&quot;, fontsize=14)
for value in g.containers:
 g.bar_label(value)
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/feature-importances-chart-2.png" alt="">
Now, we can see each importance value clearly, or almost clearly, because the <code>bill_length_mm</code> value is being cut by a vertical line that is part of the chart's outer border. Borders are used to enclose an area as a means of focusing more attention on it, but in this case, we don't need to enclose, because there is only one graph. Let's remove the border and improve the numbers' readability:
<pre><code class="hljs">g = sns.barplot(data=importances_df, 
 x=&quot;importances&quot;, 
 y=&quot;feature_names&quot;)
 
# removing the borders with despine
sns.despine(bottom=True, left=True)
g.set_title(&quot;Feature importances&quot;, fontsize=14)
for value in g.containers:
 g.bar_label(value)
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/feature-importances-chart-3.png" alt="">
The chart seems easier to read, but the ticks on the X-axis seem to be floating and we already have the values along with the bars, so we can remove the <code>xticks</code>:
<pre><code class="hljs">g = sns.barplot(data=importances_df, 
 x=&quot;importances&quot;, 
 y=&quot;feature_names&quot;)
sns.despine(bottom=True, left=True)

# setting x ticks as empty
g.set(xticks=[])
g.set_title(&quot;Feature importances&quot;, fontsize=14)
for value in g.containers:
 g.bar_label(value)
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/feature-importances-chart-4.png" alt="">
Notice how after removing the ticks, the Y and X labels are a bit hard to read. The Y-label, <code>feature_names</code>, is vertical and in the X-axis, there are only <code>importances</code>. Since the title already states that the chart is of Feature importances, we can also remove the axis labels:
<pre><code class="hljs">g = sns.barplot(data=importances_df, 
 x=&quot;importances&quot;, 
 y=&quot;feature_names&quot;)
sns.despine(bottom=True, left=True)
g.set_title(&quot;Feature importances&quot;, fontsize=14)
g.set(xticks=[])

# removing x and y axis labels by setting them to None
g.set(xlabel=None)
g.set(ylabel=None)
for value in g.containers:
 g.bar_label(value)
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/feature-importances-chart-5.png" alt="">
You can see how this chart is cleaner, easier to read and understand when compared with the first one. There are still some things we can do. Observe that the numbers are really close to the bars, it would be easier to read if there was a little more space between them.
Another element in this plot are the colors, when contrasting colors are used, it transmits an idea of separation, on the other way around, when similar colors are used, they communicate an idea of unity, or parts of a whole. Since the features are all part of penguins, we can use a colors that makes each bar distinct while maintaining unity:
<pre><code class="hljs">g = sns.barplot(data=importances_df, 
 x=&quot;importances&quot;, 
 y=&quot;feature_names&quot;,
 
 # adding mako palette
 palette=&quot;mako&quot;)
sns.despine(bottom=True, left=True)
g.set_title(&quot;Feature importances&quot;, fontsize=14)
g.set(xticks=[])
g.set(xlabel=None)
g.set(ylabel=None)
for value in g.containers:
 g.bar_label(value, 
 padding=2) # adding space (padding) between bars and values
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/feature-importances-chart-6.png" alt="">
If you want to make the results even more direct, you can change the title and add the conclusion. What is known is that the bill length was considered the most important feature according to the criteria we have previously discussed. This can be the first information for someone that looks at the plot, we could say that the penguin's bill length was the most important feature for species classification in the Random Forest (RF) base model :
<pre><code class="hljs">g = sns.barplot(data=importances_df, 
 x=&quot;importances&quot;, 
 y=&quot;feature_names&quot;, 
 palette=&quot;mako&quot;)
sns.despine(bottom=True, left=True)
g.set_title(&quot;The penguin&#x27;s bill length was the most important feature for species classification (RF base model)&quot;, fontsize=14)
g.set(xticks=[])
g.set(xlabel=None)
g.set(ylabel=None)
for value in g.containers:
 g.bar_label(value, padding=2)
</code></pre>
This is the final result of the feature importances chart:
<img src="https://s3.stackabuse.com/media/articles/feature-importances-chart-7.png" alt="">
<h2 id="conclusion">Conclusion</h2>
In this guide - we've built a Random Forest Classifier - and inspected the feature importances that were used to train the model in an attempt to explain what a model has learned, and what affects its reasoning.

David Landup

Cássia Sampaio

In this guide - learn how to get feature importance from a Python's Scikit-Learn RandomForestRegressor or RandomForestClassifier, and how to plot and communicate the importance of features from the training set after fitting the model.

Get Feature Importances for Random Forest with Python and Scikit-Learn

<h2 id="introduction">Introduction</h2>
In bash scripts, assigning the output of a command to variables can be convenient by storing the outputs of the commands and using them later.
<blockquote>
In this short guide, we will take a look at how you can store the output of a command as a variable in Bash.
</blockquote>
<h2 id="thebasicstosetupvariables">The Basics To Set Up Variables</h2>
Saving the output of a command as a variable is achieved through command substitution. Command substitution is a wrapper that executes the command in a subshell environment, and replaces the wrapped command with the standard output of the environment in which the command was run. This output can then be referenced later, if connected to a reference variable!
Command substitution can be achieved through back ticks or the dollar sign with parentheses:
<pre><code class="hljs">`command`

$(command)
</code></pre>
There's debate as to whether `command` (backticks) or $(command) (dollar sign and parentheses) should be used as the &quot;best practice&quot;. <code>$(command)</code> works well in nesting, and improves readability in some cases, but you can go with either syntax in the preceding examples.
That being said - assigning the output of a command to a variable in Bash is as easy as:
<pre><code class="hljs">VARIABLE=$(command)
echo &quot;${VARIABLE}&quot;
</code></pre>
Running <code>${variable}</code> is known as parameter expansion, and is used to evaluate and fetch the value associated with a reference variable.
Let's now take a look at the simple example of setup a variable for a command to change the output color:
<pre><code class="hljs">#!/bin/bash
GREEN=$(tput setaf 2)
echo &quot;${GREEN}Please&quot;

ORANGE=$(tput setaf 9)
echo &quot;${ORANGE}Visit&quot;

echo &quot;${GREEN}Paris&quot;
</code></pre>
In the snippet, we've used the <code>tput</code> command and assigned the returned value of those commands to print colorful text. The <code>setaf</code> changes the foreground color, and 3 (green) and 9 (orange) are color codes.
Now we'll move on to another example that contains multiple conditions to set up variables for different commands:
<pre><code class="hljs">#!/bin/bash
PERSON=$(whoami)
echo -e &quot;Hey ${PERSON}! I am Charlie\n&quot;

DETAILS=$(uname -a)
echo -e &quot;You&#x27;re running this script on:\n${DETAILS}\n&quot;

DATES=$(date)
echo -e &quot;The script is being run on:\n${DATES}\n&quot;

CREATE=$(touch $(date +&quot;%d%m%Y&quot;).txt)
echo -e &quot;A text file logging this run is created.${CREATE}\n&quot;

LOCATION=$(ls \
 -l *txt)
echo -e &quot;Saved text file at: ${LOCATION}&quot;
</code></pre>
In the above script, the <code>whoami</code> command returns the current user's username. The <code>uname -a</code> returns the system information, and the <code>date</code> returns the current time and date.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: We can chain variable assignment by adding multiple commands in a single nested call. The <code>CREATE</code> variable contains the output of the <code>touch</code> command, which in turn creates a file and sets the filename to the output of the <code>date +&quot;%d%m%Y</code> command.

 </div>
 </div>
 </div>
 Finally, we add a <code>multiline</code> command variable assignment concept by adding a backslash <code>(\)</code> between the <code>ls</code> command <code>-l</code> flag to display only text files using <code>*.txt</code>. The backslash is an escape character that informs the shell not to interpret the next character.
In the <code>echo</code> command, we added the <code>-e</code> flag to use the special character, i.e., <code>\n</code> (newline), to print the output in the new line.
We get the following result after executing the script:
<pre><code class="hljs">$ ./variable.sh
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/how-to-save-command-output-as-variable-in-bash.jpg" alt="">
<h2 id="conclusion">Conclusion</h2>
In this short guide, we've taken a look at how you can set the output of a command to a variable in Bash. We've taken a look at the difference between the syntaxes for command substitution, noting the readability improvements of <code>$(command)</code> over backtick based substitution. Then, we've taken a look at several examples of both simple assignment and chained/nested output assignment.

Guest Contributor

In this short guide - learn how to save the output of a Bash command as a variable, that you can call later.

How to Save Command Output as Variable in Bash?

Felipe Antunes

In this guide, learn how to use the LambdaCallback to implement custom callbacks in Python with Keras and Tensorflow, as well as how to  subclass the Callback class to implement training visualization, sending emails when training is finished, etc. with practical code examples.

Guide to Writing Custom TensorFlow/Keras Callbacks

Uchechukwu Azubuko

In this tutorial - learn how to implement a reusable VueJS component to scroll to top with JavaScript, through practical code and an example project.

Scroll to Top in Vue with Reusable Components

Arpendu Kumar Garai

Convert YAML Array into Java List with SnakeYAML

Turning a collection of numbers (or objects whose fields you'd like to inspect) into a distribution of those numbers is a common statistical technique, and is employed in various contexts in reporting and data-driven applications.
Given a collection:
<pre><code class="hljs">1, 1, 2, 1, 2, 3, 1, 4, 5, 1, 3
</code></pre>
You can inspect their distribution as a count (frequency of each element), and store the results in a map:
<pre><code class="hljs">{
&quot;1&quot;: 5,
&quot;2&quot;: 2,
&quot;3&quot;: 2,
&quot;4&quot;: 1,
&quot;5&quot;: 1
}
</code></pre>
Or, you can normalize the values based on the total number of values - thus expressing them in percentages:
<pre><code class="hljs">{
&quot;1&quot;: 0.45,
&quot;2&quot;: 0.18,
&quot;3&quot;: 0.18,
&quot;4&quot;: 0.09,
&quot;5&quot;: 0.09
}
</code></pre>
Or even express these percentages in a <code>0..100</code> format instead of a <code>0..1</code> format.
<blockquote>
In this guide, we'll take a look at how you can calculate a distribution from a collection - both using primitive types and objects whose fields you might want to report in your application.
</blockquote>
With the addition of functional programming support in Java - calculating distributions is easier than ever. We'll be working with a collection of numbers and a collection of <code>Book</code>s:
<pre><code class="hljs">public class Book {

 private String id;
 private String name;
 private String author;
 private long pageNumber;
 private long publishedYear;

 // Constructor, getters, setters, toString()
}
</code></pre>
<h2 id="calculatedistributionofcollectioninjava">Calculate Distribution of Collection in Java</h2>
Let's first take a look at how you can calculate a distribution for primitive types. Working with objects simply allows you to call custom methods from your domain classes to provide more flexibility in the calculations.
By default, we'll represent the percentages as a double from <code>0.00</code> to <code>100.00</code>.
<h3 id="primitivetypes">Primitive Types</h3>
Let's create a list of integers and print their distribution:
<pre><code class="hljs">List&lt;Integer&gt; integerList = List.of(1, 1, 2, 1, 2, 3, 1, 4, 5, 1, 3);
System.out.println(calculateIntegerDistribution(integerList));
</code></pre>
The distribution is calculated with:
<pre><code class="hljs">public static Map&lt;Integer, Double&gt; calculateIntegerDistribution(List&lt;Integer&gt; list) {
 return list.stream()
 .collect(Collectors.groupingBy(Integer::intValue,
 Collectors.collectingAndThen(Collectors.counting(),
 count -&gt; (Double.parseDouble(String.format(&quot;%.2f&quot;, count * 100.00 / list.size()))))));
}
</code></pre>
This method accepts a list and streams it. While streamed, the values are grouped by their integer value - and their values are counted using <code>Collectors.counting()</code>, before being collected into a <code>Map&lt;Integer, Double&gt;</code> where the keys represent the input values and the doubles represent their percentages in the distribution.
The key methods here is <code>collect()</code> which accepts two collectors. The key-collector collects by simply grouping by the key values (input elements). The value-collector collects via the <code>collectingAndThen()</code> method, which allows us to count the values and then format them in another format, such as <code>count * 100.00 / list.size()</code> which lets us express the counted elements in percentages:
<pre><code class="hljs">{1=45.45, 2=18.18, 3=18.18, 4=9.09, 5=9.09}
</code></pre>

 <div class="alert alert-reference">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-link-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Advice: If you'd like to read more about <code>groupingBy()</code>, <code>counting()</code> and <code>collectingAndThen()</code> - read our in-depth, example driven <a target="_blank" href="https://stackabuse.com/guide-to-java-8-collectors-groupingby/">&quot;Guide to Java 8 Collectors: groupingBy()&quot;</a>, <a target="_blank" href="https://stackabuse.com/guide-to-java-8-collectors-counting/">&quot;Guide to Java 8 Collectors: counting()&quot;</a> and <a target="_blank" href="https://stackabuse.com/guide-to-java-8-collectors-collectingandthen/">&quot;Guide to Java 8 Collectors: collectingAndThen()&quot;</a>.

 </div>
 </div>
 </div>
 <h3 id="sortdistributionbyvalueorkey">Sort Distribution by Value or Key</h3>
When creating distributions - you'll typically want to sort the values. More often than not, this'll be by key. Java <code>HashMap</code>s don't guarantee to preserve order of insertion, so we'll have to use a <code>LinkedHashMap</code> which does. Additionally, it's easiest to re-stream the map and re-collect it now that it's a much smaller size and much more manageable.
The previous operation can quickly collapse multiple thousand records into small maps, depending on the number of keys you're dealing with, so re-streaming isn't expensive:
<pre><code class="hljs">public static Map&lt;Integer, Double&gt; calculateIntegerDistribution(List&lt;Integer&gt; list) {
 return list.stream()
 .collect(Collectors.groupingBy(Integer::intValue,
 Collectors.collectingAndThen(Collectors.counting(),
 count -&gt; (Double.parseDouble(String.format(&quot;%.2f&quot;, count.doubleValue() / list.size()))))))
 // Stream the entries of the distribution map
 // to sort it and store in a LinkedHashMap
 .entrySet()
 .stream()
 .sorted(Map.Entry.comparingByKey())
 .collect(Collectors.toMap(e -&gt; Integer.parseInt(e.getKey().toString()),
 Map.Entry::getValue,
 (a, b) -&gt; {
 throw new AssertionError();
 },
 LinkedHashMap::new));
}
</code></pre>
<h3 id="objects">Objects</h3>
How can this be done for objects? The same logic applies! Instead of an identify function (<code>Integer::intValue</code>), we'll be using the desired field instead - such as the published year for our books. Let's create a few books, store them in a list and then calculate the distributions of the publishing years:
<pre><code class="hljs">Book book1 = new Book(&quot;001&quot;, &quot;Our Mathematical Universe&quot;, &quot;Max Tegmark&quot;, 432, 2014);
Book book2 = new Book(&quot;002&quot;, &quot;Life 3.0&quot;, &quot;Max Tegmark&quot;, 280, 2017);
Book book3 = new Book(&quot;003&quot;, &quot;Sapiens&quot;, &quot;Yuval Noah Harari&quot;, 443, 2011);
Book book4 = new Book(&quot;004&quot;, &quot;Steve Jobs&quot;, &quot;Water Isaacson&quot;, 656, 2011);

List&lt;Book&gt; books = Arrays.asList(book1, book2, book3, book4);
</code></pre>
Let's calculate the distribution of the <code>publishedYear</code> field:
<pre><code class="hljs">public static Map&lt;Integer, Double&gt; calculateDistribution(List&lt;Book&gt; books) {
 return books.stream()
 .collect(Collectors.groupingBy(Book::getPublishedYear,
 Collectors.collectingAndThen(Collectors.counting(),
 count -&gt; (Double.parseDouble(String.format(&quot;%.2f&quot;, count * 100.00 / books.size()))))))
 // Sort results by year
 .entrySet()
 .stream()
 .sorted(Map.Entry.comparingByKey())
 .collect(Collectors.toMap(e -&gt; Integer.parseInt(e.getKey().toString()),
 Map.Entry::getValue,
 (a, b) -&gt; {
 throw new AssertionError();
 },
 LinkedHashMap::new));
}
</code></pre>
Adjust the <code>&quot;%.2f&quot;</code> to set the floating point precision. This results in:
<pre><code class="hljs">{2011=50.0, 2014=25.0, 2017=25.0}
</code></pre>
50% of the given books (2/4) were published in 2011, 25% (1/4) were published in 2014 and 25% (1/4) in 2017. What if you want to format this result differently, and normalize the range in <code>0..1</code>?
<h2 id="calculatenormalizedpercentagedistributionofcollectioninjava">Calculate Normalized (Percentage) Distribution of Collection in Java</h2>
To normalize the percentages from a <code>0.0...100.0</code> range to a <code>0..1</code> range - we'll simply adapt the <code>collectingAndThen()</code> call to not multiply the count by <code>100.0</code> before dividing by the size of the collection.
Previously, the <code>Long</code> count returned by <code>Collectors.counting()</code> was implicitly converted into a double (multiplication with a double value) - so this time, we'll want to explicitly get the <code>doubleValue()</code> of the <code>count</code>:
<pre><code class="hljs"> public static Map&lt;Integer, Double&gt; calculateDistributionNormalized(List&lt;Book&gt; books) {
 return books.stream()
 .collect(Collectors.groupingBy(Book::getPublishedYear,
 Collectors.collectingAndThen(Collectors.counting(),
 count -&gt; (Double.parseDouble(String.format(&quot;%.4f&quot;, count.doubleValue() / books.size()))))))
 // Sort results by key
 .entrySet()
 .stream()
 .sorted(comparing(e -&gt; e.getKey()))
 .collect(Collectors.toMap(e -&gt; Integer.parseInt(e.getKey().toString()),
 Map.Entry::getValue,
 (a, b) -&gt; {
 throw new AssertionError();
 },
 LinkedHashMap::new));
}
</code></pre>
Adjust the <code>&quot;%.4f&quot;</code> to set the floating point precision. This results in:
<pre><code class="hljs">{2011=0.5, 2014=0.25, 2017=0.25}
</code></pre>
<h2 id="calculateelementcountfrequencyofcollection">Calculate Element Count (Frequency) of Collection</h2>
Finally - we can get the element count (frequency of all elements) in the collection by simply not dividing the count by the size of the collection! This is a fully non-normalized count:
<pre><code class="hljs"> public static Map&lt;Integer, Integer&gt; calculateDistributionCount(List&lt;Book&gt; books) {
 return books
 .stream()
 .collect(Collectors.groupingBy(Book::getPublishedYear,
 Collectors.collectingAndThen(Collectors.counting(),
 count -&gt; (Integer.parseInt(String.format(&quot;%s&quot;, count.intValue()))))))
 // Sort values by key
 .entrySet()
 .stream()
 .sorted(Map.Entry.comparingByKey())
 .collect(Collectors.toMap(e -&gt; Integer.parseInt(e.getKey().toString()),
 Map.Entry::getValue,
 (a, b) -&gt; {
 throw new AssertionError();
 },
 LinkedHashMap::new));
}
</code></pre>
This results in:
<pre><code class="hljs">{2011=2, 2014=1, 2017=1}
</code></pre>
Indeed, there are two books from 2011, and one from 2014 and 2017 each.
<h2 id="conclusion">Conclusion</h2>
Calculating distributions of data is a common task in data-rich applications, and doesn't require the use of external libraries or complex code. With functional programming support, Java made working with collections a breeze!
In this short draft, we've taken a look at how you can calculate frequency counts of all elements in a collection, as well as how to calculate distribution maps normalized to percentages between <code>0</code> and <code>1</code> as well as <code>0</code> and <code>100</code> in Java.

In this short guide, learn how to count the frequency of elements in a Java list or other collections, as well as calculate the percentage distributions normalized to `0..1` and `0..100` using Java Collectors.

Calculate Distribution from Collection in Java

Null values arise a lot in software development, and proper handling of <code>null</code> values can be turned into a science in and of itself. Jackson is the de facto library for serialization and deserialization of Java objects - and a common scenario pertains to serializing objects that have <code>null</code> fields.
<blockquote>
In this short tutorial, we'll take a look at how you can ignore null fields when serializing a POJO with Jackson.
</blockquote>
<h2 id="changingtheobjectmappersettings">Changing the ObjectMapper Settings</h2>
Jackson's ObjectMapper is the central API that maps objects to serialized values. Naturally, you can adjust and customize the way it works through various flags, one of which is:
<pre><code class="hljs">objectMapper.setSerializationInclusion(Include.NON_NULL);
</code></pre>
When serializing with this mapper, properties will only be included if they're non-null.
This sets the flag globally for any object being serialized with the <code>objectMapper</code> instance. If you're working with Spring Boot, and the ObjectMapper it's relying on isn't exposed, you can alter the flag in the <code>application.properties</code> file:
<pre><code class="hljs">spring.jackson.default-property-inclusion = non_null
</code></pre>
Or, if you're using <code>application.yml</code>:
<pre><code class="hljs">spring:
 jackson:
 default-property-inclusion: non_null
</code></pre>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: Older versions of Spring used <code>spring.jackson.serialization-inclusion=non_null</code> instead of <code>spring.jackson.default-property-inclusion=non_null</code>.

 </div>
 </div>
 </div>
 Alternatively, you can peel back replace the default <code>ObjectMapper</code> instance by registering a new <code>@Primary</code> <code>@Bean</code>, named <code>objectMapper()</code>, which overrides the default implementation and allows full customization over the instance that'll be used by default when serializing and deserializing:
<pre><code class="hljs">@Bean
@Primary
public ObjectMapper objectMapper() {
 return new ObjectMapper()
 .setSerializationInclusion(JsonInclude.Include.NON_NULL);
}
</code></pre>
This <code>@Bean</code> should go into any file that's annotated with the <code>@Configuration</code> annotation, and is oftentimes situated either in a specialized configuration class or the main class of the Spring Boot application.
<h2 id="changingthejackson2objectmapperbuilderinstance">Changing the Jackson2ObjectMapperBuilder Instance</h2>
Spring uses the <code>HttpMessageConverters</code> to convert between HTTP messages and objects. The default converters are the <code>ObjectMapper</code> and <code>XmlMapper</code> instances instantiated via the <code>Jackson2ObjectMapperBuilder</code>.
Instead of manually providing the primary <code>ObjectMapper</code> (replacing the one provided by the builder), you can instruct Spring on how to build the object mapper instead. This allows Spring to do its high-level configurations without you tampering with the lower-level objects, while still customizing the way it works. Additionally, you can also customize the <code>XmlMapper</code> this way in one go.
To customize the builder, you register a new <code>@Bean</code> of <code>Jackson2ObjectMapperBuilderCustomizer</code> type, which customizes and returns the builder:
<pre><code class="hljs">@Bean
public Jackson2ObjectMapperBuilderCustomizer customBuilder() {
 return builder -&gt; {
 builder.serializationInclusion(JsonInclude.Include.NON_NULL);
 }
}
</code></pre>
<h2 id="jsonincludeannotation">@JsonInclude Annotation</h2>
On the other end of the spectrum, we can use annotations, as a low-code alternative! Annotations can be applied at the class-level or method-level:
<pre><code class="hljs">@JsonInclude(JsonInclude.Include.NON_NULL)
</code></pre>
This allows you to customize only certain classes, instead of the global behavior of the object mapper.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: As of Jackson 2.0, the annotation's value is <code>JsonInclude.Include.NON_NULL</code>. For earlier versions, use <code>include=JsonSerialize.Inclusion.NON_NULL</code>.

 </div>
 </div>
 </div>
 <h3 id="jsonincludeonclasslevel">@JsonInclude on Class-Level</h3>
When you apply <code>@JsonInclude</code> at class-level, the annotation extends to all of the getters and setters:
<pre><code class="hljs">@Entity(name=&quot;property&quot;)
@JsonInclude(JsonInclude.Include.NON_NULL)
public class Property implements Serializable {
 private static final long serialVersionUID = 1L;
 
 @Id
 @GeneratedValue(strategy=GenerationType.AUTO)
 private String id;

 @Column(name=&quot;transaction_type&quot;)
 private TransactionType transactionType;

 @Column(name=&quot;property_type&quot;)
 private PropertyType propertyType;
 
 // Constructor, getters, setters, toString(), etc.
}
</code></pre>
Any given field that has a <code>null</code> value won't be serialized.
<h3 id="jsonincludeonmethodlevel">@JsonInclude on Method-Level</h3>
Alternatively, you can apply the annotation at method-level as the most granular option:
<pre><code class="hljs">@Entity(name=&quot;property&quot;)
public class Property implements Serializable {
 private static final long serialVersionUID = 1L;
 
 @Id
 @GeneratedValue(strategy=GenerationType.AUTO)
 private String id;

 @Column(name=&quot;transaction_type&quot;)
 @JsonInclude(JsonInclude.Include.NON_NULL)
 private TransactionType transactionType;

 @Column(name=&quot;property_type&quot;)
 private PropertyType propertyType;
 
 // Constructor, getters, setters, toString(), etc.
}
</code></pre>
In this snippet - the annotation is only applied to the <code>TransactionType</code> field.
<h2 id="conclusion">Conclusion</h2>
In this guide, you've learned how to ignore null fields in Jackson, with Java and Spring Boot. This can be achieved globally by replacing the underlying implicit <code>ObjectMapper</code> instance and customizing the behavior of the new primary bean you register.
Alternatively, you can customize the <code>Jackson2ObjectMapperBuilder</code> that builds the <code>ObjectMapper</code> for your application instead of replacing the already built one. For a low-code solution - you can change the <code>spring.jackson.default-property-inclusion</code> property in your properties files.
Finally - you can use the <code>@JsonInclude</code> annotation on class-level or method-level.

In this tutorial, learn how to ignore null fields when serializing POJOs with Jackson, in Java and Spring Boot. You can do this by customizing the ObjectMapper instance, changing the default-property-inclusion property in your properties file, customizing the Jackson2ObjectMapperBuilder instance, or applying the @JsonInclude annotation.

Ignore Null Fields with Jackson in Java and Spring Boot

Java Streams have been introduced all the way back in Java 8 in 2014, in an effort to introduce verbose Java to a Functional Programming paradigm. Java Streams expose many flexible and powerful functional operations to perform collection processing in one-liners.
Filtering collections based on some predicate remains one of the most commonly used functional operations, and can be performed with a <code>Predicate</code> or more concisely - with a Lambda Expression.
<blockquote>
In this short guide, we'll take a look at how you can filter a Java 8 Stream with Lambda Expressions.
</blockquote>

 <div class="alert alert-reference">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-link-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Advice: If you aren't familiar with functional interfaces, predicates and lambda expressions - for an example-driven intuition-building guide, read our in-depth <a target="_blank" href="https://stackabuse.com/guide-to-functional-interfaces-and-lambda-expressions-in-java/">&quot;Guide to Functional Interfaces and Lambda Expressions in Java&quot;</a>!

 </div>
 </div>
 </div>
 <h2 id="filteringstreamsinjava">Filtering Streams in Java</h2>
In general, any <code>Stream</code> can be filtered via the <code>filter()</code> method, and a given predicate:
<pre><code class="hljs">Stream&lt;T&gt; filter(Predicate&lt;? super T&gt; predicate)
</code></pre>
Each element in the stream is run against the predicate, and is added to the output stream if the predicate returns <code>true</code>. You can supply a <code>Predicate</code> instance:
<pre><code class="hljs">Predicate&lt;String&gt; contains = s -&gt; s.contains(&quot;_deprecated&quot;);
List&lt;String&gt; results = stream.filter(contains).collect(Collectors.toList());
</code></pre>
Or, simplify it by providing a Lambda Expression:
<pre><code class="hljs">List&lt;String&gt; results = stream.filter(s -&gt; s.contains(&quot;_deprecated&quot;))
 .collect(Collectors.toList());
</code></pre>
Or even collapse the Lambda Expression into a method reference:
<pre><code class="hljs">// Filters empty strings by invoking s -&gt; s.isEmpty() on each element
List&lt;String&gt; results = stream.filter(String::isEmpty)
 .collect(Collectors.toList());
</code></pre>
With method references, you can't pass arguments, though, you can define methods in the object you're filtering and tailor them to be easily filterable (as long as the method doesn't accept arguments and returns a <code>boolean</code>).
Remember that streams are not collections - they're streams of collections, and you'll have to collect them back into any collection such as a <code>List</code>, <code>Map</code>, etc. to give them permanence. Additionally, all operations done on stream elements either intermediate or terminal:
<ul>
<li>Intermediate operations return a new stream with changes from the previous operation</li>
<li>Terminal operations return a data type and are meant to end a pipeline of processing on a stream</li>
</ul>
<code>filter()</code> is an intermediate operation, and is meant to be chained with other intermediate operations, before the stream is terminated. To persist any changes (such as changes to elements themselves, or filtered results), you'll have to assign the resulting output stream to a new reference variable, through a terminal operation.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: Even when chaining many lambda expressions, you might not run into readability issues, with proper line breaks.

 </div>
 </div>
 </div>
 In the following examples, we'll be working with this list of books:
<pre><code class="hljs">Book book1 = new Book(&quot;001&quot;, &quot;Our Mathematical Universe&quot;, &quot;Max Tegmark&quot;, 432, 2014);
Book book2 = new Book(&quot;002&quot;, &quot;Life 3.0&quot;, &quot;Max Tegmark&quot;, 280, 2017);
Book book3 = new Book(&quot;003&quot;, &quot;Sapiens&quot;, &quot;Yuval Noah Harari&quot;, 443, 2011);
 
List&lt;Book&gt; books = Arrays.asList(book1, book2, book3);
</code></pre>
<h3 id="filtercollectionwithstreamfilter">Filter Collection with Stream.filter()</h3>
Let's filter this collection of books. Any predicate goes - so let's for example filter by which books have over 400 pages:
<pre><code class="hljs">List&lt;Book&gt; results = books.stream()
 .filter(b -&gt; b.getPageNumber() &gt; 400)
 .collect(Collectors.toList());
</code></pre>
This results in a list which contains:
<pre><code class="hljs">[
Book{id=&#x27;001&#x27;, name=&#x27;Our Mathematical Universe&#x27;, author=&#x27;Max Tegmark&#x27;, pageNumber=432, publishedYear=2014}, 
Book{id=&#x27;003&#x27;, name=&#x27;Sapiens&#x27;, author=&#x27;Yuval Noah Harari&#x27;, pageNumber=443, publishedYear=2011}
]
</code></pre>
When filtering, a really useful method to chain is <code>map()</code>, which lets you map objects to another value. For example, we can map each book to its name, and thus return only the names of the books that fit the predicate from the <code>filter()</code> call:
<pre><code class="hljs">List&lt;String&gt; results = books.stream()
 .filter(b -&gt; b.getPageNumber() &gt; 400)
 .map(Book::getName)
 .collect(Collectors.toList());
</code></pre>
This results in a list of strings:
<pre><code class="hljs">[Our Mathematical Universe, Sapiens]
</code></pre>
<h3 id="filtercollectiononmultiplepredicateswithstreamfilter">Filter Collection on Multiple Predicates with Stream.filter()</h3>
Commonly, we'd like to filter collections by more than one criteria. This can be done by chaining multiple <code>filter()</code> calls or using a short-circuit predicate, which checks for two conditions in a single <code>filter()</code> call.
<pre><code class="hljs"> List&lt;Book&gt; results = books.stream()
 .filter(b -&gt; b.getPageNumber() &gt; 400 &amp;&amp; b.getName().length() &gt; 10)
 .collect(Collectors.toList());
 
// Or

 List&lt;Book&gt; results2 = books.stream()
 .filter(b -&gt; b.getPageNumber() &gt; 400)
 .filter(b -&gt; b.getName().length() &gt; 10)
 .collect(Collectors.toList());
</code></pre>
When utilizing multiple criteria - the lambda calls can get somewhat lengthy. At this point, extracting them as standalone predicates might offer more clarity. Though, which approach is faster?
<h2 id="singlefilterwithcomplexconditionormultiplefilters">Single Filter with Complex Condition or Multiple Filters?</h2>
It depends on your hardware, how large your collection is, and whether you use parallel streams or not. In general - one filter with a complex condition will outperform multiple filters with simpler conditions (small-to-medium collections), or perform at the same level (very large collections). If your conditions are too long - you may benefit from distributing them over multiple <code>filter()</code> calls, for the improved readability, since performance is very similar.
The best choice is to try both, note the performance on the target device, and adjust your strategy accordingly.
GitHub user volkodavs did a filtering benchmark in throughput operations/s, and hosted the results on the <a target="_blank" href="https://github.com/volkodavs/javafilters-benchmarks">javafilters-benchmarks</a> repository. The results are summarized in an informative table:
<img src="https://s3.stackabuse.com/media/articles/java-stream-filter-with-lambda-expression-1.png" alt="">
It shows a clear diminishing of returns at larger collection sizes, with both approaches performing around the same level. Parallel streams benefit significantly at larger collection sizes, but curb the performance at smaller sizes (below ~10k elements). It's worth noting that parallel streams maintained their throughput much better than non-parallel streams, making them significantly more robust to input.

In this short guide, learn how to filter a stream with lambda expressions, method references and predicates in Java, with a single filter with multiple conditions (criteria) vs multiple filters benchmark and best practices.

Java - Filter a Stream with Lambda Expressions

<h2 id="introduction">Introduction</h2>
The <code>echo</code> command outputs a given string to the standard output pipe, typically pointing to the terminal. Although the standard output pipe can point to other interfaces - the <code>echo</code> command is typically used to print and display messages in the terminal. By default, the text of the displayed message inherits the color of other text in the terminal (which is customizable in and of itself). However - there are several ways you can alter the output color of <code>echo</code> - both for individual strings and for entire messages.
<blockquote>
In this short guide, we'll take a look at how you can change the output color of <code>echo</code> in Linux-based systems, using ANSI escape codes, <code>tput</code> and how you can make this process less verbose in Bash scripts.
</blockquote>
<h2 id="changeoutputcolorwithansiescapecodes">Change Output Color with ANSI Escape Codes</h2>
The easiest way to change the color is through ANSI escape sequences/codes. All ANSI escape codes start with the <code>Escape</code> character, which can be represented in various formats - <code>27</code> in decimal, <code>\x1B</code> in hexadecimal, as the control key <code>^[</code>, or <code>\033</code> in octal format. The sequences are then followed by the command:
<pre><code class="hljs">\033[command
</code></pre>
Where the opening bracket (Control Sequence Introducer) is optional, but helps separate the command from the escape character. When you put a color code as the command, it changes the color of the oncoming text:
<pre><code class="hljs">\033[0;34
</code></pre>
<code>0;34</code> is the code for the color blue, for example. With this alone, you can change the color of text in <code>echo</code> with:
<pre><code class="hljs">\033[0;34Text
</code></pre>
Where <code>Text</code> would be colored blue. Alternatively, consider a simple bash script to print &quot;Welcome to France&quot; in the colors of the French flag:
<pre><code class="hljs">#!/bin/bash 
BLUE=&#x27;\033[0;34m&#x27;
WHITE= &#x27;\033[0;37m&#x27; 
RED= &#x27;\033[0;31m&#x27; 
echo -e &quot;${Blue}Welcome ${WHITE}to ${RED}France&quot;
</code></pre>
The optional <code>-e</code> flag of the <code>echo</code> command allows you to use special characters like <code>\n</code> (newline) and <code>\t</code> (tab) inside of the input string.
Once you run the script:
<pre><code class="hljs">$ ./colors.sh
</code></pre>
It results in:
<img src="https://s3.stackabuse.com/media/articles/how-to-change-the-output-color-of-echo-in-linux-1.jpg" alt="">
The ANSI codes aren't limited to color - but can also be applied for style. The codes <code>0..9</code> represent text styles, while the codes <code>30...37</code> represent colors:
<table class="table table-striped">
 <tr>
 <td>Color</td>
 <td>Codes</td>
 <td>Text Styles</td>
 <td>Codes</td>
 </tr>
 <tr>
 <td>Black</td>
 <td>30</td>
 <td>Simple text</td>
 <td>0</td>
 </tr>
 <tr>
 <td>Red</td>
 <td>31</td>
 <td>Bold text</td>
 <td>1</td>
 </tr>
 <tr>
 <td>Green</td>
 <td>32</td>
 <td>Low intensity text</td>
 <td>2</td>
 </tr>
 <tr>
 <td>Brown/Orange</td>
 <td>33</td>
 <td>Underline text</td>
 <td>4</td>
 </tr>
 <tr>
 <td>Blue</td>
 <td>34</td>
 <td>Blinking text</td>
 <td>5</td>
 </tr>
 <tr>
 <td>Purple</td>
 <td>35</td>
 <td>Invisible text</td>
 <td>8</td>
 </tr>
 <tr>
 <td>Cyan</td>
 <td>36</td>
 <td>Strikethrough text</td>
 <td>9</td>
 </tr>
 <tr>
 <td>Light Gray</td>
 <td>37</td>
 <td></td>
 <td></td>
 </tr>
</table>
Let's create a bash script to explore some of these options:
<pre><code class="hljs">#!/bin/bash
echo -e &quot;\033[0;33mSample text&quot;
echo -e &quot;\033[1;33mBold text&quot;
echo -e &quot;\033[2;33mLow intensity text&quot;
echo -e &quot;\033[4;33mUnderline text&quot;
echo -e &quot;\033[5;33mBlinking text&quot;
echo -e &quot;\033[8;33mInvisible text&quot;
echo -e &quot;\033[9;33mStrikethrough text&quot;
</code></pre>
Running this script results in:
<img src="https://s3.stackabuse.com/media/articles/how-to-change-the-output-color-of-echo-in-linux-2.gif" alt="">
Similarly, you can change the background color of these texts using codes <code>40..47</code>:
<table class="table table-striped">
 <tr>
 <td>color</td>
 <td>Codes</td>
 </tr>
 <tr>
 <td>Black</td>
 <td>40</td>
 </tr>
 <tr>
 <td>Red</td>
 <td>41</td>
 </tr>
 <tr>
 <td>Green</td>
 <td>42</td>
 </tr>
 <tr>
 <td>Brown/Orange</td>
 <td>43</td>
 </tr>
 <tr>
 <td>Blue</td>
 <td>44</td>
 </tr>
 <tr>
 <td>Purple</td>
 <td>45</td>
 </tr>
 <tr>
 <td>Cyan</td>
 <td>46</td>
 </tr>
 <tr>
 <td>Light Gray</td>
 <td>47</td>
 </tr>
</table>
Changing the background of a given string boils down to the same rule as when changing the font color - the code itself changes the behavior:
<pre><code class="hljs">#!/bin/bash
BLUE=&#x27;\033[0;44m&#x27;
BLACK=&#x27;\033[0;30m&#x27;
WHITE=&#x27;\033[0;30;47m&#x27;
RED=&#x27;\033[0;41m&#x27;
echo -e &quot;${BLUE}Welcome ${WHITE}to ${RED}France&quot;
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/how-to-change-the-output-color-of-echo-in-linux-3.jpg" alt="">

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: As a rule of thumb - you can translate font colors to background colors by adding 10. <code>30</code> is black font color, <code>40</code> is black background color.

 </div>
 </div>
 </div>
 <h2 id="changetheoutputcolorwiththetputcommand">Change the Output Color with the <code>tput</code> Command</h2>
An alternative to ANSI codes is using the <code>tput</code> command:
<pre><code class="hljs">tput setaf color_code
</code></pre>
<code>setf</code> allows for 8 colors, while <code>setaf</code> allows for 256 colors so depending on the command you're using, you can go between <code>0..7</code> and <code>0..255</code> as the color codes. Both commands dedicate <code>0..7</code> to the same color codes, while with <code>setaf</code>, <code>8..15</code> are high-intensity colors, and <code>16..231</code> are different hues of the first 8, and <code>232..255</code> are grayscale colors:
<img src="https://s3.stackabuse.com/media/articles/how-to-change-the-output-color-of-echo-in-linux-4.png" alt=""> 
Credit: <a target="_blank" rel="nofollow noopener noreferrer" href="https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit">Wikipedia</a>
Finally, <code>tput</code> also allows you to change the background color, add bold, lower the intensity, etc. with other commands:
<table class="table table-striped">
 <tr>
 <td>Text Styles</td>
 <td>Commands</td>
 </tr>
 <tr>
 <td>Foreground color</td>
 <td>setaf</td>
 </tr>
 <tr>
 <td>Background color</td>
 <td>setab</td>
 </tr>
 <tr>
 <td>No style</td>
 <td>sgv0</td>
 </tr>
 <tr>
 <td>Bold text</td>
 <td>bold</td>
 </tr>
 <tr>
 <td>Low-intensity text</td>
 <td>dim</td>
 </tr>
 <tr>
 <td>Underline text</td>
 <td>smul</td>
 </tr>
 <tr>
 <td>Blinking text</td>
 <td>blink</td>
 </tr>
 <tr>
 <td>Reverse text</td>
 <td>rev</td>
 </tr>
</table>
Let's create another script that uses <code>tput</code> to change the output color <code>echo</code>:
<pre><code class="hljs">#!/bin/bash
YELLOW=`tput setaf 3`
echo &quot;${YELLOW}Changing&quot;
WHITE=`tput setaf 7 bold`
echo &quot;${WHITE}Colors&quot;
BLUE=`tput setaf 4 smul`
echo &quot;${BLUE}With tput&quot;
CYAN=`tput setaf 6 blink`
echo &quot;${CYAN}is less&quot;
RED=`tput setab 1 setaf 7`
echo &quot;${RED}verbose!&quot;
</code></pre>
This script will print the following output in the terminal:
<img src="https://s3.stackabuse.com/media/articles/how-to-change-the-output-color-of-echo-in-linux-5.gif" alt="">
The <code>tput</code> command delivers an easy way to print any color through a simple color code. Let's now create a script that can print every color code available for the <code>tput</code> command:
<pre><code class="hljs">#!/bin/bash
tput init 
 end = $ (($ (tput colors) - 1)) 
 w = 1 
 for c
 in $ (seq 0 $end) 
 do
eval &quot;$(printf &quot; tput setaf % 3 s &quot; &quot; $c &quot;)&quot; 
 echo - n &quot;$_&quot; 
 [[$c - ge $ ((w * 2))]] 
 offset = 2 || offset = 0 
 [[$ (((c + offset) % (w - offset))) - eq $ (((w - offset) - 1))]] 
 echo 
 done 
 tput init
</code></pre>
It will print 0 to 255 color and their codes:
<img src="https://s3.stackabuse.com/media/articles/how-to-change-the-output-color-of-echo-in-linux-6.png" alt="">
<h2 id="conclusion">Conclusion</h2>
In this short guide - we've taken a look at how you can change the color of <code>echo</code>'s output in Linux - using ANSI Escape Sequences and the <code>tput</code> command.
We've also explored how you can make the process less verbose using Bash variables, tweak background colors and style text.

In this short guide, learn how to change the output color of the echo command in Linux/Unix systems, as well as how to change the text background color and apply basic formatting, using ANSI escape codes and tput.