for the first layer of blocks you need to check the border of the screen:

1. if (blockY+blockHeight>=height-4) {
2.    // stop it
3.    blockY_Speed=0;
4.    // set position right
5.    blockY=height-blockHeight;
6. }

for the next layer of blocks:
you need to check if there's a block under your falling block.

This can be done with analyzing the color under your block (0 being your background color):

1. if (get (blockX, blockY+blockHeight+10) != 0) {
2.    // stop it
3.    blockY_Speed=0;
4. }

Greetings, Chrisir  

The first thing to do is to align all of the blocks into a grid... I think you want this... and it takes two steps:

Make all of the blocks land at the same level... replace your fall() function with the following:

1. void fall()
2.   {
3.     //Increment the y position by ySpeed unless this will put it past the height... in this case, increment it by the height minus the current y position
4.   y += min(height - y - 15 / 2, ySpeed);
5.  
6.   if (stop==false)
7.   {
8.     ybawah-=9;
9.     stop=true;
10.   }
11. }

You should have shown the code from the start...
You already have block objects, good.
Unlike calsign, I wouldn't necessarily align the blocks, it can be fun. But the collision can be a bit harder...

So, now, you can check the collision of the moving block against all the other blocks.
I would do a loop on the content of the array list.

Note: if you write ArrayList<blockdrop> allDrops = new ArrayList<blockdrop>(); you can do blockdrop drop = allDrops.get(j); without cast.
Side note: by tradition / convention, class names start with an uppercase letter. Not mandatory, but helps distinguishing these names from simple variables.

So, there are some funny things in your code.
You add a drop block on each frame, ie. some 60 blocks per second! You probably want to add one only when the currently moving block stops.
You don't loop over all the blocks: for (int j=0; j<allDrops.size()/space;j++)  Why the /space?
You don't need to update the blocks that no longer move. You should have a variable pointing to the currently moving block (not yet in the array list, that would list only the stationary blocks), and only update it. Then, you loop over the existing blocks: if it is in the same column that the moving block, test it. Check the bottom of the moving block against the top of the tested block. If they are at the same level, stop the block, add it to the list of stationary blocks and create a new block.
You can have a list of only the top blocks, but that's an unnecessary optimization, actually...

thank you very much guys for your responds,..I'm really appreciate that and that's really help me,..well,now still working on how to make those blocks sticks upon the other.,it's still not working properly actually.

Since calsign already made two (or 3) corrections (not to mention PhiLho) you should post the whole code again (as far as it is now), when you want the forum to take a look

Well,..this is the code 

As PhiLho mentioned earlier, in fall(), you need to loop over all of the other blocks. If a block has already touched the ground, then check it's y position relative to the y position of the current block... and factor that into calculating whether or not to stop falling.

by the way,..if I delete this part the blocks still can stop

ahhh,.yes,i just realized that part..

here...

this can be simplified a lot....

1. ArrayList <blockdrop> allDrops;
2. final color bg=color(102, 204, 3);
3. final int size=16;
4. final int speedNewBlock = 8; // millis (1 fast, 20 slow)
5. //
6. void setup()
7. {
8.   size(592, 600);
9.   smooth();
10.   rectMode(CENTER); 
11.   //frameRate(20);
12.   allDrops = new ArrayList();
13. }
14. //
15. void draw()
16. {
17.   background(bg);
18.   // at the beginning just drop every time,
19.   // then only every speedNewBlock millisecond
20.   if (millis()<90)
21.     addDrop();
22.   else if (millis() % speedNewBlock == 0)
23.     addDrop();
24.   // double for-loop - don't join them! 
25.   for (int j=0; j<allDrops.size(); j++)
26.   {
27.     blockdrop drop = allDrops.get(j);
28.     drop.display();
29.   }
30.   for (int j=0; j<allDrops.size(); j++)
31.   {
32.     blockdrop drop = allDrops.get(j);
33.     drop.fall();
34.   }
35. }
36. void addDrop()
37. {
38.   //make sure that the x location is a multiple of 16
39.   int dropX = size/2+int(random(0, width/size))*size;
40.   int dropY = int(random(-50, 0));
41.   blockdrop drop = new blockdrop(dropX, dropY);
42.   allDrops.add(drop);
43. }
44. // ==========================================================
45. class blockdrop
46. {
47.   int x, y;
48.   float ySpeed = 6;
49.   boolean stop = false;
50.   color col;
51.   // constr
52.   blockdrop(int x_, int y_)
53.   {
54.     x=x_;
55.     y=y_;
56.     // get color
57.     col=color(random(255), random(255), random(255));
58.     while (col==bg)
59.       col=color(random(255), random(255), random(255));
60.   }
61.   void display()
62.   {
63.     noStroke();
64.     fill(col);
65.     rect(x, y, size, size);
66.   }
67.   void fall()
68.   {
69.     //increment the y position by ySpeed unless this will put it past height..
70.     //in this case,increment it by the height minus the current y position
71.     if (!stop) {
72.       if ((height-y-(size/2)) < ySpeed)
73.       {
74.         // stop at lower screen border
75.         y+=height-y-(size/2);
76.         stop = true;
77.       }
78.       else
79.       {
80.         if (y>-40) {
81.           color a1=get(x, y+size/2+int(5));
82.           if (a1==bg)
83.           {
84.             // normal falling
85.             y+=ySpeed;
86.           }
87.           else
88.           {
89.             // stopping at other brick
90.             // go to right position
91.             while (y % size > 0)
92.               y++;
93.             stop=true;
94.           }
95.         }
96.         else
97.         {
98.           // normal falling
99.           y+=ySpeed;
100.         } // else
101.       } // if else
102.     } // if
103.   } // method
104.   //
105. } // class

woww,..cool code Chrisir,.my friend also help me and this is also a simple one

Do you guys know ballistic deposition??...The blocks sticks to the first contact,.

any idea for ballistic deposition code??

It is still matter of checking the existing, standing blocks. You don't only check the y position against the blocks in the same column, but also those in the surrounding columns. It doesn't change much the algorithm.

well,.since i'm a new user, so it is a lil bit confusing for me,.hehehe