Como obter resolução de tela em java?

136

Como obter a resolução da tela (largura x altura) em pixels?

Eu estou usando um JFrame e os métodos de swing de java.

AndreDurao
fonte
2
Você pode fornecer mais detalhes sobre o que questiona. Um liner pode levar a centenas de maneiras diferentes.
Anil Vishnoi 09/09/10
7
Eu acho que você não se importa com várias configurações de monitores. Parece que muitos desenvolvedores de aplicativos os ignoram. Todo mundo usa vários monitores onde eu trabalho, então sempre temos que pensar neles. Examinamos todos os monitores e os configuramos como objetos de tela para que possamos alvejá-los quando abrirmos novos quadros. Se você realmente não precisa dessa funcionalidade, acho que está tudo bem que você tenha feito uma pergunta aberta e aceitado uma resposta tão rapidamente.
Erick Robertson

Respostas:

267

Você pode obter o tamanho da tela com o Toolkit.getScreenSize()método

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

Em uma configuração de vários monitores, você deve usar este:

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

Se você deseja obter a resolução da tela em DPI, precisará usar o getScreenResolution()método Toolkit.


Recursos :

Colin Hebert
fonte
4
Isso não funciona para mim. Eu tenho um monitor 3840x2160, mas getScreenSizeretorna 1920x1080.
ZhekaKozlov
15

Esse código enumera os dispositivos gráficos no sistema (se vários monitores estiverem instalados) e você pode usar essas informações para determinar a afinidade do monitor ou o posicionamento automático (alguns sistemas usam um pequeno monitor lateral para exibições em tempo real enquanto um aplicativo está sendo executado em o plano de fundo e esse monitor pode ser identificado por tamanho, cores da tela 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
fonte
11

Esta chamada fornecerá as informações que você deseja.

Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
Starkey
fonte
Isso fornecerá apenas as dimensões da tela principal em um sistema com vários monitores. Veja docs.oracle.com/javase/8/docs/api/java/awt/…
Nathan
3

Essa é a resolução da tela que o componente fornecido está atualmente atribuído (algo como a maior parte da janela raiz está visível nessa tela).

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

Se você quiser respeitar as barras de ferramentas etc., também precisará calcular com isso:

GraphicsConfiguration gc = component.getGraphicsConfiguration();
Insets screenInsets = Toolkit.getDefaultToolkit().getScreenInsets(gc);
jan
fonte
3

Aqui está um código funcional (Java 8) que retorna a posição x da extremidade direita da tela mais à direita. Se nenhuma tela for encontrada, ele retornará 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);

Aqui estão os links para o JavaDoc.

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

Nathan
fonte
2

Essas três funções retornam o tamanho da tela em Java. Esse código é responsável por configurações de vários monitores e barras de tarefas. As funções incluídas são: getScreenInsets () , getScreenWorkingArea () e 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
fonte
1
int resolution =Toolkit.getDefaultToolkit().getScreenResolution();

System.out.println(resolution);
Eric Warriner
fonte
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
fonte
1

Aqui está um trecho de código que costumo usar. Ele retorna a área de tela completa disponível (mesmo nas configurações de vários monitores), mantendo as posições nativas do monitor.

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);
}

Em um computador com dois monitores full-HD, em que o esquerdo é definido como monitor principal (nas configurações do Windows), a função retorna

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

Na mesma configuração, mas com o monitor correto definido como monitor principal, a função retorna

java.awt.Rectangle[x=-1920,y=0,width=3840,height=1080]
Myrka
fonte
0
int screenResolution = Toolkit.getDefaultToolkit().getScreenResolution();
System.out.println(""+screenResolution);
chamindu ilshan
fonte
Bem-vindo ao Stack Overflow! Embora esse trecho de código possa resolver a questão, incluir uma explicação realmente ajuda a melhorar a qualidade da sua postagem. Lembre-se de que você está respondendo à pergunta dos leitores no futuro e essas pessoas podem não saber os motivos da sua sugestão de código. Tente também não sobrecarregar seu código com comentários explicativos, pois isso reduz a legibilidade do código e das explicações!
Kayess