En pocas palabras, layout_weight especifica cuánto espacio adicional del diseño se asignará a la vista.

LinearLayout permite asignar un peso a niños individuales. Este atributo asigna un valor de "importancia" a una vista, y le permite expandirse para llenar cualquier espacio restante en la vista padre. El peso predeterminado de las vistas es cero.

Cálculo para asignar cualquier espacio restante entre el hijo

En general, la fórmula es:

Espacio asignado to child = (peso individual del niño) / (suma del peso de cada niño en Diseño lineal)

Ejemplo 1

Si hay tres cuadros de texto y dos de ellos declaran un peso de 1, mientras que el tercero no tiene peso (0), entonces el espacio restante se asigna de la siguiente manera:

1er cuadro de texto= 1/(1+1+0)

2o cuadro de texto= 1/(1+1+0)

3er cuadro de texto = 0/(1+1+0)

Ejemplo 2

Digamos que tenemos una etiqueta de texto y dos texto editar elementos en una fila horizontal. La etiqueta no tiene layout_weight especificado, por lo que ocupa el espacio mínimo requerido para renderizar. Si el layout_weight de cada uno de los dos elementos de edición de texto se establece en 1, el ancho restante en el diseño padre se dividirá por igual entre ellos (porque afirmamos que son igualmente importantes).

Cálculo:

1ª etiqueta = 0/(0+1+1)

2o cuadro de texto= 1/(0+1+1)

3er cuadro de texto = 1/(0+1+1)

Si, en cambio, el el primer cuadro de texto tiene un layout_weight de 1, y el segundo cuadro de texto tiene un layout_weight de 2, luego un tercio del espacio restante se le dará al primero y dos tercios al segundo (porque afirmamos que el segundo es más importante).

Cálculo:

1ª etiqueta = 0/(0+1+2)

2o cuadro de texto= 1/(0+1+2)

3er cuadro de texto = 2/(0+1+2)

Artículo de origen

Agregando a las otras respuestas, lo más importante para que esto funcione es establecer el ancho (o alto) del diseño en 0px

android:layout_width="0px"

De lo contrario verás basura

Si hay varias vistas que abarcan un LinearLayout, entonces layout_weight les da a cada una un tamaño proporcional. Una vista con un valor layout_weight más grande "pesa" más, por lo que obtiene un espacio más grande.

Aquí hay una imagen para hacer las cosas más claras.

Teoría

El término layout weight está relacionado con el concepto de weighted average en matemáticas. Es como en una clase universitaria donde la tarea vale el 30%, la asistencia vale el 10% , el examen medio vale el 20%, y la final vale el 40%. Sus puntuaciones para esas partes, cuando se ponderan juntas, le dan su calificación total.

Es lo mismo para el peso del diseño. El Views en un LinearLayout horizontal puede cada uno tomar un cierto porcentaje de la anchura total. (O un porcentaje de la altura para una vertical LinearLayout.)

El Diseño

El LinearLayout que uses se verá algo como esto:

<LinearLayout
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:orientation="horizontal">

    <!-- list of subviews -->

</LinearLayout>

Tenga en cuenta que debe usar layout_width="match_parent" para LinearLayout. Si usa wrap_content, entonces no funcionará. También tenga en cuenta que layout_weight no funciona para las vistas en RelativeLayouts (ver aquí y aquí para las respuestas SO que tratan este tema).

Las vistas

Cada vista en horizontal LinearLayout se ve algo como esto:

<Button
    android:layout_width="0dp"
    android:layout_height="wrap_content"
    android:layout_weight="1" />

Tenga en cuenta que necesita usar layout_width="0dp" junto con layout_weight="1". Olvidar esto causa muchos problemas a los nuevos usuarios. (Vea este artículo para obtener diferentes resultados que puede obtener al no establecer el ancho en 0.) Si sus puntos de vista son en una vertical LinearLayout entonces usarías layout_height="0dp", por supuesto.

En el ejemplo anterior de Button puse el peso en 1, pero puedes usar cualquier número. Es solo el total lo que importa. Se puede ver en las tres filas de botones en la primera imagen que publiqué, los números son todos diferentes, pero como las proporciones son las mismas, los anchos ponderados no cambian en cada fila. A algunas personas les gusta usar números decimales que tienen una suma de 1 para que en un diseño complejo esté claro lo que el el peso de cada parte.

Una nota final. Si tiene muchos diseños anidados que usan layout_weight, puede ser malo para el rendimiento.

Extra

Aquí está el diseño xml para la imagen superior:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="android:layout_weight="
        android:textSize="24sp" />

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal">

        <Button
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:text="1" />

        <Button
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="2"
            android:text="2" />

        <Button
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:text="1" />

    </LinearLayout>

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="android:layout_weight="
        android:textSize="24sp" />

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal">

        <Button
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="10"
            android:text="10" />

        <Button
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="20"
            android:text="20" />

        <Button
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="10"
            android:text="10" />

    </LinearLayout>

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="android:layout_weight="
        android:textSize="24sp" />

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal">

        <Button
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight=".25"
            android:text=".25" />

        <Button
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight=".50"
            android:text=".50" />

        <Button
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight=".25"
            android:text=".25" />

    </LinearLayout>

