javafx适配双屏幕
首先初始化 stage
Stage stage= new Stage();
有三种方式获取屏幕的信息
// 使用ScreenProperties.DEFAULT的话，是当前stage如果在第一块屏幕打开的话，则获得第一块屏幕的参数，如果当前stage在第二块屏幕打开的话，则获得第二块屏幕的参数
ScreenProperties screenProperties = new ScreenProperties(stage, ScreenProperties.DEFAULT);
// 使用ScreenProperties.FIRST_SCREEN的话，会获得第一块屏幕的参数
ScreenProperties screenProperties = new ScreenProperties(stage, ScreenProperties.FIRST_SCREEN);
// 使用ScreenProperties.SECOND_SCREEN的话，会获得第二块屏幕的参数（如果只有一块屏幕的话，返回的是当前这块屏幕的参数）
ScreenProperties screenProperties = new ScreenProperties(stage, ScreenProperties.SECOND_SCREEN);
在第二块屏幕上全屏显示
ScreenProperties screenProperties = new ScreenProperties(stage, ScreenProperties.SCREEN);
screenStage.setWidth(screenProperties.getFullScreenWidth());
screenStage.setHeight(screenProperties.getFullScreenHeight());
screenStage.setX(screenProperties.getFullScreenX());
screenStage.setY(screenProperties.getFullScreenY());
在默认的屏幕上最大化显示：（该方法有适配导航栏在上下左右的情况）
ScreenProperties screenProperties = new ScreenProperties(stage, ScreenProperties.DEFAULT);
screenStage.setWidth(screenProperties.getMaximizeWidth());
screenStage.setHeight(screenProperties.getMaximizeHeight());
screenStage.setX(screenProperties.getMinX());
screenStage.setY(screenProperties.getMinY());
窗口位于屏幕中心：（具体参数要自己调）
ScreenProperties screenProperties = new ScreenProperties(stage, ScreenProperties.DEFAULT);
// 设置宽为最大化时的宽度一半，高为最大化时高度的一半
stage.setWidth(screenProperties.getMaximizeWidth() * 0.5);
stage.setHeight(screenProperties.getMaximizeHeight() * 0.5);
// x轴位于中心往左移当前stage的一半（setX和setY必须得放在setWidth和setHeight后面,因为这里要获取stage.getWidth()和stage.getHeight()）
stage.setX(screenProperties.getCenterX() - (stage.getWidth() / 2));
// y轴靠中心位置往上一些，看起来更顺眼一点
stage.setY(screenProperties.getCenterY() - (stage.getHeight() / 1.6));
这里提供ScreenProperties 的代码:
public class ScreenProperties {
/**
* 最大化时的屏幕高度（不会覆盖任务栏）
*/
private double maximizeHeight;
/**
* 最大化时的屏幕宽度（不会覆盖任务栏）
*/
private double maximizeWidth;
/**
* 全屏时屏幕高度（覆盖任务栏）
*/
private double fullScreenHeight;
/**
* 全屏时屏幕宽度（覆盖任务栏）
*/
private double fullScreenWidth;
/**
* 全屏时屏幕的左上角x坐标（覆盖任务栏）
*/
private double fullScreenX;
/**
* 全屏时屏幕的左上角y坐标（覆盖任务栏）
*/
private double fullScreenY;
/**
* 最大化时左上角的x轴坐标（不会覆盖任务栏，因为任务栏可能在“上下左右”四个位置，所以这个值会变动）
*/
private double minX;
/**
* 最大化时左上角的y轴坐标（不会覆盖任务栏，因为任务栏可能在“上下左右”四个位置，所以这个值会变动）
*/
private double minY;
/**
* 最大化时右下角的x轴坐标（不会覆盖任务栏，因为任务栏可能在“上下左右”四个位置，所以这个值会变动）
*/
private double maxX;
/**
* 最大化时右下角的y轴坐标（不会覆盖任务栏，因为任务栏可能在“上下左右”四个位置，所以这个值会变动）
*/
private double maxY;
/**
* 最大化时屏幕中心点的x坐标
*/
private double centerX;
/**
* 最大化时屏幕中心点的y坐标
*/
private double centerY;
/**
* 主界面为正常大小窗口时，默认的左上角x坐标
*/
private double indexX;
/**
* 主界面为正常大小窗口时，默认的左上角y坐标
*/
private double indexY;
/**
* 主界面为正常大小窗口时的窗口的宽度
*/
private double indexWidth;
/**
* 主界面为正常大小窗口时的窗口的高度
*/
private double indexHeight;
/**
* 默认当前窗口在第几块屏幕，就在第几块屏幕显示
*/
public static final int DEFAULT = 0;
/**
* 在第一块屏幕显示
*/
public static final int FIRST_SCREEN = 1;
/**
* 在第二块屏幕显示
*/
public static final int SECOND_SCREEN = 2;
/**
* 第一屏幕,全屏窗口大小（覆盖任务栏）
*/
private Rectangle firstRectangle;
/**
* 第一屏幕,最大化窗口大小（不覆盖任务栏）
*/
private Rectangle2D firstRectangle2D;
/**
* 第二屏幕,全屏窗口大小（覆盖任务栏）
*/
private Rectangle secondRectangle;
/**
* 第二屏幕,最大化窗口大小（不覆盖任务栏）
*/
private Rectangle2D secondRectangle2D;
/**
* 获得所有屏幕设备的信息
*/
private GraphicsDevice[] gd = GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices();
/**
* 构造函数
*
* @param stage 当前stage对象
* @param index {@link ScreenProperties#DEFAULT} 默认
* {@link ScreenProperties#FIRST_SCREEN} 在第一块屏幕显示
* {@link ScreenProperties#SECOND_SCREEN} 在第二块屏幕显示
*/
public ScreenProperties(Stage stage, int index) {
if (stage == null) {
return;
}
// 当前stage的中心点的x坐标(当屏幕位置为"第二屏幕-第一屏幕"的时候，该值小于0)
double centerXOfStage = stage.getX() + stage.getWidth() / 2;
// 初始化firstRectangle和secondRectangle
initRectangle();
// 只有一个屏幕的情况下，不管index参数是什么，都是在第一屏幕显示
if (gd.length == 1) {
initFirstDevice();
} else {
// 多个屏幕的情况(这里只适配2个屏幕的情况)
if (index == FIRST_SCREEN) {
// 在第一块屏幕显示
initFirstDevice();
} else if (index == SECOND_SCREEN) {
// 在第二块屏幕显示
initSecondDevice();
} else {
// 其它情况, 当前stage在第几块屏幕，就在第几块屏幕显示（根据Stage的中心点来判断它在第几块屏幕）
// 如果第二块屏幕的左上角坐标小于0，说明当前屏幕位置为：第二屏幕 - 第一屏幕（第二块屏幕在第一块屏幕的左边）
if (secondRectangle2D.getMinX() < 0) {
// 此时第二屏幕的x坐标都是小于0的
if (centerXOfStage < 0) {
// 窗口的中心点在第二块屏幕，则在第二屏幕显示
initSecondDevice();
} else {
// 窗口的中心点在第一个屏幕，则在第一屏幕显示
initFirstDevice();
}
} else {
// 当前屏幕位置：第一屏幕 - 第二屏幕（第二块屏幕在第一块屏幕的右边），此时第二屏幕x坐标是大于第一屏幕的宽度
if (centerXOfStage > firstRectangle.width) {
// 窗口的中心点在第二块屏幕，则在第二屏幕显示
initSecondDevice();
} else {
// 窗口的中心点在第一个屏幕，则在第一屏幕显示
initFirstDevice();
}
}
}
}
}
/**
* 初始化第一个屏幕的信息
*/
private void initFirstDevice() {
initDeviceInfo(firstRectangle, firstRectangle2D);
// 全屏时的x坐标为最大化时左上角的x坐标
fullScreenX = 0;
// 全屏时的y坐标为0
fullScreenY = 0;
}
/**
* 初始化第二块屏幕的信息
*/
private void initSecondDevice() {
initDeviceInfo(secondRectangle, secondRectangle2D);
// 如果屏幕位置："第二屏幕-第一屏幕"
if (secondRectangle2D.getMinX() < 0) {
// 此时全屏的x坐标为0 减去自己（第二块）的屏幕宽度
fullScreenX = 0 - secondRectangle.width;
} else {
// 此时全屏的x坐标为 第一块屏幕的宽度
fullScreenX = firstRectangle.width;
}
// 全屏时的y坐标为0
fullScreenY = 0;
}
/**
* 初始化屏幕信息
*
* @param rectangle 全屏
* @param rectangle2D 最大化
*/
private void initDeviceInfo(Rectangle rectangle, Rectangle2D rectangle2D) {
// 全屏时
fullScreenWidth = rectangle.width;
fullScreenHeight = rectangle.height;
// 最大化
maximizeWidth = rectangle2D.getWidth();
maximizeHeight = rectangle2D.getHeight();
// 最大化时右上角坐标
minX = rectangle2D.getMinX();
minY = rectangle2D.getMinY();
// 最大化时左下角坐标
maxX = rectangle2D.getMaxX();
maxY = rectangle2D.getMaxY();
// 最大化时的中心点位置(最大化时左上角坐标 + 最大化时窗口宽度的一半)
centerX = minX + maximizeWidth / 2;
centerY = minY + maximizeHeight / 2;
// 主页面处于正常窗口大小时的宽度(为最大化时的宽度的八分之一)
indexWidth = maximizeWidth * 0.9;
// 主页面处于正常窗口大小时的高度(为最大化时的宽度的九分之一)
indexHeight = maximizeHeight * 0.9;
// 主页面为正常窗口大小时的右上角x坐标(为最大化时左上角的x坐标 + 最大化时的宽度的五分之一)
indexX = minX + maximizeWidth * 0.05;
// 主页面为正常窗口大小时的右上角y坐标(为最大化时左上角的y坐标 + 为最大化时的高度的五分之一)
indexY = minY + maximizeHeight * 0.05;
}
/**
* 非常奇葩的一点：通过GraphicsDevice[] gd = ge.getScreenDevices();取得的设备是按照从左往右的顺序得到的
* 例如现在屏幕位置：第二屏幕 - 第一屏幕，则gd[0]是第二屏幕，gd[1]是第一屏幕
* 例如现在屏幕位置：第一屏幕 - 第二屏幕，则gd[0]是第一屏幕，gd[1]是第二屏幕
* 太坑了吧！！！
* 更坑爹的是，使用Screen secondScreen = Screen.getScreens().get(0); 其中get(0)为第一屏幕,get(1)为第二屏幕（不会因为屏幕位置排序而变化）
* 如果你有更好的获取两个屏幕下设备的信息的方法，你可以更改下
*/
private void initRectangle() {
// 获得第一个屏幕最大化窗口的信息（不覆盖任务栏）
Screen firstScreen = Screen.getScreens().get(0);
firstRectangle2D = firstScreen.getVisualBounds();
// 只有一块屏幕
if (gd.length == 1) {
// 获得第一个屏幕全屏时的信息(覆盖任务栏)
firstRectangle = gd[0].getDefaultConfiguration().getBounds();
} else {
// 多块屏幕（只适配2块）
// 获得第二个屏幕最大化窗口的信息（不覆盖任务栏）
Screen secondScreen = Screen.getScreens().get(1);
secondRectangle2D = secondScreen.getVisualBounds();
// 左边的屏幕（全屏）
Rectangle leftRectangle = gd[0].getDefaultConfiguration().getBounds();
// 右边的屏幕（全屏）
Rectangle rightRectangle = gd[1].getDefaultConfiguration().getBounds();
// 屏幕位置：第二屏幕 - 第一屏幕
if (secondRectangle2D.getMinX() < 0) {
secondRectangle = leftRectangle;
firstRectangle = rightRectangle;
} else {
// 屏幕位置：第一屏幕 - 第二屏幕
firstRectangle = leftRectangle;
secondRectangle = rightRectangle;
}
}
}
public double getMaximizeHeight() {
return maximizeHeight;
}
public double getMaximizeWidth() {
return maximizeWidth;
}
public double getFullScreenHeight() {
return fullScreenHeight;
}
public double getFullScreenWidth() {
return fullScreenWidth;
}
public double getFullScreenX() {
return fullScreenX;
}
public double getFullScreenY() {
return fullScreenY;
}
public double getMinX() {
return minX;
}
public double getMinY() {
return minY;
}
public double getMaxX() {
return maxX;
}
public double getMaxY() {
return maxY;
}
public double getCenterX() {
return centerX;
}
public double getCenterY() {
return centerY;
}
public double getIndexX() {
return indexX;
}
public double getIndexY() {
return indexY;
}
public double getIndexWidth() {
return indexWidth;
}
public double getIndexHeight() {
return indexHeight;
}
}