Różnica

android:layout_gravity jest zewnętrzną grawitacją widoku. Określa kierunek, w którym Widok powinien dotykać obramowania swojego rodzica.

android:gravity jest wewnątrz grawitacji tego widoku. Określa, w którym kierunku ma być wyrównana jego zawartość.

Odpowiedniki HTML/CSS

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

Łatwy trik, który pomoże Ci zapamiętać

Weźmy layout-gravity jako "leżącą-zewnętrzną-grawitację".

Inside-Outside

• gravity porządkuje Zawartośćwewnątrz widoku.
• layout_gravity układa pozycję widokuNa Zewnątrz samego siebie.

Czasami pomaga też zobaczyć zdjęcie. Zielony i niebieski to TextViews, a pozostałe dwa kolory tła to LinearLayouts.

Uwagi

• layout_gravity nie działa dla widoków w RelativeLayout. Użyj go do wyświetlenia w LinearLayout lub FrameLayout. Zobacz moje odpowiedź uzupełniająca aby uzyskać więcej szczegółów.
• szerokość (lub wysokość) widoku musi być większa niż jego zawartość. W przeciwnym razie gravity nie będzie miało żadnego efektu. Tak więc wrap_content i gravity są razem bez znaczenia.
• szerokość (lub wysokość) widoku musi być mniejsza od rodzica. W przeciwnym razie layout_gravity nie będzie miało żadnego efektu. Tak więc match_parent i layout_gravity są razem bez znaczenia.
• layout_gravity=center wygląda tak samo jak layout_gravity=center_horizontal tutaj, ponieważ są w pionowym układzie liniowym. Nie możesz wyśrodkować w tym przypadku pionowo, więc layout_gravity=center tylko centruje poziomo.
• ta odpowiedź dotyczyła tylko ustawienia gravity i layout_gravity na widokach w układzie. Aby zobaczyć, co się stanie, gdy ustawisz gravity samego układu nadrzędnego, sprawdź odpowiedź uzupełniającą , o której wspomniałem powyżej. (Podsumowanie: gravity nie działa dobrze na RelativeLayout, ale może być przydatne z LinearLayout.)

więc pamiętaj, układ _gravity układa widok w swoim układzie . Grawitacja porządkuje treść wewnątrz widoku.

Xml

Oto xml dla powyższego obrazu w celach informacyjnych:

<?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>

Powiązane

• różnica między wypełnieniem a marginesem widoku
• Match_parent vs wrap_content
• Jak ustawić zarówno grawitację, jak i grawitację układu LinearLayout programowo

Krótka odpowiedź: użyj android:gravity lub setGravity() do kontrolowania grawitacji wszystkich widoków potomnych kontenera; użyj android:layout_gravity lub setLayoutParams() do kontrolowania grawitacji pojedynczego widoku w kontenerze.

Długa historia: aby kontrolować grawitację w kontenerze układu liniowego, takim jak LinearLayout lub RadioGroup, istnieją dwa podejścia:

1) aby kontrolować grawitację wszystkich widoków potomnych kontenera LinearLayout (tak jak w książce), użyj android:gravity (nie android:layout_gravity) w pliku XML układu lub metody setGravity() w kodzie.

2) aby kontrolować grawitacja widoku potomnego w jego kontenerze, użyj atrybutu android:layout_gravity XML. W kodzie należy uzyskać LinearLayout.LayoutParams widoku i ustawić jego grawitację. Oto przykład kodu, który ustawia przycisk na dole w poziomo zorientowanym kontenerze: {]}

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);

Dla kontenera poziomego LinearLayout, pozioma grawitacja jego widoku potomnego jest wyrównana do lewej jeden po drugim i nie może być zmieniana. Ustawienie android:layout_gravity na center_horizontal nie ma wpływu. Domyślną grawitacją pionową jest środek (lub center_vertical) i można ją zmienić na Góra lub dół. W rzeczywistości domyślną wartością layout_gravity jest -1, Ale Android umieścił ją na środku pionowo.

Aby zmienić poziome pozycje widoków potomnych w poziomym kontenerze liniowym, można użyć layout_weight, margin i padding widoku potomnego.

Podobnie w przypadku kontenera grupy widoku pionowego, pionowa grawitacja jego widoku potomnego jest wyrównana do góry jeden pod drugim i nie może być zmieniona. Domyślną poziomą grawitacją jest środek (lub center_horizontal) i można ją zmienić na lewą lub racja.

