how is sizeof each arraylist object determined

Programming Questions

jane38

how is sizeof each arraylist object determined

in Programming Questions • 7 months ago

for some time now I have been using arraylist as a means to store data

but there is always some worry about getting the the size of the list too big,

so how is the size of each object determined especially when you are using your own custom class

is the class wrapped for each object or are the parameters passed to the constructor alone are saved when the new objects are created and when manipulating that object are the parameters again passed to the same class

the main reason I'm asking this is because after I got into processing I have started looking into java 2d Garphics

I made the class below to draw shapes I realize that I could just use the shape method already provided but I did not want to simply save the x,y,width,height alone but the fill and stroke color as well

you can actually see that the contains method is actually from the button example from processing

NOTE: I have not actually used string switch case before but that actually works

class drawShape {
private float x, y, width, height;
Color fillcolor, strokecolor;
String shapetype;
Shape shape;
public drawShape(String shapetype, float x, float y, float width, float height, Color fillcolor,Color strokecolor)
{
this.x =x;
this.y = y;
this.width=width;
this.height=height;
this.fillcolor= fillcolor;
this.strokecolor= strokecolor;
this.shapetype= shapetype;
}
public void draw(Graphics g) {
Graphics2D g2 = (Graphics2D)g;
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
shapetype.toLowerCase();
float x1 = Math.min(x, width);
float y1 = Math.min(y, height);
float width1 = Math.abs(x-width);
float height1 = Math.abs(y- height);
switch(shapetype)
{
case "rect":
shape = new Rectangle2D.Float(x1,y1,width1,height1);
break;
case "ellipse":
shape = new Ellipse2D.Float(x1,y1,width1,height1);
break;
case "line":
shape = new Line2D.Float(x, y, width, height);
break;
default:
System.out.println("No Shape Selected");
break;
}
g2.setStroke(new BasicStroke(4));
g2.setPaint(strokecolor);
g2.draw(shape);
g2.setPaint(fillcolor);
g2.fill(shape);
}
boolean contains(float posx, float posy) {
float diameter= (float) Math.PI*((width/2)*(height/2));
float disX = x - posx;
float disY = y - posy;
if (Math.sqrt((disX*disX) + (disY*disY)) < diameter/2 ) {
return true;
} else {
return false;
}
}
}

EDIT: since I'm asking anyways let me ask on more thing

I have seen

