在Android中获取屏幕宽度和高度

时间：2011-01-20 03:17:01

标签： android

如何获取屏幕宽度和高度并在以下位置使用此值：

@Override protected void onMeasure(int widthSpecId, int heightSpecId) {
    Log.e(TAG, "onMeasure" + widthSpecId);
    setMeasuredDimension(SCREEN_WIDTH, SCREEN_HEIGHT - 
        game.findViewById(R.id.flag).getHeight());
}

34 个答案:

答案 0 :(得分：840)

使用此代码，您可以获得运行时Display's Width & Height 

DisplayMetrics displayMetrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);
int height = displayMetrics.heightPixels;
int width = displayMetrics.widthPixels;

在视图中，您需要执行以下操作：

((Activity) getContext()).getWindowManager()
                         .getDefaultDisplay()
                         .getMetrics(displayMetrics);

在某些设备具有Navigatio Bar的情况下，必须检查运行时

public boolean showNavigationBar(Resources resources)
    {
        int id = resources.getIdentifier("config_showNavigationBar", "bool", "android");
        return id > 0 && resources.getBoolean(id);
    }

如果设备有导航栏，则计算其高度

private int getNavigationBarHeight() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
            DisplayMetrics metrics = new DisplayMetrics();
            getWindowManager().getDefaultDisplay().getMetrics(metrics);
            int usableHeight = metrics.heightPixels;
            getWindowManager().getDefaultDisplay().getRealMetrics(metrics);
            int realHeight = metrics.heightPixels;
            if (realHeight > usableHeight)
                return realHeight - usableHeight;
            else
                return 0;
        }
        return 0;
    }

因此设备的最终高度为

int height = displayMetrics.heightPixels + getNavigationBarHeight() ;

答案 1 :(得分：223)

有一个非常简单的答案，没有传递上下文

public static int getScreenWidth() {
    return Resources.getSystem().getDisplayMetrics().widthPixels;
}

public static int getScreenHeight() {
    return Resources.getSystem().getDisplayMetrics().heightPixels;
}

注意：如果您想要高度包含导航栏，请使用以下方法 

WindowManager windowManager =
        (WindowManager) BaseApplication.getApplication().getSystemService(Context.WINDOW_SERVICE);
    final Display display = windowManager.getDefaultDisplay();
    Point outPoint = new Point();
    if (Build.VERSION.SDK_INT >= 19) {
        // include navigation bar
        display.getRealSize(outPoint);
    } else {
        // exclude navigation bar
        display.getSize(outPoint);
    }
    if (outPoint.y > outPoint.x) {
        mRealSizeHeight = outPoint.y;
        mRealSizeWidth = outPoint.x;
    } else {
        mRealSizeHeight = outPoint.x;
        mRealSizeWidth = outPoint.y;
    }

答案 2 :(得分：45)

只是为了更新parag和SpK的答案，以便与不推荐使用的方法的当前SDK向后兼容性保持一致：

int Measuredwidth = 0;  
int Measuredheight = 0;  
Point size = new Point();
WindowManager w = getWindowManager();

if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB)    {
    w.getDefaultDisplay().getSize(size);
    Measuredwidth = size.x;
    Measuredheight = size.y; 
}else{
    Display d = w.getDefaultDisplay(); 
    Measuredwidth = d.getWidth(); 
    Measuredheight = d.getHeight(); 
}

答案 3 :(得分：21)

为什么不

  

DisplayMetrics displaymetrics = getResources（）。getDisplayMetrics（）;

然后使用

  

displayMetrics.widthPixels（heightPixels）

答案 4 :(得分：10)

尝试以下代码： -

<强> 1 

Display display = getWindowManager().getDefaultDisplay();
Point size = new Point();
display.getSize(size);
int width = size.x;
int height = size.y;

<强> 2 

Display display = getWindowManager().getDefaultDisplay(); 
int width = display.getWidth();  // deprecated
int height = display.getHeight();  // deprecated

或

int width = getWindowManager().getDefaultDisplay().getWidth(); 
int height = getWindowManager().getDefaultDisplay().getHeight();

第3 

DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);

metrics.heightPixels;
metrics.widthPixels;

答案 5 :(得分：6)

•Kotlin Version通过Extension Property

如果您想了解屏幕大小（以像素为单位）以及dp，使用这些扩展名属性确实会有所帮助：


DimensionUtils.kt 

import android.content.res.Resources
import android.graphics.Rect
import android.graphics.RectF
import android.util.DisplayMetrics
import kotlin.math.roundToInt

