¿Cómo puedo obtener la resolución de pantalla en Java?

136

¿Cómo se puede obtener la resolución de la pantalla (ancho x alto) en píxeles?

Estoy usando un JFrame y los métodos de swing de Java.

AndreDurao
fuente
2
¿Puede proporcionar más detalles sobre lo que pregunta? Un revestimiento puede conducir a cientos de formas diferentes.
Anil Vishnoi
77
Supongo que no te importan las configuraciones de varios monitores. Parece que muchos desarrolladores de aplicaciones ignoran estos. Todo el mundo usa varios monitores donde yo trabajo, por lo que siempre tenemos que pensar en ellos. Sondeamos todos los monitores y los configuramos como objetos de pantalla para que podamos apuntarlos cuando abrimos nuevos marcos. Si realmente no necesita esta funcionalidad, entonces creo que está bien que haya hecho una pregunta abierta y haya aceptado una respuesta tan rápido.
Erick Robertson

Respuestas:

267

Puede obtener el tamaño de la pantalla con el Toolkit.getScreenSize()método.

Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
double width = screenSize.getWidth();
double height = screenSize.getHeight();

En una configuración de monitores múltiples, debe usar esto:

GraphicsDevice gd = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
int width = gd.getDisplayMode().getWidth();
int height = gd.getDisplayMode().getHeight();

Si desea obtener la resolución de pantalla en DPI, deberá utilizar el getScreenResolution()método Toolkit.


Recursos:

Colin Hebert
fuente
44
Esto no funciona para mi. Tengo un monitor de 3840x2160, pero getScreenSizedevuelve 1920x1080.
ZhekaKozlov
15

Este código enumerará los dispositivos gráficos en el sistema (si hay varios monitores instalados), y puede usar esa información para determinar la afinidad del monitor o la ubicación automática (algunos sistemas usan un pequeño monitor lateral para pantallas en tiempo real mientras se ejecuta una aplicación en el fondo y dicho monitor se puede identificar por tamaño, colores de pantalla, etc.):

// Test if each monitor will support my app's window
// Iterate through each monitor and see what size each is
GraphicsEnvironment ge      = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice[]    gs      = ge.getScreenDevices();
Dimension           mySize  = new Dimension(myWidth, myHeight);
Dimension           maxSize = new Dimension(minRequiredWidth, minRequiredHeight);
for (int i = 0; i < gs.length; i++)
{
    DisplayMode dm = gs[i].getDisplayMode();
    if (dm.getWidth() > maxSize.getWidth() && dm.getHeight() > maxSize.getHeight())
    {   // Update the max size found on this monitor
        maxSize.setSize(dm.getWidth(), dm.getHeight());
    }

    // Do test if it will work here
}
Rick Hodgin
fuente
11

Esta llamada le dará la información que desea.

Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
Starkey
fuente
Esto solo dará las dimensiones de la pantalla principal en un sistema de monitores múltiples. Ver docs.oracle.com/javase/8/docs/api/java/awt/…
Nathan
3

Esta es la resolución de la pantalla que el componente dado está asignado actualmente (algo así como la mayor parte de la ventana raíz es visible en esa pantalla).

public Rectangle getCurrentScreenBounds(Component component) {
    return component.getGraphicsConfiguration().getBounds();
}

Uso:

Rectangle currentScreen = getCurrentScreenBounds(frameOrWhateverComponent);
int currentScreenWidth = currentScreen.width // current screen width
int currentScreenHeight = currentScreen.height // current screen height
// absolute coordinate of current screen > 0 if left of this screen are further screens
int xOfCurrentScreen = currentScreen.x

Si desea respetar las barras de herramientas, etc., también deberá calcular con esto:

GraphicsConfiguration gc = component.getGraphicsConfiguration();
Insets screenInsets = Toolkit.getDefaultToolkit().getScreenInsets(gc);
ene
fuente
3

Aquí hay un código funcional (Java 8) que devuelve la posición x del borde más a la derecha de la pantalla más a la derecha. Si no se encuentran pantallas, entonces devuelve 0.

  GraphicsDevice devices[];

  devices = GraphicsEnvironment.
     getLocalGraphicsEnvironment().
     getScreenDevices();

  return Stream.
     of(devices).
     map(GraphicsDevice::getDefaultConfiguration).
     map(GraphicsConfiguration::getBounds).
     mapToInt(bounds -> bounds.x + bounds.width).
     max().
     orElse(0);

Aquí hay enlaces a JavaDoc.

GraphicsEnvironment.getLocalGraphicsEnvironment ()
GraphicsEnvironment.getScreenDevices ()
GraphicsDevice.getDefaultConfiguration ()
GraphicsConfiguration.getBounds ()

Nathan
fuente
2

Estas tres funciones devuelven el tamaño de la pantalla en Java. Este código tiene en cuenta las configuraciones de varios monitores y las barras de tareas. Las funciones incluidas son: getScreenInsets () , getScreenWorkingArea () y getScreenTotalArea () .

