Refactor code to find four co-linear points

The easiest way to flatten this kind of a structure is to reverse the sense of the if. That is, where you have

if (first.equals(next)) {
    // do stuff
}

Instead write

if (!first.equals(next)) {
    continue;
}
// do stuff

This only works where you don't have an else clause (so unfortunately I chose a bad example), but it can work wonders in bringing your code closer to the left margin.

From there I would start seeing where I could extract methods, especially but not exclusively where there is duplication in the code. The block of code beginning with

SortedSet<Point> line = new TreeSet<Point>();

looks like a good candidate for this.

Several comments

1) according to java coding conventions we write { at the same line where operator is, i.e.

if () {
}

and not

if () 
{
{

2) If you do not have special reason to use primitive wrapper (e.g. Double) use primitive double

The next comments are not about java but about general programming style

3) avoid writing so complicated conditions into while loop 4) try to simplify conditions. I think that list.add(0, element) works exactly like list.add(element) when list is empty. Therefore code:

                        if (lines.isEmpty())
                        {

                          lines.add(line);
                        }

                        else
                         {
                            lines.add(0, line);;
                            weedDuplicates( line);
                         }

Can be re-written as:

if (!lines.isEmpty()) {
    weedDuplicates( line);
}
lines.add(0, line);;

5) the code

if (first.equals(next) == false)

is the same as:

if (!first.equals(next))

Well, I frankly speaking I did not understand exactly what are you doing in this code fragment but probably the algorithm can be simplified too.

I'm not convinced that the code does what you claim.

First, let's clarify the parameters. Is there a relationship between arrayOfSlopes and tempArray? Your description suggests that arrayOfSlopes can be derived from tempArray, with each arrayOfSlopes[i] being the slope of a line between the origin and tempArray[i]. If that is so, then your function should only take a Point[] argument, named better (points will do for a name). This being a public function, you should make the interface as caller-friendly as possible, and requiring the caller to pass in two arrays that obey some unwritten consistency rule between them is inappropriate.

It appears that arrayOfSlopes and tempArray must follow rules about the ordering of their elements — elements must be sorted by slope? That's not obvious from the non-existent JavaDoc. You also treat tempArray[0] specially, though I can't tell why.

Next, what is lines? It appears to be a static class variable (it's the only way I can imagine to make this code compile). Putting the answer in a class variable makes no sense. Either you return lines as a result from this function, or you make this code a non-public instance method and store the result in an instance variable.

If arrayOfSlopes contains the slope of each point relative to the origin, then matching slopes will only yield lines that pass through the origin.

Does Point refer to java.awt.Point? You store them in a SortedSet, though, which means that they must be Comparable to each other. How is the comparison function defined?

Your else if is redundant — a simple else would be equivalent.