Dunno any serious way on how to do it.
Nevertheless, here's my less than competent attempt:

final byte numSample = 100;
int sumLessThan5 = 0;

for (int i=0; i!=numSample; ++i) {
  int x = (int) random(10);
  if (x>4 && random(2)>1.5)    x = (int) random(5);
  if (x<5)    ++sumLessThan5;
  print(x+"\t");
}

println( "\n\n" + (float) sumLessThan5/numSample );

exit();

P.S.: Just found out now that Java seems to accept bitwise operators for comparing boolean values! 
That is, I can also use & instead of && and | instead of ||.
Even the ultra rarely used ^, which has no corresponding relational one. ( ^^ exists in C though)
I've always thought it would be wrong to do it!

One way to do that is to expand the scope of the generated numbers, then to map to the range you want, with different map rules depending on the area.
For example, 0-4 becomes 0-8 and 5-10 becomes 9-14. So you draw numbers between 0 and 14. If between 0 and 8, map to 0-4, otherwise, map to 9-14.
I hope it is clear.

Side note on GoToLoop finding: this is indeed legal... and rarely used. It has a quite different behavior from the logical operators. See:

1. // Not initialized
2. String s = null;
3. // Check if we have something: classical test. Works.
4. boolean b = s != null && s.length() > 1;
5. // A typo, and you get a NPE!
6. boolean b = s != null & s.length() > 1;

Why?
The && version is lazy, if one condition is false, it is sure the whole expression is false, so it takes the shortcut to tell the whole expression is false.
The & version is eager: it first evaluates each term of the expression, then it evaluates the logical operators. So you will get the NullPointerException because s.length() will be evaluated despite the fact that s == null.
That's why these binary operators are rarely used with booleans, in practice.
Except the XOR, for which a logical counterpart isn't useful. I rarely use it too, but occasionally: sometime, I prefer to write:
if (a ^ b)
rather than
if (a && !b || !a && b)

Thx for the info, PhiLho. I've already knew about much of that.
What I didn't have any idea is that Java would accept boolean values as operands for bitwise operators.

My conclusion is that Java overloads its operators &, |, ^ to accept true and false booleans.
In the same vein as the operator + accepts both numbers & strings!

However, I can't use whole number operands mixed w/ boolean operands like:
println( true & 1 );

And I can't use any whole numbers at all w/ relational operators.
They are boolean exclusive:
println( 4 || -2 );

I've read about that bitwise operators are somewhat faster than their relational counterparts.
Since they are direct calc w/o heavy parsing.

Even w/ short-circuiting (laziness), which I abuse as much as I can;
for simple comparisons which don't involve calling functions and too big calc,
bitwise (eagerness) can surprisingly surpass relational ones!

That's what I wanted to explain myself.  ^_^