David Landup

Cansın Güler

In this extensive guide, we'll take a look at functional programming and applying Predicates in Java, with Lambda Functions!

Functional Programming in Java 8: Definitive Guide to Predicates

<h2 id="introduction">Introduction</h2>
A stream represents a sequence of elements and supports different kinds of operations that lead to the desired result. The source of a stream is usually a Collection or an Array, from which data is streamed from.
Streams differ from collections in several ways; most notably in that the streams are not a data structure that stores elements. They're functional in nature, and it's worth noting that operations on a stream produce a result and typically return another stream, but do not modify its source.
To &quot;solidify&quot; the changes, you collect the elements of a stream back into a <code>Collection</code>.
Many simple mathematical operations and concepts find their usage in programming, and most often these are just as straightforward in programming as they are in math itself. Summing up elements isn't indifferent to this, and it's usage is often overlooked because there are many ways to utilize this simple task.
<blockquote>
In this guide, we'll take a look at how to sum all elements in a collection in Java, using <code>summingDouble()</code>, <code>summingLong()</code> and <code>summingInt()</code>.
</blockquote>

 <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: It's worth noting that you can sum the elements themselves, if they're summable, or <a target="_blank" href="https://stackabuse.com/java-8-streams-guide-to-reduce/">reduce them</a> to a numerical representation and then sum the reductions, if they aren't.

 </div>
 </div>
 </div>
 <h2 id="collectorsandstreamcollect">Collectors and Stream.collect()</h2>
Collectors represent implementations of the <code>Collector</code> interface, which implements various useful reduction operations, such as accumulating elements into collections, summarizing elements based on a specific parameter, etc.
<blockquote>
All predefined implementations can be found within the <code>Collectors</code> class.
</blockquote>
You can also very easily implement your own collector and use it instead of the predefined ones, though - you can get pretty far with the built-in collectors, as they cover the vast majority of cases in which you might want to use them.
To be able to use the class in our code we need to import it:
<pre><code class="hljs">import static java.util.stream.Collectors.*;
</code></pre>
<code>Stream.collect()</code> performs a mutable reduction operation on the elements of the stream.

 <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">
 A mutable reduction operation collects input elements into a mutable container, such as a <code>Collection</code>, as it processes the elements of the stream.

 </div>
 </div>
 </div>
 <h2 id="definitionofthesumming_collectors">Definition of the summing_() Collectors</h2>
Within the <code>Collectors</code> class itself, we find an abundance of unique methods that deliver on the different needs of a user. One such group is made of summing methods - <code>summingInt()</code>, <code>summingDouble()</code> and <code>summingLong()</code>.
Even though each of these methods work for a distinctive data type listed within their names, they all work fairly similarly, with minor differences:
<pre><code class="hljs">public static &lt;T&gt; Collector&lt;T,?,Integer&gt; summingInt(ToIntFunction&lt;? super T&gt; mapper)

public static &lt;T&gt; Collector&lt;T,?,Double&gt; summingDouble(ToDoubleFunction&lt;? super T&gt; mapper)

public static &lt;T&gt; Collector&lt;T,?,Long&gt; summingLong(ToLongFunction&lt;? super T&gt; mapper)
</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 generic <code>T</code> in the method signatures represents the type of the input elements we're working with.

 </div>
 </div>
 </div>
 Earlier we stated that these methods can only be used for numerical inputs. The predefined <code>ToIntFunction</code>, <code>ToDoubleFunction</code> and <code>ToLongFunction</code> from <code>java.util.function</code> enable us to do exactly such conversions - from object types to their primitive <code>int, double, long</code> types.
Before we begin diving into each of the individual methods, we'll be defining a class that we'll use for our examples alongside a few fields.
This class will be called <code>Product</code>:
<pre><code class="hljs">public class Product {
 private String name;
 private Integer quantity;
 private Double price;
 private Long productNumber;

 // Constructor, getters and setters
}
</code></pre>
The class has four fields of different types:
<ul>
<li><code>String name</code> - we won't end up using this field since this is a non-numeric value, but in order to have meaningful examples we need to name our products.</li>
<li><code>Integer quantity</code> - the number of products in our inventory.</li>
<li><code>Double price</code> - the price of the product.</li>
<li><code>Long productNumber</code> - a six-digit code for every of our products.</li>
</ul>
Alongside these four fields, we also have a simple constructor and getters for everything except the name of the product itself. Let's also instantiate our <code>List</code> of products in the main program:
<pre><code class="hljs">List&lt;Product&gt; products = Arrays.asList(
 new Product(&quot;Milk&quot;, 37, 3.60, 12345600L),
 new Product(&quot;Carton of Eggs&quot;, 50, 1.20, 12378300L),
 new Product(&quot;Olive oil&quot;, 28, 37.0, 13412300L),
 new Product(&quot;Peanut butter&quot;, 33, 4.19, 15121200L),
 new Product(&quot;Bag of rice&quot;, 26, 1.70, 21401265L)
);
</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: Besides this class, which we'll have to reduce to a field in order to sum, we'll also be taking a look at examples of <code>List</code>s consisting only of <code>Integer</code>, <code>Double</code> and <code>Long</code> elements.

 </div>
 </div>
 </div>
 <h3 id="collectorssummingint">Collectors.summingInt()</h3>