/**
 * @author aminography
 */

private val displayMetrics: DisplayMetrics by lazy { Resources.getSystem().displayMetrics }

val screenRectPx: Rect
    get() = displayMetrics.run { Rect(0, 0, widthPixels, heightPixels) }

val screenRectDp: RectF
    get() = displayMetrics.run { RectF(0f, 0f, widthPixels.px2dp, heightPixels.px2dp) }

val Number.px2dp: Float
    get() = this.toFloat() / displayMetrics.density

val Number.dp2px: Int
    get() = (this.toFloat() * displayMetrics.density).roundToInt()

用法：

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val widthPx = screenRectPx.width()
        val heightPx = screenRectPx.height()
        println("[PX] screen width: $widthPx , height: $heightPx")

        val widthDp = screenRectDp.width()
        val heightDp = screenRectDp.height()
        println("[DP] screen width: $widthDp , height: $heightDp")
    }
}

结果：

当设备处于 portrait 方向时：

[PX] screen width: 1440 , height: 2392
[DP] screen width: 360.0 , height: 598.0

当设备处于 landscape 方向时：

[PX] screen width: 2392 , height: 1440
[DP] screen width: 598.0 , height: 360.0

答案 6 :(得分：5)

获取屏幕宽度和高度的值。

Display display = getWindowManager().getDefaultDisplay();
Point size = new Point();
display.getSize(size);
width = size.x;
height = size.y;

答案 7 :(得分：5)

使用Android很容易：

int width  = Resources.getSystem().getDisplayMetrics().widthPixels;
int height = Resources.getSystem().getDisplayMetrics().heightPixels;

答案 8 :(得分：5)

DisplayMetrics dimension = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(dimension);
        int width = dimension.widthPixels;
        int height = dimension.heightPixels;

答案 9 :(得分：4)

DisplayMetrics lDisplayMetrics = getResources().getDisplayMetrics();
int widthPixels = lDisplayMetrics.widthPixels;
int heightPixels = lDisplayMetrics.heightPixels;

答案 10 :(得分：4)

public class DisplayInfo {
    int screen_height=0, screen_width=0;
    WindowManager wm;
    DisplayMetrics displaymetrics;

    DisplayInfo(Context context) {
        getdisplayheightWidth(context);
    }

    void getdisplayheightWidth(Context context) {
        wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
        displaymetrics = new DisplayMetrics();
        wm.getDefaultDisplay().getMetrics(displaymetrics);
        screen_height = displaymetrics.heightPixels;
        screen_width = displaymetrics.widthPixels;
    }

    public int getScreen_height() {
        return screen_height;
    }

    public int getScreen_width() {
        return screen_width;
    }
}

答案 11 :(得分：3)

此处显示的方法已弃用/过期但仍在使用。需要获取API 13

检查出来

Display disp= getWindowManager().getDefaultDisplay();
Point dimensions = new Point();
disp.getSize(size);
int width = size.x;
int height = size.y;

答案 12 :(得分：3)

