I wouldn't worry about it. I can paint 160k transparent sprites from the same sprite sheet in less than 5ms. There was a thread about a year ago where people were trying to see how many bouncy balls they could paint in a frame and it was some kind of ridiculous number (much higher than my 160k).
Ultimately those numbers depend on the hardware and driver quality.
Depends on the pixel area they cover. For pixel sized stuff you can do at least 1 million, but on high-end hardware almost 10 million.
When using the GPU, it works in parallel with the CPU. Your CPU feeds the raw vertex data to the GPU, and the GPU then processes the vertices, constructs triangles out of them and colors the covered pixels. CPU-wise you need to feed the GPU data fast enough to keep it from stalling. If you don't, you get a CPU bottleneck where the GPU has to wait for more instructions. It's even easier to get a GPU bottleneck, since with just a single quad you can cover the whole screen, for example:
CPU generates 4 vertices and sends them to the GPU.
---> GPU processes 4 vertices ---> GPU creates a quad (= 2 triangles) ---> GPU processes 1920x1080 = around 2 million pixels
OpenGL is just as potent as DirectX, so you have the exact same GPU capabilities as any other game out there, including commercial ones. For 2D the real problem is CPU performance. OpenGL commands are actually pretty expensive though (Java ---> native call ---> driver ---> GPU), so it's important to as CPU efficiently as possible draw as much as possible.
Some tips:
- Instead of using glBegin()-glEnd(), batch the sprite vertices together into a VBO and draw it with glDrawArrays().
- Texture binds make batching impossible since you need to do OpenGL calls in between to switch textures. Consider creating texture atlases (for example a tile set texture instead of individual tile textures) and picking out parts of it with texture coordinates.
Some GPU numbers to give you a general idea:
Pixels:
A low-end GPU can easily draw 5+ million pixels per frame (not including clearing the screen. glClear() is ridiculously fast). A high-end GPU can do over 40 million pixels per frame at 60 FPS. It does however depend on what operations you perform per pixel. Texturing and blending both have a small but noticeable cost.
Vertices:
At least 1+ million for 2D. In other words don't worry about vertices.
TL;DR: frameTime = max(cpuTime, gpuTime), and in the case of 2D CPU time is almost always higher. Focus on optimizing it.