public static boolean almostEqual(double a, double b, double eps){
    return Math.abs(a-b)<eps;
}

Where eps is measure of equality.

This is often need when using doubles as you can get small rounding errors.

if(Math.abs(lineNumber - startLineNumber) <= 2)

You can change 2 to 5. This is says; if the difference between two values is less than 2. i.e it could be -2, -1, 0, 1 or 2.

For double a similar solution is to test "equality" using

if(Math.abs(a - b) < ERR) // where ERR is 1e-4 or 1e-9

What is a good value of ERR to use depends on the situation.

1. Please make the class final to let noone inherit the class.
   1. Nobody would expect a AsserationError if he can inherit the class.
   2. Everyone who inherit the class would have duplicate javadoc.
2. Please throw a RuntimeException or an IllegalStateException because the javadoc matches better.
3. ;P let me miss seriousness.
4. i miss strictfp at the class definition because the math-processor may wrong.
5. getFloatTolerance you dont need the getter. If it would be a bean, you need it but it is no bean.
6. setFloatTolerance throws a IAE, but this behaviour is not part of the javadoc, and if you add this behaviour to the javadoc you shall write the signature of the method matching to the javadoc. assertProperLength should be have the correct javadoc and signature too (including the pending methods).
7. The classname Numbers should be named "NumberHelper".
8. The above code runs without resulting in any assertion errors. (Yipee!!), Yipee but wait ... did you run it as JUnit-Tests or activated the -ea by manual?
9. Some methods needs to have javadoc.

I have a few more but ill stop here because this class is not thread-save.

I would use a library for this, the one I normally use is DoubleMath fro Googles Guava library. https://google.github.io/guava/releases/19.0/api/docs/com/google/common/math/DoubleMath.html

if (DoubleMath.fuzzyEquals(a, b, epsilon)) { // a and b are equal within the tolerance given } there is also a fuzzyCompare.

1) Don't override equals/hashCode only for unit testing purposes

These methods have a semantic and their semantic is not taking into consideration all fields of the class to make a test assertion possible.

2) Rely on testing library to perform your assertions

Assert(students.contains(expectedStudent)

or that (posted in the John Bollinger answer):

Assert(students.stream().anyMatch(s -> expectedStudent.matches(s)));

are great anti patterns in terms of unit testing.
When an assertion fails, the first thing that you need is knowing the cause of the error to correct the test.
Relying on a boolean to assert the list comparison doesn't allow that at all.
KISS (Keep it simple and stupid): Use testing tools/features to assert and don't reinvent the wheel because these will provide the feedback needed when your test fails.

3) Don't assert double with equals(expected, actual).

To assert double values, unit testing libraries provide a third parameter in the assertion to specify the allowed delta such as :

public static void assertEquals(double expected, double actual, double delta) 

in JUnit 5 (JUnit 4 has a similarly thing).

Or favor BigDecimal to double/float that is more suitable for this kind of comparison.

But it will not completely solve your requirement as you need to assert multiple fields of your actual object. Using a loop to do that is clearly not a fine solution.
Matcher libraries provide a meaningful and elegant way to solve that.

4) Use Matcher libraries to perform assertions on specific properties of objects of the actual List

With AssertJ :

//GIVEN
...

//WHEN
List<Student> students = getStudents();

//THEN
Assertions.assertThat(students)
           // 0.1 allowed delta for the double value
          .usingComparatorForType(new DoubleComparator(0.1), Double.class) 
          .extracting(Student::getId, Student::getName, Student::getGpa)
          .containsExactly(tuple(1234, "Peter Smith", 3.89),
                           tuple(...),
          );

Some explanations (all of these are AssertJ features) :

• usingComparatorForType() allows to set a specific comparator for the given type of elements or their fields.

• DoubleComparator is a AssertJ comparator providing the facility to take an epsilon into consideration in the double comparison.

• extracting defines values to assert from the instances contained in the List.

• containsExactly() asserts that the extracted values are exactly (that is no more, no less and in the exact order) these defined in the Tuples.

IBM has a recommendation for comparing two floats, using division rather than subtraction - this makes it easier to select an epsilon that works for all ranges of input.

if (abs(a/b - 1) < epsilon)

As for the value of epsilon, I would use 5.96e-08 as given in this Wikipedia table, or perhaps 2x that value.