Display display = ((WindowManager) this.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
int mWidthScreen = display.getWidth();
int mHeightScreen = display.getHeight();

答案 13 :(得分：2)

由于 getMetrics 和 getRealMetrics 已弃用，Google 建议按如下方式确定屏幕宽度和高度：

WindowMetrics windowMetrics = getActivity().getWindowManager().getMaximumWindowMetrics();
Rect bounds = windowMetrics.getBounds();
int widthPixels = bounds.width();
int heightPixels = bounds.height();

但是，我想出了另一种可以得到相同结果的方法：

Configuration configuration = mContext.getResources().getConfiguration();
Display.Mode mode = display.getMode();
int widthPixels = mode.getPhysicalWidth();
int heightPixels = mode.getPhysicalHeight();

答案 14 :(得分：2)

对于Kotlin用户而言

fun Activity.displayMetrics(): DisplayMetrics {
   val displayMetrics = DisplayMetrics();
   windowManager.defaultDisplay.getMetrics(displayMetrics);
   return displayMetrics
}

在“活动”中，您可以像这样使用它

    displayMetrics().let { displayMetrics -> 
        val height = displayMetrics.heightPixels
        val width = displayMetrics.widthPixels
    }

或分段

    activity?.displayMetrics()?.run {
        val height = heightPixels
        val width = widthPixels
    }

答案 15 :(得分：2)

如android官方文档所述，对于默认显示，请使用Context＃getDisplay（），因为此方法在API级别30中已弃用。

getWindowManager（）。 getDefaultDisplay （）。 getMetrics （displayMetrics）;

这碗代码有助于确定宽度和高度。

public static int getWidth(Context context) {
    DisplayMetrics displayMetrics = new DisplayMetrics();
    Display display = context.getDisplay();
    if (display != null) {
        display.getRealMetrics(displayMetrics);
        return displayMetrics.widthPixels;
    }
    return -1;
}

对于高度：

public static int getHeight(Context context) {
    DisplayMetrics displayMetrics = new DisplayMetrics();
    Display display = context.getDisplay();
    if (display != null) {
        display.getRealMetrics(displayMetrics);
        return displayMetrics.heightPixels;
    }
    return -1;
}

答案 16 :(得分：2)

如android官方文档所述，对于默认显示，请使用Context＃getDisplay（），因为此方法在API级别30中已弃用。

getWindowManager（）。 getDefaultDisplay （）。 getMetrics （displayMetrics）;

下面给出的这段代码是在kotlin中编写的，是根据最新版本的Android帮助您确定宽度和高度而编写的：

fun getWidth(context: Context): Int {
    var width:Int = 0
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
        val displayMetrics = DisplayMetrics()
        val display: Display? = context.getDisplay()
        display!!.getRealMetrics(displayMetrics)
        return displayMetrics.widthPixels
    }else{
        val displayMetrics = DisplayMetrics()
        this.windowManager.defaultDisplay.getMetrics(displayMetrics)
        width = displayMetrics.widthPixels
        return width
    }
}

fun getHeight(context: Context): Int {
    var height: Int = 0
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
        val displayMetrics = DisplayMetrics()
        val display = context.display
        display!!.getRealMetrics(displayMetrics)
        return displayMetrics.heightPixels
    }else {
        val displayMetrics = DisplayMetrics()
        this.windowManager.defaultDisplay.getMetrics(displayMetrics)
        height = displayMetrics.heightPixels
        return height
    }
}

答案 17 :(得分：2)

您可以从上下文

获取宽度和高度

java：

  int width= context.getResources().getDisplayMetrics().widthPixels;
  int height= context.getResources().getDisplayMetrics().heightPixels;

kotlin

    val width: Int = context.resources.displayMetrics.widthPixels
    val height: Int = context.resources.displayMetrics.heightPixels

答案 18 :(得分：2)

完整的方法，它返回真正的分辨率：

            WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
            Point size = new Point();
            wm.getDefaultDisplay().getRealSize(size);
            final int width = size.x, height = size.y;

由于这可以在不同的方向上发生变化，这里有一个解决方案（在Kotlin中），无论方向如何，都要做到正确：

/**
 * returns the natural orientation of the device: Configuration.ORIENTATION_LANDSCAPE or Configuration.ORIENTATION_PORTRAIT .<br></br>
 * The result should be consistent no matter the orientation of the device
 */
@JvmStatic
fun getScreenNaturalOrientation(context: Context): Int {
    //based on : http://stackoverflow.com/a/9888357/878126
    val windowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
    val config = context.resources.configuration
    val rotation = windowManager.defaultDisplay.rotation
    return if ((rotation == Surface.ROTATION_0 || rotation == Surface.ROTATION_180) && config.orientation == Configuration.ORIENTATION_LANDSCAPE || (rotation == Surface.ROTATION_90 || rotation == Surface.ROTATION_270) && config.orientation == Configuration.ORIENTATION_PORTRAIT)
        Configuration.ORIENTATION_LANDSCAPE
    else
        Configuration.ORIENTATION_PORTRAIT
}

/**
 * returns the natural screen size (in pixels). The result should be consistent no matter the orientation of the device
 */
@JvmStatic
fun getScreenNaturalSize(context: Context): Point {
    val screenNaturalOrientation = getScreenNaturalOrientation(context)
    val wm = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
    val point = Point()
    wm.defaultDisplay.getRealSize(point)
    val currentOrientation = context.resources.configuration.orientation
    if (currentOrientation == screenNaturalOrientation)
        return point
    else return Point(point.y, point.x)
}

答案 19 :(得分：1)

只需使用下面的函数返回屏幕大小的宽度和高度作为整数数组

private int[] getScreenSIze(){
        DisplayMetrics displaymetrics = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(displaymetrics);
        int h = displaymetrics.heightPixels;
        int w = displaymetrics.widthPixels;

        int[] size={w,h};
        return size;

    }

