Java programa de Figuras geométricas en un plano (Circulo, Triangulo, Cuadrado)

[r2montero]

Buenas a tod@s!

Tengo que realizar un programa de figuras geométricas pero no sé ni por dónde empezar, se trata de realizar varios ejercicios con figuras geométricas en un vector (Circulo, Triangulo, Cuadrado, Polígono regular de N lados).

Hay que inscribirlas en un plano de 100x100 y poder calcular las áreas, apotemas, perímetros, coordenadas, áreas compartidas si las hay, figuras concéntricas si se da el caso, superposición, yuxtaposición.

Lo que más problemas me da es el bendito plano de 100x100, no se me ocurre como crearlo ni como referenciar las figuras en el, según mi profesor no tiene por que ser gráfico todo el asunto, aunque podría ser.

Para no hacer más enredo les dejo adjuntas las imágenes del enunciado  y espero con ansias sus sugerencias y consejos...

Saludos!

[Ogramar]

Hola r2montero no es fácil (tampoco excesivamente difícil), requiere que tengas ya cierta soltura con java además de aprender a trabajar todo el interfaz gráfico y bibliotecas swing y awt

Por suerte hay mucha información en internet por ejemplo dentro de los propios tutoriales java https://docs.oracle.com/javase/tutorial/2d/geometry/index.html

Este sería un ejemplo. Aquí el plano sería de 400x400 definido mediante setSize (el plano lo define aquí usando un JFrame) y dentro del plano dibuja diferentes figuras. Para referenciar las figuras dentro del plano métodos como

drawRect(int x, int y, int width, int height)
Draws the outline of the specified rectangle.

Ya te permiten establecer coordenadas (x, y)

Código de ejemplo:

Código: [Seleccionar]

import javax.swing.*;
import java.awt.*;

public class TestFiguras extends JFrame{
     public TestFiguras(){
          setSize(400,400);
          setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
          setLocationRelativeTo(null);
          setVisible(true);
     }

     public static void main(String a[]){
         new TestFiguras();
     }

     public void paint(Graphics g){
          g.drawOval(40, 40, 60, 60); //Dibuja un circulo
          g.drawRect(80, 30, 200, 200); // Dibuja un cuadrado
          g.drawRect(200, 100, 100, 200); // Dibuja un rectángulo
     }
}

Inténtalo y pega el código para tratar de ayudarte

Salu2

[r2montero]

Muchas gracias Ogramar!

El problema está en que aún no hemos visto nada sobre la GUI, eso está para más adelante, incluso el profesor nos dijo que no tenía que ser gráfico, de hacerlo sería un plus, por lo mismo de no manejarlo aún.

En caso de no hacerlo con los gráficos y las bibliotecas Swing como podría hacerse? De hecho yo al verlo pensé que solamente con gráficos puede hacerse, pero el profesor asegura que es "muy sencillo" hacerlo sin utilizar la GUI, pero no tengo idea de cómo crear el plano y referenciar en el las figuras.

Otra delimitación que nos ha dado el profe es que no se le pueden solicitar las medidas de los lados de las figuras al usuario, estas medidas deben obtenerse con cálculos mediante las coordenadas y el plano.

Saludos!

[Ogramar]

Hola de nuevo, si no quiere usarse una interfaz gráfica, puedes trabajarlo todo nada más que de forma abstracta y con base matemática. Digamos que todo será definido matemáticamente y no habrá nada visual. Esto es algo interesante de cara al aprendizaje, aunque puede resultar bastante tedioso sobre todo para quienes no tengan la base matemática suficiente.

Un planteamiento que se me ocurre es el siguiente: defines una clase Punto que conste de dos atributos enteros, coordenadaX y coordenadaY.

Los puntos te servirán para referenciar posiciones de cualquier elemento del sistema. Ahora tendrás que pensar que todo lo que trabajes estará sobre unos ejes de coordenadas donde tu punto de referencia será el (0,0)

Defines una clase denominada Plano (realmente preferiría llamarla AreaDeTrabajo, ya que no va a darse la definición matemática de un plano sino de un área).

En la clase AreaDeTrabajo tendríamos como atributos dos puntos: Punto coordenadasOrigen y Punto coordenadasFin

Para coordenadasOrigen defines como atributos coordenadaX = 0 y coordenadaY = 0

Para coordenadasFin defines como atributos coordenadaX = 100 y coordenadaY = 100

