Sus nombres deberían ayudarte:

• android:gravity establece la gravedad de los contenidos (es decir, sus subvistas) de la View se usa en.
• android:layout_gravity establece la gravedad del View or Layout relativo a su padre.

Y un ejemplo es aquí.

Dentro fuera

• gravity organiza el contenido dentro la vista.
• layout_gravity organiza la posición de la vista afuera de sí mismo.

A veces también ayuda ver una imagen. El verde y el azul son TextViews y los otros dos colores de fondo son LinearLayouts.

Notas

• LA layout_gravity no funciona para vistas en un RelativeLayout. Úselo para vistas en un LinearLayout or FrameLayout. Mira mi respuesta suplementaria para más información.
• El ancho (o alto) de la vista debe ser mayor que su contenido. De lo contrario gravity no tendrá ningún efecto. Por lo tanto, wrap_content y gravity juntos no tienen sentido.
• El ancho (o alto) de la vista debe ser menor que el del padre. De lo contrario layout_gravity no tendrá ningún efecto. Por lo tanto, match_parent y layout_gravity juntos no tienen sentido.
• LA layout_gravity=center se ve igual que layout_gravity=center_horizontal aquí porque están en un diseño lineal vertical. No se puede centrar verticalmente en este caso, por lo que layout_gravity=center solo se centra horizontalmente.
• Esta respuesta solo se refirió a la configuración gravity y layout_gravity en las vistas dentro de un diseño. Para ver qué sucede cuando configura el gravity del diseño principal en sí, consulte el respuesta suplementaria al que me referí anteriormente. (Resumen: gravity no funciona bien en un RelativeLayout pero puede ser útil con un LinearLayout.)

Así que recuerda, diseño_gravity organiza una vista en su diseño. Gravity organiza el contenido dentro de la vista.

xml

Aquí está el xml de la imagen de arriba para su referencia:

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

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1"
        android:background="#e3e2ad"
        android:orientation="vertical" >

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="center_horizontal"
            android:textSize="24sp"
            android:text="gravity=" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:background="#bcf5b1"
            android:gravity="left"
            android:text="left" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:background="#aacaff"
            android:gravity="center_horizontal"
            android:text="center_horizontal" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:background="#bcf5b1"
            android:gravity="right"
            android:text="right" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:background="#aacaff"
            android:gravity="center"
            android:text="center" />

    </LinearLayout>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1"
        android:background="#d6c6cd"
        android:orientation="vertical" >

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

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:layout_gravity="left"
            android:background="#bcf5b1"
            android:text="left" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:layout_gravity="center_horizontal"
            android:background="#aacaff"
            android:text="center_horizontal" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:layout_gravity="right"
            android:background="#bcf5b1"
            android:text="right" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:layout_gravity="center"
            android:background="#aacaff"
            android:text="center" />

    </LinearLayout>

</LinearLayout>

Relacionado:

• Diferencia entre el relleno y el margen de una vista
• Match_parent frente a wrap_content
• Cómo establecer la gravedad y la gravedad del diseño de un LinearLayout mediante programación

La diferencia

android:layout_gravity son los fuera gravedad de la vista. Especifica la dirección en la que la vista debe tocar el borde de su padre.

android:gravity son los Dentro de gravedad de esa Vista. Especifica en qué dirección debe alinearse su contenido.

Equivalentes HTML / CSS

(si viene con experiencia en desarrollo web)

Android                 | CSS
————————————————————————+————————————
android:layout_gravity  | float
android:gravity         | text-align

Truco fácil para ayudarte a recordar

¡ES HORA layout-gravity como "Lay-outside-gravity".

Respuesta corta: use android:gravity or setGravity() para controlar la gravedad de todas las vistas de los niños de un contenedor; usar android:layout_gravity or setLayoutParams() para controlar la gravedad de una vista individual en un contenedor.

Larga historia: para controlar la gravedad en un contenedor de diseño lineal como LinearLayout or RadioGroup, hay dos enfoques:

1) Para controlar la gravedad de TODAS las vistas de los niños de un LinearLayout contenedor (como lo hizo en su libro), use android:gravity (¿No estás registrado como android:layout_gravity) en el archivo XML de diseño o setGravity() método en código.