在onCreate功能或按钮上单击添加以下代码以输出屏幕尺寸，如下所示

 int[] screenSize= getScreenSIze();
        int width=screenSize[0];
        int height=screenSize[1];
        screenSizes.setText("Phone Screen sizes \n\n  width = "+width+" \n Height = "+height);

答案 20 :(得分：1)

我使用以下代码获取屏幕尺寸

getWindow().getDecorView().getWidth()
getWindow().getDecorView().getHeight()

答案 21 :(得分：0)

displayMetrics.heightPixels

使用该方法，您可以获取屏幕高度。 如果要将宽度从displayMetrics.widthPixels更改为var resultArr = []; yourobj.forEach((item,index)=>{ if(item.id === 2) { // nothing } else { resultArr.push(item); } }) 。

它还包括必需的api构建版本。

答案 22 :(得分：0)

对于我的带有 Android 11 的 Galaxy M51，似乎所有这些答案都失败了。在做了一些研究之后，我发现了这个代码：

WindowMetrics windowmetrics = MainActivity.getWindowManager().getCurrentWindowMetrics();
Rect rect = windowmetrics.getBounds();
int width = rect.right;
int height =rect.bottom;

显示我的真实设备分辨率为 1080x2400，其余仅返回 810x1800。

答案 23 :(得分：0)

fun Activity.getRealScreenSize(): Pair<Int, Int> { //<width, height>
return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
    val size = Point()
    display?.getRealSize(size)
    Pair(size.x, size.y)
} else {
    val size = Point()
    windowManager.defaultDisplay.getRealSize(size)
    Pair(size.x, size.y)

}}

这是一个扩展功能，您可以通过这种方式在您的活动中使用：

 override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    val pair = getRealScreenSize()
    pair.first //to get width
    pair.second //to get height
}

答案 24 :(得分：0)

DisplayMetrics displayMetrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);
int height = displayMetrics.heightPixels;
int width = displayMetrics.widthPixels;

在某些情况下这可能不起作用。 getMetrics comments：

获取显示指标，以描述其尺寸和密度 显示。此方法返回的大小不一定 代表显示器的实际原始尺寸（本机分辨率）。

  1. 可以调整返回的大小，以排除某些始终可见的系统装饰元素。

  2. 它可能会进行缩放以提供与最初为较小的显示器设计的较旧应用程序的兼容性。

  3. 取决于显示所属的WindowManager，它可以有所不同。

  • 如果从非活动上下文请求（例如通过（WindowManager）的应用程序上下文） getApplicationContext（）。getSystemService（Context.WINDOW_SERVICE） 指标将报告基于当前的整个显示的大小 旋转并减去系统装饰面积。

  • 如果活动请求（使用getWindowManager（）或（WindowManager）getSystemService（Context.WINDOW_SERVICE））发出结果 指标将与当前应用程序窗口指标相对应。在这种情况下，大小可以小于多窗口模式下的物理大小。

因此，要获得实际大小：

DisplayMetrics displayMetrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getRealMetrics(displayMetrics);
int height = displayMetrics.heightPixels;
int width = displayMetrics.widthPixels;

或：

Point point = new Point();
getWindowManager().getDefaultDisplay().getRealSize(point);
int height = point.y;
int width = point.x;

答案 25 :(得分：0)

我更新了Kotlin语言的答案！

对于Kotlin：您应该调用Window Manager并获取指标。用这种简单的方法。

val displayMetrics = DisplayMetrics()
windowManager.defaultDisplay.getMetrics(displayMetrics)

var width = displayMetrics.widthPixels
var height = displayMetrics.heightPixels

如何使用Kotlin语言以独立活动的方式有效地使用它？

在这里，我在一般Kotlin类中创建了一个方法。您可以在所有活动中使用它。

private val T_GET_SCREEN_WIDTH:String = "screen_width"
private val T_GET_SCREEN_HEIGHT:String = "screen_height"

private fun getDeviceSizes(activity:Activity, whichSize:String):Int{

    val displayMetrics = DisplayMetrics()
    activity.windowManager.defaultDisplay.getMetrics(displayMetrics)

    return when (whichSize){
        T_GET_SCREEN_WIDTH -> displayMetrics.widthPixels
        T_GET_SCREEN_HEIGHT -> displayMetrics.heightPixels
        else -> 0 // Error
    }
}

联系人：@canerkaseler