W rzeczywistości widok potomny, taki jak przycisk, ma również atrybut android:gravity XML i metodę setGravity() do kontrolowania widoków potomnych -- tekstu w nim. Button.setGravity(int) jest powiązany z tym developer.android.com wpis .

Z tego, co mogę zebrać layout_gravity jest grawitacją tego widoku wewnątrz jego rodzica, agrawitacją jest grawitacją dzieci wewnątrz tego widoku.

Myślę, że to słuszne, ale najlepszym sposobem, aby się dowiedzieć, jest pobawić się.

Spójrz na zdjęcie, aby było jasne o grawitacji

Chociaż pytanie jest już odpowiedział Mam kilka próbek demonstrujących użycie grawitacji, layout_gravity, i layout_weight.

Przykłady znajdziesz na stronie http://juanpickselov.com/LayoutExamples.zip

Utworzyłem pliki w Eclipse, usunąłem .podfoldery svn i zawierają style, ciągi, kolory itp. Pliki układu są głównym punktem dema. Ponieważ jestem początkującym programistą Javy i Androida, może się okazać, że Java jest nieefektywna. Pliki mogą być skopiowane do projektu Eclipse lub używałem ich również w Netbeans z wtyczką Android development dostępną dla tego IDE.

Jeśli a chcemy ustawić grawitację zawartości wewnątrz widoku, użyjemy "android: gravity", a jeśli chcemy ustawić grawitację tego widoku (jako całości) w jego widoku nadrzędnym, użyjemy"android:layout_gravity".

Pomyślałem, że dodam tutaj własne wyjaśnienie - pochodząc z tła na iOS, tak zinternalizowałem te dwa w kategoriach iOS: "grawitacja układu" wpływa na Twoją pozycję w superview. "Grawitacja" wpływa na położenie Twoich podwidań wewnątrz ciebie. Powiedział w inny sposób, układ grawitacji pozycjonuje Ciebie, podczas gdy grawitacja pozycjonuje twoje dzieci.

Istnieje wiele różnic w gravity i layout-gravity. Zamierzam wyjaśnić moje doświadczenie na temat tych 2 pojęć ( wszystkie informacje, które dostałem dzięki mojej obserwacji i niektórych stron internetowych ).

Wykorzystanie grawitacji i układu-grawitacja w FrameLayout .....

Uwaga:-

1. Gravity {[42] } jest używana wewnątrz widoku zawartość , ponieważ niektórzy użytkownicy mają odpowiedź i jest ona taka sama dla wszystkich ViewGroup Layout.

2. Layout-gravity jest stosowany z widok rodzica, ponieważ niektórzy użytkownicy mają odpowiedź.

3. Gravity and Layout-gravity czy praca bardziej przydatna Z FrameLayout dzieci . We can't use Gravity and Layout-gravity w tagu FrameLayout ....

4. Możemy ustawić widok potomny w dowolnym miejscu FrameLayout używając layout-gravity.

5. Możemy użyć każdej pojedynczej wartości grawitacji wewnątrz FrameLayout (np.:- center_vertical, center_horizontal, center,top, itd), ale nie jest to możliwe w przypadku innych układów ViewGroup .

6. FrameLayout w pełni pracuje nad Layout-gravity. Przykład: - jeśli pracuj nad FrameLayout wtedy nie musisz zmieniać całego układu aby dodać nowy widok. Wystarczy dodać Widok jako ostatni w FrameLayout i dać mu Layout-gravity z wartością.( to jest awantury układu-grawitacji z FrameLayout ).

Spójrz na przykład ......

<?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>

Wyjście:-

Użycie grawitacji i Layout-grawitacja w LinearLayout .....

Gravity działa tak samo jak wyżej ale tutaj różnica polega na tym, że możemy użyć grawitacji wewnątrz LinearLayout View i RelativeLayout View, co nie jest możliwe w FrameLayout View.

LinearLayout z orientacją pionową ....

Notatka: - tutaj możemy ustawić tylko 3 wartości layout_gravity czyli (left | right | center (zwany także center_horizontal)).

Spójrz na przykład: -

<?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>

Wyjście:-

LinearLayout z orientacją poziomą ....

Notatka: - tutaj możemy ustawić również 3 wartości layout_gravity czyli (top | bottom | center (zwany także center_vertical)).

Spójrz na przykład:-

<?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>

Wyjście:-

Uwaga:- nie możemy użyć layout_gravity w RelativeLayout Views, ale możemy użyć gravity, aby ustawić RelativeLayout childs na tej samej pozycji....

