DEV Community: Eugen (Baeldung)

Three Simple Examples of the Find Command

Eugen (Baeldung) — Fri, 17 Jul 2020 18:27:27 +0000

1. Overview

Looking for files is a common operation when we work in the Linux command-line. The find command is a handy utility to find files.

In this short tutorial, we'll have a look at three simple but practical examples of the find command.

2. Find Files by a Filename Pattern

Searching for files matching a particular name or name pattern could be the most common use-case of the find command. Using the find command, we can pass the -name option and a filename pattern to locate the files.

For example, we can use the -name option to find all json files under our Python installation directory /usr/lib/python3.8:

$ find /usr/lib/python3.8 -name '*.json' 
/usr/lib/python3.8/site-packages/glances/outputs/static/package.json
/usr/lib/python3.8/site-packages/glances/outputs/static/package-lock.json
/usr/lib/python3.8/site-packages/compose/config/config_schema_v3.5.json
/usr/lib/python3.8/site-packages/compose/config/config_schema_v3.8.json
/usr/lib/python3.8/site-packages/compose/config/config_schema_v2.0.json
...
/usr/lib/python3.8/site-packages/jsonschema/schemas/draft3.json
/usr/lib/python3.8/site-packages/jsonschema/schemas/draft6.json
/usr/lib/python3.8/site-packages/zmq/utils/config.json
/usr/lib/python3.8/site-packages/zmq/utils/compiler.json
/usr/lib/python3.8/site-packages/guzzle_sphinx_theme/guzzle_sphinx_theme/static/fonts/source-serif-pro/bower.json

The command is pretty straightforward. But it's worthwhile to mention that when we use the -name option with a pattern, the find command will match against basenames only — that is, the leading directories will be ignored.

For example, if we want to find the two json files under the */utils/ directory, this command will fail:

$ find /usr/lib/python3.8 -name '*/utils/*.json'
find: warning: ‘-name’ matches against basenames only, but the given pattern contains a directory separator (‘/’),
thus the expression will evaluate to false all the time.  Did you mean ‘-wholename’?

As the warning message suggested, we can use the option -wholename to do the search with leading directories:

$ find /usr/lib/python3.8 -wholename '*/utils/*.json'                                    
/usr/lib/python3.8/site-packages/zmq/utils/config.json
/usr/lib/python3.8/site-packages/zmq/utils/compiler.json

It works! The expected result is printed.

However, it's worth noting that the -wholename option is GNU-specific. This option is not supported by HP-UX find and not a part of the POSIX 2008 standard.

A more portable way to match leading directories and basenames is to use the -path option:

$ find /usr/lib/python3.8 -path '*/utils/*.json'
/usr/lib/python3.8/site-packages/zmq/utils/config.json
/usr/lib/python3.8/site-packages/zmq/utils/compiler.json

3. Find Files by Size

Sometimes, we want to find files that are larger or smaller than a certain size. We can use the -size option of the find command to do exactly that.

Let's find all files larger than 5MB under the Python installation directory:

$ find /usr/lib/python3.8 -size '+5M'
/usr/lib/python3.8/config-3.8-x86_64-linux-gnu/libpython3.8.a
/usr/lib/python3.8/site-packages/PyQt5/QtWidgets.abi3.so

The -size option requires a "+/-n[UNIT]" parameter to do the search.

The "+" stands for greater than, while the "-" means less than. The --size option supports six units:

b: 512-byte blocks
c: bytes
w: two-byte words
k: kilobytes
M: megabytes
G: gigabytes

4. Find Files with the Same Filename

In the last example, let's find out the files with the same filename.

We'll find all files matching the "README.*" pattern under the Python installation directory, grouping together those with the same filename:

$ find /usr/lib/python3.8 -name 'README.*' | awk -F'/' 'a[$NF]++{print $NF" -> "$0}' | sort
README.md -> /usr/lib/python3.8/site-packages/dulwich/contrib/README.md
README.md -> /usr/lib/python3.8/site-packages/guzzle_sphinx_theme/guzzle_sphinx_theme/static/fonts/source-serif-pro/README.md
README.txt -> /usr/lib/python3.8/idlelib/Icons/README.txt
...
README.txt -> /usr/lib/python3.8/site-packages/zc/lockfile/README.txt

In this example, we passed the output of the find command to an awk one-liner. The awk one-liner is responsible for finding the files with duplicate names. Finally, the sort command groups the results.

Using the find command, not only can we find files that have the same names, but we can also find duplicate files as well.

5. Conclusion

The find command is a common Linux command-line utility. In this short article, we had a look at three simple examples of this command.

The Adapter Pattern in Java

Eugen (Baeldung) — Tue, 24 Dec 2019 08:35:20 +0000

1. Overview

In this quick tutorial, we'll have a look at the Adapter pattern and its Java implementation.

2. The Adapter Pattern

An Adapter pattern acts as a connector between two incompatible interfaces that otherwise cannot be connected directly. An Adapter wraps an existing class with a new interface so that it becomes compatible with the client’s interface.

The main motive behind using this pattern is to convert an existing interface into another interface that the client expects. It's usually implemented once the application is designed.

2.1. Adapter Pattern Example

Consider a scenario in which there is an app that's developed in the US which returns the top speed of luxury cars in miles per hour (MPH). Now we need to use the same app for our client in the UK that wants the same results but in kilometers per hour (km/h).

To deal with this problem, we'll create an adapter which will convert the values and give us the desired results:

First, we'll create the original interface Movable which is supposed to return the speed of some luxury cars in miles per hour:

public interface Movable {
    // returns speed in MPH 
    double getSpeed();
}

We'll now create one concrete implementation of this interface:

public class BugattiVeyron implements Movable {

    @Override
    public double getSpeed() {
        return 268;
    }
}

Now we'll create an adapter interface MovableAdapter that will be based on the same Movable class. It may be slightly modified to yield different results in different scenarios:

public interface MovableAdapter {
    // returns speed in KM/H 
    double getSpeed();
}

The implementation of this interface will consist of private method convertMPHtoKMPH() that will be used for the conversion:

public class MovableAdapterImpl implements MovableAdapter {
    private Movable luxuryCars;

    // standard constructors

    @Override
    public double getSpeed() {
        return convertMPHtoKMPH(luxuryCars.getSpeed());
    }

    private double convertMPHtoKMPH(double mph) {
        return mph * 1.60934;
    }
}

Now we'll only use the methods defined in our Adapter, and we'll get the converted speeds. In this case, the following assertion will be true:

@Test
public void whenConvertingMPHToKMPH_thenSuccessfullyConverted() {
    Movable bugattiVeyron = new BugattiVeyron();
    MovableAdapter bugattiVeyronAdapter = new MovableAdapterImpl(bugattiVeyron);

    assertEquals(bugattiVeyronAdapter.getSpeed(), 431.30312, 0.00001);
}

As we can notice here, our adapter converts 268 mph to 431 km/h for this particular case.

2.2. When to Use Adapter Pattern

When an outside component provides captivating functionality that we'd like to reuse, but it's incompatible with our current application. A suitable Adapter can be developed to make them compatible with each other
When our application is not compatible with the interface that our client is expecting
When we want to reuse legacy code in our application without making any modification in the original code

3. Conclusion

In this article, we had a look at the Adapter design pattern in Java.

The full source code for this example is available over on GitHub.