De este modo ya tienes definido el plano o área de trabajo.

Lo siguiente sería por ejemplo definir la clase Triangulo. Dentro de esta clase tendrías tres atributos Punto, uno para cada vértice del triángulo, por ejemplo Punto vertice1, Punto vertice2, Punto vertice3.

Definiendo coordenadas para los vértices ya tienes definido el triángulo. Un ejemplo sería:

Para vertice1: coordenadaX = 0 y coordenadaY = 0
Para vertice2: coordenadaX = 20 y coordenadaY = 0
Para vertice3: coordenadaX = 10 y coordenadaY = 10

Fíjate que con estos valores ya puedes determinar si el triángulo está dentro del plano o área de trabajo, por ejemplo un triángulo que tuviera estos datos

Para vertice1: coordenadaX = 0 y coordenadaY = 0
Para vertice2: coordenadaX = 200 y coordenadaY = 0
Para vertice3: coordenadaX = 10 y coordenadaY = 10

No sería válido, ya que ningún valor de coordenada puede situarse fuera del límite definido por el plano o área de trabajo.

Todo esto se podría dibujar, pero igualmente se puede trabajar sin dibujarlo simplemente usando clases y análisis matemático.

Ahora dentro de la clase triángulo necesitas añadir los métodos oportunos (además de los getters y setters), por ejemplo un método calcularArea.

Para calcular el área necesitas saber cuál es la base y cuál es la altura del triángulo. La base es el lado del triángulo de mayor longitud. Tendrías que calcular la distanciaVertice1_Vertice2, la distanciaVertice1_Vertice3 y la distanciaVertice2_Vertice3.

La distancia puede calcularse de varias maneras, una de ellas basándonos en vectores. Dado un vector definido por dos puntos A(x, y) y otro B(x', y') la distancia es el módulo del vector sqr ((x'-x)^2+ (y'-y)^2), esto es simplemente el teorema de pitágoras aplicado a un triángulo rectángulo definido por los puntos A y B.

Una vez calculadas las tres distancias, la mayor de ellas será la base del triángulo.

Ahora necesitas la altura. La altura puedes calcularla como la recta perpendicular a la base que pasa por el vértice que no está en la base del triángulo.

Con la base y la altura puedes calcular el área.

Esto seguramente se pueda hacer de otras maneras o plantearlo de forma más simple, yo he puesto lo que se me ha ocurrido pensándolo rápido. A lo mejor te puedes apoyar en clases del api de java que lo simplifiquen todo. A lo mejor puedes usar la clase Area del api java ¿?


Para el ejemplo anterior, tendríamos que area = base * altura / 2

Para vertice1: coordenadaX = 0 y coordenadaY = 0
Para vertice2: coordenadaX = 20 y coordenadaY = 0
Para vertice3: coordenadaX = 10 y coordenadaY = 10

Nuestra base es 20 y nuestra altura 10, nuestra área sería (20*10)/2 = 200/2 = 100

De este modo se iría resolviendo todo: matemáticamente.

Todo esto son ideas, lo que te recomiendo es que pienses primero cómo plantearlo y luego vayas paso por paso, crea una clase, sus métodos y pruébalo bien antes de pasar a crear otra clase.

Si vas pegando el código que vayas generando intentaremos echar una mano

Salu2

[r2montero]

Mil gracias Ogramar!

Me puse manos a la obra para ir avanzando, ya voy saliendo para clases  pero acá dejo el código para que se pueda ir revisando a ver si entendí bien... 

Me parece que la clase Point iría así:

Código: [Seleccionar]

/**
 * Clase Point para definir las Coordenadas X y Y
 * para referencia en el area de trabajo.
 * @author Jose Ricardo Rojas Montero. A24418
 */
public class Point {
    //coordenadas
    private int x = 0;
    private int y = 0;
   
    /**
     * Constructor de la clase
     * @param x Define las coordenadas horizontales del area de trabajo.
     * @param y Define las coordenadas verticales del area de trabajo.
     */
    public Point(int x, int y) {
    this.x = x;
    this.y = y;
    }//Fin del Constructor

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }
   
   
   
}//Fin de la clase Point
Esto es lo que tengo de la clase WorkArea  . Para ser sincero no entendí bien lo de los atributos de las coordenadas y los constructores (en caso de llevar, ya que es una medida fija)...

Código: [Seleccionar]