The <code>summingInt()</code> method returns a <code>Collector</code> that produces the sum of a integer-valued function applied to the input elements. In other words - it sums the integers in the collection and returns the result. In the case of no input elements, the return value is <code>0</code>.
Let's start off with a basic example with a <code>List</code> of <code>Integers</code>:
<pre><code class="hljs">List&lt;Integer&gt; numbers = Arrays.asList(1, 2, 3, 4, 5);
Integer sum = numbers.stream().collect(Collectors.summingInt(Integer::intValue));
System.out.println(&quot;Sum: &quot; + sum);
</code></pre>
We apply the <code>.stream()</code> method to create a stream of <code>Integer</code> instances, after which we use the previously discussed <code>.collect()</code> method to collect the elements using <code>summingInt()</code>. The method itself, again, accepts the <code>ToIntFunction</code>, which can be used to reduce instances to an integer that can be summed.
Since we're using Integers already, we can simply pass in a method reference denoting their <code>intValue</code>, as no further reduction is needed:
<pre><code class="hljs">Sum: 15
</code></pre>
More often than not - you'll be working with lists of custom objects and would like to sum some of their fields. For instance, we can sum the quantities of each product in the <code>productList</code>, denoting the total inventory we have.
In such a case, the we can use a method reference, such as <code>Product::getQuantity</code> as our <code>ToIntFunction</code>, to reduce the objects into a single integer each, and then sum these integers:
<pre><code class="hljs">Integer sumOfQuantities = products.stream().collect(Collectors.summingInt(Product::getQuantity));
System.out.println(&quot;Total number of products: &quot; + sumOfQuantities);
</code></pre>
This results in:
<pre><code class="hljs">Total number of products: 174
</code></pre>
<blockquote>
If you'd like to read more about reduction and reducing operations, which are typically at the core of summing and averaging operations, amongst other tasks - read our <a target="_blank" href="https://stackabuse.com/java-8-streams-guide-to-reduce/">Java 8 Streams: Definitive Guide to reduce()</a>!
</blockquote>
<h3 id="collectorssummingdouble">Collectors.summingDouble()</h3>
In much the same way <code>summingInt()</code> returns the result of summed integer values - <code>summingDouble()</code> returns the result of summed double values.
This method varies from the <code>summingInt()</code> in one regard, however. The sum returned can vary depending on the order in which values are recorded, due to accumulated rounding errors. Values sorted by increasing order tend to produce more accurate results.

 <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 any value is a <code>NaN</code> or the sum at any point is <code>NaN</code>, the result will also be <code>NaN</code>.

 </div>
 </div>
 </div>
 Let's start off with a list of doubles:
<pre><code class="hljs">List&lt;Double&gt; numbers = Arrays.asList(3.0, 5.5, 11.3, 40.3, 21.1);
Double sum = numbers.stream().collect(Collectors.summingDouble(Double::doubleValue));
System.out.println(sum);
</code></pre>
After rounding off our output it prints out:
<pre><code class="hljs">81.2
</code></pre>
Again, we typically work with custom objects and not wrapper/primitive types. Prices of our products are expressed in doubles, so we could sum prices. If we were to buy a single instance of every product in the inventory, what would the price be?
Let's use <code>summingDouble()</code> to get a quote for the price:
<pre><code class="hljs">Double sumOfPrices = products.stream().collect(Collectors.summingDouble(Product::getPrice));
System.out.println(&quot;The total sum of prices: &quot; + sumOfPrices);
</code></pre>
This gives us:
<pre><code class="hljs">The total sum of prices: 47.69
</code></pre>
If we wanted to get a little creative and count the total price of all of our products combined we can do that using this method as well. However, it does require beforehand calculations that makes this significantly easier:
<pre><code class="hljs">List&lt;Double&gt; productPrices = new ArrayList&lt;&gt;();
for(Product product : products){
 productPrices.add(product.getPrice() * product.getQuantity());
}

Double sumOfPrices = productPrices.stream().collect(Collectors.summingDouble(Double::doubleValue));
System.out.println(&quot;Sum of all product prices : &quot; + sumOfPrices);
</code></pre>
Running this code gives us the following:
<pre><code class="hljs">Sum of all product prices : 1411.67
</code></pre>
<h3 id="collectorssumminglong">Collectors.summingLong()</h3>
The third and last method from the summing group of methods is <code>summingLong()</code>. This method, as the previous two do, returns a <code>Collector</code> that produces the sum of a long-valued function applied to the input elements. If no elements are present, the result is <code>0</code>:
<pre><code class="hljs">List&lt;Long&gt; numbers = Arrays.asList(23L, 11L, 13L, 49L, 7L);
Long sum = numbers.stream().collect(Collectors.summingLong(Long::longValue));
System.out.println(sum);
</code></pre>
This outputs:
<pre><code class="hljs">103
</code></pre>
Finally, our <code>productNumber</code> field is of type <code>Long</code>. Turns out, the numbers were carefully chosen to encode a secret message once split up and converted from decimal to ASCII. We'll sum the longs and write a custom helper function to decode the message:
<pre><code class="hljs">Long productNumbers = products.stream().collect(Collectors.summingLong(Product::getProductNumber));
System.out.println(productNumbers);
System.out.println(decodeMessage(productNumbers));
</code></pre>
The <code>decodeMessage()</code> method takes in a <code>Long</code>, breaks it up and considers each two characters as a decimal representation of a <code>Character</code>, before adding the characters up and returning the message:
<pre><code class="hljs">public static String decodeMessage(Long encodedMessage) {
 String message = String.valueOf(encodedMessage);
 String[] characters = message.split(&quot;&quot;);
 StringBuilder result = new StringBuilder();

 for (int i = 1; i &lt; characters.length; i+=2) {
 result.append(Character.toString(Integer.parseInt(characters[i-1]+characters[i])));
 }

 return result.toString();
}
</code></pre>
Awesome, let's take a look at the result:
<pre><code class="hljs">74658665
JAVA
</code></pre>
Not an exciting secret message, by all means, but a message nonetheless.
<h2 id="conclusion">Conclusion</h2>
In this guide, we've taken a look at summing collectors, and explored the <code>summingInt()</code>, <code>summingDouble()</code> and <code>summingLong()</code> methods.
We've explored their usage on primitive wrappers, as well as custom objects, which are typically reduced to a field for summation operations.

Branko Ilic

In this Java 8 Streams guide, we'll take a look at the summing collectors for integers, doubles and longs in Java, with practical examples and tips.

