<h2 id="introduction">Introduction</h2>
A lot of applications handle files in some way and file manipulation is one of the core knowledges in any programming language.
In order to manipulate files, we need to know where they're located. Having an overview of files in a directory is paramount if we want to accomplish this, especially if we can perform operations on them through iteration. There are several ways to do this in Java, which we'll show throughout this article.
For the sake of simplicity, all examples will be written for the following file tree:
<pre><code class="hljs">Programming
|-- minimax.c
|-- super_hack.py
|-- TODO.txt
`-- CodingMusic
 |-- Girl Talk - All Day.mp3
 |-- Celldweller - Frozen.mp3
 |-- Lim Taylor - Isn't It Wonderful.mp3
 `-- Radiohead - Everything in Its Right Place.mp3
</code></pre>
<h2 id="filelist">File.list()</h2>
The simplest method to list the names of files and folders in a given directory, without traversing the sub-directories, is the helper method <code>.list()</code>, which returns an array of <code>String</code>s.
We do this by using the <code>.list()</code> method on a <code>File</code> instance:
<pre><code class="hljs">public class Pathnames {

 public static void main(String[] args) {
 // Creates an array in which we will store the names of files and directories
 String[] pathnames;

 // Creates a new File instance by converting the given pathname string
 // into an abstract pathname
 File f = new File(&quot;D:/Programming&quot;);

 // Populates the array with names of files and directories
 pathnames = f.list();

 // For each pathname in the pathnames array
 for (String pathname : pathnames) {
 // Print the names of files and directories
 System.out.println(pathname);
 }
 }
}
</code></pre>
Using a simple <a target="_blank" href="/java-flow-control-for-and-for-each-loops/">for-each</a> loop, we iterate through the array and print out the <code>String</code>s.
<pre><code class="hljs">CodingMusic
minimax.c
super_hack.py
TODO.txt
</code></pre>
Using this approach, all of the items in the <code>CodingMusic</code> directory aren't shown, and a downside to this approach is that we can't really do anything to the files themselves. We're just getting their names. It's useful when we just want to take a look at the files at face-value.
<h3 id="filenamefilter">FilenameFilter</h3>
Another thing we can do with the <code>.list()</code> method is to create a <code>FilenameFilter</code> to return only the files we want:
<pre><code class="hljs">File f = new File(&quot;D:/Programming&quot;);

// This filter will only include files ending with .py
FilenameFilter filter = new FilenameFilter() {
 @Override
 public boolean accept(File f, String name) {
 return name.endsWith(&quot;.py&quot;);
 }
 };

// This is how to apply the filter
pathnames = f.list(filter);
</code></pre>
Running this piece of code would yield:
<pre><code class="hljs">super_hack.py
</code></pre>
<h2 id="filelistfiles">File.listFiles()</h2>
Similar to the previous method, this one can be used to return the names of files and directories, but this time we get them as an array of <code>File</code> objects, which gives us the ability to directly manipulate them:
<pre><code class="hljs">public class Pathnames {
 public static void main(String args[]) {

 // try-catch block to handle exceptions
 try {
 File f = new File(&quot;D:/Programming&quot;);

 FilenameFilter filter = new FilenameFilter() {
 @Override
 public boolean accept(File f, String name) {
 // We want to find only .c files
 return name.endsWith(&quot;.c&quot;);
 }
 };

 // Note that this time we are using a File class as an array,
 // instead of String
 File[] files = f.listFiles(filter);

 // Get the names of the files by using the .getName() method
 for (int i = 0; i &lt; files.length; i++) {
 System.out.println(files[i].getName());
 }
 } catch (Exception e) {
 System.err.println(e.getMessage());
 }
 }
}
</code></pre>
Output:
<pre><code class="hljs">minimax.c
</code></pre>
Now, let's traverse deeper into the file system using recursion and some more methods to use on the <code>File</code> object:
<pre><code class="hljs">public class ListFilesRecursively {
 public void listFiles(String startDir) {
 File dir = new File(startDir);
 File[] files = dir.listFiles();

 if (files != null &amp;&amp; files.length &gt; 0) {
 for (File file : files) {
 // Check if the file is a directory
 if (file.isDirectory()) {
 // We will not print the directory name, just use it as a new
 // starting point to list files from
 listDirectory(file.getAbsolutePath());
 } else {
 // We can use .length() to get the file size
 System.out.println(file.getName() + &quot; (size in bytes: &quot; + file.length()+&quot;)&quot;);
 }
 }
 }
 }
 public static void main(String[] args) {
 ListFilesRecursively test = new ListFilesRecursively();
 String startDir = (&quot;D:/Programming&quot;);
 test.listFiles(startDir);
 }
}
</code></pre>
Output:
<pre><code class="hljs">Girl Talk - All Day.mp3 (size in bytes: 8017524)
Celldweller - Frozen.mp3 (size in bytes: 12651325)
Lim Taylor - Isn't It Wonderful.mp3 (size in bytes: 6352489)
Radiohead - Everything in Its Right Place.mp3 (size in bytes: 170876098)
minimax.c (size in bytes: 20662)
super_hack.py (size in bytes: 114401)
TODO.txt (size in bytes: 998)
</code></pre>
<h2 id="fileswalk">Files.walk()</h2>
In Java 8 and later we can use the <code>java.nio.file.Files</code> class to populate a <code>Stream</code> and use that to go through files and directories, and at the same time recursively walk all subdirectories.
Note that in this example we will be using <a target="_blank" href="/lambda-expressions-in-java/">Lambda Expressions</a>:
<pre><code class="hljs">public class FilesWalk {
 public static void main(String[] args) {
 try (Stream&lt;Path&gt; walk = Files.walk(Paths.get(&quot;D:/Programming&quot;))) {
 // We want to find only regular files
 List&lt;String&gt; result = walk.filter(Files::isRegularFile)
 .map(x -&gt; x.toString()).collect(Collectors.toList());

 result.forEach(System.out::println);
 } catch (IOException e) {
 e.printStackTrace();
 }
 }
}
</code></pre>
Here, we've populated a <code>Stream</code> using the <code>.walk()</code> method, passing a <code>Paths</code> argument. The <code>Paths</code> class consists of static methods that return a <code>Path</code> based on a String URI - and using a <code>Path</code>, we can locate the file easily.
The <code>Path</code>, <code>Paths</code>, <code>Files</code>, and many other classes belong to the <code>java.nio</code> package, which was introduced in Java 7 as a more modern way to represent files in a non-blocking way.
Then, using the Collections Framework, a list is generated.
Running this piece of code will yield:
<pre><code class="hljs">D:\Programming\Coding Music\Radiohead - Everything in Its Right Place.mp3
D:\Programming\Coding Music\Lim Taylor - Isn't It Wonderful.mp3
D:\Programming\Coding Music\Celldweller - Frozen.mp3
D:\Programming\Coding Music\Girl Talk - All Day.mp3
D:\Programming\minimax.c
D:\Programming\super_hack.py
D:\Programming\TODO.txt
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Handling files in some way is a core task for most programming languages, and this includes the ability to list and find files in the file system. In order to manipulate files, we need to know where they're located. Having an overview of files in a directory is paramount if we want to accomplish this, especially if we can perform operations on them through iteration.
In this article we showed a number of different ways in Java to list files on the file system, using both linear and recursive approaches.