public class WorkArea {
    //Coordenadas x,y para cada punto
    private int xCoord = 0;
    private int yCoord = 0;
   
    //Limites del area de trabajo
    private final Point originCoords = new Point(0,0);
    private final Point endCoords = new Point(100,100);
   
    public WorkArea() {
    }
}
Esta es la interfaz Figure (ya que el ejercicio pide interfaces y clases abstractas):

Código: [Seleccionar]

public interface Figure {
   
    public double calcArea(); //Calculo del area.
    public int calcPerimeter(); //Calculo del perimetro.
    public double calcApothem(); //Calculo la apotema.
}
Y finalmente lo que llevo de la clase Triangle:

Código: [Seleccionar]

public class Triangle implements Figure {
    //vertices para el triangulo
    private Point vertex1;
    private Point vertex2;
    private Point vertex3;
   
    public Triangle(int vertex1X, int vertex1Y,
                    int vertex2X, int vertex2Y,
                    int vertex3X, int vertex3Y) {
       
        vertex1 = new Point(vertex1X, vertex1Y);
        vertex2 = new Point(vertex2X, vertex2Y);
        vertex1 = new Point(vertex3X, vertex3Y);
    } //Fin del Constructor
   
    public double calcArea() {
        double area = 0;
       
       
       
        return area;
    }
   
    public int calcPerimeter() {
        int perimeter = 0;
       
       
       
        return perimeter;
    }
   
    public double calcApothem() {
        double apothem = 0;
       
       
       
        return apothem;
    }

}//Fin de la clase Triangle

Apenas vuelva de clase continúo y posteo más avances...  Salu2!

[Ogramar]

Lo que has hecho lo veo perfecto como punto de partida. Lo único que no entiendo es para qué incluyes en la clase workarea

    private int xCoord = 0;
    private int yCoord = 0;

¿Para qué necesitas esto?

Salu2

[r2montero]

Hola!

Eso lo hice para la definir los atributos que me indicaste en la clase Plano o WorkArea en este caso, responde a esto:

En la clase AreaDeTrabajo tendríamos como atributos dos puntos: Punto coordenadasOrigen y Punto coordenadasFin

Para coordenadasOrigen defines como atributos coordenadaX = 0 y coordenadaY = 0

Para coordenadasFin defines como atributos coordenadaX = 100 y coordenadaY = 100

Serian las coordenadas coordenadaX y coordenadaY.

Respecto a la pregunta de las areas:

En la clase AreaDeTrabajo tendríamos como atributos dos puntos: Punto coordenadasOrigen y Punto coordenadasFin

Para coordenadasOrigen defines como atributos coordenadaX = 0 y coordenadaY = 0

Para coordenadasFin defines como atributos coordenadaX = 100 y coordenadaY = 100

Practicamente hay que crear todo "a pie" entonces no creo que me dejen apoyarme así...

Saludos y gracias por el tiempo! Perdón si estoy siendo más molesto de la cuenta.

[Ogramar]

No es molestia, intentamos ayudar en la medida de lo posible

Hay una cosa que no sé si has entendido bien respecto de lo que yo planteaba.

La clase Point representa un punto en el espacio de coordenadas. Pero no un punto del área de trabajo, ni un límite del área de trabajo. Es simplemente un punto, tu puedes usar los puntos para definir el centro de un círculo, o para definir los vértices de un triángulo, o para definir el extremo inferior izquierdo y superior derecho de un rectángulo y del área de trabajo, etc.

Por ello el comentario en la clase Point

Código: [Seleccionar]

/**
 * Clase Point para definir las Coordenadas X y Y
 * para referencia en el area de trabajo.
 * @author Jose Ricardo Rojas Montero. A24418
 */
no sería correcto

En realidad sería

Código: [Seleccionar]

/**
 * Clase Point para definir las Coordenadas X y Y
 * de un punto
 * @author Jose Ricardo Rojas Montero. A24418
 */
Con esa lógica tendríamos

Código: [Seleccionar]

  /**
     * Constructor de la clase
     * @param x Define las coordenadas horizontales de un punto
     * @param y Define las coordenadas verticales de un punto
     */
Y en la clase workarea sobraría lo indicado de modo que tendríamos

Código: [Seleccionar]

public class WorkArea {
 
    //Limites del area de trabajo
    private final Point originCoords = new Point(0,0);
    private final Point endCoords = new Point(100,100);
   
