well it depends on the polygon. processing has some built in setups that you can use :

1. rect(); ellipse(); quad(); triangle();
   

if you need custom ones then you want to use the beginShape() and endShape() methods you just need to call vertices between them like so:

1. beginShape();
2. vertex(x, y);
3. vertex(x, y);
4. vertex(x, y);
5. vertex(x, y);
6. vertex(x, y);
7. vertex(x, y);
8. endShape();

there are some parameters to how the shape draws that you can call in the begin and endshape methods

To rotate each shape you want to use the translate() and rotate methods() within a push and pop matrix set up like so:

1. pushMatrix();
2.       rotate(45);
3.       beginShape();
4.             vertex(x, y);
5.             vertex(x, y);
6.             vertex(x, y);
7.             vertex(x, y);
8.             vertex(x, y);
9.             vertex(x, y);
10.       endShape();
11. popMatrix();

now collision detection will be complicated depending on your polygons. Rectangles and circles are easy but once you get into complicated shapes I would recommend finding the rectangular or area around the polygon(a circle or rectangle whose circumference or perimeter touches the farthest points of your shape) as a start. Check out this link for a solution for polygon collision detection http://www.openprocessing.org/visuals/?visualID=6786 its going to be a shit ton of math no matter what.

Hope this helps :)

So there isn't any pre-coded library with this kind of stuff? What about AWT's Polygon?

I didn't put it in the code above but if you are going to use the code I put you probably are going to want to set an array of points with the for loop instead. Then you can use that array to draw your shape as well as test line segment intersections.

" What about AWT's Polygon?"
Check by yourself: Polygon has hit detection, but that's against a point or a rectangle... Same for the mentioned OpenProcessing sketch.

Perhaps libraries like Geomerative or ToxicLib have more sophisticated methods.

Potentially, a way to do that is to decompose each polygon in a series of triangles, and test triangle-triangle collision. After checking the much faster bounding box collision first, of course.

I don't know if it's an overkill for your case.  But physics libraries often have polygon collision functionality.  And you can always turn off gravity, friction, damping, etc... to have the polygons act less "physical".

http://processing.org/learning/anatomy/