这是一个有点旧，但我自己有麻烦(需要在一个片段中创建动画对象)。这个解决方案对我来说很有效，我相信这是不言自明的。

class YourFragment: Fragment() {
    var width = 0
    var height = 0


override fun onCreateView(
    inflater: LayoutInflater, container: ViewGroup?,
    savedInstanceState: Bundle?
): View? {
    // Inflate the layout for this fragment
    val root = inflater.inflate(R.layout.fragment_winner_splash, container, false)
    container?.width.let {
        if (it != null) {
            width = it
        }
    }
    container?.height.let {
        if (it != null) {
            height = it
        }
    }
    
    return root
}
 

芬兰湾的科特林:

由于使用视图，我曾面临过一次生产崩溃。高度/视图。宽度导致NaN，而我使用view .post()，有时视图尺寸返回0值。

So,

使用视图。doOnPreDraw{//你的动作在这里}，这是:

OneShotPreDrawListener，所以它只调用一次。 实现OnPreDrawListener，确保视图被布局和测量

基本的问题是，你必须等待实际测量的绘制阶段(特别是像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().

用法:

imageView.size { width, height ->
            //your code
        }

延伸:

fun <T : View> T.size(function: (Int, Int) -> Unit) {
    if (isLaidOut && height != 0 && width != 0) {
        function(width, height)
    } else {
        if (height == 0 || width == 0) {
            var onLayoutChangeListener: View.OnLayoutChangeListener? = null
            var onGlobalLayoutListener: ViewTreeObserver.OnGlobalLayoutListener? = null

            onGlobalLayoutListener = object : ViewTreeObserver.OnGlobalLayoutListener {
                override fun onGlobalLayout() {
                    if (isShown) {
                        removeOnLayoutChangeListener(onLayoutChangeListener)
                        viewTreeObserver.removeOnGlobalLayoutListener(this)
                        function(width, height)
                    }
                }
            }

            onLayoutChangeListener = object : View.OnLayoutChangeListener {
                override fun onLayoutChange(
                    v: View?,
                    left: Int,
                    top: Int,
                    right: Int,
                    bottom: Int,
                    oldLeft: Int,
                    oldTop: Int,
                    oldRight: Int,
                    oldBottom: Int
                ) {
                    val width = v?.width ?: 0
                    val height = v?.height ?: 0
                    if (width > 0 && height > 0) {
                        // remove after finish
                        viewTreeObserver.removeOnGlobalLayoutListener(onGlobalLayoutListener)
                        v?.removeOnLayoutChangeListener(this)
                        function(width, height)
                    }
                }
            }

            viewTreeObserver.addOnGlobalLayoutListener(onGlobalLayoutListener)
            addOnLayoutChangeListener(onLayoutChangeListener)
        } else {
            function(width, height)
        }
    }
}

AndroidX在AndroidX .core.view中有多个扩展函数可以帮助你完成这类工作

为此，您需要使用Kotlin。

最适合这里的是doOnLayout:

在布局此视图时执行给定的操作。如果视图已经布局并且它没有请求布局，操作将立即执行，否则，操作将在视图下一次布局后执行。 该操作只会在下一个布局中被调用一次，然后被删除。

在你的例子中:

bt.doOnLayout {
    val ra = RotateAnimation(0,360,it.width / 2,it.height / 2)
    // more code
}

依赖:androidx.core: core-ktx: 1.0.0

如果你使用RxJava & RxBindings，一行。类似的方法没有样板。这也解决了蒂姆·奥廷(Tim Autin)的回答中隐藏警告的问题。

RxView.layoutChanges(yourView).take(1)
      .subscribe(aVoid -> {
           // width and height have been calculated here
      });

就是它了。不需要取消订阅，即使从未调用。