A simple clusterness measure of data in one dimension using Java
In my opinion your code is perfectly fine! I just found some fussy thinks.

HTML Comments
In Robert C. Martin's book Clean Code under HTML Comments you can read

HTML in source code comments is an abomination [...]. It makes the comments hard to read in the one place where they should be easy to read — the editor/IDE. If comments are going to be extracted by some tool (like Javadoc) to appear in a Web page, then it should be the responsibility of that tool, and not the programmer, to adorn the comments with appropriate HTML.

In to places you uses the &lt;code&gt;-tag. Which can be replaced by javadocs {@code}
For example from

&lt;code&gt;x1, x2, ..., xn&lt;/code&gt; 


to
{@code x1, x2, ..., xn}


Duplicated Statement
The statement points.size() - 1 occurs three times inside the method computeClusternessMeasure. Even it is only a \$O(1)\$-statement it makes it easier to read the variable indexOfLastEntry instead of points.size() - 1

An Other Argument
Currently computeClusternessMeasure takes a Collection but instead you need a List. This &quot;transformation&quot; has nothing to do with the algorithm and a a collection makes additional to that no sense..
Furthermore you need to sort it..
Take a First-Class-Collection as Argument
If you want to keep the flexibility you could create a First-Class-Collection.

Any class that contains a collection should contain no other member variables. Each collection gets wrapped in its own class, so now behaviors related to the collection have a home.

The method signature I want to create is double computeClusternessMeasure(SortedMessurementPoints points)
public class SortedMessurementPoints {

      private List&lt;Double&gt; points;
   
      public SortedMessurementPoints(Collection&lt;Double&gt; points) {
          List&lt;Double&gt; asList = new ArrayList(points);
          Collection.sort(asList )
          this.points = asList;
      }

      public double get(int index) {
          return points.get(index);
      }

      public int indexOfLastEntry() {
            return points.size() - 1;
      }
}

public double computeClusternessMeasure(SortedMessurementPoints points) {
    double minimumPoint = points.get(0);
    double maximumPoint = points.get(points.indexOfLastEntry());
    double range = maximumPoint - minimumPoint;

    if (range == 0.0) {
        // Once here, all data points are equal and so CM must be 1.0.
        return 1.0;
    }

    double expectedDifference = range / points.indexOfLastEntry();
    double sum = 0.0;

    for (int i = 0; i &lt; points.indexOfLastEntry(); i++) {
        double currentDifference = points.get(i + 1) - points.get(i);
        sum += Math.min(Math.abs(expectedDifference - currentDifference),
                                     expectedDifference);
    }

    return sum / range;
}