public final class ViewUtils {

    public interface ViewUtilsListener {
        void onDrawCompleted();
    }

    private ViewUtils() {
    }

    public static void onDraw(View view, ViewUtilsListener listener) {
        view.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
            @Override
            public void onGlobalLayout() {
                if (view.getHeight() != 0 && view.getWidth() != 0) {
                    if (listener != null) {
                        listener.onDrawCompleted();
                    }
                    view.getViewTreeObserver().removeOnGlobalLayoutListener(this);
                }
            }
        });
    }
}

你可以这样用;

ViewUtils.onDraw(view, new ViewUtils.ViewUtilsListener() {
                @Override
                public void onDrawCompleted() {
                    int width = view.getWidth();
                    int height = view.getHeight();
                }
            });

我们可以用

@Override
 public void onWindowFocusChanged(boolean hasFocus) {
  super.onWindowFocusChanged(hasFocus);
  //Here you can get the size!
 }

正如Ian在这篇Android开发者文章中所述:

Anyhow, the deal is that layout of the contents of a window happens after all the elements are constructed and added to their parent views. It has to be this way, because until you know what components a View contains, and what they contain, and so on, there's no sensible way you can lay it out. Bottom line, if you call getWidth() etc. in a constructor, it will return zero. The procedure is to create all your view elements in the constructor, then wait for your View's onSizeChanged() method to be called -- that's when you first find out your real size, so that's when you set up the sizes of your GUI elements. Be aware too that onSizeChanged() is sometimes called with parameters of zero -- check for this case, and return immediately (so you don't get a divide by zero when calculating your layout, etc.). Some time later it will be called with the real values.

我们需要等待绘制视图。为此，请使用OnPreDrawListener。芬兰湾的科特林的例子:

val preDrawListener = object : ViewTreeObserver.OnPreDrawListener {

                override fun onPreDraw(): Boolean {
                    view.viewTreeObserver.removeOnPreDrawListener(this)

                    // code which requires view size parameters

                    return true
                }
            }

            view.viewTreeObserver.addOnPreDrawListener(preDrawListener)

一个Kotlin扩展来观察全局布局，并在高度动态就绪时执行给定的任务。

用法:

view.height { Log.i("Info", "Here is your height:" + it) }

实现:

fun <T : View> T.height(function: (Int) -> Unit) {
    if (height == 0)
        viewTreeObserver.addOnGlobalLayoutListener(object : ViewTreeObserver.OnGlobalLayoutListener {
            override fun onGlobalLayout() {
                viewTreeObserver.removeOnGlobalLayoutListener(this)
                function(height)
            }
        })
    else function(height)
}

基本的问题是，你必须等待实际测量的绘制阶段(特别是像wrap_content或match_parent这样的动态值)，但通常这个阶段在onResume()之前还没有完成。所以你需要一个变通的方法来等待这个阶段。对此有不同的解决方案:

1. 监听绘制/布局事件:ViewTreeObserver

ViewTreeObserver被不同的绘图事件触发。通常OnGlobalLayoutListener是你想要的测量值，所以在布局阶段之后，监听器中的代码将被调用，这样测量值就准备好了:

view.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
            @Override
            public void onGlobalLayout() {
                view.getViewTreeObserver().removeOnGlobalLayoutListener(this);
                view.getHeight(); //height is ready
            }
        });

注意:监听器将被立即删除，否则它将在每个布局事件中触发。如果你必须支持应用SDK Lvl < 16使用这个来注销监听器:

removeGlobalOnLayoutListener (ViewTreeObserver)OnGlobalLayoutListener受害者)

2. 添加一个可运行对象到布局队列:

不是很有名，也是我最喜欢的解决方案。基本上只需要使用视图的post方法和你自己的runnable。这基本上是将你的代码排在视图的度量、布局等之后，就像Romain Guy说的那样:

UI事件队列将按顺序处理事件。后 setContentView()被调用时，事件队列将包含一条消息 请求重新布局，这样你发布到队列中的任何事情都会发生 在布局通过之后

例子:

final View view=//smth;
...
view.post(new Runnable() {
            @Override
            public void run() {
                view.getHeight(); //height is ready
            }
        });

相对于ViewTreeObserver的优势:

你的代码只执行一次，你不必在执行后禁用观察者，这可能是一个麻烦 更少的详细语法

引用:

https://stackoverflow.com/a/3602144/774398 https://stackoverflow.com/a/3948036/774398

3.覆盖视图的onLayout方法

这只在逻辑可以封装在视图本身的特定情况下是可行的，否则这是一个相当冗长和麻烦的语法。

view = new View(this) {
    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        super.onLayout(changed, l, t, r, b);
        view.getHeight(); //height is ready
    }
};

还要注意，onLayout将被调用很多次，所以要考虑在方法中所做的事情，或者在第一次之后禁用代码

4. 检查是否已通过布局阶段

如果你有代码在创建ui时执行了多次，你可以使用下面的support v4 lib方法:

View viewYouNeedHeightFrom = ...
...
if(ViewCompat.isLaidOut(viewYouNeedHeightFrom)) {
   viewYouNeedHeightFrom.getHeight();
}

如果视图自创建以来至少经历过一次布局，则返回true 最后附着在窗户上或从窗户上分离的。

附加:获取静态定义的度量

如果只需要获得静态定义的高度/宽度就足够了，你可以这样做:

View.getMeasuredWidth () View.getMeasuredHeigth ()

但请注意，这可能与绘制后的实际宽度/高度不同。javadoc更详细地描述了两者的区别:

The size of a view is expressed with a width and a height. A view actually possess two pairs of width and height values. The first pair is known as measured width and measured height. These dimensions define how big a view wants to be within its parent (see Layout for more details.) The measured dimensions can be obtained by calling getMeasuredWidth() and getMeasuredHeight(). The second pair is simply known as width and height, or sometimes drawing width and drawing height. These dimensions define the actual size of the view on screen, at drawing time and after layout. These values may, but do not have to, be different from the measured width and height. The width and height can be obtained by calling getWidth() and getHeight().