答案 26 :(得分：0)

    int getScreenSize() {
        int screenSize = getResources().getConfiguration().screenLayout &
                Configuration.SCREENLAYOUT_SIZE_MASK;
//        String toastMsg = "Screen size is neither large, normal or small";
        Display display = ((WindowManager) getSystemService(WINDOW_SERVICE)).getDefaultDisplay();
        int orientation = display.getRotation();

        int i = 0;
        switch (screenSize) {

            case Configuration.SCREENLAYOUT_SIZE_NORMAL:
                i = 1;
//                toastMsg = "Normal screen";
                break;
            case Configuration.SCREENLAYOUT_SIZE_SMALL:
                i = 1;
//                toastMsg = "Normal screen";
                break;
            case Configuration.SCREENLAYOUT_SIZE_LARGE:
//                toastMsg = "Large screen";
                if (orientation == Surface.ROTATION_90
                        || orientation == Surface.ROTATION_270) {
                    // TODO: add logic for landscape mode here
                    i = 2;
                } else {
                    i = 1;
                }


                break;
            case Configuration.SCREENLAYOUT_SIZE_XLARGE:
                if (orientation == Surface.ROTATION_90
                        || orientation == Surface.ROTATION_270) {
                    // TODO: add logic for landscape mode here
                    i = 4;
                } else {
                    i = 3;
                }

                break;


        }
//        customeToast(toastMsg);
        return i;
    }

答案 27 :(得分：0)

对于Chrome OS的多屏显示或即将推出的可折叠产品，此处的答案均无法正常工作。

  

寻找当前配置时，请始终使用getResources().getConfiguration()中当前活动中的配置。 请勿使用后台活动中的配置或系统资源中的配置。后台活动没有大小，并且系统配置中可能包含多个大小和方向冲突的窗口< / strong>，因此无法提取可用数据。

答案是

val config = context.getResources().getConfiguration()
val (screenWidthPx, screenHeightPx) = config.screenWidthDp.dp to config.screenHeightDp.dp

答案 28 :(得分：0)

尝试 Kotlin

的此代码 
 val display = windowManager.defaultDisplay
 val size = Point()
 display.getSize(size)
 var DEVICE_WIDTH = size.x
 var DEVICE_HEIGHT = size.y

答案 29 :(得分：0)

两个步骤。首先，扩展Activity类

class Example extends Activity

第二：使用此代码

 DisplayMetrics displayMetrics = new DisplayMetrics();
 WindowManager windowmanager = (WindowManager) getApplicationContext().getSystemService(Context.WINDOW_SERVICE);
 windowmanager.getDefaultDisplay().getMetrics(displayMetrics);
 int deviceWidth = displayMetrics.widthPixels;
 int deviceHeight = displayMetrics.heightPixels;

答案 30 :(得分：0)

这个set of utilities可以与Android中的大小抽象一起使用。

它包含一个班级SizeFromDisplay.java 您可以像这样使用它：

ISize size = new SizeFromDisplay(getWindowManager().getDefaultDisplay());
size.width();
size.hight();

答案 31 :(得分：0)

屏幕分辨率是屏幕中像素的总数。以下程序将提取设备的屏幕分辨率。它将打印屏幕宽度和高度。这些值以像素为单位。 

public static Point getScreenResolution(Context context) {
// get window managers
WindowManager manager =  (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);
Display display = manager.getDefaultDisplay();
Point point = new Point();
display.getSize(point);

 // get width and height
 int width = point.x;
 int height = point.y;

 return point;

}

答案 32 :(得分：0)

我在本页中找到了 weigan 的最佳答案，以下是Xamarin.Android中如何使用它的方法：

public int GetScreenWidth()
{
    return Resources.System.DisplayMetrics.WidthPixels;
}

public int GetScreenHeight()
{
    return Resources.System.DisplayMetrics.HeightPixels;
}

答案 33 :(得分：-2)

       @Override
        protected void onPostExecute(Drawable result) {
            Log.d("width",""+result.getIntrinsicWidth());
            urlDrawable.setBounds(0, 0, 0+result.getIntrinsicWidth(), 600);

            // change the reference of the current drawable to the result
            // from the HTTP call
            urlDrawable.drawable = result;

            // redraw the image by invalidating the container
            URLImageParser.this.container.invalidate();

            // For ICS
            URLImageParser.this.container.setHeight((400+URLImageParser.this.container.getHeight()
                    + result.getIntrinsicHeight()));

            // Pre ICS`enter code here`
            URLImageParser.this.container.setEllipsize(null);
        }
相关问题
最新问题