<blockquote>
In this short tutorial, you'll learn how to reverse a list in-place and out-of-place in Java.
</blockquote>
<h2 id="reversinginplaceandoutofplace">Reversing In-Place and Out-Of-Place</h2>
When performing operations on lists - you might want to consider whether the operations are done in-place (changes are enacted on the original object), or whether they're out-of-place (changes are enacted on a copy, and the original object is unchanged).
Some languages and libraries prefer different default behaviors. In Java, most operations on reversing lists will be in-place.
If this is your desired behavior - great! If not, you'll want to create a copy of the list before reversing the copy:
<pre><code class="hljs">List&lt;Integer&gt; list = new ArrayList&lt;&gt;(Arrays.asList(1, 2, 3));
List&lt;Integer&gt; listCopy = new ArrayList&lt;&gt;(list);
</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: The <code>clone()</code> method doesn't create a deep copy. Creating a list using <code>new ArrayList&lt;&gt;(list)</code> doesn't create a deep copy. Creating deep copies is discouraged, and surprisingly difficult to do in a generic way (and doesn't make sense in some cases, depending on the data type(s) in the list). This won't stop you from being able to reverse <code>list</code> and not have the elements of <code>listCopy</code> being reversed, though.

 </div>
 </div>
 </div>
 <h2 id="collectionsreverse">Collections.reverse()</h2>
The <code>Collections.reverse()</code> method is the standard method for reversing a collection, and acts as the &quot;missing&quot; <code>List.reverse()</code> method. It reverses the list in-place:
<pre><code class="hljs">List&lt;Integer&gt; list = new ArrayList&lt;&gt;(Arrays.asList(1, 2, 3));
List&lt;Integer&gt; listCopy = new ArrayList&lt;&gt;(list);

Collections.reverse(list);

System.out.println(list); // [3, 2, 1]
System.out.println(listCopy); // [1, 2, 3]
</code></pre>
<h2 id="guavaslistsreverselist">Guava's Lists.reverse(list)</h2>
If you're using Google Guava already in your project, you can also leverage the <code>Lists</code> class, which offers the <code>reverse()</code> method, which doesn't sort the original list in-place, but creates a copy and reverses the copy:
<pre><code class="hljs">List&lt;Integer&gt; list = new ArrayList&lt;&gt;(Arrays.asList(1, 2, 3));
List&lt;Integer&gt; reversedList = Lists.reverse(list);

System.out.println(list); // [3, 2, 1]
System.out.println(reversedList); // [1, 2, 3]
</code></pre>
If you don't have it already, you can add Google Guava to your project using Maven, by including its dependency in your <code>pom.xml</code> file:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;com.google.guava&lt;/groupId&gt;
 &lt;artifactId&gt;guava&lt;/artifactId&gt;
&lt;/dependency&gt;
</code></pre>
Or via Gradle:
<pre><code class="hljs">implementation group: &#x27;com.google.guava&#x27;, name: &#x27;guava&#x27;
</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: If you don't already have Google Guava, or don't intend to use it for other parts of your project - don't import it just for this operation, and stick to the <code>Collections.reverse()</code> method. Guava is a large dependency, and it's a major overkill use it for this operation only.

 </div>
 </div>
 </div>
 <h2 id="listaddandlistremove">List.add() and List.remove()</h2>
If you wish to perform additional operations besides just reversing the list - you can iterate through the original list, remove the elements from the end, pass them through an arbitrary method, and add them back at the start of the list:
<pre><code class="hljs">// Just return the input - placeholder for any other operation
public static int process(int input) {
 return input;
}

List&lt;Integer&gt; list = new ArrayList&lt;&gt;(Arrays.asList(1, 2, 3));

for (int i = 0, j = list.size()-1; i &lt;= j; i++) {
 int lastValue = process(list.remove(j));
 list.add(i, lastValue);
}

System.out.println(list); // [3, 2, 1]
</code></pre>
<h2 id="benchmark">Benchmark</h2>
So, which is the fastest? This also depends on whether you want to perform the operation in-place or out-of-place.
<h3 id="inplacereversalbenchmark">In-Place Reversal Benchmark</h3>
Let's benchmark both approaches on all three of the methods, starting with out-of-place:
<pre><code class="hljs">List&lt;Integer&gt; list = new Random().ints(100, 1, 11)
 .boxed()
 .collect(Collectors.toList());

int runs = 1000;

long start1 = System.currentTimeMillis();
for (int i = 0; i &lt; runs; i++) {
 reverseListCollections(list);
}
long end1 = System.currentTimeMillis();
System.out.println(String.format(&quot;Collections.reverse() took: %s miliseconds&quot;, end1-start1));

long start2 = System.currentTimeMillis();
for (int i = 0; i &lt; runs; i++) {
 reverseListGuava(list);
}
long end2 = System.currentTimeMillis();
System.out.println(String.format(&quot;Guava&#x27;s Lists.reverse() took: %s miliseconds&quot;, end2-start2));

long start3 = System.currentTimeMillis();
for (int i = 0; i &lt; runs; i++) {
 reverseListManually(list);
}
long end3 = System.currentTimeMillis();
System.out.println(String.format(&quot;Manually took: %s miliseconds&quot;, end3-start3));

System.out.println(&quot;Original list: &quot; + list);
</code></pre>
This results in:
<pre><code class="hljs">Collections.reverse() took: 3 miliseconds
Guava&#x27;s Lists.reverse() took: 4 miliseconds
Manually took: 13 miliseconds
Original list: [6, 7, 9, 7, 2, 5, 4, 1, 3, 2, 2, 6, ...
</code></pre>
What happens when we increase the number of elements from 100 to 1000?
<pre><code class="hljs">Collections.reverse() took: 9 miliseconds
Guava&#x27;s Lists.reverse() took: 4 miliseconds
Manually took: 133 miliseconds
Original list: [10, 2, 2, 6, 2, 4, 7, 3, 9, 2, 7, 5, ...
</code></pre>
Guava retains the 4ms mark! The manual approach has the worst time complexity, and it rose linearly. <code>Collections.reverse()</code> suffer less from scaling up, but Guava's implementation suffers the least. Though, keep in mind that we don't manually copy the list for the Guava approach. Will the benchmark change when we ditch the idea of having an &quot;original&quot; and &quot;reversed&quot; list?
<h3 id="outofplacereversalbenchmark">Out-Of-Place Reversal Benchmark</h3>
With 1000 elements, and each operating on a non-reversed copy of the list (which was excluded from the time measurements), when we remove the manual copy from each method and re-run the code:
<pre><code class="hljs">Collections.reverse() took: 7 miliseconds
Guava&#x27;s Lists.reverse() took: 3 miliseconds
Manually took: 131 miliseconds
Original list: [6, 8, 10, 7, 3, 8, 7, 1, 1, 9, 5, ...
</code></pre>
Guava still manages to consistently outperform both <code>Collections.reverse()</code> and the manual approach.
<h2 id="conclusion">Conclusion</h2>
In this short guide, you've learned how to reverse a list in Java, in-place and out-of-place, preserving the original list from the operation. We've used the <code>Collections.reverse()</code> method, Google Guava's <code>Lists.reverse()</code> method and a manual approach.

David Landup

In this short guide, you'll learn how to reverse a list in Java, in-place and out-of-place, preserving the original list from the operation. We've used the `Collections.reverse()` method, Google Guava's `Lists.reverse()` method and a manual approach.

Reversing a List in Java - In-Place and Out-Of-Place

Jackson is a very common library for handling JSON and serialization/deserialization in general in Java and Spring Boot based projects.
<blockquote>
Jackson handles property names by mapping them as they are to JSON - so <code>propertyName</code> in a POJO will have a corresponding <code>propertyName</code> in JSON. This convention is followed when converting JSON to POJO as well, and if the names don't match, the conversion can't be done.
</blockquote>
However, there are many cases in which you'd want the serialized JSON properties to have different names, such as standardizing naming conventions for other services (using cases like <code>snake_case</code>, instead of <code>CamelCase</code>) or conflicting property names (a <code>Customer</code> can have a <code>firstName</code>, just as an <code>Agent</code> - and a report may contain both of their <code>firstName</code> properties and needs to be serialized).
Let's create a <code>Book</code> class, with a few simple fields:
<pre><code class="hljs">public class Book {
 private String title;
 private String author;
 private int releaseYear;
 
 public Book() {}
 public Book(String title, String author, int releaseYear) {
 this.title = title;
 this.author = author;
 this.releaseYear = releaseYear;
 }
 // Getters, setters, toString(), etc.
}
</code></pre>
<h2 id="changejsonfieldnameswithjackson">Change JSON Field Names with Jackson</h2>
When usually converting an instance of a <code>Book</code> into JSON, we'd write the value of the object as a JSON string using <code>ObjectMapper</code>:
<pre><code class="hljs">ObjectMapper mapper = new ObjectMapper();
Book book = new Book(&quot;Our Mathematical Universe&quot;, &quot;Max Tegmark&quot;, 2014);
 
String jsonBook = mapper.writeValueAsString(book);
System.out.println(jsonBook);
</code></pre>
This results in:
<pre><code class="hljs">{&quot;title&quot;:&quot;Our Mathematical Universe&quot;,&quot;author&quot;:&quot;Max Tegmark&quot;,&quot;releaseYear&quot;:2014}
</code></pre>
The <code>title</code>, <code>author</code> and <code>releaseYear</code> are a 1-to-1 mapping to the <code>title</code>, <code>author</code> and <code>releaseYear</code> fields of the POJO. To change the name of a JSON property and retain it after serialization, there's no need to change your POJO! It's enough to annotate the relevant field with <code>@JsonProperty</code>, and supply the JSON name:
<pre><code class="hljs">public class Book {
 @JsonProperty(&quot;book_title&quot;)
 private String title;
 @JsonProperty(&quot;book_author&quot;)
 private String author;
 @JsonProperty(&quot;book_release_year&quot;)
 private int releaseYear;
 
 public Book(){}
 public Book(String title, String author, int releaseYear) {
 this.title = title;
 this.author = author;
 this.releaseYear = releaseYear;
 }
 // Getters, setters, toString(), etc.
}
</code></pre>
Now, when we instantiate the object and convert it to JSON:
<pre><code class="hljs">ObjectMapper mapper = new ObjectMapper();
Book book = new Book(&quot;Our Mathematical Universe&quot;, &quot;Max Tegmark&quot;, 2014);

String jsonBook = mapper.writeValueAsString(book);
System.out.println(jsonBook);
</code></pre>
The code results in:
<pre><code class="hljs">{&quot;book_title&quot;:&quot;Our Mathematical Universe&quot;,&quot;book_author&quot;:&quot;Max Tegmark&quot;,&quot;book_release_year&quot;:2014}
</code></pre>
<h2 id="changejsonfieldnamesinjsontopojoconversion">Change JSON Field Names in JSON-to-POJO Conversion?</h2>
It's worth noting that the name change isn't one-sided. The same annotation works both ways, and can bridge an incoming JSON with different names into a valid object. For instance, a JSON representing a book with <code>book_title</code>, wouldn't be mapped to the <code>title</code> property of the <code>Book</code> class by default, as they aren't the same.
Since we've annotated <code>title</code> as <code>book_title</code> - the conversion works just fine:
<pre><code class="hljs">Book bookReconstructed = mapper.readValue(jsonBook, Book.class);
System.out.print(bookReconstructed);
</code></pre>
This results in:
<pre><code class="hljs">Book{title=&#x27;Our Mathematical Universe&#x27;, author=&#x27;Max Tegmark&#x27;, releaseYear=2014}
</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: To construct an object from JSON, your class needs to have an empty constructor as well. Jackson first instantiates the empty object, and then populates the fields using the getters and setters.

 </div>
 </div>
 </div>
 <h2 id="annotategettersandsetterswithjsonproperty">Annotate Getters and Setters with @JsonProperty</h2>
Do you want to encode different names for serialization and deserialization? For instance, you can serialize <code>Book</code> into a JSON with <code>bt</code> denoting the book's title, but consume JSON with <code>book_title</code>. You can customize the getters and setters of the <code>Book</code> class with <code>@JsonProperty</code> annotations:
<pre><code class="hljs">@JsonProperty(&quot;bt&quot;)
public String getBt() {
 return title;
}

@JsonProperty(&quot;book_title&quot;)
public void setTitle(String title) {
 this.title = title;
}
</code></pre>
This way, when serialized, the <code>getBt()</code> method will serialize the <code>title</code> as a <code>bt</code> field in JSON. When reading from JSON (deserializing), you'll need to supply a <code>book_title</code>, that gets mapped to <code>title</code>.

 <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: Both <code>bt</code> and <code>book_title</code> will be mapped to the <code>title</code> field, but this doesn't make <code>bt</code> and <code>book_title</code> interchangeable. Jackson won't be able to convert between them without first converting to <code>title</code>.

 </div>
 </div>
 </div>
 Now, you can instantiate a book, serialize it, and deserialize another String into a book with:
<pre><code class="hljs">ObjectMapper mapper = new ObjectMapper();
Book book = new Book(&quot;Our Mathematical Universe&quot;, &quot;Max Tegmark&quot;, 2014);

// Serialization
String jsonBook = mapper.writeValueAsString(book);
System.out.println(jsonBook);

// Deserialization
String input = &quot;{\&quot;author\&quot;:\&quot;Max Tegmark\&quot;,\&quot;releaseYear\&quot;:2017,\&quot;book_title\&quot;:\&quot;Life 3.0\&quot;}&quot;;
Book bookReconstructed = mapper.readValue(input, Book.class);
System.out.print(bookReconstructed);
</code></pre>
This results in:
<pre><code class="hljs">{&quot;author&quot;:&quot;Max Tegmark&quot;,&quot;releaseYear&quot;:2014,&quot;bt&quot;:&quot;Our Mathematical Universe&quot;}
Book{title=&#x27;Life 3.0&#x27;, author=&#x27;Max Tegmark&#x27;, releaseYear=2017}
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this short tutorial, we've taken a look at how Jackson maps object fields to JSON, and how you can change the name of the fields before serialization. We've also explored the idea of using different JSON names for serialization and deserialization, using the <code>@JsonProperty</code> annotation on method-level, rather than field-level.

In this short tutorial, learn how to change JSON field names with Jackson in Java, as well as how to handle different JSON names during serialization and deserialization, and how Jackson's mapping between fields and JSON names works.

Change JSON Field Name with Jackson in Java

Jackson is one of the most common libraries for working with serialization and deserialization in Java and Spring Boot, primarily used for parsing and converting between POJOs and JSON.
Though, if you've worked with Jackson, you'll notice a distinct lack of pretty-printing by default:
<pre><code class="hljs">{Task 1=In_Progress, Task 2=Done, Task 3=Planned}
</code></pre>
<blockquote>
In this short tutorial, you'll learn how to pretty-print JSON with Jackson in standard Java and with Spring Boot.
</blockquote>
We'll be working with a JSON string, and a POJO converted into a JSON string, since these behave differently:
<pre><code class="hljs">public class Book {
 private String title;
 private String author;
 private int releaseYear;

 public Book(String title, String author, int releaseYear) {
 this.title = title;
 this.author = author;
 this.releaseYear = releaseYear;
 }
 // Getters, setters, toString(), ...
</code></pre>
Let's instantiate a <code>Book</code> instance, and a string for the input:
<pre><code class="hljs">String inputString = &quot;{\n&quot; +
 &quot;\&quot;Task 1\&quot; : \&quot;In_Progress\&quot;,\n&quot; +
 &quot;\&quot;Task 2\&quot; : \&quot;Done\&quot;,\n&quot; +
 &quot;\&quot;Task 3\&quot; : \&quot;Planned\&quot;\n&quot; +
 &quot;}&quot;;

Book book = new Book(&quot;Our Mathematical Universe&quot;, &quot;Max Tegmark&quot;, 2014);
</code></pre>
<h2 id="prettyprintjsonwithjacksononce">Pretty-Print JSON with Jackson Once</h2>
If you'd like to simply pretty-print once, in a single call, rather than setting the global printing flag - you can simply use the <code>writerWithDefaultPrettyPrinter()</code> call before writing a value as a string:
<pre><code class="hljs">ObjectMapper mapper = new ObjectMapper();

Object jsonString = mapper.readValue(inputString, Object.class);
String indentedString = mapper.writerWithDefaultPrettyPrinter()
 .writeValueAsString(jsonString);
 
 
System.out.println(jsonString);
System.out.println(indentedString);
</code></pre>
The input string was read from (JSON-to-Object), and the value of this object was written back into a string, using pretty-printing (Object-to-JSON):
<pre><code class="hljs">{Task 1=In_Progress, Task 2=Done, Task 3=Planned}

{
 &quot;Task 1&quot; : &quot;In_Progress&quot;,
 &quot;Task 2&quot; : &quot;Done&quot;,
 &quot;Task 3&quot; : &quot;Planned&quot;
}
</code></pre>
Alternatively, when using <code>readTree()</code>, the resulting <code>JsonNode</code> has a <code>toPrettyString()</code> function that serves as a great simple way to convert strings to pretty-printed JSON:
<pre><code class="hljs">ObjectMapper mapper = new ObjectMapper();
Object jsonString = mapper.readTree(inputString).toPrettyString();
System.out.println(jsonString);
</code></pre>
This is a quick and simple way to format an input JSON string! When working with POJOs, instead of reading from a given input, we'll only perform Object-to-JSON conversion and enable pretty-printing:
<pre><code class="hljs">ObjectMapper mapper = new ObjectMapper();

String jsonBook = mapper.writeValueAsString(book);
String indentedBook = mapper.writerWithDefaultPrettyPrinter()
 .writeValueAsString(book);


System.out.println(jsonBook);
System.out.println(indentedBook);
</code></pre>
<pre><code class="hljs">{&quot;title&quot;:&quot;Our Mathematical Universe&quot;,&quot;author&quot;:&quot;Max Tegmark&quot;,&quot;releaseYear&quot;:2014}
{
 &quot;title&quot; : &quot;Our Mathematical Universe&quot;,
 &quot;author&quot; : &quot;Max Tegmark&quot;,
 &quot;releaseYear&quot; : 2014
}
</code></pre>
<h2 id="globalprettyprintsetting">Global Pretty-Print Setting</h2>
Alternatively, you can enable global pretty-printing, if that's the preferable global behavior of Jackson for your project. This is as easy as using the <code>enable()</code> method of the <code>ObjectMapper()</code> instance when you're instantiating it:
<pre><code class="hljs">ObjectMapper mapper = new ObjectMapper().enable(SerializationFeature.INDENT_OUTPUT);
</code></pre>
As soon as you write an object as a JSON string - pretty-printing will be enabled by default:
<pre><code class="hljs">Object jsonString = mapper.readValue(inputString, Object.class);
String indentedString = mapper.writeValueAsString(jsonString);

System.out.println(jsonString);
System.out.println(indentedString);
</code></pre>
This results in:
<pre><code class="hljs">{Task 1=In_Progress, Task 2=Done, Task 3=Planned}
{
 &quot;Task 1&quot; : &quot;In_Progress&quot;,
 &quot;Task 2&quot; : &quot;Done&quot;,
 &quot;Task 3&quot; : &quot;Planned&quot;
}
</code></pre>
With POJOs:
<pre><code class="hljs">String jsonBook = mapper.writeValueAsString(book);
System.out.println(jsonBook);
</code></pre>
<pre><code class="hljs">{
 &quot;title&quot; : &quot;Our Mathematical Universe&quot;,
 &quot;author&quot; : &quot;Max Tegmark&quot;,
 &quot;releaseYear&quot; : 2014
}
</code></pre>
This approach is significantly less verbose if pretty-printing is a common display format.
<h2 id="prettyprintingjacksonwithspringboot">Pretty-Printing Jackson with Spring Boot</h2>
If you're using Spring Boot, without a manual <code>ObjectMapper</code> instance being created and rely on the underlying serializer, you can set the <code>indent_output</code> flag to <code>true</code> in the <code>application.properties</code> file:
<pre><code class="hljs">spring.jackson.serialization.indent_output=true
</code></pre>
Or, in <code>application.yaml</code>:
<pre><code class="hljs">spring:
 jackson:
 serialization:
 INDENT_OUTPUT: true
</code></pre>
This sets the <code>SerializationFeature.INDENT_OUTPUT</code> flag in Spring's <code>ObjectMapper</code> instance.
<h2 id="conclusion">Conclusion</h2>
In this short tutorial, we've taken a look at how you can pretty-print JSON from a String or POJO using Jackson. We've explored single-print changes (when you only want to pretty-print once) and setting the global Jackson flag for <code>ObjectMapper</code>. Finally, we took a look at changing Spring Boot properties for enabling pretty printing with Jackson.

In this practical tutorial, learn how to enable pretty printing for JSON strings and POJOs when using Jackson, Java and Spring Boot - both once and globally.

Pretty-Printing JSON with Jackson in Java and Spring Boot

<h2 id="introduction">Introduction</h2>
The Adapter Design Pattern is a popular Structural Design Pattern used in software engineering. This guide looks at how we can implement the Adapter Design Pattern in Python.
Design Patterns are template-like solutions - practically recipes for solving recurring, common problems in software development. The Adapter Pattern is based upon the concept of a real-world adapter! For instance, a laptop's charger may have a 3-pin plug at the end, but the wall socket may only be a 2-pin socket. To plug a 3-pin charger into this socket, we'd need an adapter, that accepts a 3-pin plug, and adapts the interface into the 2-pin socket.
A 2-pin charger and a 3-pin charger have the same basic function (conduct electricity from the socket to the laptop), but have a different form, and one can easily adapt into the other. Whenever you have software components with the same basic function but different forms, you can apply the Adapter Design Pattern.
<blockquote>
The Adapter Pattern follows this exact principle. It allows two incompatible interfaces to work together without modifying the internals of each component. This is achieved by adapting one interface, to another, externally.
</blockquote>
Let's look at some basic terminology before diving deeper into the world of Adapter Patterns:
<ul>
<li>Client Interface: An interface that specifies the functions that the client should implement.</li>
<li>Client: A class that implements the client interface.</li>
<li>Adaptee/Service: The incompatible class that needs to collaborate with the client interface.</li>
<li>Adapter: The class that makes the collaboration between the service and the client possible.</li>
</ul>
<h2 id="differenttypesofadapterpatterns">Different Types of Adapter Patterns</h2>
The adapter design pattern can be implemented in two different ways:
<h3 id="objectadapter">Object Adapter</h3>
With this method, the adapter class implements the methods from the client interface. Thus, the client object and the adapter object are compatible with each other. The service object forms a <code>has-a</code> relationship with the adapter object i.e. the service object belongs to the adapter object.
We know that the service class is not compatible with the client. The adapter class wraps around the service object by instantiating itself with that object. Now, the service object can be accessed through the adapter object, allowing the client to interact with it.
We can implement the object adapter in all of the modern programming languages.
<h3 id="classadapter">Class Adapter</h3>
With this method, the adapter has an <code>is-a</code> relationship with the service class. In this scenario, the adapter implements the methods required by the client, but it inherits from multiple adaptees, giving it the ability to call their incompatible functions directly. The biggest drawback with this variation is that we can only use it in the programming languages that support multiple inheritance of classes.
<h2 id="implementationoftheadapterdesignpatterninpython">Implementation of the Adapter Design Pattern in Python</h2>
In the section below, we will implement the Adapter design pattern in Python, specifically using the object adapter variation. The section is divided into two parts. First, we will create the environment where the Adapter Pattern should be used. It's important to see clearly how this pattern can solve some software problems. The second section will use an adapter to resolve the issue.
<h3 id="incompatibilityissuebetweenclasses">Incompatibility Issue Between Classes</h3>
Let's look at the compatibility issue when the client and service class implement different functionalities. Create a client class with the following methods and save it in a folder as <code>car.py</code>:
<pre><code class="hljs">import random

class Car:
 def __init__(self):
 self.generator = random.Random()

 def accelerate(self):
 random_num = self.generator.randint(50, 100)
 speed = random_num
 print(f&quot;The speed of the car is {speed} mph&quot;)

 def apply_brakes(self):
 random_num = self.generator.randint(20, 40)
 speed = random_num
 print(f&quot;The speed of the car is {speed} mph after applying the brakes&quot;)

 def assign_driver(self, driver_name):
 print(f&quot;{driver_name} is driving the car&quot;)
</code></pre>
Here, we have created a <code>Car</code> class with three methods: <code>accelerate()</code>, <code>apply_brakes()</code> and <code>assign_driver()</code>. We imported the <code>random</code> module and used it to generate numbers that set the car's speed after accelerating and applying the brakes. The <code>assign_driver()</code> method displays the car driver's name.
Next, we have to create a service or adaptee class that wishes to collaborate with the client class <code>Car</code>. Create a Motorcycle class like this and save it in your folder as <code>motorcycle.py</code>:
<pre><code class="hljs">import random

class Motorcycle:
 def __init__(self):
 self.generator = random.Random()

 def rev_throttle(self):
 random_num = self.generator.randint(50, 100)
 speed = random_num
 print(f&quot;The speed of the motorcycle is {speed} mph&quot;)

 def pull_brake_lever(self):
 random_num = self.generator.randint(20, 40)
 speed = random_num
 print(
 f&quot;The speed of the motorcycle is {speed} mph after applying the brakes&quot;)

 def assign_rider(self, rider_name):
 print(f&quot;{rider_name} is riding the motorcycle&quot;) 
</code></pre>
A service class, <code>Motorcycle</code> is created above with three methods <code>rev_throttle()</code>, <code>pull_brake_lever()</code>, and <code>assign_rider()</code>. Notice the difference between the methods of the service and client class despite their similar functionality. The <code>accelerator()</code> method increases the speed of the car while the <code>rev_throttle()</code> method increases the motorcycle's speed. Likewise, <code>apply_brakes()</code> and <code>pull_brake_lever()</code> apply brakes in the respective vehicles. Finally, the <code>assign_driver()</code> and <code>assign_rider()</code> methods assign the vehicle operator.
Next, let's create a class to access these different methods. First, add an <code>__init.py__</code> in the same folder you created <code>car.py</code> and <code>motorcycle.py</code>:
<pre><code class="hljs">touch __init__.py
</code></pre>
Now add the following code in a new file <code>drive.py</code>:
<pre><code class="hljs">from car import Car
from motorcycle import Motorcycle
import traceback

if __name__ == &#x27;__main__&#x27;:
 car = Car()
 bike = Motorcycle()

 print(&quot;The Motorcycle\n&quot;)
 bike.assign_rider(&quot;Subodh&quot;)
 bike.rev_throttle()
 bike.pull_brake_lever()
 print(&quot;\n&quot;)

 print(&quot;The Car\n&quot;)
 car.assign_driver(&quot;Sushant&quot;)
 car.accelerate()
 car.apply_brakes()
 print(&quot;\n&quot;)

 print(&quot;Attempting to call client methods with the service object\n&quot;)

 try:
 bike.assign_driver(&quot;Robert&quot;)
 bike.accelerate()
 bike.apply_brakes()
 except AttributeError:
 print(&quot;Oops! bike object cannot access car methods&quot;)
 traceback.print_exc()
</code></pre>
This script creates our client and service objects. We first import the <code>Car</code> and <code>Motorcycle</code> classes and create objects with them. Then we invoke the methods from the <code>bike</code> object (<code>Motorcycle</code> class). After, we invoke the methods of the <code>car</code> object (<code>Car</code> class). When executed, all the code mentioned so far will work.
However, an exception is raised when we try to invoke the methods of the <code>Car</code> class with the <code>bike</code> object. When we run this script:
<pre><code class="hljs">The Motorcycle

Subodh is riding the motorcycle
The speed of the motorcycle is 91 mph
The speed of the motorcycle is 37 mph after applying the brakes


The Car

Sushant is driving the car
The speed of the car is 59 mph
The speed of the car is 33 mph after applying the brakes


Attempting to call client methods with the service object

Oops! bike object cannot access car methods
Traceback (most recent call last):
 File &quot;drive.py&quot;, line 24, in &lt;module&gt;
 bike.assign_driver(&quot;Robert&quot;)
AttributeError: &#x27;Motorcycle&#x27; object has no attribute &#x27;assign_driver&#x27;
</code></pre>
In this case, we can modify the <code>Motorcycle</code> class or the <code>drive.py</code> script to use the right methods. However, in many cases, we may not have access to the source code of the client or service class. Also, this is a simple example. With larger clients and services, it may not be feasible to refactor either of them in case we break compatibility with other systems.
Instead, we can use an adapter to bridge the compatibility gap between our client code and our service object.
<h3 id="usingadapterstosolvetheincompatibilityissue">Using Adapters to Solve the Incompatibility Issue</h3>
In a new file, <code>motorcycle_adapter.py</code>, add the following class:
<pre><code class="hljs">class MotorcycleAdapter:

 def __init__(self, motorcycle):
 self.motorcycle = motorcycle

 def accelerate(self):
 self.motorcycle.rev_throttle()

 def apply_brakes(self):
 self.motorcycle.pull_brake_lever()

 def assign_driver(self, name):
 self.motorcycle.assign_rider(name)
</code></pre>
We created a <code>MotorcycleAdapter</code> class, which instantiates itself with a service object (<code>motorcycle</code>). The adapter implements the client methods which are <code>accelerate()</code>, <code>apply_brakes()</code> and <code>assign_driver()</code>. Inside the body of the <code>accelerate()</code> method, we have used the <code>motorcycle</code> instance of the service object to call the <code>rev_throttle()</code> service method. Likewise, the other methods use the corresponding methods of the <code>Motorcycle</code> class.
Now, let's update <code>drive.py</code> so we can use the adapter in the <code>try/except</code> block:
<pre><code class="hljs">from car import Car
from motorcycle import Motorcycle
from motorcycle_adapter import MotorcycleAdapter # Import the adapter class
import traceback

if __name__ == &#x27;__main__&#x27;:
 car = Car()
 bike = Motorcycle()
 bike_adapter = MotorcycleAdapter(bike) # Create the adapter

 ...

 try:
 print(&quot;Attempting to call client methods with the service object using an adapter\n&quot;)
 bike_adapter.assign_driver(&quot;Robert&quot;)
 bike_adapter.accelerate()
 bike_adapter.apply_brakes()
 except AttributeError:
 print(&quot;Oops! bike object cannot access car methods&quot;)
 traceback.print_exc()
</code></pre>
Here,<code>bike_adapter</code> is an object of the <code>MotorcycleAdapter</code> class. We supplied the <code>bike</code> object to the <code>MotorcycleAdapter</code> class' constructor. Executing this script gives us the following output:
<pre><code class="hljs">The Motorcycle

Subodh is riding the motorcycle
The speed of the motorcycle is 88 mph
The speed of the motorcycle is 35 mph after applying the brakes


The Car

Sushant is driving the car
The speed of the car is 91 mph
The speed of the car is 24 mph after applying the brakes


Attempting to call client methods with the service object

Attempting to call client methods with the service object using an adapter

Robert is riding the motorcycle
The speed of the motorcycle is 67 mph
The speed of the motorcycle is 25 mph after applying the brakes
</code></pre>
Without having to adjust the underlying <code>Motorcycle</code> class, we can get it to work like a <code>Car</code> using an adapter!
<h2 id="prosandconsofadapterdesignpattern">Pros and Cons of Adapter Design Pattern</h2>
The advantages of Adapter Patterns are:
<ul>
<li>We can achieve low coupling between the adapter class and the client class.</li>
<li>We can reuse the adapter class to incorporate numerous service classes in the application.</li>
<li>We can increase the flexibility of the program by introducing multiple adapters without interfering with the client code</li>
</ul>
The disadvantages of Adapter Pattern are:
<ul>
<li>The program's complexity increases with the addition of adapter class and service class.</li>
<li>There is an increase of overhead in the program as the requests are forwarded from one class to another.</li>
<li>Adapter Pattern(class adapter) uses multiple inheritance, which all the programming languages may not support.</li>
</ul>
<h2 id="conclusion">Conclusion</h2>
In this article, we learned about the adapter design pattern, its types, and the problems they solve. We implemented the Adapter Pattern in Python so that we can interact with a <code>Motorcycle</code> object, like a <code>Car</code> object by using an adapter so the interface of each class doesn't change.

Guest Contributor

Marcus Sanatan

We'll implement the adapter design pattern in Python so that we can interact with an object with an incompatible interface.

Adapter Design Pattern in Python

<h2 id="introduction">Introduction</h2>
Counting the number of word occurrences in a string is a fairly easy task, but has several approaches to doing so. You have to account for the efficiency of the method as well, since you'll typically want to employ automated tools when you don't want to perform manual labor - i.e. when the search space is large.
In this guide, you'll learn how to count the number of word occurrences in a string in Java:
<pre><code class="hljs">String searchText = &quot;Your body may be chrome, but the heart never changes. It wants what it wants.&quot;;
String targetWord = &quot;wants&quot;;
</code></pre>
We'll search for the number of occurrences of the <code>targetWord</code>, using <code>String.split()</code>, <code>Collections.frequency()</code> and Regular Expressions.
<h2 id="countwordoccurrencesinstringwithstringsplit">Count Word Occurrences in String with String.split()</h2>
The simplest way to count the occurrence of a target word in a string is to split the string on each word, and iterate through the array, incrementing a <code>wordCount</code> on each match. Note that when a word has any sort of punctuation around it, such as <code>wants.</code> at the end of the sentence - the simple word-level split will correctly treat <code>wants</code> and <code>wants.</code> as separate words!
To work around this, you can easily remove all punctuation from the sentence before splitting it:
<pre><code class="hljs">String[] words = searchText.replaceAll(&quot;\\p{Punct}&quot;, &quot;&quot;).split(&quot; &quot;);

int wordCount = 0;
for (int i=0; i &lt; words.length; i++)
 if (words[i].equals(targetWord))
 wordCount++;
System.out.println(wordCount);
</code></pre>
In the <code>for</code> loop, we simply iterate through the array, checking whether the element at each index is equal to the <code>targetWord</code>. If it is, we increment the <code>wordCount</code>, which at the end of the execution, prints:
<pre><code class="hljs">2
</code></pre>
<h2 id="countwordoccurrencesinstringwithcollectionsfrequency">Count Word Occurrences in String with Collections.frequency()</h2>
The <code>Collections.frequency()</code> method provides a much cleaner, higher-level implementation, which abstracts away a simple <code>for</code> loop, and checks for both identity (whether an object is another object) and equality (whether an object is equal to another object, depending on the qualitative features of that object).
The <code>frequency()</code> method accepts a list to search through, and the target object, and works for all other objects as well, where the behavior depends on how the object itself implements <code>equals()</code>. In the case of strings, <code>equals()</code> checks for the contents of the string:
<pre><code class="hljs">// Clean text of punctuation marks
searchText = searchText.replaceAll(&quot;\\p{Punct}&quot;, &quot;&quot;);
// Search through list of words
int wordCount = Collections.frequency(Arrays.asList(searchText.split(&quot; &quot;)), targetWord);
System.out.println(wordCount);
</code></pre>
Here, we've converted the array obtained from <code>split()</code> into a Java <code>ArrayList</code>, using the helper <code>asList()</code> method of the <code>Arrays</code> class. The reduction operation <code>frequency()</code> returns an integer denoting the frequency of <code>targetWord</code> in the list, and results in:
<pre><code class="hljs">2
</code></pre>
<h2 id="wordoccurrencesinstringwithmatcherregularexpressionsregex">Word Occurrences in String with Matcher (Regular Expressions - RegEx)</h2>
Finally, you can use Regular Expressions to search for patterns, and count the number of matched patterns. Regular Expressions are made for this, so it's a very natural fit for the task. In Java, the <code>Pattern</code> class is used to represent and compile Regular Expressions, and the <code>Matcher</code> class is used to find and match patterns.
Using RegEx, we can code the punctuation invariance into the expression itself, so there's no need to externally format the string or remove punctuation, which is preferable for large texts where storing another altered version in memory might be expensive:
<pre><code class="hljs">Pattern pattern = Pattern.compile(&quot;\\b%s(?!\\w)&quot;.format(targetWord));
// Or if you want to avoid string formatting
Pattern pattern = Pattern.compile(&quot;\\bwants(?!\\w)&quot;);
Matcher matcher = pattern.matcher(searchText);

int wordCount = 0;
while (matcher.find())
 wordCount++;

System.out.println(wordCount);
</code></pre>
This also results in:
<pre><code class="hljs">2
</code></pre>
<h2 id="efficiencybenchmark">Efficiency Benchmark</h2>
So, which is the most efficient? Let's run a small benchmark:
<pre><code class="hljs">int runs = 100000;

long start1 = System.currentTimeMillis();
for (int i = 0; i &lt; runs; i++) {
 int result = countOccurencesWithSplit(searchText, targetWord);
}

long end1 = System.currentTimeMillis();
System.out.println(String.format(&quot;Array split approach took: %s milliseconds&quot;, end1-start1));

long start2 = System.currentTimeMillis();
 for (int i = 0; i &lt; runs; i++) {
 int result = countOccurencesWithCollections(searchText, targetWord);
}

long end2 = System.currentTimeMillis();
System.out.println(String.format(&quot;Collections.frequency() approach took: %s milliseconds&quot;, end2-start2));

long start3 = System.currentTimeMillis();
for (int i = 0; i &lt; runs; i++) {
 int result = countOccurencesWithRegex(searchText, targetWord);
}

long end3 = System.currentTimeMillis();
System.out.println(String.format(&quot;Regex approach took: %s milliseconds&quot;, end3-start3));
</code></pre>
Each method will be run 100000 times (the higher the number, the lower the variance and results due to chance, due to the law of large numbers). Running this code results in:
<pre><code class="hljs">Array split approach took: 152 milliseconds
Collections.frequency() approach took: 140 milliseconds
Regex approach took: 92 milliseconds
</code></pre>
However - what happens if we make the search more computationally expensive by making it larger? Let's generate a synthetic sentence:
<pre><code class="hljs">List&lt;String&gt; possibleWords = Arrays.asList(&quot;hello&quot;, &quot;world &quot;);
StringBuffer searchTextBuffer = new StringBuffer();

for (int i = 0; i &lt; 100; i++) {
 searchTextBuffer.append(String.join(&quot; &quot;, possibleWords));
}
System.out.println(searchTextBuffer);
</code></pre>
This create a string with the contents:
<pre><code class="hljs">hello world hello world hello world hello ...
</code></pre>
Now, if we were to search for either &quot;hello&quot; or &quot;world&quot; - there'd be many more matches than the two from before. How do our methods do now in the benchmark?
<pre><code class="hljs">Array split approach took: 606 milliseconds
Collections.frequency() approach took: 899 milliseconds
Regex approach took: 801 milliseconds
</code></pre>
Now, array splitting comes out fastest! In general, benchmarks depend on various factors - such as the search space, the target word, etc. and your personal use case might be different from the benchmark.

 <div class="alert alert-warn">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-exclamation-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Advice: Try the methods out on your own text, note the times, and pick the most efficient and elegant one for you.

 </div>
 </div>
 </div>
 <h2 id="conclusion">Conclusion</h2>
In this short guide, we've taken a look at how to count word occurrences for a target word, in a string in Java. We've started out by splitting the string and using a simple counter, followed by using the <code>Collections</code> helper class, and finally, using Regular Expressions.
In the end, we've benchmarked the methods, and noted that the performance isn't linear, and depends on the search space. For longer input texts with many matches, splitting arrays seems to be the most performant. Try all three methods on your own, and pick the most performant one.

In this practical tutorial - learn how to count the number of times a target word shows up in a string in Java, using String.split(), Collections.frequency() and Regular Expressions (RegEx).

Java: Count Number of Word Occurrence in String

<h2 id="introduction">Introduction</h2>
Thresholding is a simple and efficient technique to perform basic segmentation in an image, and to binarize it (turn it into a binary image) where pixels are either <code>0</code> or <code>1</code> (or <code>255</code> if you're using integers to represent them).
Typically, you can use thresholding to perform simple background-foreground segmentation in an image, and it boils down to variants on a simple technique for each pixel:
<pre><code class="hljs">if pixel_value &gt; threshold:
 pixel_value = MAX
else:
 pixel_value = 0
</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: This essential process is known as Binary Thresholding. There are various ways you can tweak this general idea, and we've covered them in the previous guide - <a target="_blank" href="https://stackabuse.com/opencv-thresholding-in-python-with-cv2threshold/">&quot;OpenCV Thresholding in Python with cv2.threshold()&quot;</a>.

 </div>
 </div>
 </div>
 Simple thresholding has glaring issues and requires fairly pristine input, which makes it not-so-practical for many use cases. The main offender is a global threshold which is applied to the entire image, whereas images are rarely uniform enough for blanket thresholds to work, unless they're artificial.
A global threshold would work well on separating characters in a black and white book, on scanned pages. A global threshold will very likely fail on a phone picture of that same page, since the lighting conditions may be variable between parts of the page, making a global cut-off point too sensitive to real data.
To combat this - we can employ local thresholds, using a technique known as adaptive thresholding. Instead of treating all parts of the image with the same rule, we can change the threshold for each local area with the one that seems fitting for it. This makes thresholding partly invariant to changes in lighting, noise and other factors. While much more useful than global thresholding, thresholding itself is a limited, rigid technique, and is best applied for help with image preprocessing (especially when it comes to identifying images to discard), rather than segmentation.
For more delicate applications that require context, you're better off employing more advanced techniques, including deep learning, which has been driving the recent advancements in computer vision.

 <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 learn more about multi-class semantic segmentation with Deep Learning - you can enroll our <a target="_blank" href="https://stackabuse.com/courses/deeplabv3-semantic-segmentation-with-keras/">DeepLabV3+ Semantic Segmentation with Keras</a>!

 </div>
 </div>
 </div>
 <h2 id="adaptivethresholdingwithopencv">Adaptive Thresholding with OpenCV</h2>
Let's load in an image with variable lighting conditions, where one part of the image is in more focus than another, with the picture being taken from an angle. A picture I took of Harold McGee's &quot;On Food and Cooking&quot; will serve great!
<pre><code class="hljs">img = cv2.imread(&#x27;book.jpg&#x27;)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
plt.imshow(img)
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/opencv-adaptive-thresholding-in-python-with-cv2adaptivethreshold-1.png" alt="">
Now, using regular thresholding, we can try to separate out the letters from the background, since there's a clear color difference between them. All paper-color will be treated as the background. Since we don't really know what the threshold should be - let's apply Otsu's method to find a good value, anticipating that the image is somewhat bi-modal (dominated by two colors mostly):
<pre><code class="hljs">img = cv2.imread(&#x27;book.jpg&#x27;)
# Otu&#x27;s method requires grayscale images and blurring helps
# both accentuate bi-modal colors, but also removes some noise
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
blurred = cv2.GaussianBlur(gray, (7, 7), 0)

ret, mask = cv2.threshold(blurred, 0, 255, cv2.THRESH_OTSU)
print(f&#x27;Threshold: {ret}&#x27;)

fig, ax = plt.subplots(1, 2, figsize=(12, 5))
ax[0].imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
ax[1].imshow(cv2.cvtColor(mask, cv2.COLOR_BGR2RGB))
</code></pre>
Let's take a look at the result:
<img src="https://s3.stackabuse.com/media/articles/opencv-adaptive-thresholding-in-python-with-cv2adaptivethreshold-2.png" alt="">
Ouch. The left part of the text is mainly faded, the shadow around the gutter totally ate a portion of the image, and the text is too saturated! This is an image &quot;in the wild&quot;, and blanket rules such as global thresholding don't work well. What should the threshold be? It depends on the part of the image!
The <code>cv2.adaptiveThreshold()</code> method allows us to do exactly this:
<pre><code class="hljs">cv2.adaptiveThreshold(img, 
 max_value, 
 adaptive_method, 
 threshold_method, 
 block_size, 
 C)
</code></pre>
The <code>adaptive_method</code> can be a <code>cv2.ADAPTIVE_THRESH_MEAN_C</code> or <code>cv2.ADAPTIVE_THRESH_GAUSSIAN_C</code>, where <code>C</code> is the last argument you set. Both of these methods calculate the threshold according to the neighbors of the pixel in question, where the <code>block_size</code> dictates the number of neighbors to be considered (the area of the neighborhood).
<blockquote>
<code>ADAPTIVE_THRESH_MEAN_C</code> takes the mean of the neighbors and deducts <code>C</code>, while <code>ADAPTIVE_THRESH_GAUSSIAN_C</code> takes the Gaussian-weighted sum of the neighbors and deducts <code>C</code>.
</blockquote>
It also allows you to set a binarization strategy, but is limited to <code>THRESH_BINARY</code> and <code>THRESH_BINARY_INV</code>, and changing between them will effectively switch what's &quot;background&quot; and what's &quot;foreground&quot;.
The method just returns the mask for the image - not the return code and the mask. Let's try segmenting the characters in the same image as before, using adaptive thresholding:
<pre><code class="hljs"># Read and prepare image
img = cv2.imread(&#x27;book.jpg&#x27;)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
blurred = cv2.GaussianBlur(gray, (7, 7), 0)

# Apply adaptive thresholding
mask = cv2.adaptiveThreshold(blurred, 
 255, 
 cv2.ADAPTIVE_THRESH_MEAN_C, 
 cv2.THRESH_BINARY, 
 31, 
 10)

# Plot results
fig, ax = plt.subplots(1, 2, figsize=(12, 5))
ax[0].imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
ax[1].imshow(cv2.cvtColor(mask, cv2.COLOR_BGR2RGB))
plt.tight_layout()
</code></pre>
This results in a much cleaner image:
<img src="https://s3.stackabuse.com/media/articles/opencv-adaptive-thresholding-in-python-with-cv2adaptivethreshold-3.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">
 Note: The <code>block_size</code> argument must be an uneven number.

 </div>
 </div>
 </div>
 In much the same way, we can apply Gaussian thresholding:
<pre><code class="hljs">mask = cv2.adaptiveThreshold(blurred, 
 255, 
 cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
 cv2.THRESH_BINARY, 
 31, 
 10)
</code></pre>
Which also produces a pretty satisfactory image in the end:
<img src="https://s3.stackabuse.com/media/articles/opencv-adaptive-thresholding-in-python-with-cv2adaptivethreshold-4.png" alt="">
Both the block size (neighbor area) and <code>C</code> are hyperparameters to tune here. Try out different values and choose the one that works best on your image. In general, Gaussian thresholding is less sensitive to noise and will produce a bit bleaker, cleaner images, but this varies and depends on the input.
<h2 id="limitationsofadaptivethresholding">Limitations of Adaptive Thresholding</h2>
With adaptive thresholding, we were able to avoid the overarching limitation of thresholding, but it's still relatively rigid and doesn't work great for colorful inputs. For example, if we load in an image of scissors and a small kit with differing colors, even adaptive thresholding will have issues truly segmenting it right, with certain dark features being outlined, but without entire objects being considered:
<img src="https://s3.stackabuse.com/media/articles/opencv-adaptive-thresholding-in-python-with-cv2adaptivethreshold-5.png" alt="">
If we tweak the block size and <code>C</code>, we can make it consider larger patches to be part of the same object, but then run into issues with making the neighbor sizes too global, falling back to the same overarching issues with global thresholding:
<img src="https://s3.stackabuse.com/media/articles/opencv-adaptive-thresholding-in-python-with-cv2adaptivethreshold-6.png" alt="">
<h2 id="conclusion">Conclusion</h2>
In recent years, binary segmentation (like what we did here) and multi-label segmentation (where you can have an arbitrary number of classes encoded) has been successfully modeled with deep learning networks, which are much more powerful and flexible. In addition, they can encode global and local context into the images they're segmenting. The downside is - you need data to train them, as well as time and expertise.
For on-the-fly, simple thresholding, you can use OpenCV, and battle some of the limitations using adaptive thresholding rather than global thresholding strategies. For accurate, production-level segmentation, you'll want to use neural networks.

In this practical tutorial, learn how to perform adaptive thresholding (finding many optimal threshold values) for images in OpenCV and Python and the cv2.adaptiveThreshold() method - performing binarization and background/foreground segmentation easily.

OpenCV Adaptive Thresholding in Python with cv2.adaptiveThreshold()

<h2 id="introduction">Introduction</h2>
Thresholding is a simple and efficient technique to perform basic segmentation in an image, and to binarize it (turn it into a binary image) where pixels are either <code>0</code> or <code>1</code> (or <code>255</code> if you're using integers to represent them).
Typically, you can use thresholding to perform simple background-foreground segmentation in an image, and it boils down to variants on a simple technique for each pixel:
<pre><code class="hljs">if pixel_value &gt; threshold:
 pixel_value = MAX
else:
 pixel_value = 0
</code></pre>
This essential process is known as Binary Thresholding. Now - there are various ways you can tweak this general idea, including inverting the operations (switching the <code>&gt;</code> sign with a <code>&lt;</code> sign), setting the <code>pixel_value</code> to the <code>threshold</code> instead of a maximum value/0 (known as truncating), keeping the <code>pixel_value</code> itself if it's above the <code>threshold</code> or if it's below the <code>threshold</code>.
All of these have conveniently been implemented in OpenCV as:
<ul>
<li><code>cv2.THRESH_BINARY</code></li>
<li><code>cv2.THRESH_BINARY_INV</code></li>
<li><code>cv2.THRESH_TRUNC</code></li>
<li><code>cv2.THRESH_TOZERO</code></li>
<li><code>cv2.THRESH_TOZERO_INV</code></li>
</ul>
... respectively. These are relatively &quot;naive&quot; methods in that they're fairly simple, don't account for context in images, have knowledge of what shapes are common, etc. For these properties - we'd have to employ much more computationally expensive and powerful techniques.

 <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 learn more about multi-class semantic segmentation with Deep Learning - you can enroll our <a target="_blank" href="https://stackabuse.com/courses/deeplabv3-semantic-segmentation-with-keras/">DeepLabV3+ Semantic Segmentation with Keras</a>!

 </div>
 </div>
 </div>
 Now, even with the &quot;naive&quot; methods - some heuristics can be put into place, for finding good thresholds, and these include the Otsu method and the Triangle method:
<ul>
<li><code>cv2.THRESH_OTSU</code></li>
<li><code>cv2.THRESH_TRIANGLE</code></li>
</ul>

 <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: OpenCV thresholding is a rudimentary technique, and is sensitive to lighting changes and gradients, color heterogeneity, etc. It's best applied on relatively clean pictures, after blurring them to reduce noise, without much color variance in the objects you want to segment.

 </div>
 </div>
 </div>
 Another way to overcome some of the issues with basic thresholding with a single threshold value is to use adaptive thresholding which applies a threshold value on each small region in an image, rather than globally.

 <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 adaptive thresholding, read our - <a target="_blank" href="https://stackabuse.com/opencv-adaptive-thresholding-in-python-with-cv2adaptivethreshold/">&quot;OpenCV Adaptive Thresholding in Python with cv2.adaptiveThreshold()&quot;</a>.

 </div>
 </div>
 </div>
 <h2 id="simplethresholdingwithopencv">Simple Thresholding with OpenCV</h2>
Thresholding in OpenCV's Python API is done via the <code>cv2.threshold()</code> method - which accepts an image (NumPy array, represented with integers), the threshold, maximum value and thresholding method (how the <code>threshold</code> and <code>maximum_value</code> are used):
<pre><code class="hljs">img = cv2.imread(&#x27;objects.jpg&#x27;)
# Convert from BGR to RGB colorspace
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
# Blurring usually helps with ironing out small details that can
# make segmentation maps look full of &#x27;specks&#x27;
blurred = cv2.GaussianBlur(img, (7, 7), 0)
# Run thresholding, returning the masked image and return code
ret, img_masked = cv2.threshold(blurred, 220, 255, cv2.THRESH_BINARY)
</code></pre>
The return code is just the applied threshold:
<pre><code class="hljs">print(f&quot;Threshold: {ret}&quot;) # Threshold: 125
</code></pre>
Here, since the threshold is <code>220</code> and we've used the <code>THRESH_BINARY</code> method - every pixel value above <code>220</code> will be increased to <code>255</code>, while every pixel value below <code>220</code> will be lowered to <code>0</code>, creating a black and white image, with a &quot;mask&quot;, covering the foreground objects.
<blockquote>
Why 220? Knowing what the image looks like allows you to make some approximate guesses about what threshold you can choose. In practice, you'll rarely want to set a manual threshold, and we'll cover automatic threshold selection in a moment.
</blockquote>
Let's plot the result! OpenCV windows can be a bit finicky, so we'll plot the original image, blurred image and results using Matplotlib:
<pre><code class="hljs">fig, ax = plt.subplots(1, 3, figsize=(12, 8))
ax[0].imshow(img)
ax[1].imshow(blurred)
ax[2].imshow(img_masked)
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/opencv-thresholding-in-python-with-cv2threshold-0.png" alt="">
<h3 id="thresholdingmethods">Thresholding Methods</h3>
As mentioned earlier, there are various ways you can use the threshold and maximum value in a function. We've taken a look at the binary threshold initially. Let's create a list of methods, and apply them one by one, plotting the results:
<pre><code class="hljs">methods = [cv2.THRESH_BINARY, cv2.THRESH_BINARY_INV, cv2.THRESH_TRUNC, cv2.THRESH_TOZERO, cv2.THRESH_TOZERO_INV]
names = [&#x27;Binary Threshold&#x27;, &#x27;Inverse Binary Threshold&#x27;, &#x27;Truncated Threshold&#x27;, &#x27;To-Zero Threshold&#x27;, &#x27;Inverse To-Zero Threshold&#x27;]

def thresh(img_path, method, index):
 img = cv2.imread(img_path)
 img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
 blurred = cv2.GaussianBlur(img, (7, 7), 0)
 ret, img_masked = cv2.threshold(blurred, 220, 255, method)

 fig, ax = plt.subplots(1, 3, figsize=(12, 4))
 fig.suptitle(names[index], fontsize=18)
 ax[0].imshow(img)
 ax[1].imshow(blurred)
 ax[2].imshow(img_masked)
 plt.tight_layout()

for index, method in enumerate(methods):
 thresh(&#x27;coins.jpeg&#x27;, method, index)
</code></pre>
<code>THRESH_BINARY</code> and <code>THRESH_BINARY_INV</code> are inverse of each other, and binarize an image between <code>0</code> and <code>255</code>, assigning them to the background and foreground respectively, and vice versa.
<code>THRESH_TRUNC</code> &quot;<a rel="nofollow noopener" target="_blank" href="https://en.wiktionary.org/wiki/binarize">binarizes</a>&quot; the image between <code>threshold</code> and <code>255</code>.
<code>THRESH_TOZERO</code> and <code>THRESH_TOZERO_INV</code> binarize between <code>0</code> and the current pixel value (<code>src(x, y)</code>). Let's take a look at the resulting images:
<img src="https://s3.stackabuse.com/media/articles/opencv-thresholding-in-python-with-cv2threshold-1.png" alt=""> 
<img src="https://s3.stackabuse.com/media/articles/opencv-thresholding-in-python-with-cv2threshold-2.png" alt=""> 
<img src="https://s3.stackabuse.com/media/articles/opencv-thresholding-in-python-with-cv2threshold-3.png" alt=""> 
<img src="https://s3.stackabuse.com/media/articles/opencv-thresholding-in-python-with-cv2threshold-4.png" alt=""> 
<img src="https://s3.stackabuse.com/media/articles/opencv-thresholding-in-python-with-cv2threshold-5.png" alt="">
These methods are intuitive enough - but, how can we automate a good threshold value, and what does a &quot;good threshold&quot; value even mean? Most of the results so far had non-ideal masks, with marks and specks in them. This happens because of the difference in the reflective surfaces of the coins - they're not uniformly colored due to the difference in how ridges reflect light.
We can, to a degree, battle this by finding a better global threshold.
<h2 id="automaticoptimizedthresholdingwithopencv">Automatic/Optimized Thresholding with OpenCV</h2>
OpenCV employs two effective global threshold searching methods - Otsu's method, and the Triangle method.
Otsu's method assumes that it's working on bi-modal images. Bi-modal images are images whose color histograms only contain two peaks (i.e. has only two distinct pixel values). Considering that the peaks each belong to a class such as a &quot;background&quot; and &quot;foreground&quot; - the ideal threshold is right in the middle of them.
<img src="https://s3.stackabuse.com/media/articles/opencv-thresholding-in-python-with-cv2threshold-6.png" alt=""> 
Image credit: <a href="https://scipy-lectures.org/">https://scipy-lectures.org/</a>
<blockquote>
You can make some images more bi-modal with gaussian blurs, but not all.
</blockquote>
An alternative algorithm is the triangle algorithm, which calculates the distance between the maximum and minimum of the gray-level histogram and draws a line. The point at which that line is maximally far away from the rest of the histogram is chosen as the threshold:
<img src="https://s3.stackabuse.com/media/articles/opencv-thresholding-in-python-with-cv2threshold-7.png" alt="">
There's no competition between them - they each work on different types of images, so it's best to try them out and see which returns the better result. Both of these assume a grayscale image, so we'll need to convert the input image to gray via <code>cv2.cvtColor()</code>:
<pre><code class="hljs">img = cv2.imread(img_path)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
blurred = cv2.GaussianBlur(gray, (7, 7), 0)

ret, mask1 = cv2.threshold(blurred, 0, 255, cv2.THRESH_OTSU)
ret, mask2 = cv2.threshold(blurred, 0, 255, cv2.THRESH_TRIANGLE)
# ...
masked = cv2.bitwise_and(img, img, mask=mask1)
</code></pre>
Let's run the image through with both methods and visualize the results:
<pre><code class="hljs">methods = [cv2.THRESH_OTSU, cv2.THRESH_TRIANGLE]
names = [&#x27;Otsu Method&#x27;, &#x27;Triangle Method&#x27;]

def thresh(img_path, method, index):
 img = cv2.imread(img_path)
 gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
 blurred = cv2.GaussianBlur(gray, (7, 7), 0)

 ret, img_masked = cv2.threshold(blurred, 0, 255, method)
 print(f&quot;Threshold: {ret}&quot;)

 fig, ax = plt.subplots(1, 3, figsize=(12, 5))
 fig.suptitle(names[index], fontsize=18)
 ax[0].imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
 ax[1].imshow(cv2.cvtColor(gray, cv2.COLOR_BGR2RGB))
 ax[2].imshow(cv2.cvtColor(img_masked, cv2.COLOR_BGR2RGB))

for index, method in enumerate(methods):
 thresh(&#x27;coins.jpeg&#x27;, method, index)
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/opencv-thresholding-in-python-with-cv2threshold-9.png" alt=""> 
<img src="https://s3.stackabuse.com/media/articles/opencv-thresholding-in-python-with-cv2threshold-10.png" alt="">
Here, the triangle method outperforms Otsu's method, because the image isn't bi-modal:
<pre><code class="hljs">import numpy as np

img = cv2.imread(&#x27;coins.jpeg&#x27;)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
blurred = cv2.GaussianBlur(gray, (7, 7), 0)

histogram_gray, bin_edges_gray = np.histogram(gray, bins=256, range=(0, 255))
histogram_blurred, bin_edges_blurred = np.histogram(blurred, bins=256, range=(0, 255))

fig, ax = plt.subplots(1, 2, figsize=(12, 4))

ax[0].plot(bin_edges_gray[0:-1], histogram_gray)
ax[1].plot(bin_edges_blurred[0:-1], histogram_blurred)
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/opencv-thresholding-in-python-with-cv2threshold-8.png" alt="">
However, it's clear how the triangle method was able to work with the image and produce a more satisfying result.
<h2 id="limitationsofopencvthresholding">Limitations of OpenCV Thresholding</h2>
Thresholding with OpenCV is simple, easy and efficient. Yet, it's fairly limited. As soon as you introduce colorful elements, non-uniform backgrounds and changing lighting conditions - global thresholding as a concept becomes too rigid.
Images are usually too complex for a single threshold to be enough, and this can partially be addressed through adaptive thresholding, where many local thresholds are applied instead of a single global one. While also limited, adaptive thresholding is much more flexible than global thresholding.
<h2 id="conclusion">Conclusion</h2>
In recent years, binary segmentation (like what we did here) and multi-label segmentation (where you can have an arbitrary number of classes encoded) has been successfully modeled with deep learning networks, which are much more powerful and flexible. In addition, they can encode global and local context into the images they're segmenting. The downside is - you need data to train them, as well as time and expertise.
For on-the-fly, simple thresholding, you can use OpenCV. For accurate, production-level segmentation, you'll want to use neural networks.

In this practical tutorial - learn how to perform basic background foreground segmentation with Python, OpenCV and thresholding, using the cv2.threshold() method. We'll cover binarization methods, including Otsu's and the Triangle methods for finding optimal global thresholds.

OpenCV Thresholding in Python with cv2.threshold()

Learning Rate Warmup with Cosine Decay in Keras/TensorFlow

<h2 id="introduction">Introduction</h2>
By setting the focus on an element, we gently guide a user to the next expected input field, giving them a better browsing experience with less guesswork.
<blockquote>
In this article, we will learn how to set focus on an element after rendering our React application or a React component.
</blockquote>
In traditional HTML, it was easy to set an element to focus using the <code>autofocus</code> attribute within our <code>&lt;input&gt;</code> tag, which is a boolean attribute and is by default set to <code>false</code>. It instructs the browser to focus on that specific input field, and the user can begin entering values immediately:
<pre><code class="hljs">&lt;form&gt;
 &lt;input type=&quot;text&quot; autofocus&gt; // Will focus
 &lt;input type=&quot;text&quot;&gt; // Won&#x27;t focus
&lt;/form&gt;
</code></pre>
This is going to work in our React applications as well. Still, when we want to set focus on an element after rendering with more programmatic control - we can make use of the <code>useEffect()</code> hook in functional components and the <code>componentDidMount()</code> lifecycle method in class components.
<h2 id="howtosetfocusonelementafterrenderinginfunctionalcomponents">How to Set Focus On Element After Rendering in Functional Components</h2>
Previously, before the introduction of React hooks, we could not handle operations like this with Functional components.
Since the introduction of hooks, we can know when our application/component has fully rendered so that we can perform specific actions using the <code>useEffect()</code> hook. We also have access to the <code>useRef()</code> hook, which we can use to reference a particular element directly.
Suppose we have a form with two fields, and we want one of the fields to be set on focus after the component renders:
<pre><code class="hljs">const App = () =&gt; {
 return (
 &lt;div className=&#x27;container&#x27;&gt;
 &lt;form&gt;
 &lt;input type=&quot;text&quot; placeholder=&#x27;This has focus&#x27; /&gt;
 &lt;input type=&quot;text&quot; placeholder=&#x27;No focus when we render&#x27; /&gt;
 &lt;/form&gt;
 &lt;/div&gt;
 )
}
export default App;
</code></pre>
Let's get started by getting a reference to the input using the <code>useRef()</code> React hook. To do this, we would first import <code>useRef()</code> from React, create a <code>ref</code> and set its value to null by default then and then attach the created <code>ref</code> to our React element via the <code>ref</code> attribute:
<pre><code class="hljs">import { useRef } from &#x27;react&#x27;;

const App = () =&gt; {
 const inputReference = useRef(null);

 return (
 &lt;div className=&#x27;container&#x27;&gt;
 &lt;form&gt;
 &lt;input type=&quot;text&quot; ref={inputReference} placeholder=&#x27;This has focus&#x27; /&gt;
 &lt;input type=&quot;text&quot; placeholder=&#x27;No focus when we render&#x27; /&gt;
 &lt;/form&gt;
 &lt;/div&gt;
 )
}
export default App;
</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: Notice we only attached the created reference to one of the input elements, which is the one we want to set to focus.

 </div>
 </div>
 </div>
 Let's now proceed to use the <code>useEffect()</code> hook to add focus to the element after rendering our application:
<pre><code class="hljs">import { useRef, useEffect } from &#x27;react&#x27;

const App = () =&gt; {
 const inputReference = useRef(null);

 useEffect(() =&gt; {
 // ...
 }, [])

 return (
 &lt;div className=&#x27;container&#x27;&gt;
 &lt;form&gt;
 &lt;input type=&quot;text&quot; ref={inputReference} placeholder=&#x27;This has focus&#x27; /&gt;
 &lt;input type=&quot;text&quot; placeholder=&#x27;No focus when we render&#x27; /&gt;
 &lt;/form&gt;
 &lt;/div&gt;
 )
}
export default App;
</code></pre>
In the code above, notice that we imported the <code>useEffect()</code> hook and then made use of the hook with an empty dependency array (<code>[]</code>) to make sure it only fires when the component initially mounts. Finally, to make the referenced element focus, we will access the ref via the <code>current</code> attribute and then attach the <code>focus()</code> method:
<pre><code class="hljs">useEffect(() =&gt; {
 inputReference.current.focus();
}, [])
</code></pre>
At this point, when our application or component renders, the referenced element will automatically be focused:
<pre><code class="hljs">import { useRef, useEffect } from &#x27;react&#x27;;

const App = () =&gt; {
 const inputReference = useRef(null);

 useEffect(() =&gt; {
 inputReference.current.focus();
 }, []);

 return (
 &lt;div className=&#x27;container&#x27;&gt;
 &lt;form&gt;
 &lt;input type=&quot;text&quot; ref={inputReference} placeholder=&#x27;This has focus&#x27; /&gt;
 &lt;input type=&quot;text&quot; placeholder=&#x27;No focus when we render&#x27; /&gt;
 &lt;/form&gt;
 &lt;/div&gt;
 )
}
export default App;
</code></pre>
<h2 id="howtosetfocusonelementafterrenderinginclasscomponents">How to Set Focus On Element After Rendering in Class Components</h2>
So far, we have seen how to set focus on an element with a functional component, but it's an entirely different syntax with class components as we no longer make use of hooks because they only work in functional components. In class components, we create our ref within the <code>constructor()</code> method and make use of the <code>componentDidMount()</code> method to set the referenced element to focus once our application renders:
<pre><code class="hljs">import React, { Component } from &#x27;react&#x27;;

export class App extends Component {
 constructor(props) {
 super(props);
 this.inputReference = React.createRef();
 }

 componentDidMount() {
 this.inputReference.current.focus();
 }

 render() {
 return (
 &lt;div className=&#x27;container&#x27;&gt;
 &lt;form&gt;
 &lt;input type=&quot;text&quot; ref={this.inputReference} placeholder=&#x27;This has focus&#x27; /&gt;
 &lt;input type=&quot;text&quot; placeholder=&#x27;No focus when we render&#x27; /&gt;
 &lt;/form&gt;
 &lt;/div&gt;
 )
 }
}
export default App;
</code></pre>
In the code above, we used the <code>constructor()</code> method to create a reference, which we attached to the input element:
<pre><code class="hljs">constructor(props) {
 super(props);
 this.inputReference = React.createRef();
}
</code></pre>
We then used the <code>componentDidMount()</code> lifecycle method, which is very similar to the <code>useEffect()</code> hook, to ensure that the element is set on focus once our application/component renders:
<pre><code class="hljs">componentDidMount() {
 this.inputReference.current.focus();
}
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we have learned how to set an element to focus using an input field once our application or component renders in both the Class and Functional components. Both methods are the same but have different syntax since they are two different types of components.

Joel Olawanle

In this guide, learn how to set focus on an element after JavaScript's React component renders it, using functional and class components.