Marko Petrović

Java: List Files in a Directory

<h2 id="introduction">Introduction</h2>
In this tutorial you will learn how to deploy a Flask application to Heroku. The app can be as simple as a &quot;Hello World&quot; app to a social media monitoring platform!
Nowadays there is no business that doesn't have a web app to help it a reach greater audience, or maybe provide its services through an online portal.
Today you are about to learn how to make an API using Flask as a case study for how to deploy your app on Heroku.
<h2 id="buildingarestapiwithflask">Building a REST API with Flask</h2>
In your project directory, let's start off by creating a <a target="_blank" href="/python-virtual-environments-explained/">virtualenv</a>:
<pre><code class="hljs">$ python -m venv venv/
</code></pre>
And let's activate it with the <code>source</code> command:
<pre><code class="hljs">$ source venv/bin/activate
</code></pre>
Then, let's use <code>pip</code> to install the libraries we're going to use - <code>flask</code> to build the app and <code>gunicorn</code> as our server:
<pre><code class="hljs">$ pip install flask
$ pip install gunicorn
</code></pre>
Our application is going to be a simple API that receives a name and returns a welcome message:
<pre><code class="hljs"># app.py
from flask import Flask, request, jsonify
app = Flask(__name__)

@app.route(&#x27;/getmsg/&#x27;, methods=[&#x27;GET&#x27;])
def respond():
 # Retrieve the name from url parameter
 name = request.args.get(&quot;name&quot;, None)

 # For debugging
 print(f&quot;got name {name}&quot;)

 response = {}

 # Check if user sent a name at all
 if not name:
 response[&quot;ERROR&quot;] = &quot;no name found, please send a name.&quot;
 # Check if the user entered a number not a name
 elif str(name).isdigit():
 response[&quot;ERROR&quot;] = &quot;name can&#x27;t be numeric.&quot;
 # Now the user entered a valid name
 else:
 response[&quot;MESSAGE&quot;] = f&quot;Welcome {name} to our awesome platform!!&quot;

 # Return the response in json format
 return jsonify(response)

@app.route(&#x27;/post/&#x27;, methods=[&#x27;POST&#x27;])
def post_something():
 param = request.form.get(&#x27;name&#x27;)
 print(param)
 # You can add the test cases you made in the previous function, but in our case here you are just testing the POST functionality
 if param:
 return jsonify({
 &quot;Message&quot;: f&quot;Welcome {name} to our awesome platform!!&quot;,
 # Add this option to distinct the POST request
 &quot;METHOD&quot; : &quot;POST&quot;
 })
 else:
 return jsonify({
 &quot;ERROR&quot;: &quot;no name found, please send a name.&quot;
 })

# A welcome message to test our server
@app.route(&#x27;/&#x27;)
def index():
 return &quot;&lt;h1&gt;Welcome to our server !!&lt;/h1&gt;&quot;

if __name__ == &#x27;__main__&#x27;:
 # Threaded option to enable multiple instances for multiple user access support
 app.run(threaded=True, port=5000)
</code></pre>
To test your application locally, let's hit the <a rel="nofollow" target="_blank" href="http://127.0.0.1:5000/">http://127.0.0.1:5000/</a> endpoint. If everything is fine, we should be greeted with a welcome message:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-a-flask-application-to-heroku-1.png" alt="welcome message">
We can also send a name as a parameter, such as <code>http://localhost:5000/getmsg/?name=Mark</code>:
<pre><code class="hljs">{&quot;MESSAGE&quot;:&quot;Welcome Mark to our awesome platform!!&quot;}
</code></pre>
With our application ready, let's deploy it to Heroku.
<h2 id="heroku">Heroku</h2>
<a rel="nofollow" target="_blank" href="https://www.heroku.com">Heroku</a> is one of the first cloud platform as a service (PaaS) and supports several languages - Ruby, Java, Node.js, Scala, Clojure, Python, PHP, and Go.
The first thing we need to do is define which libraries our application uses. That way, Heroku knows which ones to provide for us, similar to how we install them locally when developing the app.
To achieve this, we need to create a <code>requirements.txt</code> file with all of the modules:
<pre><code class="hljs">$ pip freeze &gt; requirements.txt
</code></pre>
This way we end up with a <code>requirements.txt</code> file that contains the libraries we're using and their versions:
<pre><code class="hljs">Click==7.0
Flask==1.1.1
gunicorn==19.9.0
itsdangerous==1.1.0
Jinja2==2.10.1
MarkupSafe==1.1.1
Werkzeug==0.15.6
</code></pre>
Note: One of the common mistakes is misspelling requirements, it is a real pain when you debug your code for hours and find out that the app doesn't run because the server didn't download the modules. The only way for Heroku to know the modules that you are using is to add them to the <code>requirements.txt</code> file, so be careful!
For Heroku to be able to run our application like it should, we need to define a set of processes/commands that it should run beforehand. These commands are located in the <code>Procfile</code>:
<pre><code class="hljs">web: gunicorn app:app
</code></pre>
The <code>web</code> command tells Heroku to start a web server for the application, using <code>gunicorn</code>. Since our application is called <code>app.py</code>, we've set the <code>app</code> name to be <code>app</code> as well.
<h3 id="herokuaccount">Heroku Account</h3>
Now, we should <a rel="nofollow" target="_blank" href="https://signup.heroku.com">create a Heroku account</a>.
Once that is out of the way, on the dashboard, select New -&gt; Create new app:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-a-flask-application-to-heroku-2.png" alt="new application">
Choose a name for the application and choose a region of where you'd like to host it:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-a-flask-application-to-heroku-3.png" alt="app naming">
Once the application is created on Heroku, we're ready to deploy it online.
<h3 id="git">Git</h3>
To upload our code, we'll use <a target="_blank" href="/tag/git/">Git</a>. First, let's make a git repository:
<pre><code class="hljs">$ git init .
</code></pre>
And now, let's add our files and <code>commit</code>:
<pre><code class="hljs">$ git add app.py Procfile requirements.txt
$ git commit -m &quot;first commit&quot;
</code></pre>
<h3 id="deployingtheapptoheroku">Deploying the App to Heroku</h3>
To finally deploy the application, we'll need to install the <a rel="nofollow" target="_blank" href="https://devcenter.heroku.com/articles/heroku-command-line">Heroku CLI</a> with which we'll run Heroku-related commands. Let's login to our account using our credentials by running the command:
<pre><code class="hljs">$ heroku login -i
</code></pre>
Alternatively, we can login using the browser if we run the command:
<pre><code class="hljs">$ heroku login
</code></pre>
At this point, while logged in, we should add our repository to the remote one:
<pre><code class="hljs">$ heroku git:remote -a {your-project-name}
</code></pre>
Be sure to replace <code>{your-project-name}</code> with the actual name of your project you selected in the earlier step.
And with that done, let's upload the project by <a target="_blank" href="/git-push-local-branch-and-track-it/">pushing</a> it to Heroku:
<pre><code class="hljs">$ git push heroku master
</code></pre>
A lengthy progress log should come up on your terminal, ending with:
<pre><code class="hljs">...
remote: -----&gt; Discovering process types
remote: Procfile declares types -&gt; web
remote:
remote: -----&gt; Compressing...
remote: Done: 45.1M
remote: -----&gt; Launching...
remote: Released v4
remote: https://{your-project-name}.herokuapp.com/ deployed to Heroku
remote:
remote: Verifying deploy... done.
To https://git.heroku.com/{your-project-name}.git
 ae85864..4e63b46 master -&gt; master
</code></pre>
Congratulations, you have successfully uploaded your first web app to Heroku! It's now time now to test and verify our API.
<h2 id="testingtheapi">Testing the API</h2>
In the log that has been shown in the console you will find a link for your application <code>https://{your-project-name}.herokuapp.com/</code>, this link can also be found under the Settings tab, in the Domains and certificates section:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-a-flask-application-to-heroku-4.png" alt="application url">
Visiting the link, we can reach our application, which is now online and public:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-a-flask-application-to-heroku-5.png" alt="welcome message">
In case there were any errors, you can access the logs and troubleshoot from there:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-a-flask-application-to-heroku-6.png" alt="log link">
You can manually test your app in the browser, by typing the URL and adding the path for the <code>/getmsg/</code> route. Though, as applications tend to get more and more complex, it's advised to use tools like <a rel="nofollow" target="_blank" href="https://www.getpostman.com">Postman</a>.
Now let's test the <code>GET</code> request to our application with a <code>name</code> parameter:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-a-flask-application-to-heroku-7.png" alt="local request with parameters">
Now let's test a URL that isn't bound to any function, like for example <code>/newurl</code>, with a GET request:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-a-flask-application-to-heroku-8.png" alt="new url">
As expected, our Flask app returned a 404 response.
Note: You can change the view of the output from Pretty, Raw, and Preview, which shows you how the output would look in your browser.
Now let's test a <code>POST</code> request:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-a-flask-application-to-heroku-9.png" alt="post request">
Also, let's see what happens if we completely omit the <code>name</code> parameter:
<pre><code class="hljs">{&quot;ERROR&quot;:&quot;no name found, please send a name.&quot;}
</code></pre>
We've tested our app and confirmed that everything is working fine. To see the history of your server and what requests were made you can check the logs for your site via Heroku:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-a-flask-application-to-heroku-10.png" alt="Heroku log">
You can see here the <code>POST</code> request we made to our page <code>/post/</code>.
Also, you can see the history of building the application. Moreover, if there's any problem during building you can find it in the log page.
<h2 id="conclusion">Conclusion</h2>
In this article we showed a simple example of building our first simple API on Heroku using the Flask micro-framework. The development process remains the same as you continue to build your application.
Heroku offers a free plan and Student plans. The free plan is limited but it works pretty good for a starting app, POC, or a simple project for example. However, if you want to scale your application then you'll want to consider one of the plans that are available on the site from <a rel="nofollow" target="_blank" href="https://www.heroku.com/pricing">here</a>.
For more info on Heroku you can check the Heroku <a rel="nofollow" target="_blank" href="https://devcenter.heroku.com/articles/getting-started-with-python">manual itself</a>.

Ali Abdelaal

Deploying a Flask Application to Heroku

<h2 id="introduction">Introduction</h2>
Conditional statements and loops are a very important tool in programming. There aren't many things we could do with code that can only execute line-by-line.
That's what &quot;flow control&quot; means - guiding the execution of our program, instead of letting it execute line-by-line regardless of any internal or external factors. Every programming language supports some form of flow control, if not explicitly via <code>if</code>s and <code>for</code>s or similar statements - then it implicitly gives us the tools to create such constructs, i.e. low-level programming languages usually achieve that affect with a lot of <code>go-to</code> commands.
<blockquote>
Loops were a concept used long before computer programming was even a thing, but the first person to use a software loop was Ada Lovelace, commonly known by her maiden name - Byron, while calculating <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Bernoulli_number">Bernoulli numbers</a>, back in the 19th century.
</blockquote>
In Java, there are several ways to control the flow of the code:
<ul>
<li><a target="_blank" href="/java-flow-control-if-and-if-else-statements">if and if-else statements</a></li>
<li><a target="_blank" href="/flow-control-in-java-the-switch-statement">switch statements</a></li>
<li><a target="_blank" href="/java-flow-control-while-and-do-while-statements/"><code>while</code> and <code>do-while</code> statements</a></li>
<li><a target="_blank" href="/java-flow-control-for-and-for-each-loops/"><code>for</code> and <code>enhanced for</code> statements</a></li>
<li><a target="_blank" href="/java-flow-control-break-and-continue-statements/"><code>break</code> and <code>continue</code> statements</a></li>
</ul>
<h2 id="break">break</h2>
The <code>break</code> statement is one of Java's &quot;jump statements&quot;, since it transfers the code execution to another part of code. We've already seen the <code>break</code> keyword used in the <a target="_blank" href="/java-flow-control-the-switch-statement">switch statement</a>. We'll revisit it here, along with other use cases:
<ul>
<li>It can be used to stop execution of a <code>switch</code> statement case, instead of letting it continue executing code for following cases as well</li>
<li>It can be used to exit a loop before it has finished all its iterations, or as a form of exiting purposefully-created infinite loops</li>
<li>It can be used as an acceptable form of the &quot;go-to&quot; statement when we have multiple nested loops</li>
</ul>
The first two are relatively similar, since both are used to prematurely end the execution of one or more blocks of code:
<pre><code class="hljs">// Finding at which index element a is in an array
int[] arr = {1,2,3,4,5,6};
int foundAt = -1;

int a = 4;

for (int i = 0; i &lt; arr.length; i++) {
 System.out.println(arr[i]);
 if (arr[i] == a) {
 foundAt = i;
 break;
 }
}
if (foundAt != -1)
 System.out.println(a + &quot; was found at index &quot; + foundAt);
else System.out.println(a + &quot; wasn&#x27;t found in the array&quot;);
</code></pre>
Output:
<pre><code class="hljs">1
2
3
4
4 was found at index 3
</code></pre>
As we can see, the <code>for</code> loop executed as usual until it ran into the <code>break</code> statement, at which point Java stopped executing the loop and continued execution at the first line after the <code>for</code> loop.
Here's another example:
<pre><code class="hljs">Scanner s = new Scanner(System.in);

while (true) {
 System.out.println(&quot;Do you wish to exit the infinite loop? Y/N&quot;);
 if (s.hasNext()) {
 String answer = s.next();
 if (answer.equals(&quot;Y&quot;) || answer.equals(&quot;y&quot;))
 break;
 }
}
</code></pre>
This loop will keep asking the user if he wishes to exit the loop until they either reply with the appropriate characters, where we exit the loop using <code>break</code>, or terminate the program with <code>Ctrl + C</code>.
By default the <code>break</code> statement only exits the innermost loop it's in.
If we wanted to find the first position at which a certain element can be found in a matrix, and we wanted to <code>break</code> out of the loops as soon as we found it (similar to the example with an array above), writing the following wouldn't work:
<pre><code class="hljs">int[][] matrix = {{1,2,3},{4,5,6},{7,8,9}};

int foundAtI = -1;
int foundAtJ = -1;

int a = 4;

for (int i = 0; i &lt; matrix.length; i++) {
 for (int j = 0; j &lt; matrix[i].length; j++) {
 System.out.print(matrix[i][j] + &quot; &quot;);
 if (matrix[i][j] == a) {
 foundAtI = i;
 foundAtJ = j;
 break;
 }
 }
 System.out.println();
}

System.out.println();
if (foundAtI != -1)
 System.out.println(a + &quot; was found at indices [&quot; + foundAtI + &quot;,&quot; + foundAtJ + &quot;]&quot;);
else System.out.println(a + &quot; wasn&#x27;t found in the matrix&quot;);
</code></pre>
Output:
<pre><code class="hljs">1 2 3 
4 
7 8 9 
4 was found at indices [1,0]
</code></pre>
We can see that the loop continued executing even after finding 4 in the matrix, after stuttering in the row in which 4 was located. This is because the <code>break</code> only exited the innermost loop, i.e. it stopped iterating through the current row and skipped to the next one. Furthermore, our task was to find the first occurrence of 4 in the matrix, and this way we'd return the last occurrence of 4 in our matrix.
This is where labeled statements come into play, which we'll take a look at next.
<h3 id="labeledstatements">Labeled Statements</h3>
Labeled statements can be used together with the <code>break</code> or <code>continue</code> statements to simulate a <code>go-to</code>.
Labels can be applied to any code block between <code>{}</code>, <code>for</code>, <code>for-each</code>, <code>while</code>, <code>do-while</code>, <code>if</code> and <code>switch</code> statements, as well as expressions, assignments, <code>return</code> statements, <code>try</code> blocks, and <code>throw</code> statements. We then use them with the <code>break</code> and <code>continue</code> statements.
Labels work by applying an identifier to a construct:
<pre><code class="hljs">Identifier : Construct
</code></pre>
Such as:
<pre><code class="hljs">someLoop: for (int i = 0; i &lt; 100; i++) {}
someLabel: {
 int i = 10;
}
</code></pre>
We can then call upon these labeled statements via a <code>break</code> or <code>continue</code>. For example, here we've labeled our outer loop as simply <code>outer</code>. In order to exit two or more nested loops, we <code>break</code> the outer loop by calling the label:
<pre><code class="hljs">outer: for (int i = 0; i &lt; matrix.length; i++) {
 for (int j = 0; j &lt; matrix[i].length; j++) {
 System.out.print(matrix[i][j] + &quot; &quot;);
 if (matrix[i][j] == a) {
 foundAtI = i;
 foundAtJ = j;
 break outer;
 }
 }
 System.out.println();
}
</code></pre>
Using this labeled loop in place of the loop in the example above yields the correct result and behavior:
<pre><code class="hljs">1 2 3
4
4 was found at indices [1,0]
</code></pre>
You can't use <code>break label</code> if the <code>break</code> isn't located within a block of code designated by that label or it will cause an error during compilation.
<h2 id="continue">continue</h2>
The <code>continue</code> statement simply skips the rest of the current iteration and proceeds to the next one. It's useful when we want to skip entire (or part of) iterations that meet certain conditions, especially if they're performance heavy.
For a <code>while</code> loop, &quot;skipping&quot; the rest of the iteration means going straight back to checking the condition before the next iteration, and for a <code>for</code> loop this means going to the &quot;step&quot; part of the <code>for</code> loop (the part where we usually increment/decrement the control variable) and then checking the condition before the next iteration.
<code>continue</code> is usually used with an <code>if</code> statement -&gt; we will <code>continue</code> if a certain condition is met. We use this <code>if</code> to execute the rest of the iteration only if the condition is not met, and skip using <code>continue</code>. For example
<pre><code class="hljs">// We want to print every number from 1 to 20, except those divisible by 3
for (int i = 1; i &lt;= 20; i++) {
 if (i % 3 == 0)
 continue;
 
 System.out.println(i);
}
</code></pre>
The <code>continue</code> in our example could easily be avoided by using a slightly modified <code>if</code> statement, mainly by printing the number if <code>i % 3 != 0</code> is true, otherwise doing nothing.
General advice regarding both <code>break</code> and (especially) <code>continue</code> is to try and use them mostly at the beginning of iterations as some form of preconditions that we're checking. Using a <code>continue</code> somewhere in the middle of the iteration is a great way to cause bugs that take you a while to figure out.
Of course, you can also use <code>continue</code> with labeled statements:
<pre><code class="hljs">start: for (int i = 0; i &lt; 10; i++) {
 System.out.println();
 for (int j = 0; j &lt; 10; j++) {
 if (j &gt;= i)
 continue start;
 }
 System.out.println(&quot;Since j will always be equal to or more than i, the &#x27;start&#x27; loop will continue running indefinitely, and this piece of code will never run.&quot;);
}
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Flow control in code is essential just about every application. Statements that alter the flow of code are fundamental building blocks and every aspiring developer should be completely in control/aware of how they work.
Using the <code>break</code> and <code>continue</code> statements, Java developers can simulate <code>go-to</code> statements and break out of certain loops if need be.

Olivera Popović

Java Flow Control: break and continue Statements

Dhananjay Singh

Spring Cloud: Contract

One of the many benefits of using version control software like Git is how easily you can copy the entire contents and history of a project with a simple command in your terminal. Once on your local machine, you can then make the changes/additions/deletions that you want, and <a target="_blank" href="/git-push-local-branch-and-track-it/">push</a> it back to the origin repo.
In this short article we'll see how you can clone a Git repository from a remote (or local) source.
<h2 id="cloningrepositories">Cloning Repositories</h2>
In order to clone a remote repository you'll want to use the <code>git clone</code> command, which is typically used in this fashion:
<pre><code class="hljs">$ git clone &lt;repo-url&gt;
</code></pre>
This will clone the repository in to your current working directory using the name of the repo as the destination directory. In order to clone it in to a different directory, you can specify one as the second parameter to <code>clone</code>:
<pre><code class="hljs">$ git clone &lt;repo-url&gt; &lt;directory&gt;
</code></pre>
An example of this command for a public GitHub repo would look like the following:
<pre><code class="hljs">$ git clone git@github.com:scottwrobinson/twentyjs.git twentyjs-clone
Cloning into &#x27;twentyjs-clone&#x27;...
remote: Enumerating objects: 48, done.
remote: Total 48 (delta 0), reused 0 (delta 0), pack-reused 48
Receiving objects: 100% (48/48), 9.35 KiB | 0 bytes/s, done.
Resolving deltas: 100% (22/22), done.
</code></pre>
Like all Git commands, there are quite a few flags that can be used here. Below are some of the more commonly used ones for <code>git clone</code>:
<ul>
<li><code>-l</code> or <code>--local</code>: This tells Git that the repo we're cloning is on our local machine, which bypasses the normal &quot;git aware&quot; transport mechanism. The files under <code>.git/objects/</code> are also hard-linked to the original repo, which saves disk space. This flag is unnecessary if the repo is specified as a local path, but must be explicitly specified if the local repo is specified as a URL.</li>
<li><code>--no-tags</code>: Do not download any of the repo's tags. This setting is also saved so that subsequent <code>git pull</code> and <code>git fetch</code> calls do not download tags.</li>
<li><code>-o &lt;name&gt;</code> or <code>--origin &lt;name&gt;</code>: Rename the remote repository for this clone from &quot;origin&quot; to whatever is specified by <code>&lt;name&gt;</code>.</li>
<li><code>-n</code> or <code>--no-checkout</code>: Don't check out HEAD after cloning</li>
<li><code>--bare</code>: Places the files from <code>&lt;directory&gt;/.git</code> directly in to the location specified by <code>&lt;directory&gt;</code>. This is good for when you need a copy of the repo, but you don't need to work directly out of it for development purposes.</li>
</ul>
Remember, I've only mentioned the most commonly used flags specific to the <code>clone</code> command. There are quite a few more, which you can check out using the <code>git help clone</code> command in your terminal.
<h2 id="cloninglocalrepositories">Cloning Local Repositories</h2>
As you've probably guessed from some of the flags mentioned above, you can also clone repositories that are already on your local machine. This is done by specifying the repo's directory path instead of a URL. Here is an example of what that would look like:
<pre><code class="hljs">$ git clone /Users/scott/sandbox/twentyjs /Users/scott/projects/twentyjs
</code></pre>
With this command the <code>twentyjs</code> Git project would be copied in to the new <code>projects/twentyjs</code> directory. You can ommit the destination path, but keep in mind that you either need to be in a different working directory than where it resides or you need to give it a different name to avoid conflicts.
<h2 id="otherprotocols">Other Protocols</h2>
There are a number of ways to specify which repository you want to clone, wheter you're cloning a local or remote repo. The differences are in the protocol you specify, which also must be supported by the server hosting the repo. When choosing a protocol, be sure to consider security requirements and use the most secure protocols when necessary or able.
A few examples of protocols that are natively supported by Git are shown below:
<ul>
<li><code>git://example.com[:port]/path/to/repo/project.git</code></li>
<li><code>ssh://[user@]example.com[:port]/path/to/repo/project.git</code></li>
<li><code>http[s]://example.com[:port]/path/to/repo/project.git</code></li>
<li><code>ftp[s]://example.com[:port]/path/to/repo/project.git</code> (not recommended due to deprecation)</li>
</ul>
Other URL forms are also supported, depending on the protocol being used, like this one for SSH:
<ul>
<li><code>user@example.com:path/to/repo/project.git</code></li>
</ul>
As for local repositories, you can use one of the following forms:
<ul>
<li><code>/path/to/repo/project.git</code></li>
<li><code>file:///path/to/repo/project.git</code></li>
</ul>

Scott Robinson

Git: Clone a Repository

Java Flow Control: for and for-each Loops

<h2 id="introduction">Introduction</h2>
Object detection is a technology that falls under the broader domain of <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Computer_vision">Computer Vision</a>. It deals with identifying and tracking objects present in images and videos. Object detection has multiple applications such as face detection, vehicle detection, pedestrian counting, self-driving cars, security systems, etc.
The two major objectives of object detection include:
<ul>
<li>To identify all objects present in an image</li>
<li>Filter out the object of attention</li>
</ul>
In this article, you will see how to perform object detection in Python with the help of the <a rel="nofollow" target="_blank" href="https://imageai.readthedocs.io/en/latest/detection/index.html">ImageAI</a> library.
<h2 id="deeplearningforobjectdetection">Deep Learning for Object Detection</h2>
Deep learning techniques have been proven state of the art for various object detection problems. The following are some of the commonly used deep learning approaches for object detection:
<ul>
<li>ImageAI</li>
<li><a rel="nofollow" target="_blank" href="https://leonardoaraujosantos.gitbooks.io/artificial-inteligence/content/single-shot-detectors.html">Single Shot Detectors</a></li>
<li><a rel="nofollow" target="_blank" href="https://appsilon.com/object-detection-yolo-algorithm/">YOLO (You only look once)</a></li>
<li><a rel="nofollow" target="_blank" href="https://leonardoaraujosantos.gitbooks.io/artificial-inteligence/content/single-shot-detectors.html">Region-based Convolutional Neural Networks</a></li>
</ul>
In the rest of this article, we will see what exactly ImageAI is and how to use it to perform object detection.
<h2 id="imageai">ImageAI</h2>
ImageAI is a Python library built to empower developers to build applications and systems with self-contained deep learning and Computer Vision capabilities using a few lines of straight forward code. ImageAI contains a Python implementation of almost all of the state-of-the-art deep learning algorithms like <a rel="nofollow" target="_blank" href="https://arxiv.org/abs/1708.02002">RetinaNet</a>, <a rel="nofollow" target="_blank" href="https://pjreddie.com/darknet/yolo/">YOLOv3</a>, and TinyYOLOv3.
ImageAI makes use of several APIs that work offline - it has object detection, video detection, and object tracking APIs that can be called without internet access. ImageAI makes use of a pre-trained model and can easily be customized.
The <code>ObjectDetection</code> class of the ImageAI library contains functions to perform object detection on any image or set of images, using pre-trained models. With ImageAI, you can detect and recognize 80 different kinds of common, everyday objects.
<h3 id="settingupyourenvironment">Setting up your Environment</h3>
In this part of the tutorial, we will work through the installation of ImageAI.
To use ImageAI you need to install a few dependencies. The first step is to have Python installed on your computer. Download and install Python 3 from the <a rel="nofollow" target="_blank" href="https://www.python.org/">official Python website</a>.
Once you have Python installed on your computer, install the following dependencies using <code>pip</code>:
TensorFlow
<pre><code class="hljs">$ pip install tensorflow
</code></pre>
OpenCV
<pre><code class="hljs">$ pip install opencv-python
</code></pre>
Keras
<pre><code class="hljs">$ pip install keras
</code></pre>
ImageAI
<pre><code class="hljs">$ pip install imageAI
</code></pre>
Now download the <a rel="nofollow" target="_blank" href="https://github.com/OlafenwaMoses/ImageAI/releases/download/1.0/yolo-tiny.h5">TinyYOLOv3</a> model file that contains the classification model that will be used for object detection.
<h3 id="performingobjectdetectionwithimageai">Performing Object Detection with ImageAI</h3>
Now let's see how to actually use the ImageAI library. I'll explain step by step how you can build your first object detection model with ImageAI.
<h4 id="step1">Step 1</h4>
Our first task here is to create the necessary folders. For this tutorial we need the following folders:
<ul>
<li>Object detection: root folder</li>
<li>models: stores pre-trained model</li>
<li>input: stores image file on which we want to perform object detection</li>
<li>output: stores image file with detected objects</li>
</ul>
After you have created your folders, your <code>Object detection</code> folder should have the following sub-folders:
<pre><code class="hljs">├── input
├── models
└── output

3 directories, 0 files
</code></pre>
<h4 id="step2">Step 2</h4>
Open your preferred text editor for writing Python code and create a new file <code>detector.py</code>.
<h4 id="step3">Step 3</h4>
Import <code>ObjectDetection</code> class from the ImageAI library.
<pre><code class="hljs">from imageai.Detection import ObjectDetection
</code></pre>
<h4 id="step4">Step 4</h4>
Now that you have imported imageAI library and the <code>ObjectDetection</code> class , the next thing is to create an instance of the class <code>ObjectDetection</code>, as shown here:
<pre><code class="hljs">detector = ObjectDetection()
</code></pre>
<h4 id="step5">Step 5</h4>
Let's specify the path from our input image, output image, and model.
<pre><code class="hljs">model_path = &quot;./models/yolo-tiny.h5&quot;
input_path = &quot;./input/test45.jpg&quot;
output_path = &quot;./output/newimage.jpg&quot;
</code></pre>
<h4 id="step6">Step 6</h4>
After instantiating the <code>ObjectDetection</code> class we can now call various functions from the class. The class contains the following functions to call pre-trained models: <code>setModelTypeAsRetinaNet()</code>, <code>setModelTypeAsYOLOv3()</code>, and <code>setModelTypeAsTinyYOLOv3()</code>.
For the purpose of this tutorial, I'll be using the pre-trained <code>TinyYOLOv3</code> model, and hence we will use the <code>setModelTypeAsTinyYOLOv3()</code> function to load our model.
<pre><code class="hljs">detector.setModelTypeAsTinyYOLOv3()
</code></pre>
<h4 id="step7">Step 7</h4>
Next, we are going to call the function <code>setModelPath()</code>. This function accepts a string which contains the path to the pre-trained model:
<pre><code class="hljs">detector.setModelPath(model_path)
</code></pre>
<h4 id="step8">Step 8</h4>
This step calls the function <code>loadModel()</code> from the <code>detector</code> instance. It loads the model from the path specified above using the <code>setModelPath()</code> class method.
<pre><code class="hljs">detector.loadModel()
</code></pre>
<h4 id="step9">Step 9</h4>
To detect objects in the image, we need to call the <code>detectObjectsFromImage</code> function using the <code>detector</code> object that we created in the previous section.
This function requires two arguments: <code>input_image</code> and <code>output_image_path</code>. <code>input_image</code> is the path where the image we are detecting is located, while the <code>output_image_path</code> parameter is the path to store the image with detected objects. This function returns a dictionary which contains the names and percentage probabilities of all the objects detected in the image.
<pre><code class="hljs">detection = detector.detectObjectsFromImage(input_image=input_path, output_image_path=output_path)
</code></pre>
<h4 id="step10">Step 10</h4>
The dictionary items can be accessed by traversing through each item in the dictionary.
<pre><code class="hljs">for eachItem in detection:
 print(eachItem[&quot;name&quot;] , &quot; : &quot;, eachItem[&quot;percentage_probability&quot;])
</code></pre>
<h4 id="completecodeforobjectdetection">Complete Code for Object Detection</h4>
Here is the complete code for the image detection:
<pre><code class="hljs">from imageai.Detection import ObjectDetection

detector = ObjectDetection()

model_path = &quot;./models/yolo-tiny.h5&quot;
input_path = &quot;./input/test45.jpg&quot;
output_path = &quot;./output/newimage.jpg&quot;

detector.setModelTypeAsTinyYOLOv3()
detector.setModelPath(model_path)
detector.loadModel()
detection = detector.detectObjectsFromImage(input_image=input_path, output_image_path=output_path)

for eachItem in detection:
 print(eachItem[&quot;name&quot;] , &quot; : &quot;, eachItem[&quot;percentage_probability&quot;])
</code></pre>
In the output, you can see the name of each detected object along with its percentage probability as shown below: 
Output
<pre><code class="hljs">car : 54.72719073295593
car : 58.94589424133301
car : 62.59384751319885
car : 74.07448291778564
car : 91.10507369041443
car : 97.26507663726807
car : 97.55765795707703
person : 53.6459743976593
person : 56.59831762313843
person : 72.28181958198547
</code></pre>
Original image:
The original image, i.e. &quot;test45&quot;, looked like this:
<img src="https://stackabuse.s3.amazonaws.com/media/object-detection-with-imageai-python-1.jpg" alt="">
Image with Object Detection:
After the object detection, the resulting image looks like this:
<img src="https://stackabuse.s3.amazonaws.com/media/object-detection-with-imageai-python-2.jpg" alt="">
You can see that ImageAI has successfully identified cars and persons in the image.
<h2 id="conclusion">Conclusion</h2>
Object detection is one of the most common computer vision tasks. This article explains how to perform object detection in Python using the ImageAI library with the help of an example.
References
<ul>
<li><a rel="nofollow" target="_blank" href="https://imageai.readthedocs.io/en/latest/detection/index.html">https://imageai.readthedocs.io/en/latest/detection/index.html</a></li>
</ul>

Guest Contributor

Object Detection with ImageAI in Python

Usman Malik

Python for NLP: Working with Facebook FastText Library

<h2 id="introduction">Introduction</h2>
Conditional statements and loops are a very important tool in programming. There aren't many things we could do with code that can only execute line-by-line.
That's what &quot;flow control&quot; means - guiding the execution of our program, instead of letting it execute line-by-line regardless of any internal or external factors. Every programming language supports some form of flow control, if not explicitly via <code>if</code>s and <code>for</code>s or similar statements - then it implicitly gives us the tools to create such constructs, i.e. low-level programming languages usually achieve that affect with a lot of <code>go-to</code> commands.
<blockquote>
Loops were a concept used long before computer programming was even a thing, but the first person to use a software loop was Ada Lovelace, commonly known by her maiden name - Byron, while calculating <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Bernoulli_number">Bernoulli numbers</a>, back in the 19th century.
</blockquote>
In Java, there are several ways to control the flow of the code:
<ul>
<li><a target="_blank" href="/java-flow-control-if-and-if-else-statements">if and if-else statements</a></li>
<li><a target="_blank" href="/flow-control-in-java-the-switch-statement">switch statements</a></li>
<li><a target="_blank" href="/java-flow-control-while-and-do-while-statements/"><code>while</code> and <code>do-while</code> statements</a></li>
<li><a target="_blank" href="/java-flow-control-for-and-for-each-loops/"><code>for</code> and <code>enhanced for</code> statements</a></li>
<li><a target="_blank" href="/java-flow-control-break-and-continue-statements/"><code>break</code> and <code>continue</code> statements</a></li>
</ul>
<h2 id="while">while</h2>
A loop is a set of instructions that are repeatedly executed until some condition is met, or alternatively as long as a condition is <code>true</code>. The <code>while</code> loop in Java works on the latter principle, it repeats a block of code as long as the condition evaluates to <code>true</code>:
<pre><code class="hljs">while(condition) {
 // Block of code to be executed
}
</code></pre>
When Java encounters a <code>while</code> loop it does the following:
<ul>
<li>Is the <code>condition</code> true?
<ul>
<li>Yes -&gt; execute the block of code. Check the condition again.</li>
<li>No -&gt; don't execute the block of code. Don't check the condition again.</li>
</ul>
</li>
</ul>
This means that if we had a statement like <code>while(true)</code>, the block of code would execute indefinitely (or at least, try to). This is called an infinite loop and is to be avoided unless we have a way of breaking out of the loop - typically with a <code>break</code> statement.
The <code>condition</code> can be any type of <code>Boolean</code> expression, the same as with <code>if</code> statements.
Since <code>while</code> checks the <code>condition</code> before executing any code, it is possible that the block of code within the while loop is never executed if the <code>condition</code> was <code>false</code> at the beginning.
This is different from a <code>for</code> loop, which typically executes a set number of times. <code>while</code> loops, on the other hand, are often used to execute an unknown number of times.
Here's an example of a <code>while</code> loop that sums up all the digits of an <code>int</code>.
<pre><code class="hljs">int n = 123;
int sumOfDigits = 0;

while(n &gt; 0) {
 int lastDigit = n % 10; // Retrieves the last digit of n via the modulus operator
 n = n / 10; // &quot;Removes&quot; the last digit from n via division

 sumOfDigits += lastDigit; // Adds the current digit to the sum
}

System.out.println(sumOfDigits);
</code></pre>
The execution of this code works in the following way:
<ul>
<li>The while condition is checked, <code>n</code> is 123 and <code>sumOfDigits</code> is 0. Is <code>n &gt; 0</code> equal to <code>true</code>? Yes -&gt; execute the code in the loop.</li>
<li>The while condition is checked, <code>n</code> is 12 and <code>sumOfDigits</code> is 3. Is <code>n &gt; 0</code> equal to <code>true</code>? Yes -&gt; execute the code in the loop.</li>
<li>The while condition is checked, <code>n</code> is 1 and <code>sumOfDigits</code> is 5. Is <code>n &gt; 0</code> equal to <code>true</code>? Yes -&gt; execute the code in the loop.</li>
<li>The while condition is checked, <code>n</code> is 0 and <code>sumOfDigits</code> is 6. Is <code>n &gt; 0</code> equal to <code>true</code>? No -&gt; execute the first line after the loop, in our case print out the result.</li>
</ul>
After executing the while loop 3 times, a value of 6 is printed to the console.
The body of the while loop can be empty, and sometimes developers like to write shorthand <code>while</code> loops when possible. Additionally, the same rule of shortening <code>if</code> and <code>else</code> statements applies to <code>while</code>. So a single-line <code>while</code> loop can be re-written without the brackets, like this:
<pre><code class="hljs">// This...
while(i &lt; j) {
 System.out.println(&quot;i &quot; + i++ + &quot; j &quot; + j--);
}

// ...becomes this:
while(i &lt; j)
 System.out.println(&quot;i &quot; + i++ + &quot; j &quot; + j--);
</code></pre>
Also notice that the variables used in the checked condition can be changed either within the <code>while</code> loops code block or within the checked condition itself:
<pre><code class="hljs">while(++i &lt; --j)
 System.out.println(&quot;i &quot; + i + &quot; j &quot; + j);
</code></pre>
Both of these result in the same output:
<pre><code class="hljs">i 1 j 9
i 2 j 8
i 3 j 7
i 4 j 6
</code></pre>
However, they may reduce readability and should be avoided if they do.
<h2 id="dowhile">do-while</h2>
This loop does essentially the same thing as <code>while</code>, but it guarantees that the block of code will be executed at least once.
This is because, unlike in <code>while</code>, the code is executed before the condition is checked. So even if we start off with a <code>false</code> condition, it'll execute the code and then check if it should do it again:
<pre><code class="hljs">int i = 0;

// This will print once
do {
 System.out.println(i);
 i--;
} while(i &gt; 0);
</code></pre>
The output of the code is:
<pre><code class="hljs">0
</code></pre>
After the code reaches <code>while(i &gt; 0)</code>, it stops the iterations.
For example, one use-case for <code>do-while</code> is to ask the user if they want to try doing something again in case it fails.
<pre><code class="hljs">do {
 // Try to connect to a server, access a resource, etc...
 String status = connectToServer();

 // Ask user whether they want to try again
 String userInput = getUserInput(&quot;Connection status is &quot; + status + &quot;. Want to try again?&quot;);
} while(userInput == &quot;yes&quot;);
</code></pre>
This can be done with a regular <code>while</code> loop, but it's more readable and intuitive this way.
<h2 id="conclusion">Conclusion</h2>
Flow control in code is essential for absolutely every application. Statements that alter the flow of code are fundamental building blocks and every aspiring developer should be completely in control/aware of how they work.
<code>while</code> and <code>do-while</code> loops are good for executing a block of code an unknown number of times, where a condition is checked every time the code block re-runs.