Coś, co widziałem na blogu Sandipa, że prawie przegapiłem, naprawił mój problem. Powiedział, że layout_gravity nie działa z LinearLayout.

Jeśli używasz LinearLayout i ustawienia grawitacji doprowadzają cię do szału (jak ja), przełącz się na coś innego.

Przełączyłem się na RelativeLayout, a następnie użyłem layout_alignParentLeft i layout_alignParentRight na 2 zawarte TextView s, aby je na jednej linii przejść daleko w lewo i daleko w prawo.

Łatwo zapamiętać, że grawitacja dotyczy nas wewnątrz Ziemi. Więc {[0] } jest dla wewnątrz widoku.

Zapamiętaj out in lay out _gravity co pomoże Ci zapamiętać, że android:layout_gravity będzie odnosić się do OUT widoku

android:gravity służy do określenia sposobu umieszczenia zawartości obiektu w samym obiekcie. Innymi słowy, android: gravity jest używany do określenia grawitacji zawartości widoku.

android:layout_gravity jest atrybucją, którą dziecko może dostarczyć swojemu rodzicowi, aby określić powagę widoku w jego rodzicach.

Więcej szczegółów można znaleźć na stronie

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

Podstawowa różnica między tymi dwoma jest taka, że-

Android: gravity jest używany do dziecięcych elementów widoku.

Android: layout_gravity jest używany dla tego elementu w odniesieniu do widoku nadrzędnego.

Gravity: pozwala przenieść zawartość wewnątrz kontenera. (Jak będą umieszczane pod-widoki).

Ważne: (poruszaj się wzdłuż osi X lub osi Y w dostępnej przestrzeni).

Przykład: Załóżmy, że jeśli masz pracować z LinearLayout (Height: match_parent, Width: match_parent) jako głównym elementem poziomu, to będziesz mieć dostęp do pełnej klatki; a widoki potomne mówią, że 2 widoki tekstowe (Height: wrap_content, Width: wrap_content) wewnątrz LinearLayout może być poruszał się wzdłuż osi x / y, używając odpowiednich wartości grawitacji na rodzicu.

Layout_gravity: pozwala na nadpisanie nadrzędnego zachowania grawitacyjnego tylko wzdłuż osi X.

Ważne: (Przesuń [override] wzdłuż osi X w dostępnej przestrzeni).

Przykład: jeśli pamiętamy o poprzednim przykładzie, wiemy, że grawitacja umożliwiła nam poruszanie się wzdłuż osi x / y, czyli umieszczanie podglądów tekstu wewnątrz LinearLayout. Powiedzmy, że LinearLayout określa grawitację: środek; oznacza to, że każdy widok tekstu musi być wyśrodkowany zarówno w pionie, jak i w poziomie. Teraz, jeśli chcemy, aby jeden z TextView poszedł w lewo/w prawo, możemy nadpisać określone zachowanie grawitacji za pomocą layout_gravity na TextView.

Bonus: jeśli kopiesz głębiej, dowiesz się, że tekst w widoku tekstowym działa jako podgląd podrzędny; więc jeśli zastosujesz grawitację w widoku tekstowym, tekst wewnątrz widoku tekstowego będzie się poruszać. (cała koncepcja ma zastosowanie również tutaj)

Gravity służy do ustawiania wyrównania tekstu w widokach, ale layout_gravity służy do ustawiania widoków. Weźmy przykład jeśli chcesz wyrównać tekst napisany w editText następnie użyj gravity i chcesz wyrównać ten editText lub dowolny przycisk lub dowolny widok, a następnie użyj layout_gravity, więc jest to bardzo proste.

Gravity: służy do prostych widoków, takich jak textview, edittext itp.

Layout_gravity: jest używany do bieżącego widoku tylko grawitacji w kontekście jego względnego widoku nadrzędnego, takiego jak układ liniowy lub FrameLayout, aby Widok był środkowy lub inny ciężar jego rodzica.

android:gravity

Służy do dostosowania zawartości widoku względem jego określonej pozycji (przydzielonego obszaru). android:gravity="left" nie zrobiłby nic, jeśli layout_width jest równe "wrap_content"

android:layout_gravity 

Jest używany do wyświetlania samego względem pliku nadrzędnego lub układu.

android:gravity -> Ustawia wagę zawartości widoku, na której jest używany.

android:layout_gravity -> ustawia grawitację widoku lub układu rodzica