public void draw(Graphics g) {
Graphics2D g2 = (Graphics2D)g;

sometimes it is cast to graphics2d object

I have also seen this

what exactly is the difference

public void draw(Graphics2D g2) {

Replies(9)

GoToLoop

Re: how is sizeof each arraylist object determined

7 months ago

The ArrayList and other Collections when used for objects,
only stores the memory address of each instance of them.
So, the List itself only uses up enough RAM to store a pointer reference to them. It's very little!

Now, each object instance itself needs enough RAM to store a whole copy of all of its non- static fields.
And I dunno about how methods can influence how much RAM is spent for each instance creation.

In short, every time a new statement is issued, lotsa RAM are allocated, over and over!

quarks

Re: how is sizeof each arraylist object determined

7 months ago

By convention all class names (in Java) start with an uppercase letter and I strongly recommend that you do that, so in your program I would rename your class to DrawShape.

so how is the size of each object determined especially when you are using your own custom class

This is not very easy in Java because there is no built in mechanism / method to do it, but it is the sum of the memory used by it's attributes. So in your class you have

private float x, y, width, height;
Color fillcolor, strokecolor;
String shapetype;
Shape shape;

The floats being primitives are easy since each float requires 4 bytes so that is 16 bytes.
The others are more difficult because they are 'object references'. As the name suggests each identifier is a reference to an object NOT an object itself. The object reference is used internally to locate the actual object in memory. All object references require the same amount of memory (not sure how much but I suspect its 8 bytes). Just as integers are initialised to zero, object references are initialised to null which means that there is no matching object - yet. The new keyword is used to create an object.

Now in your constructor you have

this.x =x;
this.y = y;
this.width=width;
this.height=height;
this.fillcolor= fillcolor;
this.strokecolor= strokecolor;
this.shapetype= shapetype;

The first 4 copy the contents of one float into another, each of the last three copies the object reference (not the actual object if any) from the parameter to the attribute (field variable). No new objects are being created.

If you have declare and create an arraylist for your class

// declares the array list myshapes will be set to null
ArrayList<DrawShape> myshapes;
// Create the actual object and myshapes will no longer be equal to null
myshapes = new ArrayList<DrawShape();

First thing is that the arraylist holds references to DrawShape objects and will grow and shrink as you add / remove DrawShape objects.

With regard to the last part about Graphics and Graphics2D. Graphics2D extends (inherits from) the Graphics class which means that it can do everything the Graphics class can do and more besides. For instance Graphics2D provides functions for clipping images, gradient fills which are not possible with the Graphics class.

Since Graphics2D inherits from Graphics then a Graphics object reference can be used with both Graphic and Graphics2D objects. In the first example a Graphics2D object is being passed to the draw method and is accepted because the parameter type is a Graphic reference. Although g is actual referencing a Graphics2D object the computer thinks it is a Graphics object because the parameter says so. It means that all the extra functionality of Graphics2D is unavailable, so we create a new Graphics2D reference (g2) and cast the Graphics object to a Graphics2D object.

There is no real difference between the two formats and if g is in reality a Graphics object (rather than Graphics2D) both will fail anyway, but for different reasons.

HTH

GoToLoop

Re: how is sizeof each arraylist object determined

7 months ago

About the PGraphics g variable, which is a field of class PApplet. It is the canvas itself!

But the way I see it, the difference between:

public void draw(Graphics g) {
Graphics2D g2 = (Graphics2D) g;

and:

public void draw(Graphics2D g2) {

I guess the former does not make sense, since g2 has the same memory address of g.
Accessing the contents of 1, is the same as using the other!
And worse, it's overshadowing the very own Processing's g!

NOTE: I have not actually used string switch case before but that actually works.

I guess it's a Java 7 feature thingy?

jane38

Re: how is sizeof each arraylist object determined

7 months ago

GoToLoop sorry
but I should have been more clearer my code is all Java so the g variable is actually part of Java Grpahics2D
the only reason I asked on here is because this forum is good and general array-lists questions can be asked

GoToLoop

Re: how is sizeof each arraylist object determined

7 months ago

... so the g variable is actually part of Java Graphics2D...

I guess the same applies! public void draw(Graphics2D g2) {...} makes more sense!

No need to have 2 variables pointing to the same memory address,
as you did there -> Graphics2D g2 = (Graphics2D) g;!

And as quarks already explained, if you don't need the extras from Graphics2D,
you can opt to just use vanilla Graphics!

quarks

Re: how is sizeof each arraylist object determined

7 months ago

@GoToLoop
As you say there is little difference between the 2 draw methods, but these examples come from the world of Java not the world of Processing. The Graphics and Graphics2D classes are very different from the PGraphics class which is the base class for the different renderers used in Processing i.e. JAVA2D (default) , P2D, P3D and OPENGL.

So the PApplet g attribute can be an object of type
PGraphicsJava2D (JAVA2D)
PGraphicsOpenGL (OPENGL)
PGraphics2D (P2D)
PGraphics3D (P3D)

Note that in Processing 2.0, PGraphics2D and PGraphics3D are subclasses of PGraphicsOpenGL.

The PGraphicsJava2D class has a field called g2 which is of type Graphics2D and you can use this to access the full Java2D API bypassing the Processing methods. The following code shows how to get a reference to the Graphics2D reference so it can be used in the sketch.

import java.awt.*;
Graphics2D g2d;
void setup(){
size(200,200);
g2d = ((PGraphicsJava2D)g).g2;
}

NOTE: I have not actually used string switch case before but that actually works.

I guess it's a Java 7 feature thingy?

You are correct it is a Java 7 thing, but my research would suggest that it is probably more efficient to use an int to represent the shape type and there is less chance of typo errors.

quarks

Re: how is sizeof each arraylist object determined

7 months ago

I have seen

public void draw(Graphics g) {

Graphics2D g2 = (Graphics2D)g;

sometimes it is cast to graphics2d object

I have also seen this

what exactly is the difference

public void draw(Graphics2D g2) {

In pure Java the draw method is used to display the 'face' of a control. That control might be a button, scrollbar or a panel used for pixel level drawing.

The draw method is NEVER called directly rather you call the repaint() method which generates an event that requests the component be redrawn. When the event is picked up by the program it will execute the draw method automatically for you.

Again in pure Java GUIs can be created using Java AWT (Abstract Windowing Toolkit) or JavaSwing. The draw method is appropriate for the AWT, Swing has different syntax.

SInce AWT existed before Java2D then I suggest that you use the former syntax i.e.

public void draw(Graphics g) {
Graphics2D g2 = (Graphics2D)g;

The reasons are complicated to explain but the syntax is more appropriate when using AWT components.

jane38

Re: how is sizeof each arraylist object determined

7 months ago

the one reason I like the java graphics from what I have seen so far at least is that you only need to call the repaint when you need to, while in processing the draw method is a loop controlled by frame-rate,

though it is possible to do the same thing in java by calling repaint in the paint method and controlling it with

Thread.sleep(ms) setting the ms to how ever many second you want

GoToLoop

Re: how is sizeof each arraylist object determined

7 months ago

You can turn off the callback function draw() by issuing a noLoop().
Then, you can either make draw() go once w/ redraw(),
or turn it on all over again w/ loop().

And do not forget you can control its FPS w/ frameRate().
And there's also a frameCount variable to check out how many times draw() has been called!

Top Reply