</LinearLayout>

layout_weight le dice a Android cómo distribuir tus View s en un LinearLayout. Android primero calcula la proporción total requerida para todos los Viewque tienen un peso especificado y coloca cada View de acuerdo con la fracción de la pantalla que ha especificado que necesita. En el siguiente ejemplo, Android ve que los TextView s tienen un layout_weight de 0 (este es el valor predeterminado) y los EditText s tienen un layout_weight de 2 cada uno, mientras que el Button tiene un peso de 1. Así que Android asigna 'lo suficiente' espacio para mostrar tvUsername y tvPassword y luego divide el resto del ancho de la pantalla en 5 partes iguales, dos de las cuales se asignan a etUsername, dos a etPassword y la última parte a bLogin:

<LinearLayout android:orientation="horizontal" ...>

    <TextView android:id="@+id/tvUsername" 
    android:text="Username" 
    android:layout_width="wrap_content" ... />

    <EditText android:id="@+id/etUsername"
    android:layout_width="0dp"
    android:layout_weight="2" ... />

    <TextView android:id="@+id/tvPassword"
    android:text="Password"
    android:layout_width="wrap_content" />

    <EditText android:id="@+id/etPassword"
    android:layout_width="0dp"
    android:layout_weight="2" ... />

    <Button android:id="@+id/bLogin"
    android:layout_width="0dp"
    android:layout_weight="1"
    android:text="Login"... />

</LinearLayout>

Parece:
y

Piénsalo de esa manera, será más simple

Si tiene 3 botones y sus pesos son 1,3,1 en consecuencia, funcionará como una tabla en HTML

Proporcione 5 porciones para esa línea: 1 porción para el botón 1, 3 porción para el botón 2 y 1 porción para el botón 1

Atención,

Una de las mejores explicaciones para mí fue esta (del tutorial de Android, busque el paso 7):

Layout_weight se usa en LinearLayouts para asignar "importancia" a las Vistas dentro del layout. Todas las vistas tienen un layout_weight predeterminado de cero, lo que significa que ocupan solo el espacio en la pantalla que necesitan ser mostradas. La asignación de un valor superior a cero dividirá el resto del espacio disponible en la vista padre, de acuerdo con el valor de cada vista layout_weight y su relación con el layout_weight total especificado en el layout actual para este y otros elementos de la vista.

Para dar un ejemplo: digamos que tenemos una etiqueta de texto y dos elementos de edición de texto en una fila horizontal. La etiqueta no tiene layout_weight especificada, por lo que ocupa el espacio mínimo requerido para renderizar. Si el layout_weight de cada uno de los dos elementos de edición de texto se establece en 1, el ancho restante en el diseño padre se dividirá por igual entre ellos (porque reclamamos son igualmente importantes). Si el primero tiene un layout_weight de 1 y el segundo tiene un layout_weight de 2, entonces un tercio del espacio restante se le dará al primero, y dos tercios al segundo (porque afirmamos que el segundo es más importante).

Http://developer.android.com/guide/topics/ui/layout-objects.html#linearlayout

Layout_weight define cuánto espacio debe obtener el control respectivamente con respecto a otros controles.

Por favor mira el weightSum de LinearLayout y el layout_weight de cada vista. android: weightSum = " 4 "android: layout_weight =" 2 "android: layout_weight =" 2 " Su layout_height son ambos 0px, pero no estoy seguro de que sea relevan

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:orientation="vertical"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:weightSum="4">

<fragment android:name="com.example.SettingFragment"
    android:id="@+id/settingFragment"
    android:layout_width="match_parent"
    android:layout_height="0px"
    android:layout_weight="2"
    />

<Button
    android:id="@+id/dummy_button"
    android:layout_width="match_parent"
    android:layout_height="0px"
    android:layout_weight="2"
    android:text="DUMMY"
    />
</LinearLayout>

Para adicional ：

Para la orientación vertical, no olvides establecer height a 0dp

android:layout_height="0dp"

Para la orientación horizontal, no olvides establecer width a 0dp

android:layout_width="0dp"

Combinando ambas respuestas de

Flo & rptwsthi y roetzi,

Recuerde cambiar su layout_width=0dp/px, de lo contrario el comportamiento layout_weight actuará inversamente con el número más grande ocupado el espacio más pequeño y el número más bajo ocupado el espacio más grande.

Además, algunas combinaciones de pesos causarán que no se pueda mostrar algún diseño (ya que sobre ocupó el espacio).

Cuidado con esto.

Agregar android:autoSizeTextType="uniform" cambiará el tamaño del texto automáticamente

Como su nombre indica, Layout weight especifica la cantidad o porcentaje de espacio que un campo o widget en particular debe ocupar el espacio de la pantalla.
Si especificamos el peso en orientación horizontal, entonces debemos especificar layout_width = 0px.
Del mismo modo, si especificamos el peso en orientación vertical, entonces debemos especificar layout_height = 0px.