2) Para controlar la gravedad de una vista infantil en su contenedor, use android:layout_gravity Atributo XML. En el código, uno necesita obtener el LinearLayout.LayoutParams de la vista y establezca su gravedad. Aquí hay un ejemplo de código que establece un botón en la parte inferior de un contenedor orientado horizontalmente:

import android.widget.LinearLayout.LayoutParams;
import android.view.Gravity;
...

Button button = (Button) findViewById(R.id.MyButtonId);
// need to cast to LinearLayout.LayoutParams to access the gravity field
LayoutParams params = (LayoutParams)button.getLayoutParams(); 
params.gravity = Gravity.BOTTOM;
button.setLayoutParams(params);

Para horizontal LinearLayout contenedor, la gravedad horizontal de su vista secundaria se alinea a la izquierda una tras otra y no se puede cambiar. Configuración android:layout_gravity a center_horizontal no tiene efecto. La gravedad vertical predeterminada es center (o center_vertical) y se puede cambiar a arriba o abajo. En realidad, el predeterminado layout_gravity Valor es -1 pero Android lo puso en el centro verticalmente.

Para cambiar las posiciones horizontales de las vistas secundarias en un contenedor lineal horizontal, se puede usar layout_weight, margen y relleno de la vista secundaria.

De manera similar, para el contenedor Grupo de vistas vertical, la gravedad vertical de su vista secundaria está alineada en la parte superior una debajo de la otra y no se puede cambiar. La gravedad horizontal predeterminada es el centro (o center_horizontal) y se puede cambiar a izquierda o derecha.

En realidad, una vista secundaria como un botón también tiene android:gravity Atributo XML y el setGravity() método para controlar sus vistas secundarias: el texto que contiene. La Button.setGravity(int) está vinculado a esto entrada developer.android.com.

De lo que puedo reunir diseño_gravedad es la gravedad de esa vista dentro de su padre, y gravedad es la gravedad de los niños dentro de esa vista.

Creo que esto es correcto, pero la mejor manera de averiguarlo es jugando.

Mira la imagen para tener claridad sobre la gravedad.

Si queremos establecer la gravedad del contenido dentro de una vista, usaremos "android: gravity", y si queremos establecer la gravedad de esta vista (como un todo) dentro de su vista principal, usaremos "android: layout_gravity ".

Un truco fácil de recordar es que la gravedad se aplica a nosotros dentro de la tierra. Entonces, android:gravity es para dentro la vista.

Recuerda el salir in ponersalir_gravedad que te ayudaría a recordar eso android:layout_gravity se referiría a afuera la vista

Solo pensé en agregar mi propia explicación aquí, viniendo de un contexto en iOS, así es como he internalizado los dos en términos de iOS: "Layout Gravity" afecta su posición en la supervista. La "gravedad" afecta la posición de sus subvistas dentro de usted. Dicho de otra manera, Layout Gravity lo posiciona usted mismo mientras que la gravedad posiciona a sus hijos.

Hay muchas diferencias en el gravity y layout-gravity. Voy a explicar mi experiencia sobre estos 2 conceptos (Toda la información que obtuve debido a mi observación y algunos sitios web.).

Uso de gravedad y gravedad de diseño en FrameLayout .....

Nota: -

1. Gravedad se usa dentro del Ver contenido ya que algunos usuarios tienen respuesta y es igual para todos ViewGroup Layout.

2. Layout-gravity se usa con la vista principal ya que algunos usuarios tienen respuesta.

3. Gravity and Layout-gravity is trabajar más útil con el FrameLayout niños. We can't use Gravity and Layout-gravity en la etiqueta de FrameLayout ...

4. Podemos configurar Child View en cualquier lugar de la FrameLayout usando layout-gravity .

5. Podemos usar todos los valores de gravedad dentro del FrameLayout (por ejemplo: - center_vertical, center_horizontal, center,top, etc.), pero no es posible con otros diseños de ViewGroup.