    public WorkArea() {
    }
}
Para definir el área de trabajo utilizas dos puntos (que definen un rectángulo), no te hace falta más

Si lo ves de otra manera coméntalo...

Salu2

[r2montero]

Muchas gracias por las aclaraciones!

Acá están la Clases Triangle, Square y Circle terminadas? , lo que no se es si esta bien la validación de las coordenadas en el constructor y la forma del mensaje en la apotema, además de si será necesario definir un toString()...

Clase Triangle:

Código: [Seleccionar]

public class Triangle implements Figure {
    //vertices para el triangulo
    private Point vertex1;
    private Point vertex2;
    private Point vertex3;
   
    //variables para los lados
    private double side1;
    private double side2;
    private double side3;
   
    //Constructor de la clase
    public Triangle(int vertex1X, int vertex1Y,
                    int vertex2X, int vertex2Y,
                    int vertex3X, int vertex3Y) {
       
        if(vertex1X >= 0 && vertex1X <=100 &&
           vertex1Y >= 0 && vertex1Y <=100 &&
           vertex2X >= 0 && vertex2X <=100 &&
           vertex2Y >= 0 && vertex2Y <=100 &&
           vertex3X >= 0 && vertex3X <=100 &&
           vertex3Y >= 0 && vertex3Y <=100) {
       
           vertex1 = new Point(vertex1X, vertex1Y);
           vertex2 = new Point(vertex2X, vertex2Y);
           vertex3 = new Point(vertex3X, vertex3Y);
           
           //calcula los valores los lados del triangulo con T. Pitagoras
           side1 = Math.sqrt((Math.pow((vertex2.getX() - vertex1.getX()), 2)) +
                             (Math.pow((vertex2.getY() - vertex1.getY()), 2)));
           side2 = Math.sqrt((Math.pow((vertex3.getX() - vertex2.getX()), 2)) +
                             (Math.pow((vertex3.getY() - vertex2.getY()), 2)));
           side3 = Math.sqrt((Math.pow((vertex1.getX() - vertex3.getX()), 2)) +
                             (Math.pow((vertex1.getY() - vertex3.getY()), 2)));
        }else {
            System.out.println("Las Coordenadas de los vertices estar entre 0 y 100");
           
        }
    } //Fin del Constructor
   
    /**
     * Calcula el area con la formula de Heron
     * @return Devuelve el area del triangulo.
     */       
    public double calcArea() {
        double area;
        double semiperimeter;
       
        semiperimeter = (side1 + side2 + side3)/2;
        area = Math.sqrt((semiperimeter * (semiperimeter - side1) *
                         (semiperimeter - side2) * (semiperimeter - side3)));
        return area;
    }
   
    /**
     * Suma los lados del Triangulo para calcular el perimetro.
     * @return Devuelve el perimetro del triangulo.
     */
    public double calcPerimeter() {
        double perimeter;
       
        perimeter = side1 + side2 + side3;
       
        return perimeter;
    }
   
    /**
     * Calcula la apotema del triangulo si este es equilatero.
     * @return Devuelve la apotema del triangulo.
     */
    public double calcApothem() {
        double apothem;
       
        if(side1 == side2 && side2 == side3) {
            apothem = ((Math.sqrt(side1/2) / side1) * side1);
            return apothem;
        }else {
            System.out.println("Para calcular la apotema el triangulo debe ser equilatero");
            apothem = 0;
        }
       
        return apothem;
     }

    public Point getVertex1() {
        return vertex1;
    }

    public void setVertex1(Point vertex1) {
        this.vertex1 = vertex1;
    }

    public Point getVertex2() {
        return vertex2;
    }

    public void setVertex2(Point vertex2) {
        this.vertex2 = vertex2;
    }

    public Point getVertex3() {
        return vertex3;
    }

    public void setVertex3(Point vertex3) {
        this.vertex3 = vertex3;
    }

    public double getSide1() {
        return side1;
    }

    public void setSide1(double side1) {
        this.side1 = side1;
    }

    public double getSide2() {
        return side2;
    }

    public void setSide2(double side2) {
        this.side2 = side2;
    }

    public double getSide3() {
        return side3;
    }

    public void setSide3(double side3) {
        this.side3 = side3;
    }

}//Fin de la clase Triangle

Clase Square:

Código: [Seleccionar]

public class Square implements Figure {
    //vertices para el cuadrado
    private Point vertex1;
    private Point vertex2;
    private Point vertex3;
    private Point vertex4;
   