Guide to Java 8 Collectors: summingDouble(), summingLong() and summingInt()

Data takes many shapes and forms - one of the most common data structure being lists/arrays. Strings are, essentially, sequences of alphanumeric characters. The parallel between these is apparent, and we often convert between one and the other.
<blockquote>
In this guide, we'll take a look at how to convert/collect a list to a string in Python.
</blockquote>
<h2 id="convertlisttostringinpythonwithjoin">Convert List to String in Python with join()</h2>
The general approach you'll be using is the <code>join()</code> function, with a couple of options to choose from. The function is invoked on a string denoting a separator - and this separator will be added between all joined items.

 <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: Although you can define a separator upfront, it's typically just instantiated as an empty string, upon which the <code>join()</code> function is called.

 </div>
 </div>
 </div>
 Let's take a look at a list of characters that we'd like to join:
<pre><code class="hljs">base_list = [&#x27;M&#x27;, &#x27;K&#x27;, &#x27;V&#x27;, &#x27;N&#x27;, &#x27;L&#x27;, &#x27;I&#x27;, &#x27;L&#x27;, &#x27;F&#x27;, &#x27;S&#x27;, &#x27;L&#x27;, &#x27;L&#x27;, &#x27;V&#x27;]
</code></pre>
The simplest way to join these into a single string is to just pass the list into the <code>join()</code> function:
<pre><code class="hljs">string = &quot;&quot;.join(base_list)
print(string)
</code></pre>
This results in:
<pre><code class="hljs">MKVNLILFSLLV
</code></pre>
We've joined a few characters, denoting the amino-acids present at the start of the sequence of a protein found in the E. coli bacteria!
Each of these elements is of type <code>str</code>, so there's no issue in naturally putting these into a string. Though, sometimes, you might want to convert a certain element into a different type.
Additionally, if you use a different delimiter, you can get a different representation as well:
<pre><code class="hljs">string = &quot;, &quot;.join(base_list)
</code></pre>
This results in:
<pre><code class="hljs">M, K, V, N, L, I, L, F, S, L, L, V
</code></pre>
<h2 id="convertlisttostringinpythonwithlistcomprehension">Convert List to String in Python with List Comprehension</h2>

 <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: Python implicitly converts any data types it can, so you won't need to explicitly convert them in most cases.

 </div>
 </div>
 </div>
 If you do have to convert the elements, you can simply use a list comprehension:
<pre><code class="hljs">string = &quot;&quot;.join(str(element) for element in base_list)
</code></pre>
Each element in the list is now passed through the <code>str()</code> function, which converts them to a string. You can substitute this with any other function, including custom ones. For instance, let's create a function that capitalizes each element in the 'off chance' an element isn't capitalized as it should be:
<pre><code class="hljs">base_list = [&#x27;m&#x27;, &#x27;K&#x27;, &#x27;V&#x27;, &#x27;N&#x27;, &#x27;L&#x27;, &#x27;I&#x27;, &#x27;L&#x27;, &#x27;f&#x27;, &#x27;S&#x27;, &#x27;L&#x27;, &#x27;L&#x27;, &#x27;V&#x27;]

def capitalize_char(char):
 return char.upper()

string = &quot;&quot;.join(capitalize_char(element) for element in base_list)

print(string)
</code></pre>
<code>m</code> and <code>f</code> have been flipped to lowercase, which shouldn't have happened. We've passed in the <code>capitalize_char()</code> function into the list comprehension, returning the capitalized version of each element we've passed in. This results in:
<pre><code class="hljs">MKVNLILFSLLV
</code></pre>
<h2 id="convertlisttostringinpythonwithmap">Convert List to String in Python with map()</h2>
Finally, for a more clean and easy way to pass elements through a function - we can use <code>map()</code>. Generally, the <code>map()</code> function is used to map values of one collection to another, typically using a different (or even reduced) format.
For instance, you could map each character to another list of booleans, where each boolean represents if the character is uppercase or not.
Of course, you can also always do a 1-to-1 mapping using the <code>map()</code> function and, well, just map a string to a string, joining them together into a single one:
<pre><code class="hljs">base_list = [&#x27;M&#x27;, &#x27;K&#x27;, &#x27;V&#x27;, &#x27;N&#x27;, &#x27;L&#x27;, &#x27;I&#x27;, &#x27;L&#x27;, &#x27;F&#x27;, &#x27;S&#x27;, &#x27;L&#x27;, &#x27;L&#x27;, &#x27;V&#x27;]

string = &quot;&quot;.join(map(str, base_list))

print(string)
</code></pre>
This results in:
<pre><code class="hljs">MKVNLILFSLLV
</code></pre>
<blockquote>
If you'd like to read more about mapping in Python, read our <a target="_blank" href="https://stackabuse.com/map-filter-and-reduce-in-python-with-examples/">Guide to map(), filter() and reduce() in Python</a>!
</blockquote>
<h2 id="conclusion">Conclusion</h2>
In this short guide, we've taken a look at how to convert a list to a string in Python, collecting the elements into a single piece.
Strings are inherently lists of characters, and they behave in much the same way, but can be treated as individual elements as well.
You've learned how to use the <code>join()</code> function in its plain form, as well as how to use it with list comprehensions, custom methods and the <code>map()</code> function!

In this short practical guide, learn how to join strings into a list with the join() function, list comprehensions, custom methods and the map() function!

Python: Convert List to String with join()

In this guide, learn how to use Collectors.groupingByConcurrent() collector in Java 8 to collect and group elements of streams concurrently, with downstream collectors and suppliers, through examples.

Guide to Java 8 Collectors: groupingByConcurrent()

Data can take many shapes and forms - and it's oftentimes represented as strings.
Be it from a CSV file or input text, we split strings oftentimes to obtain lists of features or elements.
<blockquote>
In this guide, we'll take a look at how to split a string into a list in Python, with the <code>split()</code> method.
</blockquote>
<h2 id="splitstringintolistinpython">Split String into List in Python</h2>
The <code>split()</code> method of the string class is fairly straightforward. It splits the string, given a delimiter, and returns a list consisting of the elements split out from the string.

 <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">
 By default, the delimiter is set to a whitespace - so if you omit the delimiter argument, your string will be split on each whitespace.

 </div>
 </div>
 </div>
 Let's take a look at the behavior of the <code>split()</code> method:
<pre><code class="hljs">string = &quot;Age,University,Name,Grades&quot;

lst = string.split(&#x27;,&#x27;)

print(lst)
print(&#x27;Element types:&#x27;, type(lst[0]))
print(&#x27;Length:&#x27;, len(lst))
</code></pre>
Our string had elements delimited with a comma, as in a CSV (comma-separated values) file, so we've set the delimiter appropriately.
This results in a list of elements of type <code>str</code>, no matter what other type they can represent:
<pre><code class="hljs">[&#x27;Age&#x27;, &#x27;University&#x27;, &#x27;Name&#x27;, &#x27;Grades&#x27;]
Element types: &lt;class &#x27;str&#x27;&gt;
Length: 4
</code></pre>
<h2 id="splitstringintolisttrimwhitespacesandchangecapitalization">Split String into List, Trim Whitespaces and Change Capitalization</h2>
Not all input strings are clean - so you won't always have a perfectly formatted string to split. Sometimes, strings may contain whitespaces that shouldn't be in the &quot;final product&quot; or have a mismatch of capitalized and non-capitalized letters.
Thankfully, it's pretty easy to process this list and each element in it, after you've split it:
<pre><code class="hljs"># Contains whitespaces after commas, which will stay after splitting
string = &quot;age, uNiVeRsItY, naMe, gRaDeS&quot;
lst = string.split(&#x27;,&#x27;)

print(lst)
</code></pre>
This results in:
<pre><code class="hljs">[&#x27;age&#x27;, &#x27; uNiVeRsItY&#x27;, &#x27; naMe&#x27;, &#x27; gRaDeS&#x27;]
</code></pre>
No good! Each element starts with a whitespace and the elements aren't properly capitalized at all. Applying a function to each element of a list can easily be done through a simple <code>for</code> loop so we'll want to apply a <code>strip()</code>/<code>trim()</code> (to get rid of the whitespaces) and a capitalization function.
Since we're not only looking to capitalize the first letter but also keep the rest lowercase (to enforce conformity), let's define a helper function for that:
<pre><code class="hljs">def capitalize_word(string):
 return string[:1].capitalize() + string[1:].lower()
</code></pre>
The method takes a string, slices it on its first letter and capitalizes it. The rest of the string is converted to lowercase and the two changed strings are then concatenated.
We can now use this method in a loop as well:
<pre><code class="hljs">string = &quot;age, uNiVeRsItY, naMe, gRaDeS&quot;

lst = string.split(&#x27;,&#x27;)
lst = [s.strip() for s in lst]
lst = [capitalize_word(s) for s in lst]

print(lst)
print(&#x27;Element types:&#x27;, type(lst[0]))
print(&#x27;Length:&#x27;, len(lst))
</code></pre>
This results in a clean:
<pre><code class="hljs">[&#x27;Age&#x27;, &#x27;University&#x27;, &#x27;Name&#x27;, &#x27;Grades&#x27;]
Element types: &lt;class &#x27;str&#x27;&gt;
Length: 4
</code></pre>
<h2 id="splitstringintolistandconverttointeger">Split String into List and Convert to Integer</h2>
What happens if you're working with a string-represented list of integers? After splitting, you won't be able to perform integer operations on these, since they're ostensibly strings.
Thankfully, we can use the same <code>for</code> loop as before to convert the elements into integers:
<pre><code class="hljs">string = &quot;1,2,3,4&quot;

lst = string.split(&#x27;,&#x27;)
lst = [int(s) for s in lst]

print(lst)
print(&#x27;Element types:&#x27;, type(lst[0]))
print(&#x27;Length:&#x27;, len(lst))
</code></pre>
Which now results in:
<pre><code class="hljs">[1, 2, 3, 4]
Element types: &lt;class &#x27;int&#x27;&gt;
Length: 4
</code></pre>
<h2 id="splitstringintolistwithlimiter">Split String into List with Limiter</h2>
Besides the delimiter, the <code>split()</code> method accepts a limiter - the number of times a split should occur.
It's an integer and is defined after the delimiter:
<pre><code class="hljs">string = &quot;Age, University, Name, Grades&quot;

lst = string.split(&#x27;,&#x27;, 2)
print(lst)
</code></pre>
Here, two splits occur, on the first and second comma, and no splits happen after that:
<pre><code class="hljs">[&#x27;Age&#x27;, &#x27; University&#x27;, &#x27; Name, Grades&#x27;]
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this short guide, you've learned how to split a string into a list in Python.
You've also learned how to trim the whitespaces and fix capitalization as a simple processing step alongside splitting a string into a list.

In this short guide, learn how to split a string into a list in Python. Also, learn how to split a string and then trim the elements, and make the first letters capitalized, through practical examples!

Python: Split String into List with split()

In this detailed guide, learn how to use the groupingBy() collector in Java 8 to collect and group elements of streams, with downstream collectors and suppliers, through examples.

Guide to Java 8 Collectors: groupingBy()

The Portable Document Format (PDF) is not a WYSIWYG (What You See is What You Get) format. It was developed to be platform-agnostic, independent of the underlying operating system and rendering engines.
To achieve this, PDF was constructed to be interacted with via something more like a programming language, and relies on a series of instructions and operations to achieve a result. In fact, PDF is based on a scripting language - <a rel="nofollow noreferrer noopener" target="_blank" href="https://www.adobe.com/products/postscript.html">PostScript</a>, which was the first device-independent Page Description Language.
In this guide, we'll be using <a rel="nofollow noreferrer noopener" target="_blank" href="https://borbpdf.com/">borb</a> - a Python library dedicated to reading, manipulating and generating PDF documents. It offers both a low-level model (allowing you access to the exact coordinates and layout if you choose to use those) and a high-level model (where you can delegate the precise calculations of margins, positions, etc to a layout manager).
<blockquote>
In this guide, we'll take a look at how to convert a UTF-8 book (from Project Gutenberg) to a PDF document.
</blockquote>

 <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: Project Gutenberg eBooks may be freely used in the United States because most are not protected by U.S. copyright law. They may not be free of copyright in other countries.

 </div>
 </div>
 </div>
 <h2 id="installingborb">Installing borb</h2>
borb can be downloaded from source on <a rel="nofollow noopener" target="_blank" href="https://github.com/jorisschellekens/borb">GitHub</a>, or installed via <code>pip</code>:
<pre><code class="hljs">$ pip install borb
</code></pre>
<h2 id="installingunidecode">Installing unidecode</h2>
For this project we will also use <code>unidecode</code>, it's a wonderful little library that converts text from UTF-8 to ASCII. Keep in mind that not every character in UTF-8 can be represented as an ASCII character.
This is a lossy conversion, in principle so there will be some discrepancy every time you do a conversion:
<pre><code class="hljs">$ pip install unidecode
</code></pre>
<h2 id="creatingapdfdocumentwithborb">Creating a PDF Document with borb</h2>
Creating a PDF document using borb typically follows the same steps every time:
<pre><code class="hljs">from borb.pdf.document import Document
from borb.pdf.page.page import Page
from borb.pdf.pdf import PDF

import typing
import re

from borb.pdf.canvas.layout.page_layout.multi_column_layout import SingleColumnLayout
from borb.pdf.canvas.layout.page_layout.page_layout import PageLayout

# Create empty Document
pdf = Document()

# Create empty Page
page = Page()

# Add Page to Document
pdf.append_page(page)

# Create PageLayout
layout: PageLayout = SingleColumnLayout(page)
</code></pre>
<h2 id="creatingebookswithborb">Creating Ebooks with borb</h2>

 <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'll be dealing with raw text books. Each book will have a different structure and each book requires a different approach to rendering. This is a highly subjective (styling) and highly book-dependent task, though, the general process is the same.

 </div>
 </div>
 </div>
 The book we'll be downloading is UTF-8 encoded. Not every font supports every character. In fact, the PDF spec defines 14 standard fonts (which every reader/writer ought to have embedded), none of which support the full UTF-8 range.
So, to make our lives a bit easier, we're going to be using this little utility function to convert a <code>str</code> to ASCII:
<pre><code class="hljs">from unidecode import unidecode

def to_ascii(s: str) -&gt; str:
 s_out: str = &quot;&quot;
 for c in s:
 if c == &#x27;“&#x27; or c == &#x27;”&#x27; or c == &#x27;â&#x27;:
 s_out += &#x27;&quot;&#x27;
 else:
 s_out += unidecode(c) 
 return s_out
</code></pre>
Next, in our main method, we're going to be downloading the UTF-8 book.
In our example, we'll be using &quot;The Mysterious affair at Styles&quot; by Agatha Christie, which can be easily obtained in raw format from Project Gutenberg:
<pre><code class="hljs"># Define which ebook to fetch
url = &#x27;https://www.gutenberg.org/files/863/863-0.txt&#x27;

# Download text
import requests
txt = requests.get(url).text
print(&quot;Downloaded %d bytes of text...&quot; % len(txt))

# Split to lines
lines_of_text: typing.List[str] = re.split(&#x27;\r\n&#x27;, txt)
lines_of_text = [to_ascii(x) for x in lines_of_text]

# Debug
print(&quot;This ebook contains %d lines... &quot; % len(lines_of_text))
</code></pre>
This prints:
<pre><code class="hljs">Downloaded 361353 bytes of text...
This ebook contains 8892 lines...
</code></pre>
The first lines of text are a general header added by Project Gutenberg. We don't really want that in our eBook so we're going to simply delete it, by checking whether a line starts with a certain pattern and slicing it off via the <a target="_blank" href="https://stackabuse.com/python-slice-notation-on-string/">slice notation</a>:
<pre><code class="hljs"># Skip header
header_offset: int = 0
for i in range(0, len(lines_of_text)):
 if lines_of_text[i].startswith(&quot;*** START OF THE PROJECT GUTENBERG EBOOK&quot;):
 header_offset = i + 1
 break
while lines_of_text[header_offset].isspace():
 header_offset += 1
lines_of_text = lines_of_text[header_offset:]
print(&quot;The first %d lines are the gutenberg header...&quot; % header_offset)
</code></pre>
This prints:
<pre><code class="hljs">The first 24 lines are the gutenberg header...
</code></pre>
Similarly, the last lines of text are just a copyright notice. We'll delete that as well:
<pre><code class="hljs"># Skip footer
footer_offset: int = len(lines_of_text)
for i in range(0, len(lines_of_text)):
 if &quot;*** END OF THE PROJECT GUTENBERG EBOOK&quot; in lines_of_text[i]:
 footer_offset = i
 break
lines_of_text = lines_of_text[0:footer_offset]
print(&quot;The last %d lines are the gutenberg footer ..&quot; % (len(lines_of_text) - footer_offset))
</code></pre>
With that out of the way, we're going to process the main body of text.
This code took some trial and error and if you're working with a different book - it will take some trial and error too.
Figuring out when to insert a chapter title, when to start a new paragraph, what the table of contents is, etc. depends on the book as well. This is an opportunity to play around with borb a bit, and try to parse the input yourself with a different book:
<pre><code class="hljs">from borb.pdf.canvas.layout.text.paragraph import Paragraph
from borb.pdf.canvas.layout.text.heading import Heading
from borb.pdf.canvas.color.color import HexColor, X11Color
from decimal import Decimal

# Main processing loop
i: int = 0
while i &lt; len(lines_of_text):
 
 # Process lines
 paragraph_text: str = &quot;&quot;
 while i &lt; len(lines_of_text) and not len(lines_of_text[i]) == 0:
 paragraph_text += lines_of_text[i]
 paragraph_text += &quot; &quot;
 i += 1

 # Empty line
 if len(paragraph_text) == 0:
 i += 1
 continue

 # Space
 if paragraph_text.isspace():
 i += 1
 continue

 # Contains the word &#x27;CHAPTER&#x27; multiple times (likely to be table of contents)
 if sum([1 for x in paragraph_text.split(&#x27; &#x27;) if &#x27;CHAPTER&#x27; in x]) &gt; 2:
 i += 1
 continue

 # Debug
 print(&quot;Processing line %d / %d&quot; % (i, len(lines_of_text)))

 # Outline
 if paragraph_text.startswith(&quot;CHAPTER&quot;):
 print(&quot;Adding Header of %d bytes ..&quot; % len(paragraph_text))
 try:
 page = Page()
 pdf.append_page(page)
 layout = SingleColumnLayout(page)
 layout.add(Heading(paragraph_text, font_color=HexColor(&quot;13505B&quot;), font_size=Decimal(20)))
 except:
 pass
 continue

 # Default
 try:
 layout.add(Paragraph(paragraph_text))
 except:
 pass
 
 # Default behavior
 i += 1
</code></pre>
All that's left is to store the final PDF document:
<pre><code class="hljs">with open(&quot;output.pdf&quot;, &quot;wb&quot;) as pdf_file_handle:
 PDF.dumps(pdf_file_handle, pdf)
</code></pre>
<img src="https://s3.stackabuse.com/media/articles/using-borb-to-create-e-books-from-project-gutenberg-1.png" alt="creating pdf ebooks with borb">
<h2 id="conclusion">Conclusion</h2>
In this guide you've learned how to process a large piece of text and create a PDF out of it automatically using borb.
Creating books from raw text files is not a standard process, and you'll have to test things out and play around with the loops and the way you treat text to get it right.

Joris Schellekens

Using borb with Python to Create E-books From Project Gutenberg

<h2 id="introduction">Introduction</h2>
Strings are one of the most common data types used in software - they represent strings of characters that we parse as words.
String concatenation is a pretty standard task, especially since we don't always deal with static strings. We often create strings dynamically, such as with ES6 Templates, or simply concatenate strings to form new ones.
<blockquote>
If you'd like to read more about creating dynamic formatted strings - read our <a target="_blank" href="https://stackabuse.com/es6-template-string-literals-in-nodejs/">Guide to ES6 Templates/String Literals in Node.js</a>!
</blockquote>
In this tutorial, we'll take a look at how to join/append/concatenate strings in JavaScript.

 <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: Strings are immutable, meaning they can't really be changed. Whenever you call a changing operation on a string, a copy is constructed with the changes applied and it's returned instead of the original one.

 </div>
 </div>
 </div>
 <h2 id="concatenatewiththeoperator">Concatenate With the + Operator</h2>
The easiest, and probably most intuitive approach to string concatenation is using the <code>+</code> operator:
<pre><code class="hljs">console.log(&quot;hello &quot; + &quot;world&quot;);
</code></pre>
Running this short piece of code results in:
<pre><code class="hljs">hello world
</code></pre>
It is possible to assign a string in memory to a reference variable, and reference the object instead of concatenating it directly:
<pre><code class="hljs">let firstWord = &quot;hello &quot;;
let secondWord = &quot;world&quot;;
let newWord = firstWord + secondWord;
</code></pre>
This also results in:
<pre><code class="hljs">hello world
</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: In most cases, you can reasonably replace a <code>=</code> and <code>+</code> with the shorthand <code>+=</code>, which lets you omit the reference to the first operand, which will be replaced with the variable you're assigning the result to.

 </div>
 </div>
 </div>
 Instead, you could be writing the short-hand version:
<pre><code class="hljs">let word = &quot;hello &quot;;
word += &quot;world&quot;;
console.log(word);
</code></pre>
It's worth noting that other data types can be thrown into the mix as well, and whenever implicit conversion is possible - JavaScript will &quot;match&quot; the data types into strings.
For instance, integers are easily converted to strings so if you try concatenating an integer onto a string - the integer is converted before being appended. A string may not be converted into an integer at all times - such as when it doesn't represent a number or has odd formatting, so generally, it's easier to convert to a string, than from a string:
<pre><code class="hljs">var str = &quot;hello&quot;;
var int = 21;
var boolean = true;

console.log(str+int);
console.log(str+boolean)
</code></pre>
This results in both the boolean and integer being converted into string representations and then appended to the &quot;hello&quot; string:
<pre><code class="hljs">hello21
hellotrue
</code></pre>
<h2 id="stringprototypeconcat">String.prototype.concat()</h2>
The <code>concat()</code> method was created specifically for this task - to concatenate strings. It can be invoked over any string, and accepts another string to be concatenated to the calling one.
In a sense, it's similar to using the short-hand <code>+=</code> operator:
<pre><code class="hljs">let string1 = &quot;Java&quot;;
let string2 = &quot;Script&quot;;

console.log(string1.concat(string2));
</code></pre>
This results in:
<pre><code class="hljs">JavaScript
</code></pre>
Additionally, you can specify a delimiter as the first argument, which is then added in-between all of the concatenated strings:
<pre><code class="hljs">let string1 = &quot;Java&quot;;
let string2 = &quot;Script&quot;;

console.log(string1.concat(&quot;, &quot;, string2));
</code></pre>
This results in:
<pre><code class="hljs">Java, Script
</code></pre>
<h2 id="arrayprototypejoin">Array.prototype.join()</h2>
The <code>join()</code> method of the <code>Array</code> class is used to join the elements of an array into a string, with a default delimiter of a comma (<code>,</code>).
This allows us to deal with a larger number of strings in a much more concise way, and it's not unheard of to read a file into an array, or to work with an array of strings you'd like to join together.
If you don't pass in any arguments into the method - the default value will be used to delimit the newly joined strings. Let's pass in an empty string to skip that and just join them similar to what we've seen before:
<pre><code class="hljs">let elements = [&quot;JavaScript&quot;, &quot;HTML&quot;, &quot;CSS&quot;];
console.log(elements.join(&quot;&quot;));
</code></pre>
This results in:
<pre><code class="hljs">JavaScriptHTMLCSS
</code></pre>
<h2 id="whichapproachtouse">Which Approach to Use?</h2>
It's advised to prefer the <code>concat()</code> function instead of the + operator, due to performance benefits. However, this doesn't actually always hold and takes in several assumptions into mind.
First of all - the number of strings you're concatenating plays a role in this, as well as other factors you might not even be aware of. Let's benchmark the <code>concat()</code> method as well as the <code>+</code> operator:
<pre><code class="hljs">console.time(&#x27;Concatenating with Operator&#x27;);
concatWithOperator();
console.timeEnd(&#x27;Concatenating with Operator&#x27;);

console.time(&#x27;Concatenating with Function&#x27;);
concatWithFunction();
console.timeEnd(&#x27;Concatenating with Function&#x27;);

function concatWithOperator() {
 let result = &quot;&quot;;
 for (let i = 0; i &lt; 10000; i++) {
 result += i;
 }
}

function concatWithFunction() {
 let result = &quot;&quot;;
 for (let i = 0; i &lt; 10000; i++) {
 result = result.concat(i);
 }
}
</code></pre>
This results in:
<pre><code class="hljs">Concatenating with Operator: 3.232ms
Concatenating with Function: 1.509ms
</code></pre>
But wait, let's switch the environment and run this on a different machine:
<pre><code class="hljs">Concatenating with Operator: 1.985ms
Concatenating with Function: 1.990ms
</code></pre>
And let's run that on the same machine again:
<pre><code class="hljs">Concatenating with Operator: 2.030ms
Concatenating with Function: 0.934ms
</code></pre>
The execution times vary wildly (although, all of them are acceptable in speed). It's also worth noting the official statement from <a target="_blank" rel="nofollow noopener noreferrer" href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/concat">MDN</a>, regarding the performance benefits:
<blockquote>
It is strongly recommended that the assignment operators (+, +=) are used instead of the concat() method.
</blockquote>
Which might seem odd, given the fact that <code>concat()</code> outperforms the operators in the tests or at worst is the same speed. What gives? Well, benchmarking code like this isn't as easy as simply running it and observing the results.
Your browser, its version, as well as the optimizer it uses may vary from machine to machine, and properties like those really impact the performance. For instance, we've used different strings in the concatenation, the ones generated from iteration. If we were to use the same string, an optimizer such as Google's V8 would further optimize the usage of the string.

 <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">
 Test and verify your own code instead of taking advice at face value. Not all machines and environments are the same, and what works great on one, might not work great on another. Take this into consideration when creating applications as well.

 </div>
 </div>
 </div>
 <h2 id="conclusion">Conclusion</h2>
We've taken a look at how to concatenate strings in JavaScript using the <code>+</code> operator, the <code>join()</code> method of the <code>Arrays</code> class as well as the <code>concat()</code> method of the <code>String</code> class.
We've taken a look at the official stance and ran our own tests to see which approach is the most performant - and as usual, it depends on various factors.

In this short tutorial, we'll take a look at how to join/concatenate/append strings in JavaScript using the + operator, concat() and join() methods, as well as benchmark and test our code's performance.

How to Join/Concatenate Strings in JavaScript

<h2 id="introduction">Introduction</h2>
<blockquote>
Sorting is one of the fundamental techniques used in solving problems, especially in those related to writing and implementing efficient algorithms.
</blockquote>
Usually, sorting is paired with searching - meaning we first sort elements in the given collection, then search for something within it, as it is generally easier to search for something in a sorted, rather than an unsorted collection, as we can make educated guesses and impose assumptions on the data.
<blockquote>
There are many algorithms that can efficiently sort elements, but in this guide we'll be taking a look at how to implement Counting Sort in Java.
</blockquote>
<h2 id="countingsortinjava">Counting Sort in Java</h2>
Counting Sort is a stable, non-comparative sorting algorithm, and its main use is for sorting arrays of non-negative integers.
Counting Sort counts the number of objects that have distinct key values, and then applying a prefix sum on those counts to determine the position of each key in the output. Like all other non-comparative sorting algorithms, Counting Sort also performs the sort without any comparisons between the elements to be sorted. Also, being a stable sorting algorithm, Counting Sort preserves the order of the elements with equal keys sorted in the output array as they were in the original array.
This operation results in, essentially, a list of integer occurrences, which we typically name the count array. Counting Sort uses the auxiliary count array to determine the positions of elements:
<img src="https://s3.stackabuse.com/media/articles/radix-sort-in-python-2.png" alt="img">
Each index in the count array represents an element in the input array. The value associated with this index is the number of occurrences (the count) of the element in the input array.
The best way to get a feel of how Counting Sort works is by going through an example. Consider we have an array:
<pre><code class="hljs">int[] arr = {0, 8, 4, 7, 9, 1, 1, 7};
</code></pre>
For simplicity's sake, the elements in the array will only be single digits, that is numbers from <code>0</code> through <code>9</code>. Since the largest value we can have is <code>9</code>, let's label the maximum value as <code>max = 9</code>.
This is important because we'll need to designate a new count array, consisting of <code>max + 1</code> elements. This array will be used for counting the number of occurrences of every digit within our original array we're given to sort, so we need to initialize the whole count array to <code>0</code>, that is:
<pre><code class="hljs">int[] countArray = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
</code></pre>
<blockquote>
Since there are 10 possible elements our array can have, there are ten zero's for every single digit.
</blockquote>
Since we've defined the array we'll be working on, and we have also defined our count array to keep count of each occurrence of a digit, we need to go through the following step to make Counting Sort work:
Step 1:
By going through our whole array <code>arr</code> in a single <code>for</code> loop, for every <code>i</code> from <code>0</code> to <code>n-1</code>, where <code>n</code> is the number of elements in <code>arr</code>, we'll count the occurrence of each digit by incrementing the value on the position <code>arr[i]</code> in our <code>countArray</code>. Let's see that in code:
<pre><code class="hljs">for (int i = 0; i &lt; arr.length; i++)
 countArray[arr[i]]++;
</code></pre>
After the first step, our <code>countArray</code> looks like this: [1, 2, 0, 0, 1, 0, 0, 2, 1, 1].
Step 2:
Since we now have our <code>countArray</code> filled with values, we go on to the next step - applying prefix sums to the <code>countArray</code>. Prefix sums are basically formed when we add each of the previous numbers in the array onto the next cumulatively, forming a sum of all yet seen prefixes:
<pre><code class="hljs">for (int i=1; i &lt; countArray.length; i++)
 countArray[i] += countArray[i-1];
</code></pre>
And after applying this step we get the following <code>countArray</code>: [1, 3, 3, 3, 4, 4, 4, 6, 7, 8].
Step 3:
The third and last step is calculating the element positions in the sorted output based off the values in the <code>countArray</code>. For this purpose, we'll need a new array that we'll call <code>outputArray</code>. The size of the <code>outputArray</code> is the same as our original <code>arr</code>, and we once again initialize this array to all zeros:
<pre><code class="hljs">int[] outputArray = {0, 0, 0, 0, 0, 0, 0, 0};
</code></pre>
As we've mentioned earlier, Counting Sort is a stable sort. If we iterate through our <code>arr</code> array from <code>0</code> to <code>n-1</code> we may end up switching the elements around and ruin the stability of this sorting algorithm, so we iterate the array in the reverse order.
We'll find the index in our <code>countArray</code> that is equal to the value of the current element <code>arr[i]</code>. Then, at the position <code>countArray[arr[i]] - 1</code> we'll place the element <code>arr[i]</code>. This guarantees we keep the stability of this sort. Afterwards, we decrement the value <code>countArray[i]</code> by one, and continue on doing the same until <code>i &gt;= 0</code>:
<pre><code class="hljs">for (int i = arr.length-1; i &gt;= 0; i--) {
 outputArray[countArray[arr[i]] - 1] = arr[i];
 countArray[arr[i]]--;
}
</code></pre>
At the end of the algorithm, we can just copy the values from <code>outputArr</code> into our starting array <code>arr</code> and print the sorted array out:
<pre><code class="hljs">for (int i = 0; i &lt; arr.length; i++) {
 arr[i] = outputArray[i];
 System.out.print(arr[i] + &quot; &quot;);
}
</code></pre>
Running of course gives us the sorted array with guaranteed stability (relative order) of equal elements:
<pre><code class="hljs">0 1 1 4 7 7 8 9
</code></pre>
<h2 id="complexityofcountingsort">Complexity of Counting Sort</h2>
Let's discuss both the time and space complexity of Counting Sort.
Let's say that <code>n</code> is the number of elements in the <code>arr</code> array, and <code>k</code> is the range of allowed values for those <code>n</code> elements from <code>1...n</code>. As we're working only with simple <code>for</code> loops, without any recursive calls, we can analyze the time complexity in a following manner:
<ul>
<li>Counting the occurrence of each element in our input range takes <code>O(n)</code> time,</li>
<li>Calculating the prefix sums takes up <code>O(k)</code> time,</li>
<li>And calculating the <code>outputArray</code> based on the previous two takes <code>O(n)</code> time.</li>
</ul>
Accounting for all the complexities of these individual steps, the time complexity of Counting Sort is <code>O(n+k)</code>, making Counting Sort's average case linear, which is better than most comparison based sorting algorithms. However, if the range of <code>k</code> is <code>1...n²</code>, the worst-case of Counting Sorts quickly deteriorates to <code>O(n²)</code> which is really bad.
Thankfully, this doesn't happen often, and there is a way to ensure that it never happens. This is how Radix Sort came to be - which typically uses Counting Sort as its main subroutine while sorting.
By employing Counting Sort on multiple bounded subarrays, the time complexity never deteriorates to <code>O(n²)</code>. Additionally, Radix Sort may use any stable, non-comparative algorithm instead of Counting Sort, but it's the most commonly used one.
<blockquote>
If you'd like to read more about Radix Sort, read our <a target="_blank" href="https://stackabuse.com/radix-sort-in-java/">Radix Sort in Java</a>!
</blockquote>
On the other hand, the space complexity problem is much easier. Since our <code>countArray</code> of size <code>k</code> is bigger than our starting array of <code>n</code> elements, the dominating complexity there will be <code>O(k)</code>. Important thing to note is that, the larger the range of elements in the given array, the larger is the space complexity of Counting Sort.
<h2 id="conclusion">Conclusion</h2>
In this article we've described what Counting Sort is, how it works, and how to implement it in Java.
Even though Counting Sort falls short in comparison to many other sorting algorithms (sorting only integers, having a potential bigger space complexity, etc.), it has some advantages - the main one being that Counting Sort is used as a subroutine for other, more powerful sorting algorithms, such as Radix Sort, and getting the hang of it is crucial to implementing Radix Sort.

In this guide, learn the theory behind Counting Sort and how to implement Counting Sort in Java - with time and complexity analysis.