Add nRF24L01 to a project
radio.write(&amp;Show_value, sizeof(Show_value));


I believe &quot;radio.write&quot; is used kinda like Serial.print, or
oled.print, But I don't really understand the &quot;sizeof&quot; part, maybe
that is the problem?

Sort of.  There's kind of two interrelated problems.  The major one is that the actual data of a String is not contained with the actual String type itself.  It's allocated on the heap.  What the String class contains is a pointer to it and some numbers for tracking the allocated size and amount used.
So the first problem is you're not reading the memory that actually contains the text inside the string.
sizeof(Show_value) evaluates to the size in bytes of the String class itself, which is the size of a pointer and a couple of integers, about 6 bytes, and not the size of the content of the string.
So you're sending a pointer (a memory address) that the receiver wouldn't know what to do with, and some information about how much was allocated and used and nothing of the String content.
Try:
radio.write(Show_value.c_str(), Show_value.length());

.c_str() gets a pointer to the actual string content itself.  And .length() is the actual size of the used part of the String's allocated area on the heap.
That said, it's better to avoid String where you reasonably can.

Regarding:

Does this also mean I need to replace radio.read(&amp;Show_value, sizeof(Show_value));

It would. Doing that is a bit more complicated since .c_str() yields const char *; String isn't designed to make write-access to its underlying data as easy.
Without hacking your way around String's expectations, that would require using a temporary buffer. Something like:
char buffer[33] = &quot;&quot;;  // Note: this will actually fill the entire buffer with '\0', which some find a surprise.
// The idea in the above is to accommodate the maximum RH24L01 packet size 32 bytes plus room for a null terminator.

radio.read(buffer, sizeof buffer - 1);  // We're only making the 32 byte chunk available to the .read() call, and leaving the last byte to it's '\0' value to force null termination in any case.

String s = buffer;

This assuming that you're either filling the packet with bytes, or including the null terminator in the packet, or both.  If you're using a dynamic payload size, rather than initializing the array with = &quot;&quot;;, it could be left uninitialized and the received packet size could be used to place the null terminator at the location needed.
You could wrap this in a function if you plan on doing it a lot.  But again, it's probably better if you can just use the array and not work with String.