Generating random numbers between 2 ranges for Linked List insertion

Hi i am trying to generate a random number between 2 sets of range (-30,-10) and (10,30) to store in a LinkedList Node . If the number generated is negative, we insert this element and the next (regardless of its value) at the "head" of the list. If the number generated is positive then this element and the next will be stored at the 'tail'. This is what i have so far.

public class CAO_QUANG_JUIN_P4 {

public static void main(String[] args) {
	// TODO Auto-generated method stub
	//////////////////////////bloc1:Decleration des variables//////////////////////////

	//Create a EVEN N variable between 10 and 30
	
	int N = (int)(Math.random()*20)+10;
	N = (N*2)%30;
	//Create a simple linkedlist with N nodes
	LC e1 = new LC();
	LC tete = null;
	while(N!=0) {
		if(e1==null) {
			e1 = new LC();
			tete = e1;
			e1.data = N;
			
		}
		else {
			e1.suiv = new LC();
			e1.suiv.data = N;
			e1 = e1.suiv;
		}
		N = (int)(Math.random()*20)+10;
		int M = (int)(Math.random()*-20)-10;
	}

You have two options:

1. First 'flip a coin' to decide whether positive or negative, then, either generate -10/-30 or 10/30 depending on the coin flip.
2. Generate a random number in the range [0,40] and map these onto your actual desired range.

Note that #1 is problematic if the 2 ranges aren't equally sized, if you want uniform random distribution.

As a separate note, Math.random() * 20 is wrong.

Fundamentally, by way of math proof:

1. a double in java has 64 bits. That means it can represent at most 2^64 numbers. That's a LOT of numbers, but not an infinite amount of them.
2. ... and only some of those numbers are between 0 (inclusive) and 1 (exclusive). Let's say it's 1000005 of them.
3. Given that it's exactly 10000005 of them, and every single last one of those 10000005 numbers will 'map' to one of your numbers, which have a total 'range' of 20 (or 40, doesn't matter), well, 40 doesn't fit perfectly into 10000005.
4. Therefore, I have proven that some numbers will occur more often than others, and your result is not truly random. QED.

The solution is to make an instance of Random and use its .nextInt(20) method which IS truly uniformly distributed.

Coin flip method

Random r = new Random(); // make one instance, once, in your app.
boolean goNegative = r.nextBoolean();
int nr = (goNegative ? -1 : +1) * (10 + r.nextInt(20));
// note, like in your example, 10 is possible,
//but 30 cannot be hit. Make it r.nextInt(21)
//instead if it needs to be.

Mapper method

Random r = new Random(); // make one instance, once, in your app.
int nr = r.nextInt(40);
if (nr < 20) nr -= 29; // all numbers from -29 to -10, inclusive, covered.
else nr -= 10; // covers 10-29 inclusive.

Try the following:

Random r = new Random();
// the following generates a number between 0 and 20 inclusive and adds 10 to it
int a = r.nextInt(21)+10; // between 10 and 30 inclusive

// the following does the same but changes the sign.
int b = -(r.nextInt(21)+10); // between -10 and -30 inclusive

For the negative one you could also do this.
b = -30+r.nextInt(21);

So if you want to randomly chose one from both sets you can do the following:

int n = nextInt(2) == 0 ? -30+r.nextInt(21) : r.nextInt(21)+10;

</details>