Draw the tiles of the islands that are within bounds, using LibGDX
Reduce Allocations

Creating objects while the game is running is not optimal. You are also creating those objects inside of the render method which will be called many thousands of times.  The garbage collector is good, but you will still see performance spikes when it is doing too much work.

Luckily you can eliminate all of these allocations!

One approach that you will find useful is to use Pools. This is very easy when working with many libGDX classes. Setting it up is just one line where 100 below is the maximum number of objects you think you will need at one time:

private final Pool&lt;Rectangle&gt; recPool = Pools.get(Rectangle.class, 100);


Then when you want a rectangle object:

Rectangle focusedMapRectangle = recPool.obtain();


And when you are done using the object:

recPool.free(focusedMapRectangle);


The Rectangle class has a number of set methods in order to configure it after you obtain the object.

focusedMapRectangle.setX(getMatchMap().getBottomLeft().x);
focusedMapRectangle.setY(getMatchMap().getBottomLeft().y);
focusedMapRectangle.setWidth(Gdx.graphics.getWidth() / 16);
focusedMapRectangle.setHeight(Gdx.graphics.getHeight() / 16);


I mention Pools because I think you will find it useful in the future, however I actually think there is a better approach in this case.

You do need one new Rectangle at the start of the render method because it will match the current view of the world. However, rather than creating a new object each time, you could have one Rectangle and just use the set methods above to set it to the appropriate values.

That brings me to the next offender:

getMatchMap().getIslands().forEach((island, point) -&gt; {
    Rectangle islandRectangle = new Rectangle(
        point.x,
        point.y,
        island.getMaxWidth(),
        island.getMaxHeight()
    );


What getIslands() returns is not totally clear to me, but I can tell that each island has a point associated with it. That point does not appear to be subject to change. I also assume that the maxWidth and maxHeight of the island are not subject to change. So why not pre-calculate the Rectangle for the island when first creating it? Then you can just do 

if (focusedMapRectangle.overlaps(island.getRectangle())) { 


and completely avoid allocating any new objects.

Beware of iterators

I don't know if you are using the libGDX Array and Map classes, but you should consider doing so if not. forEach by itself is not a problem, but if you are using the regular Java collection classes, iterating will lead to lots and lots of allocations. The libGDX collections are designed to avoid these allocations when iterating.

Separation of concerns

Currently your render method does two main things. It determines whether an island is in view, and then it renders it. However, it does both of those things for each island at the same time. I think that it would be better to separate the sorting from the rendering. First you would call a sortIslands() method that would put all the islands that need to be drawn into an array. Then the render method would just iterate over the array and draw the necessary islands. Later if you decide to change the way the islands are sorted, it will be much easier. It will also be more clear and more self documenting to do the sorting outside of the render method.

Is it worth it?

Sorting through the tiles to decide what needs to be rendered and what doesn't will (in my experience) end up using more resources than it is worth. I recommend profiling with and without culling in order to see if it provides any performance gains for your game.