**Get started with Spring 5 and Spring Boot 2, through the ***Learn Spring* course:

*Learn Spring*course:

**>> CHECK OUT THE COURSE**

Last modified: March 25, 2020

In this quick tutorial, we'll show how to calculate the distance between two points in Java.

Let's say we have two points on a plane: the first point A has the coordinates (x1, y1), and the second point B has the coordinates (x2, y2). We want to calculate AB, the distance between the points.

Firstly, let's build a right triangle with the hypotenuse AB:

According to the Pythagorean theorem, the sum of the squares of the lengths of the triangle's legs is the same as the square of the length of the triangle's hypotenuse: *AB ^{2} = AC^{2} + CB^{2}*.

Secondly, let's calculate AC and CB.

Obviously:

`AC = y2 - y1`

Similarly:

`BC = x2 - x1`

Let's substitute the parts of the equation:

`distance * distance = (y2 - y1) * (y2 - y1) + (x2 - x1) * (x2 - x1)`

Finally, from the above equation we can calculate the distance between the points:

`distance = sqrt((y2 - y1) * (y2 - y1) + (x2 - x1) * (x2 - x1))`

Now let's move on to the implementation part.

Although* java.lang.Math* and *java.awt.geom.Point2D *packages provide ready solutions, let's firstly implement the above formula as is:

```
public double calculateDistanceBetweenPoints(
double x1,
double y1,
double x2,
double y2) {
return Math.sqrt((y2 - y1) * (y2 - y1) + (x2 - x1) * (x2 - x1));
}
```

To test the solution, let's take the triangle with legs *3* and *4* (as shown in the picture above). It's clear that the number *5* is suitable as the value of the hypotenuse:

`3 * 3 + 4 * 4 = 5 * 5`

Let's check the solution:

```
@Test
public void givenTwoPoints_whenCalculateDistanceByFormula_thenCorrect() {
double x1 = 3;
double y1 = 4;
double x2 = 7;
double y2 = 1;
double distance = service.calculateDistanceBetweenPoints(x1, y1, x2, y2);
assertEquals(distance, 5, 0.001);
}
```

If the result of multiplication in the *calculateDistanceBetweenPoints()* method is too big, overflow can occur. Unlike that, *Math.hypot()* method prevents intermediate overflow or underflow:

```
public double calculateDistanceBetweenPointsWithHypot(
double x1,
double y1,
double x2,
double y2) {
double ac = Math.abs(y2 - y1);
double cb = Math.abs(x2 - x1);
return Math.hypot(ac, cb);
}
```

Let's take the same points as before and check that the distance is the same:

```
@Test
public void givenTwoPoints_whenCalculateDistanceWithHypot_thenCorrect() {
double x1 = 3;
double y1 = 4;
double x2 = 7;
double y2 = 1;
double distance = service.calculateDistanceBetweenPointsWithHypot(x1, y1, x2, y2);
assertEquals(distance, 5, 0.001);
}
```

Finally, let's calculate the distance with the *Point2D.distance()* method:

```
public double calculateDistanceBetweenPointsWithPoint2D(
double x1,
double y1,
double x2,
double y2) {
return Point2D.distance(x1, y1, x2, y2);
}
```

Now let's test the method in the same way:

```
@Test
public void givenTwoPoints_whenCalculateDistanceWithPoint2D_thenCorrect() {
double x1 = 3;
double y1 = 4;
double x2 = 7;
double y2 = 1;
double distance = service.calculateDistanceBetweenPointsWithPoint2D(x1, y1, x2, y2);
assertEquals(distance, 5, 0.001);
}
```

In this tutorial, we've shown a few ways to calculate the distance between two points in Java.

As always, the code used in the examples is available over on GitHub.

Follow the Java Category

Follow the Java category to get regular info about the new articles and tutorials we publish here.