RainArrayVer.java

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Random;

import javax.imageio.ImageIO;

public class Rain extends GameObjects {

	//private int yPos, xPos, width, height;  <- useless
	Random rnd = new Random();
	int count = 0;
	//ArrayList<Object> rain = new ArrayList<Object>(); // rain(y, x, color, y, x, color)
	Object[] arrain = new Object[60];

	@Override
	void draw(Graphics g) {

		g.clearRect(0, 0, 500, 500);
		
		
		if (count < arrain.length) {
			for (int i = 0; i < arrain.length; i+=3) {
				arrain[i] = i - i * 3;
				arrain[i+1] = rnd.nextInt(480);
				try {
					arrain[i+2] = ImageIO.read(new File("rock.png"));
				} catch (IOException e) {
					e.printStackTrace();
				}
				if (count < arrain.length) {
					count+=3;
				}
			}
		}
			for (int i = 0; i < arrain.length; i+=3) 
			{
				g.drawImage((Image)arrain[i+2], (int)arrain[i+1], (int)arrain[i], null);
				arrain[i] = (int)arrain[i]+1;
			}
			
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		/*if (rain.size() < 3) {
			try {
				rain.add(10);
				rain.add(rnd.nextInt(450));
				rain.add(ImageIO.read(new File("rock.png")));
			} catch (IOException e) {
				System.out.println("PROBLEM WITH ROCK.PNG");
			}			
		}
		for (int i = 0; i < rain.size(); i+=3) 
		{
			g.drawImage((Image)rain.get(i+2), (int)rain.get(i+1), (int)rain.get(i), null);
			rain.set(i, ((int)rain.get(i))+1);
		}
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}*/
	}
	

	@Override
	void update() {

	}

}

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Line2D;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Random;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class Main {

public static void main( String [] args ) {
JFrame frame = new JFrame();
frame.setSize(800, 300);
final RPanel rPanel=new RPanel();
frame.add(rPanel);
frame.setVisible( true );
frame.addWindowListener(new WindowAdapter() {
@OverRide
public void windowClosing(WindowEvent e) {
super.windowClosing(e);
rPanel.stop();
System.exit(0);
}
});
}
}

class RPanel extends JPanel {
//******_SETTINGS_*************************
private float mWind = 2.05f;
private float mGravity = 9.8f;
private double mRainChance = 0.99; // from 0 to 1

private int mRepaintTimeMS = 16;
private float mRainWidth=1;
private double mDdropInitialVelocity = 20;
private double mDropDiam = 2;
private Color mColor=new Color(0, 0, 255);
//*********************************************

private ArrayList rainV;
private ArrayList dropV;
private UpdateThread mUpdateThread;

public RPanel() {
rainV = new ArrayList<>();
dropV = new ArrayList<>();

mUpdateThread=new UpdateThread();
mUpdateThread.start();

}

public void stop() {
mUpdateThread.stopped=true;
}

public int getHeight() {
return this.getSize().height;
}

public int getWidth() {
return this.getSize().width;
}

private class UpdateThread extends Thread {
public volatile boolean stopped=false;
@OverRide
public void run() {
while (!stopped) {
RPanel.this.repaint();
try {
Thread.sleep(mRepaintTimeMS);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

@OverRide
public void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2 = (Graphics2D) g;
g2.setStroke(new BasicStroke(mRainWidth));
g2.setColor(mColor);

//DRAW DROPS
Iterator<Drop> iterator2 = dropV.iterator();
while (iterator2.hasNext()) {
    Drop drop = iterator2.next();
    drop.update();
    drop.draw(g2);

    if (drop.y >= getHeight()) {
        iterator2.remove();
    }
}

//DRAW RAIN
Iterator<Rain> iterator = rainV.iterator();
while (iterator.hasNext()) {
    Rain rain = iterator.next();
    rain.update();
    rain.draw(g2);

    if (rain.y >= getHeight()) {
        //create new drops (2-8)
        long dropCount = 1 + Math.round(Math.random() * 4);
        for (int i = 0; i < dropCount; i++) {
            dropV.add(new Drop(rain.x, getHeight()));
        }
        iterator.remove();

    }
}

//CREATE NEW RAIN
if (Math.random() < mRainChance) {
    rainV.add(new Rain());
} 

}

//*****************************************
class Rain {
float x;
float y;
float prevX;
float prevY;

public Rain() {
    Random r = new Random();
    x = r.nextInt(getWidth());
    y = 0;
}

public void update() {
    prevX = x;
    prevY = y;

    x += mWind;
    y += mGravity;
}

public void draw(Graphics2D g2) {
    Line2D line = new Line2D.Double(x, y, prevX, prevY);
    g2.draw(line);
}

}

//*****************************************
private class Drop {

double x0;  
double y0;  
double v0; //initial velocity
double t;  //time
double angle;
double x;
double y;

public Drop(double x0, double y0) {
    super();
    this.x0 = x0;
    this.y0 = y0;

    v0 = mDdropInitialVelocity;
    angle = Math.toRadians(Math.round(Math.random() * 180)); //from 0 - 180 degrees
}

private void update() {
    // double g=10;
    t += mRepaintTimeMS / 100f;
    x = x0 + v0 * t * Math.cos(angle);
    y = y0 - (v0 * t * Math.sin(angle) - mGravity * t * t / 2);
}

public void draw(Graphics2D g2) {
    Ellipse2D.Double circle = new Ellipse2D.Double(x, y, mDropDiam, mDropDiam);
    g2.fill(circle);
}

}
}