Replace get() with orElse(null).

Optional#get() throws an exception if there is nothing inside Optional. Sonar wants you to check the optional before getting the value like in the snippet below, but I won't recommend it as the whole idea of Optional class is to prevent null pointer exceptions

Optional<Department> deptOpt= studList.stream().min(comparator.comparing(Department::getDepartmentNo));

Department department = null;
if(deptOpt.isPresent())
    department = deptOpt.get();
}

A better way of doing things is the fololowing:

Department department = deptOpt.orElse(Department::new);

In this case, deptOpt returns a default Department object in case Optional doesn't contain any value (is empty).

Anyway - whatever approach you choose should fix your problem with Sonar.

First of all, consider that the check is complex and probably relatively time consuming to do. It requires some static analysis, and there might be quite a bit of code between the two calls.

Second, the idiomatic usage of the two constructs are very different. I program full time in Scala, which uses Options much more frequently than Java does. I can't recall a single instance where I needed to use a .get() on an Option. You should almost always be returning the Optional from your function, or be using orElse() instead. These are much superior ways to handle missing values than throwing exceptions.

Because .get() should rarely be called in normal usage, it makes sense for an IDE to start a complex check when it sees a .get() to see if it was used properly. In contrast, iterator.next() is the proper and ubiquitous usage of an iterator.

In other words, it's not a matter of one being bad and the other not, it's a matter of one being a common case that's fundamental to its operation and is highly likely to throw an exception during developer testing, and the other being a rarely used case that may not be exercised enough to throw an exception during developer testing. Those are the sorts of cases you want IDEs to warn you about.

You've left off a bit of information. Right now it appears your code returns Optional or null. That is the point of Optional though, it might not have anything.

if(t instanceof TileEntityMachineFrame){
    //...
} else{
    return Optional.empty();
}
    

That way you return an empty optional and not null. The next issue is your .get is giving you a warning. Since it is on an Optional, you have to consider that the Optional will be empty. The simplest replacement would be to replace get with Optional.orElse. So what happens to your constructor then?

You could replace the .get call with map.

return ( (TileEntityMachineFrame) t ).itItemHandler.map( 
    handler-> new SlotMotor( handler.motorInputWrapper, i, d.x, d.y )
);

From the javadocs for Map, "If a value is present, returns an Optional describing (as if by ofNullable(T)) the result of applying the given mapping function to the value, otherwise returns an empty Optional. "

Breaking it down more

I think you've tried to bunch up too much, you should spread it out a bit to better understand what youre doing.

Optional<ItemHandler> opt = ( (TileEntityMachineFrame) t ).itItemHandler;
ItemHandler handler = opt.get();
SlotMotor motor = new SlotMotor( handler.motorInputWrapper, i, d.x, d.y);
Optional<SlotMotor> optionalMotor = Optional.of(motor);

In that code You're getting a warning because there is a call to get without using isPresent one way to change that is to use map.

Optional<SlotMotor> optionalMotor = opt.map( 
     handler -> new SlotMotor( handler.motorInputWrapper, i, d.x, d.y )      
);

There isn't a missing call to get because we're working inside of the lambda passed to map. Plus this automatically gets you the optional you return.