    //variables para los lados
    private double side;
   
    public Square(int vertex1X, int vertex1Y,
                  int vertex2X, int vertex2Y,
                  int vertex3X, int vertex3Y,
                  int vertex4X, int vertex4Y) {
       
        if(vertex1X >= 0 && vertex1X <=100 &&
           vertex1Y >= 0 && vertex1Y <=100 &&
           vertex2X >= 0 && vertex2X <=100 &&
           vertex2Y >= 0 && vertex2Y <=100 &&
           vertex3X >= 0 && vertex3X <=100 &&
           vertex3Y >= 0 && vertex3Y <=100 &&
           vertex4X >= 0 && vertex4X <=100 &&
           vertex4Y >= 0 && vertex4Y <=100) {
       
           vertex1 = new Point(vertex1X, vertex1Y);
           vertex2 = new Point(vertex2X, vertex2Y);
           vertex3 = new Point(vertex3X, vertex3Y);
           vertex4 = new Point(vertex4X, vertex4Y);
           
           //calcula los valores los lados del cuadrado.
           side = vertex1.getX() - vertex2.getY();
                   
        }else {
            System.out.println("Las Coordenadas de los vertices estar entre 0 y 100");
        }
    }//Fin del constructor
   
    /**
     * Calcula el area del cuadrado
     * @return Devuelve el area del cuadrado
     */
    public double calcArea() {
        return side * side;
    }
   
    /**
     * Calcula el perimetro del cuadrado
     * @return Devuelve el perimetro del cuadrado
     */
    public double calcPerimeter() {
        return side * 4;
    }
   
    /**
     * Calcula la apotema del cuadrado
     * @return Devuelve la apotema del cuadrado
     */
    public double calcApothem() {
        return side / 2;
    }

    public Point getVertex1() {
        return vertex1;
    }

    public void setVertex1(Point vertex1) {
        this.vertex1 = vertex1;
    }

    public Point getVertex2() {
        return vertex2;
    }

    public void setVertex2(Point vertex2) {
        this.vertex2 = vertex2;
    }

    public Point getVertex3() {
        return vertex3;
    }

    public void setVertex3(Point vertex3) {
        this.vertex3 = vertex3;
    }

    public Point getVertex4() {
        return vertex4;
    }

    public void setVertex4(Point vertex4) {
        this.vertex4 = vertex4;
    }

    public double getSide() {
        return side;
    }

    public void setSide(double side) {
        this.side = side;
    }
   
}//Fin de la clase Square
Clase Circle:

Código: [Seleccionar]

public class Circle implements Figure {
    //variables para la coordenada central y el radio
    private Point centerCoord;
    private double radio;
   
    /**
     * Constructor de la clase Circle
     * @param x Coordenada del eje horizontal
     * @param y Coordenada del eje vertical
     * @param radio Valor del radio.
     */
    public Circle(int x, int y, double radio) {
        centerCoord = new Point(x, y);
        this.radio = radio;
    }// Fin del constructor
   
    /**
     * Calcula el area del circulo
     * @return Devuelve el valor del area del circulo
     */
    public double calcArea() {
        return Math.PI * Math.pow(radio, 2);
    }
   
    /**
     * Calcula el perimetro (Circunferencia) del circulo
     * @return Devuelve el valor del perimetro del circulo
     */
    public double calcPerimeter() {
        return 2 * Math.PI * radio;
    }
   
    /**
     * Calcula la apotema (radio) del circulo
     * @return Devuelve el valor de la apotema del circulo
     */
    public double calcApothem() {
        return radio;
    }

    public Point getCenterCoord() {
        return centerCoord;
    }

    public void setCenterCoord(Point centerCoord) {
        this.centerCoord = centerCoord;
    }

    public double getRadio() {
        return radio;
    }

    public void setRadio(double radio) {
        this.radio = radio;
    }
   
   
}// Fin de la clase Circle
Saludos!

[r2montero]

Hola! ahora me surgen un par de dudas más... para variar 

1. ¿Cómo se puede calcular el punto central de cada figura (triangulo, cuadrado, polígono regular de N lados)?

2. ¿Cómo crear el polígono regular de N lados y realizar los cálculos correspondientes al area, el perimetro la apotema y la coordenadas del punto central?

3. Se pide crear un arreglo parar contener un máximo de 10 figuras cualesquiera ¿Como creo el arreglo (vector) para figuras de diversos tipos?

