配对父母和填充父母之间有什么区别？

I'm a little confused about two XML properties: match_parent and fill_parent. It seems that both are the same. Is there any difference between them?

They're the same thing (in API Level 8+). Use match_parent.

FILL_PARENT (renamed MATCH_PARENT in API Level 8 and higher), which means that the view wants to be as big as its parent (minus padding)

...

fill_parent: The view should be as big as its parent (minus padding). This constant is deprecated starting from API Level 8 and is replaced by match_parent.

http://developer.android.com/reference/android/view/ViewGroup.LayoutParams.html

For compatibility sake it's better to stick to fill_parent, i.e, when supporting below API 8 devices. But if your app targets API 8 and upwards, you should use match_parent instead.

Functionally no difference, Google just changed the name from fill_parent to match_parent, from API level 8 (Android 2.2). FILL_PARENT is still available for compatibility reason.

LayoutParams.FILL_PARENT and LayoutParams.MATCH_PARENT both have value -1. Not sure what tempted google to change from Fill Parent to Match Parent :)

Since most of the phones are >= Android 2.2 .. you should use Match Parent for future compatibility... not sure when they will discontinue the older Fill Parent constant!

Google changed the name to avoid confusion.

Problem with the old name fill parent was that it implies its affecting the dimensions of the parent, while match parent better describes the resulting behavior - match the dimension with the parent.

Both constants resolve to -1 in the end, and so result in the identical behavior in the app. Ironically enough, this name change made to clarify things seems to have added confusion rather than eliminating it.

Just to give it a name closer to it's actual action. "fill_parent" does not fill the remaining space as the name would imply (for that you use the weight attribute). Instead, it takes up as much space as its layout parent. That's why the new name is "match_parent"

fill_parent (renamed MATCH_PARENT in API Level 8 and higher), which means that the view wants to be as big as its parent (minus padding)

fill_parent: The view should be as big as its parent (minus padding). This constant is deprecated starting from API Level 8 and is replaced by match_parent

For Android API 1.6 to 2.1 match_parent will throw you an error, so use fill_parent in these cases. To support backward compatibility, it's better to use fill_parent

• Both are static final constants that represent the value -1
• FILL_PARENT is deprecated in API level 8

So MATCH_PARENT and FILL_PARENT are the same?

Yes, MATCH_PARENT and FILL_PARENT are just different constant names for the same integer value (-1 if you are curious) used to specify a View's layout mode within its parent.

So why was MATCH_PARENT added?

I remember that Roman Guy (Android Developer at Google) said, that they have changed the name because "fill_parent" was confusing for developers. As matter of the fact, "fill_parent" does not fill the remaining space (for that you use the weight attribute) but it takes as much space as its layout parent. That's why the new name is "match_parent"

FILL_PARENT is deprecated in API level 8 and MATCH_PARENTuse higherlevel API

match_parent is used in place of fill_parent and sets it to go as far as the parent goes. Just use match_parent and forget about fill_parent. I completely ditched fill_parent and everything is perfect as usual.

Check here for more.

MATCH_PARENT and FILL_PARENT are the same?

Yes, MATCH_PARENT and FILL_PARENT are just different constant names for the same integer value (-1 if you are curious) used to specify a View's layout mode within its parent.

So why was MATCH_PARENT added?

The Android team found that developers were misinterpreting FILL_PARENT to mean that a View would fill the remaining space left in its parent. In fact, by specifying FILL_PARENT, the View is requesting to be as big as its parent.

Okay, I get how FILL_PARENT/MATCH_PARENT works. What does it matter if I use one or the other?

FILL_PARENT is deprecated. Being deprecated does not make it the Devil, but eventually it will go away. Your application is more future-proof using MATCH_PARENT. Why use the deprecated option when the current option behaves exactly the same?

Furthermore, FILL_PARENT is actually misleading. I have personally seen folks confused because it does not work the way they thought it would. In fact, I have seen a single tag using both FILL_PARENT and MATCH_PARENT, because the developer thought (understandably) that they were two different layout modes.

