Marcus Sanatan

Ruslan Hasanov

JFugue is a Java library that creates music! This is the third article of a JFugue tutorial series, and we cover rhythms and export music to MIDI format.

JFugue Beginners Guide Part III: Rhythms, Reading and Writing to MIDI

<h2 id="introduction">Introduction</h2>
In this guide, we will learn how to create and manipulate chords and chord progressions, how to use <code>setKey()</code>, <code>distribute()</code> and <code>allChordsAs()</code>methods of the <code>ChordProgression</code> class, and how to play different patterns simultaneously by using voices in JFugue.
This is the second part of the three-part tutorial series, in which we are trying to re-create the intro of the jazz version of <a rel="nofollow noopener" target="_blank" href="https://www.youtube.com/watch?v=lpt_Y5uLm6Q">Sunday Morning by Maroon 5</a>. But the steps provided in the articles, are easily applicable to any other song creation process as well.
In the previous part of the series, we covered the fundamentals of the JFugue library, learning how to use notes, octaves, durations, tempo, instruments, and patterns. At the end of the first article, we created the intro vocals without any chords. By the end of this tutorial, our song will have the chords ready to play along with the vocals.
In the final part of our tutorial series, we will learn about Rhythms in JFugue. This will allow us to build and play the rhythms on top of the previous parts. We will also take a look at how to save our music to a MIDI file using the JFugue as well as to read music from a MIDI file using the JFugue library.
If you want to check out other parts of the series, here are the links:
<ul>
<li><a target="_blank" href="/jfugue-beginners-guide-part-i-notes-durations-patterns">JFugue Beginners Guide Part I: Notes, Durations, Patterns</a></li>
<li>JFugue Beginners Guide Part II: Chords and Chord Progressions (here)</li>
<li><a target="_blank" href="/jfugue-beginners-guide-part-iii-rhythms-reading-and-writing-to-midi">JFugue Beginners Guide Part III: Rhythms, Reading and Writing to MIDI</a></li>
</ul>
<h2 id="chordsandchordprogressionsinjfugue">Chords and Chord Progressions in JFugue</h2>
When it comes to chords, JFugue offers multiple ways to create them. First, let's take a look at how to create our very own chords by combining the notes one by one.
We will create the D-Minor7 chord, which also happens to be the first chord of our song. This chord consists of four (4) notes that we can combine and play simultaneously:
<pre><code class="hljs">player.play(&quot;D+F+A+C&quot;);
</code></pre>
That works well for now but it can become a very tedious job to create every single chord note by note. In this song, we have three (3) chords (Dm, G, C) with 3 (DMin9, GMaj13, CMaj9) inversions.
We don't necessarily have to create all chords manually. You can create your chords using <code>ChordProgression</code> if you're familiar with music theory. To do so, we'll import and instantiate the <code>ChordProgression</code> class with the chord progressions of our chords:
<pre><code class="hljs">import org.jfugue.theory.ChordProgression;

ChordProgression cp = new ChordProgression(&quot;ii V I&quot;);
</code></pre>
We can also set the key of the chord progression by chaining <code>setKey()</code> method to it:
<pre><code class="hljs">ChordProgression cp = new ChordProgression(&quot;ii V I&quot;)
 .setKey(&quot;C&quot;);
</code></pre>
We can play chord progressions just as same we did with patterns:
<pre><code class="hljs">player.play(cp);
</code></pre>
<code>ChordProgression</code> implements <code>PatternProducer</code>, which, as the name suggests, produces patterns. And when we pass <code>ChordProgression</code> into the <code>Player.play()</code> method, the method asks for the pattern from <code>ChordProgression</code> and plays it just as same it does with the patterns.
Another effective method of the <code>ChordProgression</code> is <code>distribute()</code>. This method allows us to distribute a musical feature along with the chords inside of a <code>ChordProgression</code> object.
At the moment our chords in <code>cp</code> are Dm, G, and C.
Let's change all chords to 7th using <code>distribute()</code>:
<pre><code class="hljs">ChordProgression cp = new ChordProgression(&quot;ii V I&quot;)
 .setKey(&quot;C&quot;)
 .distribute(&quot;7&quot;);
player.play(cp);
</code></pre>
Another essential change would be to set the duration of each chord and to add some 'Rest' in between the chords. Using <code>allChordsAs()</code> method, we can select each chord in <code>cp</code> by typing <code>$</code> with an index number of the chord:
<pre><code class="hljs">ChordProgression cp = new ChordProgression(&quot;ii V I&quot;)
 .setKey(&quot;C&quot;)
 .distribute(&quot;7&quot;)
 .allChordsAs(&quot;$0hqit Ri $1hqi Ri $2wh Rht&quot;);
</code></pre>
We can think of <code>$0</code>, <code>$1</code>, and <code>$2</code> as placeholders that refer to the <code>ii</code>, <code>V</code>, and <code>I</code> respectively. Any modifications that we apply to them are applied to the chords in <code>cp</code>. Go ahead and play to see the difference.
Another cool thing about <code>ChordProgression</code> is that we can easily convert it to the <code>Pattern</code> and use Pattern specific methods to modify it even further:
<pre><code class="hljs">Pattern cpPattern = cp.getPattern();
System.out.print(cpPattern);
player.play(cpPattern.setTempo(180).setInstrument(&quot;DRAWBAR_ORGAN&quot;).repeat(4));
</code></pre>
With the <code>getPattern()</code> method, we convert the <code>cp</code> to a <code>Pattern</code> instance, then we print the current chords in the <code>cp</code> so that we can see the chords being filled in. Finally, we set the tempo, the instrument, and the repeat value.
The chords that JFugue plays look like:
<pre><code class="hljs">D4MIN7hqit Ri G4MAJ7hqi Ri C4MAJ7wh Rht
</code></pre>
<code>ChordProgression</code> provides a range of possibilities, but as mentioned before, it requires some knowledge of musical theory. If don't know much about music theory but have basic knowledge of chords, then you can conveniently use chords inside the patterns.
To get the full potential of the Staccato, which is proud to be human-readable, we will write our chords directly into the pattern:
<pre><code class="hljs">Pattern mainChords = new Pattern(&quot;T180 D4Min9hqit Ri G4Maj13hqi Ri C4Maj9wh Rht&quot;);
</code></pre>
Let's break <code>D4Min9hqit</code> down. &quot;D&quot; is the name of the chord, followed by the &quot;4&quot; which is the number that represents the octave, followed by &quot;Min9&quot; which stands for &quot;Minor 9th&quot;, and followed by &quot;hqit&quot; which are the duration measurements.
We can take advantage of the <code>Pattern</code> class and add some more chords to the pattern by chaining the <code>.add()</code> method:
<pre><code class="hljs">mainChords.add(&quot;D4Minhqit Ri 4Majhqi Ri C4Majwh Rht&quot;);
</code></pre>
Notice that we didn't specify the tempo in the second part of the pattern, since setting the tempo once is enough to apply it for all of the following musical events.
In the real world, not every instrument in a song plays in sequential order. Now that we have our chords playing properly, we would like to add some other patterns to play along with it, not to append directly to it, like we did with <code>add()</code>.
JFugue provides a special token called 'Voice'. Most of the songs are made of layers of patterns. For instance, the piano keeps playing chords while the drumbeat goes on and vocals sing along them. In JFugue, the 'Voice' token represents each of these individual players/singers, allowing them to play together, play at the same time.
We can use up to 16 different voices, which is the sum of the standard MIDI channels. Voice numbers can range from <code>V0</code> to <code>V15</code>. We can populate voices with any instruments we'd like. Except for the 10th channel or <code>V9</code>. This special voice layer is reserved for the percussion by default and can have different sets of percussion instruments and layers at V9 (more on that later).
Let's try to recreate the intro of the 'Sunday Morning' (Jazz version) by adding new voices to our current <code>mainChords</code>:
<pre><code class="hljs">Pattern mainChords = new Pattern(&quot;T180 V0 D4Min9hqit Ri G3Maj13hqi Ri C4Maj9wh Rh&quot;);
mainChords.add(&quot;D4Minhqit Ri G4Majhqi Ri C4Majwh Rht&quot;);