[Ogramar]

Hola para calcular el punto central de cada figura tienes que aplicar matemáticas y analizar figura a figura. Por ejemplo si tomamos el cuadrado veo que para el cuadrado has tomado 4 vértices, pero realmente creo que sólo te hacen falta dos vértices. Dado un vértice (x,y) y otro vértice (x', y') los otros dos vértices del cuadrado se pueden obtener como (x', y) y el otro como (x, y'). Mantener información sobre los 4 vértices en principio no parece que sea necesario.

A partir de los dos vértices del cuadrado tendríamos que las coordenadas para el centro del cuadrado son = ((x+x')/2, (y+y')/2 )

En las otras figuras el cálculo puede ser más complicado, por ejemplo en un triángulo no existe un centro propiamente dicho sino que se definen varios centros,

El incentro es el punto de intersección de las bisectrices de cada uno de los ángulos del triángulo (siendo una bisectriz la recta que divide a un ángulo en dos ángulos iguales),

El baricentro (también llamado centroide) de un triángulo es el punto de intersección de las medianas de dicho triángulo (siendo una mediana el segmento que une un vértice con el punto medio del lado opuesto).

El circuncentro es el punto de intersección de las mediatrices del triángulo (siendo una mediatriz la recta perpendicular a un lado que pasa por el punto medio del mismo).

El ortocentro de un triángulo es el punto de intersección de las tres alturas del triángulo (siendo una altura el segmento que parte de un vértice y es perpendicular al lado opuesto a dicho vértice).

Lo primero que tendrías que decidir es qué centro del triángulo vas a calcular y después aplicar matemáticas para calcularlo

Salu2

[r2montero]

Hola, muchas gracias por la ayuda! Ya siento que estoy corriendo contra el tiempo, la entrega es el 11 de octubre 

Un par de dudas más:

Que me sugieres para crear el polígono de N lados? Estaba pensando tal vez en un vector que vaya pidiendo n pares de coordenadas de acuerdo a n cantidad de lados, pero no se me ocurre como validar que los lados sean iguales...

Por otro lado tengo un método de ordenamiento burbuja para ordenar las figuras por área, pero se supone que no debo repetir código, cómo hacer para que el mismo método me sirva también para ordenar las figuras por perímetro y apotema?

Este es el código:

Código: [Seleccionar]

public void bubbleSort() {
        Polygon tempVar;
       
       
        for(int counter = 0; counter < polygonVector.length; counter++) {
            for(int counter2 = 0; counter2 < polygonVector.length - counter; counter++) {
                if(polygonVector[counter2 - 1].calcArea() > polygonVector[counter2].calcArea()) {
                    tempVar = polygonVector[counter2 - 1];
                    polygonVector[counter2 - 1] = polygonVector[counter2];
                    polygonVector[counter2] = tempVar;
                }
            }
        }       
    }


Como hacer para que el método cambie el  .calcArea() por un .calcPerimeter() o un .calcApothem de acuerdo al caso, esto para hacer una llamada al método y no tener que escribirlo tres veces?

[Ogramar]

Hola el cálculo del área de un polígono no es trivial, no creo que te pidan que desarrolles el algoritmo, sino más bien que te bases en el api de java o en algún algoritmo ya desarrollado. Aquí tienes una referencia http://www.mathopenref.com/coordpolygonarea2.html

Para ordenar las figuras habría distintas maneras de plantearlo:

Puedes generar una lista de números (un array o arreglo) y ordenarlo, al mismo tiempo guardas los índices en otra lista. La lista de índices te dará el orden.

Ejemplo: tienes tres figuras con area 30, 22, 45 y perímetro 123, 843, 92

Para ordenar por areas llamarías a un método ordenar pasándole (30,22,45) y te devolvería un array con los índices: 3, 1, 2 Esto significaría que la figura con mayor área es la 3, después la 1 y después la 2

Para ordenar por perímetro llamarías al mismo método pasándole (123, 843, 92) y te devolvería un array con los índices 2, 1, 3 Esto significaría que la figura con mayor perímetro es la 2, luego la 1 y luego la 3.

Otra alternativa sería ordenar la colección de figuras usando Comparable y Comparator como se explica en http://aprenderaprogramar.com/index.php?option=com_content&view=category&id=58&Itemid=180 y usando una colección que se ordene autómaticamente como SortedSet

Salu2