6. FrameLayout trabajando completamente en Layout-gravity. Ejemplo: - si trabaja en FrameLayout entonces tú no es necesario cambiar el diseño completo para agregar una nueva vista. Tu solo agregar vista como último en el FrameLayout y darle Layout-gravity con valor. (Estas son las ventajas de la gravedad del diseño con FrameLayout).

mira el ejemplo ...

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

    <TextView
        android:layout_width="match_parent"
        android:layout_height="100dp"
        android:textSize="25dp"
        android:background="#000"
        android:textColor="#264bd1"
        android:gravity="center"
        android:layout_gravity="center"
        android:text="Center Layout Gravity"/>

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="80dp"
        android:textSize="25dp"
        android:background="#000"
        android:textColor="#1b64b9"
        android:gravity="bottom"
        android:layout_gravity="bottom|center"
        android:text="Bottom Layout Gravity" />

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="80dp"
        android:textSize="25dp"
        android:background="#000"
        android:textColor="#d75d1c"
        android:gravity="top"
        android:layout_gravity="top|center"
        android:text="Top Layout Gravity"/>

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="80dp"
        android:textSize="25dp"
        android:background="#000"
        android:layout_marginTop="100dp"
        android:textColor="#d71f1c"
        android:gravity="top|right"
        android:layout_gravity="top|right"
        android:text="Top Right Layout Gravity"/>


    <TextView
        android:layout_width="wrap_content"
        android:layout_height="80dp"
        android:textSize="25dp"
        android:background="#000"
        android:layout_marginBottom="100dp"
        android:textColor="#d71cb2"
        android:layout_gravity="bottom"
        android:gravity="bottom"
        android:text="Top Left Layout Gravity"/>

</FrameLayout>

Salida:-

Uso de gravedad y distribución-gravedad en LinearLayout .....

Gravity funciona igual que el anterior, pero aquí la diferencia es que podemos usar Gravity dentro del LinearLayout View y RelativeLayout View que no es posible en FrameLayout View.

LinearLayout con orientación vertical ....

Nota: - Aquí podemos establecer solo 3 valores de layout_gravity es decir (left | right | center (también llamado center_horizontal)).

mira el ejemplo: -

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

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="100dp"
        android:textSize="25dp"
        android:background="#000"
        android:textColor="#264bd1"
        android:gravity="center"
        android:layout_gravity="center_horizontal"
        android:text="Center Layout Gravity \nor \nCenter_Horizontal"/>

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="80dp"
        android:textSize="25dp"
        android:background="#000"
        android:layout_marginTop="20dp"
        android:textColor="#d75d1c"
        android:layout_gravity="right"
        android:text="Right Layout Gravity"/>


    <TextView
        android:layout_width="wrap_content"
        android:layout_height="80dp"
        android:textSize="25dp"
        android:background="#000"
        android:layout_marginBottom="100dp"
        android:textColor="#d71cb2"
        android:layout_gravity="left"
        android:layout_marginTop="20dp"
        android:gravity="bottom"
        android:text="Left Layout Gravity"/>

</LinearLayout>

Salida:-

LinearLayout con orientación horizontal ....

Nota: - Aquí también podemos configurar 3 valores de layout_gravity es decir (top | bottom | center (también llamado center_vertical)).

mira el ejemplo: -

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

    <TextView
        android:layout_width="120dp"
        android:layout_height="100dp"
        android:textSize="25dp"
        android:background="#000"
        android:textColor="#264bd1"
        android:gravity="center"
        android:layout_gravity="bottom"
        android:text="Bottom \nLayout \nGravity"/>

    <TextView
        android:layout_width="120dp"
        android:layout_height="100dp"
        android:textSize="25dp"
        android:background="#000"
        android:layout_marginTop="20dp"
        android:textColor="#d75d1c"
        android:layout_gravity="center"
        android:text="Center \nLayout \nGravity"/>


    <TextView
        android:layout_width="150dp"
        android:layout_height="100dp"
        android:textSize="25dp"
        android:background="#000"
        android:layout_marginBottom="100dp"
        android:textColor="#d71cb2"
        android:layout_gravity="left"
        android:layout_marginTop="20dp"
        android:text="Left \nLayout \nGravity"/>

</LinearLayout>