Pattern pianoTouch = new Pattern(&quot;T180 V1 Rw | Rw | Rhi | G4qi G3s A3is CMajis ri&quot;);
pianoTouch.add(&quot;Rw | Rw | Rhi | G4s C5wa100d0&quot;);

player.play(mainChords, pianoTouch);
</code></pre>
The <code>mainChords</code> pattern is the same as it was before. We've added a new pattern <code>pianoTouch</code> and set it to the second voice channel <code>V1</code>. Since these notes occurred at the end of each chord loop, we had to hold them using <code>Rw</code> to play right at the correct time. You may have noticed that the final note of the <code>pianoTouch</code> pattern has this weird token <code>a100d0</code> glued to the whole note of C. That token represents the attack velocity and the decay velocity of the note.
We have set the attack value to 100, making our note sound a bit louder than the others, and have set the decay value to 0, which caused our note volume to decrease to zero very quickly. You can set either of them and none of them on your preference to any value between 0 to 127.
The part that we composed at <code>pianoTouch</code> plays only once in the original song. So, we want to make sure that while the <code>mainChords</code> plays on repeat, the <code>pianoTouch</code> doesn't repeat.
We can create a new pattern <code>introOnce</code> to group our other patterns. This way we can arrange what to play once and what to play on repeat. Replace the line that calls <code>play()</code> with these two lines:
<pre><code class="hljs">Pattern introOnce = new Pattern(mainChords, pianoTouch);
player.play(introOnce, mainChords.repeat(2));
</code></pre>
This should play the <code>pianoTouch</code> once, and repeat the <code>mainChords</code> 2 more times afterward.
Our song is coming along great! Now it's time to help the dancers, we will use the <code>Rhythm</code> class to guide them in the next part of the series!
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we learned how to use chords and chord progressions in the JFugue library. We also covered <code>setKey()</code>, <code>distribute()</code> and <code>allChordsAs()</code> methods of the <code>ChordProgression</code> class, how to play different patterns simultaneously by using voices, and how to apply attack/decay properties to notes or chords.
In the next and final part of the article series, we will learn how to create and use the rhythms in JFugue. By doing so, we will be able to finalize our song. We will also cover how to save our song into a MIDI file format using JFugue, as well as how to import a MIDI file and read content into the Staccato format.
You can continue to read the next part: <a target="_blank" href="/jfugue-beginners-guide-part-iii-rhythms-reading-and-writing-to-midi">JFugue Beginners Guide Part III: Rhythms, Reading and Writing to MIDI</a>.
Or if you need more details about the fundamentals of JFugue, you can check out the first article to refresh your knowledge: <a target="_blank" href="/jfugue-beginners-guide-part-i-notes-durations-patterns">JFugue Beginners Guide Part I: Notes, Durations, Patterns</a>.

JFugue is a Java library that creates music! This is the second article of a JFugue tutorial series, and we cover chords and chord progressions.

JFugue Beginners Guide Part II: Chords and Chord Progressions