HOW YOU CAN GET TRIPPED UP TRYING TO FILL_PARENT?

Here's a quick example of how MATCH_PARENT/FILL_PARENT confusion can lead to folks repeatedly applying their heads to their desks. First, take a really simple layout containing a few View instances.

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <View
        android:layout_width="match_parent"
        android:layout_height="100dp"
        android:background="#FFFF00" />
    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:gravity="center"
        android:background="@android:color/black"
        android:text="@string/hello_world"
        android:padding="50dp" />
    <View
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="#FF0000" />

</LinearLayout>

fill_parent (renamed MATCH_PARENT in API Level 8 and higher), which means that the view wants to be as big as its parent (minus padding)

fill_parent: The view should be as big as its parent (minus padding). This constant is deprecated starting from API Level 8 and is replaced by match_parent

For Android API 1.6 to 2.1 match_parent will throw you an error, so use fill_parent in these cases. To support backward compatibility, it’s better to use fill_parent

Both are static final constants that represent the value -1

FILL_PARENT is deprecated in API level 8

SO MATCH_PARENT AND FILL_PARENT ARE THE SAME?

Yes, MATCH_PARENT and FILL_PARENT are just different constant names for the same integer value (-1 if you are curious) used to specify a View’s layout mode within its parent.

SO WHY WAS MATCH_PARENT ADDED?

As Roman Guy (Android Developer at Google) said, that they have changed the name because “fill_parent” was confusing for developers. As matter of the fact, “fill_parent” does not fill the remaining space (for that you use the weight attribute) but it takes as

match_parent and fill_parent are same property, used to define width or height of a view in full screen horizontally or vertically.

These properties are used in android xml files like this.

 android:layout_width="match_parent"
 android:layout_height="fill_parent"

or

 android:layout_width="fill_parent"
 android:layout_height="match_parent"

fill_parent was used in previous versions, but now it has been deprecated and replaced by match_parent. I hope it'll help you.

Both have similar functionality only difference is that fill_parent is used up to API level 8 and match_parent is used after API level 8 or higher level.

fill_parent: The view should be as big as its parent.

now this content fill_parent is deprecated and replaced by match_parent.

To me fill parent and match parent performs the same function only that:

fill parent: Was used before API 8

match parent This was used from API 8+ Function of Both Fills the parent view aside the padding

match_parent, which means that the view wants to be as big as its parent (minus padding).

wrap_content, which means that the view wants to be just big enough to enclose its content (plus padding)

For sake of better illustration, I have created a sample layout that demonstrate this concept. To see it's effect, I added a border of each textView content.

In "Match parent" textView content, we can see it's layout width spread out of it's parent whole length.

But we can see in "Wrap Content" textView content, it's layout width wrapped in of it's content(Wrap Content) length.

When you set layout width and height as match_parent in XML property, it will occupy the complete area that the parent view has, i.e. it will be as big as the parent.

<LinearLayout
    android:layout_width="300dp"
    android:layout_height="300dp"
    android:background="#f9b0b0">

    <TextView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="#b0f9dc"/>

</LinearLayout>

Hare parent is red and child is green. Child occupy all area. Because it's width and height are match_parent.

Note : If parent is applied a padding then that space would not be included.

<LinearLayout
    android:layout_width="300dp"
    android:layout_height="300dp"
    android:background="#f9b0b0"
    android:paddingTop="20dp"
    android:paddingBottom="10dp">

    <TextView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="#b0f9dc"/>

</LinearLayout>

So TextView hight = 300dp(parent hight) - (20(paddingTop)+10(paddingBottom)) = (300 - 30) dp = 270 dp

fill_parent Vs match_parent

fill_parent is previous name of match_parent

For API Level 8 and higher fill_parent renamed as match_parent and fill_parent is deprecated now.

So fill_parent and match_parent are same.

API Documentation for fill_parent

The view should be as big as its parent (minus padding). This constant is deprecated starting from API Level 8 and is replaced by {@code match_parent}.

FILL_PARENT was renamed MATCH_PARENT in API Level 8 and higher which means that the view wants to be as big as its parent (minus padding) - Google