producción:-

Nota: - No podemos usar layout_gravity en el capítulo respecto a la RelativeLayout Views pero podemos usar gravity para establecer RelativeLayout niños en la misma posición ....

Algo que vi en el blog de Sandip que casi me pierdo, solucionó mi problema. Él dijo layout_gravity NO FUNCIONA CON LinearLayout.

Si está usando un LinearLayout y la configuración de la gravedad te está volviendo loco (como yo), luego cambia a otra cosa.

De hecho, cambié a un RelativeLayout luego usado layout_alignParentLeft y layout_alignParentRight en el 2 contenido TextViews para ponerlos en una línea para ir a la izquierda y a la derecha.

La diferencia básica entre los dos es que-

android: gravedad se utiliza para elementos secundarios de la vista.

android: layout_gravity se utiliza para este elemento con respecto a la vista principal.

android:gravity se utiliza para especificar cómo colocar el contenido del objeto dentro del propio objeto. En otras palabras, android: gravity se usa para especificar la gravedad del contenido de la vista.

android:layout_gravity es una atribución que el niño puede proporcionar a su padre, para especificar la gravedad de la vista dentro de sus padres.

Para más detalles puede visitar

http://developer.android.com/reference/android/widget/LinearLayout.LayoutParams.html

Gravedad: Le permite mover el contenido dentro de un contenedor. (Cómo se colocarán las subvistas).

Importante: (MOVER a lo largo del eje X o del eje Y dentro del espacio disponible).

Ejemplo: Digamos que si tuviera que trabajar con LinearLayout (Alto: match_parent, Width: match_parent) como elemento de nivel raíz, entonces tendrá espacio de fotograma completo disponible; y las vistas secundarias dicen 2 TextViews (Height: wrap_content, Width: wrap_content) dentro del LinearLayout se pueden mover a lo largo del eje x / y usando los valores correspondientes para la gravedad en el padre.

Diseño_Gravedad: Le permite anular el comportamiento de la gravedad principal SÓLO a lo largo del eje x.

Importante: (MOVER [anular] a lo largo del eje X dentro del espacio disponible).

Ejemplo: Si tiene en cuenta el ejemplo anterior, sabemos que la gravedad nos permitió movernos a lo largo del eje x / y, es decir; el lugar TextViews dentro de LinearLayout. Digamos que LinearLayout especifica la gravedad: centro; lo que significa que cada TextView debe estar centrado tanto vertical como horizontalmente. Ahora, si queremos que uno de los TextView vaya hacia la izquierda / derecha, podemos anular el comportamiento de gravedad especificado usando layout_gravity en TextView.

Bonificación: si profundiza, descubrirá que el texto dentro de TextView actúa como subvista; por lo que si aplica la gravedad en TextView, el texto dentro de TextView se moverá. (todo el concepto se aplica aquí también)

La gravedad se usa para establecer la alineación del texto en las vistas, pero layout_gravity se usa para establecer las vistas. Tomemos un ejemplo si desea alinear el texto escrito en editText y luego use la gravedad y desea alinear este editText o cualquier botón o cualquier vista y luego use layout_gravity, así que es muy simple.

gravedad: se utiliza para vistas simples como vista de texto, editar texto, etc.

diseño_gravedad: se usa para la gravedad de la vista actual solo en el contexto de su vista principal relativa, como Diseño lineal o FrameLayout, para hacer la vista en el centro o cualquier otra gravedad de su padre.

LA android:gravity establece la gravedad (posición) de los niños mientras que el android:layout_gravity establece la posición de la vista en sí. Espero eso ayude

android:gravity

se utiliza para ajustar el contenido de la vista en relación con su posición específica (área asignada). android:gravity="left" no haría nada si layout_width es igual a "wrap_content"

android:layout_gravity 

se utiliza para visualizarse en sí mismo en relación con el archivo principal o de diseño.

android:gravity -> Establece la gravedad del contenido de la Vista en la que se usa.

android:layout_gravity -> Establece la gravedad de la vista o el diseño de su padre

gravedad: se aplica a su propia vista.

layout-gravity --- Se aplica a la vista relacionada con su padre.