<h2 id="introduction">Introduction</h2>
JFugue is an open-source Music library that allows you to play and compose MIDI music using the Java programming language. It uses their &quot;Staccato&quot; format to parse strings of musical instructions. By using JFugue, you can convert the Staccato strings into a MIDI file, as well as import a MIDI file, and convert the content into human-readable strings.
<blockquote>
This is going to be the first part of the three-part series. In this guide, we will focus on the most fundamental parts of the JFugue library by learning about the notes, octaves, durations, tempo, instruments, and patterns. Doing so we will be able to re-create a small part of the vocals of the jazz version of <a rel="nofollow noopener" target="_blank" href="https://www.youtube.com/watch?v=lpt_Y5uLm6Q">Sunday Morning by Maroon 5</a>.
</blockquote>
In the second part of the series, we will explore how to create and manipulate chords and chord progressions in JFugue. We will learn how to use <code>setKey()</code>, <code>distribute()</code> and <code>allChordsAs()</code>methods of the <code>ChordProgression</code> class.
In the third and final part of the series, we will learn about Rhythms in JFugue. By using our previous knowledge, we will be able to finalize the intro of our song. In the final part, we will also take a look at how to save our music to a MIDI file using the JFugue as well as read music from a MIDI file using the JFugue library:
<ul>
<li>JFugue Beginners Guide Part I: Notes, Durations, Patterns (you're here)</li>
<li><a target="_blank" href="/jfugue-beginners-guide-part-ii-chords-and-chord-progressions">JFugue Beginners Guide Part II: Chords and Chord Progressions</a></li>
<li><a target="_blank" href="/jfugue-beginners-guide-part-iii-rhythms-reading-and-writing-to-midi">JFugue Beginners Guide Part III: Rhythms, Reading and Writing to MIDI</a></li>
</ul>
Let's start by preparing our development environment.
<h2 id="prerequisites">Prerequisites</h2>
Since we are going to work with MIDI, an audio output device (speakers or headphones) will be needed to observe the results.
While it is not strictly required, basic musical knowledge would help you more quickly understand some of the musical concepts referred to in the article.
<h2 id="installation">Installation</h2>
Download the official <a rel="nofollow noopener" target="_blank" href="http://www.jfugue.org/download.html">JFugue library</a> (the current version is 5.0.9) and add the JAR file to your Java project as an external library.
Alternatively, if you're using Maven, you can download the dependency through your <code>pom.xml</code> file. Though, you'll also have to add the JitPack repository:
<pre><code class="hljs">&lt;repositories&gt;
 &lt;repository&gt;
 &lt;id&gt;jitpack.io&lt;/id&gt;
 &lt;url&gt;https://jitpack.io&lt;/url&gt;
 &lt;/repository&gt;
&lt;/repositories&gt;

&lt;dependency&gt;
 &lt;groupId&gt;jfugue&lt;/groupId&gt;
 &lt;artifactId&gt;jfugue&lt;/artifactId&gt;
 &lt;version&gt;5.0.9&lt;/version&gt;
&lt;/dependency&gt;
</code></pre>
Or, if you're using Gradle:
<pre><code class="hljs">allprojects {
 repositories {
 ...
 maven { url &#x27;https://jitpack.io&#x27; }
 }
}

implementation group: &#x27;jfugue&#x27;, name: &#x27;jfugue&#x27;, version: &#x27;5.0.9&#x27;
</code></pre>
The main API of the JFugue library is the <code>Player</code> class. Let's instantiate it:
<pre><code class="hljs">import org.jfugue.player.Player;

public class MyMusic {
 public static void main(String[] args) {
 Player player = new Player();
 }
}
</code></pre>
We'll use this class to interpret and play the sounds we'd like to perform.
<h2 id="notesoctavesanddurationsinjfugue">Notes, Octaves, and Durations in JFugue</h2>
As we mentioned earlier, Staccato represents all the musical features with easy to read and write format. The official JFugue guide refers to Staccato as a “Human-Readable and Machine-Parsable Format”. It is quite flexible, not case-sensitive nor does it mind multiple whitespaces (as long as there is at least one space).
Here's how a Staccato string looks like:
<pre><code class="hljs">player.play(&quot;C D E F G A B&quot;);
</code></pre>
Run the code and ready your speakers to hear the magical sound of the MIDI.
Note: You will encounter many <code>player.play()</code> methods along with this tutorial. To avoid complications, you can keep one <code>player.play()</code> method at the end of your code and replace it each time you see a new one.
This string is pretty human-readable indeed. But you may have noticed that we didn't specify any octave nor the duration for any of the notes. When no octave information is provided, the notes will be played with the default octave, which is 5. This means that the above music string is just as same as the following one:
<pre><code class="hljs">player.play(&quot;C5 D5 E5 F5 G5 A5 B5&quot;);
</code></pre>
We can indicate the octave number between 1 and 10, where 1 is the lowest and 10 is the highest octave. The octave number must follow right after the note or chord (more on chords later on in the article):
<pre><code class="hljs">player.play(&quot;G4 G3 A3 B2&quot;);
</code></pre>
Notice that we played the same G note twice but one with the 4th octave and the second is the 3rd, which produces a different sound.
Of course, at the moment our music string doesn't sound very interesting, because all notes have the same duration. Similar to the octaves, when none is specified, the default duration of &quot;q&quot; will be used.
&quot;Q&quot; stands for the &quot;quarter note&quot;. Some of the most common durations are &quot;whole&quot;, &quot;half&quot;, &quot;quarter&quot;, &quot;eighth&quot;. Each duration is half the time faster or shorter than the previous one and two times slower or longer than the next one. The duration of the &quot;quarter&quot; (¼) note, for instance, is shorter than the &quot;half&quot; (½) note and two times longer than the &quot;eighth&quot; (⅛) note. JFugue lets you be as precise as you like, with durations down to 1/128th.
Here's the full table of durations with the decimal values from the official JFugue Guide:
<table class="table table-striped" style="font-size:15px;overflow-x:auto;">
 <thead>
 <tr>
 <th>Duration</th>
 <th>Character</th>
 <th>Decimal value</th>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td>Whole</td>
 <td>W</td>
 <td>1.0</td>
 </tr>
 <tr>
 <td>Half</td>
 <td>H</td>
 <td>0.5</td>
 </tr>
 <tr>
 <td>Quarter</td>
 <td>Q</td>
 <td>0.25</td>
 </tr>
 <tr>
 <td>Eighth</td>
 <td>I</td>
 <td>0.125</td>
 </tr>
 <tr>
 <td>Sixteenth</td>
 <td>S</td>
 <td>0.0625</td>
 </tr>
 <tr>
 <td>Thirty-second</td>
 <td>T</td>
 <td>0.03125 </td>
 </tr>
 <tr>
 <td>Sixty-fourth</td>
 <td>X</td>
 <td>0.015625 </td>
 </tr>
 <tr>
 <td>One-twenty-eighth</td>
 <td>O</td>
 <td>0.0078125</td>
 </tr>
 </tbody>
</table>
Now that we know of how the durations work in JFugue, we can put it to work in our music string (aka Staccato):
<pre><code class="hljs">player.play(&quot;G4qi G3s A3is B2is&quot;);
</code></pre>
Notice that we used two duration notations together for <code>G4qi</code>. With JFugue, you can combine as many or as few duration notations together as you like to create the sound and the feel you want. The order of the duration notations doesn't matter, but for better readability, it is recommended to use them in ascending order. Meaning, start with a greater duration followed by a lesser duration.
Another essential musical concept is Rest. To put it in the simplest sense, rest is a pause, a silence, an absence of music. In JFugue, rest is represented by the letter <code>R</code> or <code>r</code>. Similar to the notes, the rest can also have a length and the default duration value is the same as the others - quarter.
Let's try to re-create a fragment of the vocals of the Sunday Morning using all we've learned so far:
<pre><code class="hljs">player.play(&quot;G5is E5i Ri | G5s Ris E5q Rs | G5q E5i Rs D5q rs C5h Rs&quot;);
</code></pre>
You can remove all the <code>R</code> tokens and compare two versions to understand the effect of the rest.
You may have noticed that there is also a <code>|</code> (pipe) character that we haven't mentioned yet. The pipe in JFugue is merely for better readability and does not affect the audio. You can divide your Staccato by using as many or as few pipes as you like and it will not change the musical output. It looks like a 'bar line' in sheet music but unlike the bar line, a pipe does not specify the number of beats.
Since our Staccato is a string, we can use the string concatenation with the <code>+</code> operator to combine multiple strings.
Assume that we have separate strings for vocals, we can easily combine them to form a continuous string and play:
<pre><code class="hljs">String vocals = &quot;Rh G5is E5i Ri | G5s Ris E5q Rs | G5q E5i Rs D5q rs C5h Rs &quot;
 + &quot;C4i A5q G5isa50d0 Rs A5s E5i D5is Rs C5qis &quot;
 + &quot;Rqi A4s G5i E5i Rs | G5is Rs E5q | D5is C5i Rs C5q G4q Ri&quot;;
player.play(vocals);
</code></pre>
Notice the white space at the end of the first and second string. Since we're concatenating, we want to avoid joining the end of a string with the beginning of the other string like <code>RsC4i</code>.
This will not throw any errors but JFugue will just skip playing that note(s) since it's unrecognizable. Fortunately, JFugue offers a better way of combining multiple Staccatos, without having to deal with trivial matters such as whitespace at the end of each string. In the next section, we will learn about Patterns and how to use instruments.
<h2 id="usingpatternsandinstrumentsinjfugue">Using Patterns and Instruments in JFugue</h2>
Every musical element in a Staccato string is a token. Each note, rest and duration, and everything else that we will discover later in the article are tokens. A Pattern wraps a Staccato string made of tokens and allows us to manipulate it in convenient ways.
The <code>Pattern</code> class provides some efficient methods, such as <code>setTempo()</code>, <code>setInstrument()</code>, <code>setVoice()</code> and more. We can also chain these methods. By using the <code>add()</code> method, we can add multiple patterns or multiple Staccatos together.
Let's import and create a <code>Pattern</code> object to wrap our Staccato string and combine multiple strings without having to worry about the whitespaces at the end:
<pre><code class="hljs">import org.jfugue.pattern.Pattern;

Pattern vocals = new Pattern();
vocals.add(&quot;Rh G5is E5i Ri | G5s Ris E5q Rs | G5q E5i Rs D5q rs C5h Rs&quot;);
vocals.add(&quot;C4i A5q G5isa50d0 Rs A5s E5i D5is Rs C5qis&quot;);
vocals.add(&quot;Rqi A4s G5i E5i Rs | G5is Rs E5q | D5is C5i Rs C5q G4q Ri&quot;);
vocals.add(&quot;G3is A3s C4is D4s C4is D4s G4is A4s G4is A4s | E4q rs F4h&quot;);
vocals.add(&quot;G5is E5i Ri | G5s Ris E5q Rs | G5q E5i Rs A5is rs G5q A5s E5i D5i ri C5h Ri&quot;);
vocals.add(&quot;C5s A3q C5i Rs | D5i Rs Eb5qs Rs | D5q Eb5i Rs D5is Eb5s D4q Rs | C5i A4q C5h&quot;);

player.play(vocals);
</code></pre>
Adding strings together this way, not only prevents whitespace errors but also provides us with more functionalities.
If you try to play the above <code>vocals</code> pattern, you will notice that it sounds too slow. The reason, as you may have already guessed, it has to do with durations. Though, we don't want to shorten the durations, really. We want to amp up the tempo.
We can set a new tempo seamlessly by using <code>setTempo(int)</code> method of the <code>Pattern</code> instance:
<pre><code class="hljs">vocals.setTempo(180);
</code></pre>
Now we will notice the difference if we play it:
<pre><code class="hljs">player.play(vocals);
</code></pre>
So far we've only used the default instrument, which is Piano. While it's one of the more versatile instruments, unfortunately, it is not the best fit for every situation. Let's make this more &quot;Jazzy&quot; by adding some instruments:
We can chain several methods on the <code>Pattern</code> instance, changing the configuration with several settings:
<pre><code class="hljs">vocals.setTempo(180).setInstrument(&quot;TROMBONE&quot;);
</code></pre>
There are 128 instruments, including, well, not instruments such as &quot;SEASHORE&quot;, &quot;BIRDTWEET&quot; and even &quot;HELICOPTER&quot;.
You can leave the other lines as it is and run the code to hear the difference. By chaining the <code>setInstrument()</code> method to the end, we set the &quot;TROMBONE&quot; for all the Staccato strings above that call.
Of course, we can set different instruments for any individual line by embedding the instrument information into the Staccato itself:
<pre><code class="hljs">Pattern vocals = new Pattern();
vocals.add(&quot;I[TROMBONE] Rh G5is E5i Ri | G5s Ris E5q Rs | G5q E5i Rs D5q rs C5h Rs&quot;);
vocals.add(&quot;I[ALTO_SAX] C4i A5q G5isa50d0 Rs A5s E5i D5is Rs C5qis&quot;);
vocals.add(&quot;I[TROMBONE] Rqi A4s G5i E5i Rs | G5is Rs E5q | D5is C5i Rs C5q G4q Ri&quot;);
vocals.add(&quot;I[TRUMPET] G3is A3s C4is D4s C4is D4s G4is A4s G4is A4s | E4q rs F4h&quot;);
vocals.add(&quot;I[TROMBONE] G5is E5i Ri | G5s Ris E5q Rs | G5q E5i Rs A5is rs G5q A5s E5i D5i ri C5h Ri&quot;);
vocals.add(&quot;C5s A3q C5i Rs | D5i Rs Eb5qs Rs | D5q Eb5i Rs D5is Eb5s D4q Rs | C5i A4q C5h&quot;);
vocals.setTempo(180);
</code></pre>
Notice that there is no instrument information in the last line. JFugue will carry on the last instrument selection until any other selection is made. But of course, for better readability, it's better to provide instrument information whenever possible.
Again, JFugue comes with 128 predefined instruments. In case you want to discover your other options on the instruments, <a rel="nofollow noopener" target="_blank" href="https://github.com/StackAbuse/Java-Music-Programming-with-JFugue/blob/main/README.md#jfugue-instruments">here's the complete list</a>.
Similar to the instruments, we can set the tempo value inside the Staccato itself, passing the tempo value into our <code>Pattern</code> constructor when we instantiate it at the first line.
The final result of the <code>vocals</code> pattern, should look like this:
<pre><code class="hljs">Pattern vocals = new Pattern(&quot;T180&quot;);
vocals.add(&quot;I[TROMBONE] Rh G5is E5i Ri | G5s Ris E5q Rs | G5q E5i Rs D5q rs C5h Rs&quot;);
vocals.add(&quot;I[ALTO_SAX] C4i A5q G5isa50d0 Rs A5s E5i D5is Rs C5qis&quot;);
vocals.add(&quot;I[TROMBONE] Rqi A4s G5i E5i Rs | G5is Rs E5q | D5is C5i Rs C5q G4q Ri&quot;);
vocals.add(&quot;I[TRUMPET] G3is A3s C4is D4s C4is D4s G4is A4s G4is A4s | E4q rs F4h&quot;);
vocals.add(&quot;I[TROMBONE] G5is E5i Ri | G5s Ris E5q Rs | G5q E5i Rs A5is rs G5q A5s E5i D5i ri C5h Ri&quot;);
vocals.add(&quot;I[TROMBONE] C5s A3q C5i Rs | D5i Rs Eb5qs Rs | D5q Eb5i Rs D5is Eb5s D4q Rs | C5i A4q C5h&quot;);
</code></pre>
We removed the <code>vocals.setTempo(180);</code> since setting the tempo at the beginning has the same effect.
And that concludes the vocal part of our song as well as the first part of our tutorial series.
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we covered the most fundamental parts of the JFugue open-source Java Music Library. We learned how to use Notes, Durations, Tempo, and Patterns.
While these were the essentials of the JFugue, it was only a step towards the many possibilities that JFugue has to offer. In the following parts, we will explore how to manipulate chords and chord progressions, the basics of the rhythm, and how to import and export MIDI files using JFugue.
Continue to read the second part of the guide series: <a target="_blank" href="/jfugue-beginners-guide-part-ii-chords-and-chord-progressions">JFugue Beginners Guide Part II: Chords and Chord Progressions</a>.

JFugue is a Java library used to create immersive music. In this guide, we'll take a look at how to use notes, durations and patterns for basic music generation.

JFugue Beginners Guide Part I: Notes, Durations, Patterns

<h2 id="introduction">Introduction</h2>
The JSON format is one of the most popular ways to serialize data. Knowing how to read and write it is an important skill for any programmer. There are a couple of Java libraries that can parse JSON, but in this tutorial, we'll focus on an open-source project developed by Google called GSON.
GSON is a lightweight Java library that provides serialization/deserialization functionality. What makes GSON stand apart is its support for Generic Types, which is limited with some, but not all, alternative libraries.
Note: If you're not familiar with Generics and why this is a big deal - feel free to read our <a target="_blank" href="https://stackabuse.com/guide-to-understanding-generics-in-java/">Guide to Understanding Java Generics</a>.
Since we're working with an external library, let's add the dependency. If you're using Maven, you can add it with:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;com.google.code.gson&lt;/groupId&gt;
 &lt;artifactId&gt;gson&lt;/artifactId&gt;
 &lt;version&gt;${version}&lt;/version&gt;
&lt;/dependency&gt;
</code></pre>
Or if you're using Gradle, you can add:
<pre><code class="hljs">compile group: &#x27;com.google.code.gson&#x27;, name: &#x27;gson&#x27;, version: ${version}
</code></pre>
<h2 id="creatingacustomclass">Creating a Custom Class</h2>
Let's create a custom class that we'll first serialize into JSON, and into which we'll deserialize from JSON - <code>Student</code>:
<pre><code class="hljs">public class Student {
 private String firstName;
 private String lastName;
 private int studentID;
 private String email;
 private List&lt;String&gt; courses;
 private FINANCE_TYPE financeType;

 // Getters, setters, constructor, toString()
}
</code></pre>
For our <code>Student</code>, we additionally have an enum representing whether they're on the budget (<code>SUBSIDIZED</code>) or not (<code>UNSUBSIDIZED</code>):
<pre><code class="hljs">public enum FINANCE_TYPE {
 SUBSIDIZED, UNSUBSIDIZED
}
</code></pre>
<h2 id="convertjavaobjecttojsonobjectwithgson">Convert Java Object to JSON Object with GSON</h2>
Now that we have defined our class, let's make an instance of it and serialize it into its equivalent JSON representation. We will do this by using the method called <code>toJson()</code> that takes an object as an argument and returns the JSON representation of that object:
<pre><code class="hljs">// Defining courses
List&lt;String&gt; physicsCourses = Arrays.asList(&quot;Physics 8.01&quot;, &quot;Physics 8.012&quot;);
List&lt;String&gt; musicCourses = Arrays.asList(&quot;Jazz&quot;, &quot;Blues&quot;);
 
// Instantiating students
Student max = new Student(&quot;Max&quot;, &quot;Tegmark&quot;, 1254, &quot;max.tegmark@mit.edu&quot;, physicsCourses, FINANCE_TYPE.SUBSIDIZED);
Student amy = new Student(&quot;Amy&quot;, &quot;Winehouse&quot;, 1328, &quot;amy.winehouse@jazz.com&quot;, musicCourses, FINANCE_TYPE.SUBSIDIZED);

// Instantiating Gson
Gson gson = new Gson();

// Converting POJO to JSON
String maxJson = gson.toJson(max);
String amyJson = gson.toJson(amy);

System.out.println(maxJson);
System.out.println(amyJson);
</code></pre>
This converts our POJOs to JSON Strings, which when printed result in:
<pre><code class="hljs">{&quot;firstName&quot;:&quot;Max&quot;,&quot;lastName&quot;:&quot;Tegmark&quot;,&quot;studentID&quot;:1254,&quot;email&quot;:&quot;max.tegmark@mit.edu&quot;,&quot;courses&quot;:[&quot;Physics 8.01&quot;,&quot;Physics 8.012&quot;],&quot;financeType&quot;:&quot;SUBSIDIZED&quot;}
{&quot;firstName&quot;:&quot;Amy&quot;,&quot;lastName&quot;:&quot;Winehouse&quot;,&quot;studentID&quot;:1328,&quot;email&quot;:&quot;amy.winehouse@jazz.com&quot;,&quot;courses&quot;:[&quot;Jazz&quot;,&quot;Blues&quot;],&quot;financeType&quot;:&quot;SUBSIDIZED&quot;}
</code></pre>
<h2 id="convertjsonstringtojavaobject">Convert JSON String to Java Object</h2>
To reverse this process, and to map a JSON object to a POJO, we'll utilize the <code>fromJson()</code> method. It accepts a JSON String or a <code>Reader</code> and a class or a <code>TypeToken</code>.
Let's first take a look at the former:
<pre><code class="hljs">String maxJson = &quot;{\&quot;firstName\&quot;:\&quot;Max\&quot;,\&quot;lastName\&quot;:\&quot;Tegmark\&quot;,\&quot;studentID\&quot;:1254,\&quot;email\&quot;:\&quot;max.tegmark@mit.edu\&quot;,\&quot;courses\&quot;:[\&quot;Physics 8.01\&quot;,\&quot;Physics 8.012\&quot;],\&quot;financeType\&quot;:\&quot;SUBSIDIZED\&quot;}&quot;;

Gson gson = new Gson();
Student max = gson.fromJson(maxJson, Student.class);

System.out.println(max);
</code></pre>
This instantiates and populated the <code>max</code> object with the data from the JSON object:
<pre><code class="hljs">Student{firstName=&#x27;Max&#x27;, lastName=&#x27;Tegmark&#x27;, studentID=1254, email=&#x27;max.tegmark@mit.edu&#x27;, courses=[Physics 8.01, Physics 8.012], financeType=SUBSIDIZED}
</code></pre>
<h2 id="convertjsonfiletojavaobject">Convert JSON File to Java Object</h2>
Now, we might not be working with JSON in String format - we oftentimes have to read JSON files. The <code>fromJson()</code> method accepts a <code>Reader</code> instance, which we can also use to provide JSON data.
Let's move Amy's data into an <code>amy.json</code> file:
<pre><code class="hljs">{
 &quot;firstName&quot;:&quot;Amy&quot;,
 &quot;lastName&quot;:&quot;Winehouse&quot;,
 &quot;studentID&quot;:1328,
 &quot;email&quot;:&quot;amy.winehouse@jazz.com&quot;,
 &quot;courses&quot;:[
 &quot;Jazz&quot;,
 &quot;Blues&quot;
 ],
 &quot;financeType&quot;:&quot;SUBSIDIZED&quot;
}
</code></pre>
Now, we can use a <code>Reader</code>, such as <code>FileReader</code> to read this file and use that for the input instead of a String. Additionally, instead of using <code>Student.class</code>, we provide a <code>Type</code>. This <code>Type</code> is extracted from Gson's <code>TypeToken</code>, which is much analogous to Jackson's <code>TypeReference</code>:
<pre><code class="hljs">// Instantiate FileReader for amy.json
Reader input = new FileReader(&quot;./src/main/resources/amy.json&quot;);
//Instantiate Gson
Gson gson = new Gson();
// Create a Type via TypeToken for the Student class
Type type = new TypeToken&lt;Student&gt;(){}.getType();
// Read the `input` and cast into `type`
Student amy = gson.fromJson(input, type);
// Print result
System.out.println(amy);
</code></pre>
This, surely enough also instantiates and populates our <code>Student</code> POJO:
<pre><code class="hljs">Student{firstName=&#x27;Amy&#x27;, lastName=&#x27;Winehouse&#x27;, studentID=1328, email=&#x27;amy.winehouse@jazz.com&#x27;, courses=[Jazz, Blues], financeType=SUBSIDIZED}
</code></pre>
<h2 id="compactandprettyprinting">Compact and Pretty Printing</h2>
By default, GSON prints the JSON in a compact format, which we've been able to see previously:
<pre><code class="hljs">{&quot;firstName&quot;:&quot;Max&quot;,&quot;lastName&quot;:&quot;Tegmark&quot;,&quot;studentID&quot;:1254,&quot;email&quot;:&quot;max.tegmark@mit.edu&quot;,&quot;courses&quot;:[&quot;Physics 8.01&quot;,&quot;Physics 8.012&quot;],&quot;financeType&quot;:&quot;SUBSIDIZED&quot;}
{&quot;firstName&quot;:&quot;Amy&quot;,&quot;lastName&quot;:&quot;Winehouse&quot;,&quot;studentID&quot;:1328,&quot;email&quot;:&quot;amy.winehouse@jazz.com&quot;,&quot;courses&quot;:[&quot;Jazz&quot;,&quot;Blues&quot;],&quot;financeType&quot;:&quot;SUBSIDIZED&quot;}
</code></pre>
There are no whitespaces between field names and their values, object fields and objects within arrays. Additionally, not a single newline is present. If copied as a String - <code>\n</code> (newlines) will be present, though, this compact view is a a hassle to read.
We can turn on pretty-printing using Gson, fairly easily. When instantiating <code>Gson</code>, instead of calling the default, empty constructor - we can use the <code>GsonBuilder()</code> constructor:
<pre><code class="hljs">Gson gson = new GsonBuilder().setPrettyPrinting().create();
</code></pre>
Now, we can use the <code>gson</code> instance much the same way as we did before:
<pre><code class="hljs">Gson gson = new GsonBuilder().setPrettyPrinting().create();
String amyJson = gson.toJson(amy);
System.out.println(amyJson);
</code></pre>
Though, this time around, when printed - the JSON string has pretty-printing turned on:
<pre><code class="hljs">{
 &quot;firstName&quot;: &quot;Amy&quot;,
 &quot;lastName&quot;: &quot;Winehouse&quot;,
 &quot;studentID&quot;: 1328,
 &quot;email&quot;: &quot;amy.winehouse@jazz.com&quot;,
 &quot;courses&quot;: [
 &quot;Jazz&quot;,
 &quot;Blues&quot;
 ],
 &quot;financeType&quot;: &quot;SUBSIDIZED&quot;
}
</code></pre>
<h2 id="namingjsonfieldswithserializedname">Naming JSON Fields with @SerializedName</h2>
Serialization is commonly used to transfer data between services - most notably, through REST APIs. When dealing with different services, teams or even languages that are processing the data we're providing - we might want to change the serialized names of certain fields to conform to more widely accepted standards, or to the standards of a certain service that'll be processing the data we provide.
For example, we might be providing JSON data from a Java service to a Python service. Java naming conventions follow CamelCase, while Python's naming conventions follow <code>lowercase_with_underscores</code> for non-constants and classes.
Knowing that we'll be providing our data to a service or person who might want to use different conventions, we can change the serialized names of our fields to not match the ones in our POJO, via the <code>@SerializedName</code> annotation:
<pre><code class="hljs">public class Student {
 @SerializedName(&quot;first_name&quot;)
 private String firstName;
 @SerializedName(&quot;last_name&quot;)
 private String lastName;
 @SerializedName(&quot;student_id&quot;)
 private int studentID;
 @SerializedName(&quot;student_email&quot;)
 private String email;
 @SerializedName(&quot;student_courses&quot;)
 private List&lt;String&gt; courses;
 @SerializedName(&quot;student_finance_type&quot;)
 private FINANCE_TYPE financeType;

 // Getters, setters, constructor, toString()
}
</code></pre>
Now, when serialized, these names will be used instead of our field names:
<pre><code class="hljs">String amyJson = gson.toJson(amy);
System.out.println(amyJson);
</code></pre>
Which results in:
<pre><code class="hljs">{
 &quot;first_name&quot;: &quot;Amy&quot;,
 &quot;last_name&quot;: &quot;Winehouse&quot;,
 &quot;student_id&quot;: 1328,
 &quot;student_email&quot;: &quot;amy.winehouse@jazz.com&quot;,
 &quot;student_courses&quot;: [
 &quot;Jazz&quot;,
 &quot;Blues&quot;
 ],
 &quot;student_finance_type&quot;: &quot;SUBSIDIZED&quot;
}
</code></pre>
This also works the other way around - if we receive JSON with <code>first_name</code> and our <code>Student</code> POJO has <code>first_name</code> mapped to <code>firstName</code>, we'll deserialize this just fine:
<pre><code class="hljs">String input = &quot;{\&quot;first_name\&quot;:\&quot;Amy\&quot;,\&quot;last_name\&quot;:\&quot;Winehouse\&quot;,\&quot;student_id\&quot;:1328,\&quot;student_email\&quot;:\&quot;amy.winehouse@jazz.com\&quot;,\&quot;student_courses\&quot;:[\&quot;Jazz\&quot;,\&quot;Blues\&quot;],\&quot;student_finance_type\&quot;:\&quot;SUBSIDIZED\&quot;}&quot;;
Gson gson = new Gson();
Student amy = gson.fromJson(input, Student.class);
System.out.println(amy);
</code></pre>
This results in:
<pre><code class="hljs">Student{firstName=&#x27;Amy&#x27;, lastName=&#x27;Winehouse&#x27;, studentID=1328, email=&#x27;amy.winehouse@jazz.com&#x27;, courses=[Jazz, Blues], financeType=SUBSIDIZED}
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we took a look at how to convert a Java Object into a JSON Object with Gson's <code>toJson()</code> method, as well as how to convert a JSON Object into a Java Object with Gson's <code>fromJson()</code> method.
We've also explored how to enable pretty-printing, as well as change the serialized names of fields.

David Landup

Selena Hocevar

In this tutorial, we'll take a look at examples on how to convert Java Object (POJO) to JSON and how to convert JSON to Java Object using Gson.

Convert Java Object (POJO) To and From JSON with Gson

Dimitrije Stamenic

Lazar Ristic

In this guide, we'll do a deep dive into arrays and dictionaries - the two most commonly used data structures in Python and compare their usages and implementations with examples.

Dictionaries vs Arrays in Python - Deep Dive

Guest Contributor

Working with Python's PyQT Framework

<h2 id="introduction">Introduction</h2>
In this tutorial, we'll take a look at some of the most common ways to find the last element in a list in Python. First, we will cover the simplest and most Pythonic way and then show some other alternative solutions afterward.
Let's take a look at the list that we will be using:
<pre><code class="hljs">exampleList = [1, 2, &quot;Three&quot;, [&quot;Four&quot;, 5], 6]
</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: A list in Python is a collection of elements that are not necessarily the same type. One list can contain elements that are numbers, strings, nested lists, etc.

 </div>
 </div>
 </div>
 <h2 id="howtogetthelastelementinapythonlist">How to Get the Last Element in a Python List</h2>
There's several ways we can go about getting the last element of a list in Python - some of which are more intuitive and practical than others, and some of which actually change the original list in-place.
<h3 id="winnersolutionusingnegativeindexing">Winner Solution - Using Negative Indexing</h3>
Python supports the notion of negative indexing as the method of accessing list elements. This means that we can access elements in the reversed order by using the <code>[]</code> operator.
It's well known how indexing in lists works:
<pre><code class="hljs">firstElement = exampleList[0]
nthElement = exampleList[n-1]
...
</code></pre>
The first element has the index of <code>0</code>, the second has the index of <code>1</code>, and the <code>n</code>th element has an index of <code>n-1</code>.
The negative indexing follows the same logic, but in reversed order. The last element has the index of <code>-1</code>, the second to last element has the index of <code>-2</code>, and so on:
<pre><code class="hljs">lastElement = exampleList[-1]
print(&quot;Last element: &quot;, lastElement)

print(&quot;exampleList: &quot;, exampleList)

secondToLast = exampleList[-2]
print(&quot;Second to last element: &quot;, secondToLast)
</code></pre>
Which outputs:
<pre><code class="hljs">Last element: 6
exampleList: [1, 2, &#x27;Three&#x27;, [&#x27;Four&#x27;, 5], 6]
Second to last element: [&#x27;Four&#x27;, 5]
</code></pre>
Negative indexing does not change the original list. It is only a way of accessing elements without any changes to the original list.
This is by far the simplest and most Pythonic solution, favored by most.
<h3 id="usingindexing">Using Indexing</h3>
Simple indexing is usually used to access elements in a list in the original order using the <code>[]</code> operator. As described above, the first element has an index of <code>0</code>, the second element has an index of <code>1</code>, and so on. Knowing that, we can conclude that the last element has the index of <code>len(exampleList)-1</code>:
<pre><code class="hljs">lastElement = exampleList[len(exampleList)-1]
print(&quot;Last element: &quot;, lastElement)

print(&quot;exampleList: &quot;, exampleList)

secondToLast = exampleList[len(exampleList)-2]
print(&quot;Second to last element: &quot;, secondToLast)
</code></pre>
Which outputs:
<pre><code class="hljs">Last element: 6
exampleList: [1, 2, &#x27;Three&#x27;, [&#x27;Four&#x27;, 5], 6]
Second to last element: [&#x27;Four&#x27;, 5]
</code></pre>
As well as negative indexing, the indexing method is only used to access elements of the list without performing any changes to the original list.
<h3 id="usingthepopmethod">Using the pop() Method</h3>
In Python, the <code>pop()</code> method is used to remove the last element of the given list and return the removed item.
<blockquote>
The <code>pop()</code> method can optionally accept an integer argument. It is the index of the element that we want to remove, so if we call <code>exampleList.pop(0)</code>, the first element will be removed and returned.
If the argument is the negative number, the logic of the negative indexing will be performed to determine which element to remove. Calling <code>exampleList.pop(-1)</code> will result in removing the last element of the <code>examleList</code>.
</blockquote>
Though, since the <code>pop()</code> method by default already pops the last element, there's no real need to use indexing at all:
<pre><code class="hljs">lastElement = exampleList.pop()
print(&quot;Last element: &quot;, lastElement)

print(&quot;exampleList: &quot;, exampleList)
</code></pre>
Which outputs:
<pre><code class="hljs">Last element: 6
exampleList: [1, 2, &#x27;Three&#x27;, [&#x27;Four&#x27;, 5]]
</code></pre>
Note that the <code>pop()</code> method, by definition, does change the original list by removing the popped element.
<h3 id="usingslicing">Using Slicing</h3>
In Python, the slicing notation is used to get a sublist of a list. The notation itself is pretty simple:
<pre><code class="hljs">exampleList[startIndex:[endIndex[:indexStep]]]
</code></pre>
This means that we can get the sublist of the <code>exampleList</code> with indices starting from <code>startIndex</code>, all the way to the <code>endIndex</code> with the step of <code>indexStep</code>.
The <code>endIndex</code> and <code>indexStep</code> are optional arguments. If we leave the <code>endIndex</code> blank, its default value is the end of the original list. The default value for <code>indexStep</code> is <code>1</code>.
<blockquote>
If we have a list <code>letters=['a', 'b', 'c', 'd', 'e']</code> and slice it using <code>letters[1:3]</code> the resulting sublist will be <code>['b', 'c', 'd']</code>. This means that we are choosing elements of the list <code>letters</code> with indices <code>1, 2, and 3</code>.
<code>letters[0:4:2]</code> will return a sublist containing only elements on the even indices - <code>0, 2, 4</code>.
</blockquote>
The key feature of the slicing notation that we will be using is that it supports negative indexing.
This means that <code>letters[-1:]</code> can be interpreted as: get all elements in list <code>letters</code>, from the last element to the end of list <code>letters</code>. The resulting sublist will contain only the last element of the original list:
<pre><code class="hljs">lastElement = exampleList[-1:][0]
# exampleList[-1:] alone will return the sublist - [6]
# exampleList[-1:][0] will return the last element - 6
print(&quot;Last element: &quot;, lastElement)

print(&quot;exampleList: &quot;, exampleList)
</code></pre>
Which outputs:
<pre><code class="hljs">Last element: 6
exampleList: [1, 2, &#x27;Three&#x27;, [&#x27;Four&#x27;, 5], 6]
</code></pre>
The slicing method is only used to access elements of the list and to create a new list using them - without performing any changes to the original list.
<h3 id="usingthereverseiterator">Using the Reverse Iterator</h3>
Python has two built-in functions that we will use in this method - <code>reversed()</code> and <code>next()</code>.
<code>reversed()</code> accepts a list as an argument and returns the reverse iterator for that list, meaning that the iteration is reversed, starting from the last element all the way to the first element. <code>next()</code> accepts an iterator and returns the next element from the iterator:
<pre><code class="hljs">reversedIterator = reversed(exampleList)

lastElement = next(reversedIterator)
print(&quot;Last element: &quot;, lastElement)
</code></pre>
Which outputs:
<pre><code class="hljs">Last element: 6
exampleList: [1, 2, &#x27;Three&#x27;, [&#x27;Four&#x27;, 5], 6]
</code></pre>
The reversed iterator method is only used to access elements of the list in reverse order - without performing any changes to the original list.
<h3 id="usingthereversemethod">Using the reverse() Method</h3>
The <code>reverse()</code> method is used to reverse the elements of the list. It does not take any arguments and does not return any value, instead, it reverses the original list in-place. This means that we can reverse the list and access the new first element:
<pre><code class="hljs"># Update the original list by reversing its&#x27; elements
exampleList.reverse()

# Access the first element of the updated list
lastElement = exampleList[0]
print(&quot;Last element: &quot;, lastElement)

print(&quot;exampleList: &quot;, exampleList)
</code></pre>
Which outputs:
<pre><code class="hljs">Last element: 6
exampleList: [6, [&#x27;Four&#x27;, 5], &#x27;Three&#x27;, 2, 1]
</code></pre>
The <code>reverse()</code> method, by definition, does change the original list by reversing the order of its elements. Please keep in mind that this approach may be a really inefficient overkill - since it takes time to reverse a list.
<h3 id="usingitemgetter">Using itemgetter()</h3>
The <code>operator</code> module provides a lot of efficient methods performing all of the fundamental operations in Python, such as the mathematical and logical operations, as well as other object comparison and sequence operations.
The <code>itemgetter()</code> method is one of the many methods in the <code>operator</code> module. It accepts one or more integers as the argument and returns a callable object which can be seen as a type of special function.
When we call <code>operator.itemgetter(0)</code>, the resulting object will be a function that will get the first element in a collection. We can also assign a name to that object:
<pre><code class="hljs">getFirstElement = operator.itemgetter(0)
</code></pre>
Now, we can pass in a list to <code>getFirstElement(people)</code>, which returns the first element from the list <code>people</code>.
The <code>itemgetter()</code> operator supports negative indexing so retrieving the last element boils down to:
<pre><code class="hljs">import operator

getLastElement = operator.itemgetter(-1)
lastElement = getLastElement(exampleList)
print(&quot;Last element: &quot;, lastElement)

print(&quot;exampleList: &quot;, exampleList)
</code></pre>
Which outputs:
<pre><code class="hljs">Last element: 6
exampleList: [1, 2, &#x27;Three&#x27;, [&#x27;Four&#x27;, 5], 6]
</code></pre>
This approach doesn't modify the original list - it generates a callable object that accesses it using indices.
<h3 id="usingloops">Using Loops</h3>
Now, a much more manual and rudimentary approach would be using loops. We can iterate through the list, using the length of the list as the final step. Then, when on the <code>len(list)-1</code> step - we can simply return that item:
<pre><code class="hljs">for i in range(0, len(exampleList)):
 if i == (len(exampleList)-1) : lastElement = exampleList[i]
 
print(&quot;Last element: &quot;, lastElement)
print(&quot;exampleList: &quot;, exampleList)
</code></pre>
Which outputs:
<pre><code class="hljs">Last element: 6
exampleList: [1, 2, &#x27;Three&#x27;, [&#x27;Four&#x27;, 5], 6]
</code></pre>
This also doesn't change the list at all and simply accesses an element.
<h2 id="conclusion">Conclusion</h2>
There are a lot of ways to get the last element in a list in Python. The main concern when choosing the right way for you is whether or not you want the last element to be removed.
If you need to get the last element without performing any changes to the original list, then the negative indexing method is the clear winner. It is the simplest and most Pythonic way to solve this problem.
On the other hand, if you need to remove the last element, as well as access it, then you should probably go with the <code>pop()</code> method, which is the built-in method for performing exactly this behavior.

In this tutorial, we'll take a look at how to get the last element in a Python list with code examples and compare them to adhere to best coding practices.

Python: Get Last Element in List

Joris Schellekens

In this tutorial, we'll take a look at examples on how to create a PDF invoice in Python using pText - as well as how to embed files and add outlines.

Creating PDF Invoices in Python with pText

Creating PDF Invoices in Python with borb

<h2 id="introduction">Introduction</h2>
When working with Strings in Java, we oftentimes need to encode them to a specific charset, such as UTF-8.
<blockquote>
UTF-8 represents a variable-width character encoding that uses between one and four eight-bit bytes to represent all valid Unicode code points.
</blockquote>
A code point can represent single characters, but also have other meanings, such as for formatting. &quot;Variable-width&quot; means that it encodes each code point with a different number of bytes (between one and four) and as a space-saving measure, commonly used code points are represented with fewer bytes than those used less frequently.
UTF-8 uses one byte to represent code points from 0-127, making the first 128 code points a one-to-one map with ASCII characters, so UTF-8 is backward-compatible with ASCII.

 <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: Java encodes all Strings into UTF-16, which uses a minimum of two bytes to store code points. Why would we need to convert to UTF-8 then?

 </div>
 </div>
 </div>
 <blockquote>
Not all input might be UTF-16, or UTF-8 for that matter. You might actually receive an ASCII-encoded String, which doesn't support as many characters as UTF-8. Additionally, not all output might handle UTF-16, so it makes sense to convert to a more universal UTF-8.
</blockquote>
We'll be working with a few Strings that contain Unicode characters you might not encounter on a daily basis - such as <code>č</code>, <code>ß</code> and <code>あ</code>, simulating user input.
Let's write out a couple of Strings:
<pre><code class="hljs">String serbianString = &quot;Šta radiš?&quot;; // What are you doing?
String germanString = &quot;Wie heißen Sie?&quot;; // What&#x27;s your name?
String japaneseString = &quot;よろしくお願いします&quot;; // Pleased to meet you.
</code></pre>
Now, let's leverage the <code>String(byte[] bytes, Charset charset)</code> constructor of a String, to recreate these Strings, but with a different <code>Charset</code>, simulating ASCII input that arrived to us in the first place:
<pre><code class="hljs">String asciiSerbianString = new String(serbianString.getBytes(), StandardCharsets.US_ASCII);
String asciigermanString = new String(germanString.getBytes(), StandardCharsets.US_ASCII);
String asciijapaneseString = new String(japaneseString.getBytes(), StandardCharsets.US_ASCII);

System.out.println(asciiSerbianString);
System.out.println(asciigermanString);
System.out.println(asciijapaneseString);
</code></pre>
Once we've created these Strings and encoded them as ASCII characters, we can print them:
<pre><code class="hljs">��ta radi��?
Wie hei��en Sie?
������������������������������
</code></pre>
While the first two Strings contain just a few characters that aren't valid ASCII characters - the final one doesn't contain any.
To avoid this issue, we can assume that not all input might already be encoded to our liking - and encode it to iron out such cases ourselves. There are several ways we can go about encoding a String to UTF-8 in Java.
Encoding a String in Java simply means injecting certain bytes into the byte array that constitutes a String - providing additional information that can be used to format it once we form a <code>String</code> instance.
<h2 id="usingthegetbytesmethod">Using the getBytes() method</h2>
The <code>String</code> class, being made up of bytes, naturally offers a <code>getBytes()</code> method, which returns the byte array used to create the String. Since encoding is really just manipulating this byte array, we can put this array through a <code>Charset</code> to form it while getting the data.
By default, without providing a <code>Charset</code>, the bytes are encoded using the platform’s default <code>Charset</code> - which might not be UTF-8 or UTF-16. Let's get the bytes of a String and print them out:
<pre><code class="hljs">String serbianString = &quot;Šta radiš?&quot;; // What are you doing?
byte[] bytes = serbianString.getBytes(StandardCharsets.UTF_8);

for (byte b : bytes) {
 System.out.print(String.format(&quot;%s &quot;, b));
}
</code></pre>
This outputs:
<pre><code class="hljs">-59 -96 116 97 32 114 97 100 105 -59 -95 63 
</code></pre>
These are the code points for our encoded characters, and they're not really useful to human eyes. Though, again, we can leverage String's constructor to make a human-readable String from this very sequence. Considering the fact that we've encoded this byte array into <code>UTF_8</code>, we can go ahead and safely make a new String from this:
<pre><code class="hljs">String utf8String = new String(bytes);
System.out.println(utf8String);
</code></pre>
Note: Instead of encoding them through the <code>getBytes()</code> method, you can also encode the bytes through the String constructor:
<pre><code class="hljs">String utf8String = new String(bytes, StandardCharsets.UTF_8);
</code></pre>
This now outputs the exact same String we started with, but encoded to UTF-8:
<pre><code class="hljs">Šta radiš?
</code></pre>
<h2 id="encodeastringtoutf8withjava7standardcharsets">Encode a String to UTF-8 with Java 7 StandardCharsets</h2>
Since Java 7, we've been introduced to the <code>StandardCharsets</code> class, which has several <code>Charset</code>s available such as <code>US_ASCII</code>, <code>ISO_8859_1</code>, <code>UTF_8</code> and <code>UTF-16</code> among others.
Each <code>Charset</code> has an <code>encode()</code> and <code>decode()</code> method, which accepts a <code>CharBuffer</code> (which implements <code>CharSequence</code>, same as a <code>String</code>). In practical terms - this means we can chuck in a String into the <code>encode()</code> methods of a <code>Charset</code>.
The <code>encode()</code> method returns a <code>ByteBuffer</code> - which we can easily turn into a String again.
Earlier when we used our <code>getBytes()</code> method, we stored the bytes we got in an array of bytes, but when using the <code>StandardCharsets</code> class, things are a bit different. We first need to use a class called <code>ByteBuffer</code> to store our bytes. Then, we need to both encode and then decode back our newly allocated bytes. Let's see how this works in code:
<pre><code class="hljs">String japaneseString = &quot;よろしくお願いします&quot;; // Pleased to meet you.

ByteBuffer byteBuffer = StandardCharsets.UTF_8.encode(japaneseString);

String utf8String = new String(byteBuffer.array(), StandardCharsets.UTF_8);
System.out.println(utf8String);
</code></pre>
Running this code results in:
<pre><code class="hljs">よろしくお願いします
</code></pre>
<h2 id="encodeastringtoutf8withapachecommons">Encode a String to UTF-8 with Apache Commons</h2>
The Apache Commons Codec package contains simple encoders and decoders for various formats such as <a target="_blank" href="https://stackabuse.com/encoding-and-decoding-base64-strings-in-java/">Base64</a> and Hexadecimal. In addition to these widely used encoders and decoders, the codec package also maintains a collection of phonetic encoding utilities.
For us to be able to use the Apache Commons Codec, we need to add it to our project as an external dependency.
Using Maven, let's add the <code>commons-codec</code> dependency to our <code>pom.xml</code> file:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;commons-codec&lt;/groupId&gt;
 &lt;artifactId&gt;commons-codec&lt;/artifactId&gt;
 &lt;version&gt;1.15&lt;/version&gt;
&lt;/dependency&gt;
</code></pre>
Alternatively if you're using Gradle:
<pre><code class="hljs">compile &#x27;commons-codec:commons-codec:1.15&#x27;
</code></pre>
Now, we can utilize the utility classes of Apache Commons - and as usual, we'll be leveraging the <code>StringUtils</code> class.
It allows us to convert Strings to and from bytes using various encodings required by the Java specification. This class is null-safe and thread-safe, so we've got an extra layer of protection when working with Strings.
To encode a String to UTF-8 with Apache Common's <code>StringUtils</code> class, we can use the <code>getBytesUtf8()</code> method, which functions much like the <code>getBytes()</code> method with a specified <code>Charset</code>:
<pre><code class="hljs">String germanString = &quot;Wie heißen Sie?&quot;; // What&#x27;s your name?
byte[] bytes = StringUtils.getBytesUtf8(germanString);
String utf8String = StringUtils.newStringUtf8(bytes);
System.out.println(utf8String);
</code></pre>
This results in:
<pre><code class="hljs">Wie heißen Sie?
</code></pre>
Or, you can use the regular <code>StringUtils</code> class from the <code>commons-lang3</code> dependency:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;org.apache.commons&lt;/groupId&gt;
 &lt;artifactId&gt;commons-lang3&lt;/artifactId&gt;
&lt;/dependency&gt;
</code></pre>
If you're using Gradle:
<pre><code class="hljs">implementation group: &#x27;org.apache.commons&#x27;, name: &#x27;commons-lang3&#x27;, version: ${version}
</code></pre>
And now, we can use much the same approach as with regular Strings:
<pre><code class="hljs">String germanString = &quot;Wie heißen Sie?&quot;; // What&#x27;s your name?
byte[] bytes = StringUtils.getBytes(germanString, StandardCharsets.UTF_8);
String utf8String = StringUtils.toEncodedString(bytes, StandardCharsets.UTF_8);
System.out.println(utf8String);
</code></pre>
Though, this approach is thread-safe and null-safe:
<pre><code class="hljs">Wie heißen Sie?
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've taken a look at how to encode a Java String to UTF-8. We've taken a look at a few approaches - manually creating a String using <code>getBytes()</code> and manipulating them, the Java 7 <code>StandardCharsets</code> class as well as Apache Commons.

Branko Ilic

In this tutorial, we'll take a look at how to encode a String to UTF-8 in Java - using StandardCharsets, getBytes() with ByteBuffer and Apache Commons with examples.