Código:

/**
 * getScreenInsets, This returns the insets of the screen, which are defined by any task bars
 * that have been set up by the user. This function accounts for multi-monitor setups. If a
 * window is supplied, then the the monitor that contains the window will be used. If a window
 * is not supplied, then the primary monitor will be used.
 */
static public Insets getScreenInsets(Window windowOrNull) {
    Insets insets;
    if (windowOrNull == null) {
        insets = Toolkit.getDefaultToolkit().getScreenInsets(GraphicsEnvironment
                .getLocalGraphicsEnvironment().getDefaultScreenDevice()
                .getDefaultConfiguration());
    } else {
        insets = windowOrNull.getToolkit().getScreenInsets(
                windowOrNull.getGraphicsConfiguration());
    }
    return insets;
}

/**
 * getScreenWorkingArea, This returns the working area of the screen. (The working area excludes
 * any task bars.) This function accounts for multi-monitor setups. If a window is supplied,
 * then the the monitor that contains the window will be used. If a window is not supplied, then
 * the primary monitor will be used.
 */
static public Rectangle getScreenWorkingArea(Window windowOrNull) {
    Insets insets;
    Rectangle bounds;
    if (windowOrNull == null) {
        GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
        insets = Toolkit.getDefaultToolkit().getScreenInsets(ge.getDefaultScreenDevice()
                .getDefaultConfiguration());
        bounds = ge.getDefaultScreenDevice().getDefaultConfiguration().getBounds();
    } else {
        GraphicsConfiguration gc = windowOrNull.getGraphicsConfiguration();
        insets = windowOrNull.getToolkit().getScreenInsets(gc);
        bounds = gc.getBounds();
    }
    bounds.x += insets.left;
    bounds.y += insets.top;
    bounds.width -= (insets.left + insets.right);
    bounds.height -= (insets.top + insets.bottom);
    return bounds;
}

/**
 * getScreenTotalArea, This returns the total area of the screen. (The total area includes any
 * task bars.) This function accounts for multi-monitor setups. If a window is supplied, then
 * the the monitor that contains the window will be used. If a window is not supplied, then the
 * primary monitor will be used.
 */
static public Rectangle getScreenTotalArea(Window windowOrNull) {
    Rectangle bounds;
    if (windowOrNull == null) {
        GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
        bounds = ge.getDefaultScreenDevice().getDefaultConfiguration().getBounds();
    } else {
        GraphicsConfiguration gc = windowOrNull.getGraphicsConfiguration();
        bounds = gc.getBounds();
    }
    return bounds;
}
BlakeTNC
fuente
1
int resolution =Toolkit.getDefaultToolkit().getScreenResolution();

System.out.println(resolution);
Eric Warriner
fuente
1
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
double width = screenSize.getWidth();
double height = screenSize.getHeight();
framemain.setSize((int)width,(int)height);
framemain.setResizable(true);
framemain.setExtendedState(JFrame.MAXIMIZED_BOTH);
Ajeeth Kumar
fuente
1

Aquí hay un fragmento de código que uso a menudo. Devuelve el área de pantalla disponible completa (incluso en configuraciones de monitores múltiples) mientras conserva las posiciones de los monitores nativos.

public static Rectangle getMaximumScreenBounds() {
    int minx=0, miny=0, maxx=0, maxy=0;
    GraphicsEnvironment environment = GraphicsEnvironment.getLocalGraphicsEnvironment();
    for(GraphicsDevice device : environment.getScreenDevices()){
        Rectangle bounds = device.getDefaultConfiguration().getBounds();
        minx = Math.min(minx, bounds.x);
        miny = Math.min(miny, bounds.y);
        maxx = Math.max(maxx,  bounds.x+bounds.width);
        maxy = Math.max(maxy, bounds.y+bounds.height);
    }
    return new Rectangle(minx, miny, maxx-minx, maxy-miny);
}

En una computadora con dos monitores full-HD, donde el izquierdo está configurado como monitor principal (en la configuración de Windows), la función regresa

java.awt.Rectangle[x=0,y=0,width=3840,height=1080]

En la misma configuración, pero con el monitor correcto configurado como monitor principal, la función regresa

java.awt.Rectangle[x=-1920,y=0,width=3840,height=1080]
Myrka
fuente
0
int screenResolution = Toolkit.getDefaultToolkit().getScreenResolution();
System.out.println(""+screenResolution);
chamindu ilshan
fuente
¡Bienvenido a Stack Overflow! Si bien este fragmento de código puede resolver la pregunta, incluir una explicación realmente ayuda a mejorar la calidad de su publicación. Recuerde que está respondiendo la pregunta para los lectores en el futuro, y que esas personas podrían no conocer los motivos de su sugerencia de código. Por favor, también trate de no saturar su código con comentarios explicativos, ¡esto reduce la legibilidad tanto del código como de las explicaciones!
kayess