public final void measure(int widthMeasureSpec, int heightMeasureSpec) {

            ......

            if (cacheIndex < 0 || sIgnoreMeasureCache) {
                // measure ourselves, this should set the measured dimension flag back
                onMeasure(widthMeasureSpec, heightMeasureSpec);
                mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
            } else {
                long value = mMeasureCache.valueAt(cacheIndex);
                // Casting a long to int drops the high 32 bits, no mask needed
                setMeasuredDimensionRaw((int) (value >> 32), (int) value);
                mPrivateFlags3 |= PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
            }

            ......

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
                getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
}

protected final void setMeasuredDimension(int measuredWidth, int measuredHeight){
    boolean optical = isLayoutModeOptical(this);
    if (optical != isLayoutModeOptical(mParent)) {
        Insets insets = getOpticalInsets();
        int opticalWidth  = insets.left + insets.right;
        int opticalHeight = insets.top  + insets.bottom;

        measuredWidth  += optical ? opticalWidth  : -opticalWidth;
        measuredHeight += optical ? opticalHeight : -opticalHeight;
    }
    setMeasuredDimensionRaw(measuredWidth, measuredHeight);
}

public static int getDefaultSize(int size, int measureSpec) {
    int result = size;
    int specMode = MeasureSpec.getMode(measureSpec);
    int specSize = MeasureSpec.getSize(measureSpec);

    switch (specMode) {
        case MeasureSpec.UNSPECIFIED:
            result = size;
            break;
        case MeasureSpec.AT_MOST:
        case MeasureSpec.EXACTLY:
            result = specSize;
            break;
    }
    return result;
}

private static final int MODE_MASK  = 0x3 << MODE_SHIFT;

public static int getMode(int measureSpec) {
    return (measureSpec & MODE_MASK);
}

public static int getSize(int measureSpec) {
    return (measureSpec & ~MODE_MASK);
}

@Override
    protected abstract void onLayout(boolean changed,int l, int t, int r, int b);

protected void onLayout(boolean changed, int l, int t, int r, int b) {
    if (mOrientation == VERTICAL) {
        layoutVertical(l, t, r, b);
    } else {
        layoutHorizontal(l, t, r, b);
    }
}

for (int i = 0; i < count; i++) {

    ......

    switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) {
        case Gravity.CENTER_HORIZONTAL:
            childLeft = paddingLeft + ((childSpace - childWidth) / 2)
                                + lp.leftMargin - lp.rightMargin;
            break;

         case Gravity.RIGHT:
            childLeft = childRight - childWidth - lp.rightMargin;
            break;

        case Gravity.LEFT:
        default:
            childLeft = paddingLeft + lp.leftMargin;
            break;
    }

    ......

}

Matrix matrix = new Matrix();
matrix.preRotate(45);
matrix.postTranslate(200, 0);
canvas.setMatrix(matrix);
canvas.drawBitmap(bitmap, 100, 100, paint);

camera.rotateX(30);
canvas.translate(centerX, centerY); 
camera.applyToCanvas(canvas); 
canvas.translate(-centerX, -centerY);

activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);

SCREEN_ORIENTATION_PORTRAIT
SCREEN_ORIENTATION_LANDSCAPE
SCREEN_ORIENTATION_REVERSE_PORTRAIT
SCREEN_ORIENTATION_LANDSCAPE

private class IncallOrientationListener extends OrientationEventListener {
    public IncallOrientationListener(Context context) {
        super(context);
    }

    @Override
    public void onOrientationChanged(int orientation) {
        //do anything what we want
        orientationUtils.onOrientationChanged(getApplicationContext(), orientation);
    }     
}

public static boolean isTablet(Context context) {
        return (context.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) >= Configuration.SCREENLAYOUT_SIZE_LARGE;
    }

WindowManager wm = (WindowManager) getSystemService(Context.WINDOW_SERVICE);
DisplayMetrics metrics = new DisplayMetrics();
wm.getDefaultDisplay().getMetrics(metrics);
int heightPixels = metrics.heightPixels;
Log.d(TAG, "heightPixels :" + heightPixels);
int widthPixels = metrics.widthPixels;
Log.d(TAG, "widthPixels :" + widthPixels);

public final class ExampleObject {
   public static final ExampleObject INSTANCE;

   public final void example() {
   }

   static {
      ExampleObject var0 = new ExampleObject();
      INSTANCE = var0;
   }
}

public class Single {
    public static Single single = new Single();
}

public static void main(String[] args) {
        Single single = Single.single;
        System.out.println(single);
        Single single1 = Single.single;
        System.out.println(single1);
}

public class Single {

    private static class SingleHoleder {
        private static Single single = new Single();
    }

    public static Single getInstance() {
        return SingleHoleder.single;
    }
}

public final class Test {
   private static final int i = 1;
   @NotNull
   private static final Test instance = new Test();
   public static final Test.Companion Companion = new Test.Companion((DefaultConstructorMarker)null);

   public static final class Companion {
      public final int getI() {
         return Test.i;
      }

      @NotNull
      public final Test getInstance() {
         return Test.instance;
      }

      private Companion() {
      }

      // $FF: synthetic method
      public Companion(DefaultConstructorMarker $constructor_marker) {
         this();
      }
   }
}

public class SingleListDemo {  
    public static void main(String[] args) {  
        SList<String> list = new SList<>();  
  SListIterator iterator = list.iterator();  
  iterator.insert("wang");  
  System.out.println(list);  
  iterator.insert("shen");  
  System.out.println(list);  
  iterator.insert("xing");  
  System.out.println(list);  
  
  SListIterator iterator1 = list.iterator();  
  iterator1.remove();  
  System.out.println(list);  
  }  
}  
  
class SList<E> {  
    Link<E> head = new Link<>(null);  
  
 public SListIterator iterator() {  
        return new SListIterator<E>(head);  
  }  
  
    @Override  
  public String toString() {  
        if (head.next == null) {  
            return "[]";  
        } else {  
            System.out.print("[");  
            StringBuilder stringBuilder = new StringBuilder();  
            SListIterator iterator = this.iterator();  
            while (iterator.hasNext()) {  
                stringBuilder.append(iterator.next() + (iterator.hasNext() ? "," : ""));  
            }  
            return stringBuilder + "]";  
        }  
    }  
}  
  
class Link<E> {  
    E e;  
    Link<E> next;  
    public Link(E e) {  
        this.e = e;  
    }  
    public Link(E e, Link<E> next) {  
        this.e = e;  
        this.next = next;  
    }  
    @Override  
    public String toString() {  
        return e != null ? e.toString() : null;  
    }  
}  
  
class SListIterator<E> {  
    Link<E> current;  
  
    public SListIterator(Link<E> current) {  
        this.current = current;  
    }  
  
    public boolean hasNext() {  
        return current.next != null;  
    }  
  
    public void insert(E e) {  
        current.next = new Link<>(e);  
        current = current.next;  
    }  
  
    public void remove() {  
        if (current.next != null)  
            current.next = current.next.next;  
    }  
  
    public Link<E> next() {  
        current = current.next;  
        return current;  
    }  
}

public class MySortedSetDemo {  
    public static void main(String[] args) {  
        MySortedSet<Integer> integerMySortedSet = new MySortedSet<>();  
        integerMySortedSet.add(6);  
        integerMySortedSet.add(8);  
        integerMySortedSet.add(2);  
        integerMySortedSet.add(5);  
        integerMySortedSet.add(2);  
        integerMySortedSet.add(7);  
        System.out.println(integerMySortedSet);  
        MySortedSet<String> stringMySortedSet = new MySortedSet<>();  
        stringMySortedSet.add("wang");  
        stringMySortedSet.add("shen");  
        stringMySortedSet.add("xing");  
        stringMySortedSet.add("is");  
        stringMySortedSet.add("good");  
        stringMySortedSet.add("is");  
        stringMySortedSet.add("cool");  
        System.out.println(stringMySortedSet);  
    }  
}  
class MySortedSet<E> extends LinkedList<E> {  
    public int compare(E e1, E e2) {  
        System.out.println(e1.hashCode());  
        System.out.println(e2.hashCode());  
        int result = e1.hashCode() - e2.hashCode();  
        return Integer.compare(result, 0);  
    }  
    public boolean add(E e) {  
        if (!this.contains(e)) {  
            Iterator<E> iterator = this.iterator();  
            int index = 0;  
            while (iterator.hasNext()) {  
                if (compare(iterator.next(), e) < 1) {  
                    index++;  
                }  
            }  
            add(index, e);  
            return true;  
        }  
        return false;  
  }  
}

List<Integer> list = Arrays.asList(1,2,3);  
list.add(4);
//Runtime error Because the array cannot be resized

public static <T> List<T> asList(T... a) {  
    return new ArrayList<>(a);  
}

public class Prediction {
    private static Random random = new Random(47);
    private boolean shadow = random.nextDouble() > 0.5;
    @Override
    public String toString() {
        if (shadow) {
            return "Six more ";
        } else {
            return "early spring";
        }
    }
}
public class Groundhog {
    protected int number;

    public Groundhog(int number) {
        this.number = number;
    }

    @Override
    public String toString() {
        return "Groundhog #" + number;
    }
}
public static <T extends Groundhog> void detectSpring(Class<T> type) throws Exception {
        Constructor<T> ghog = type.getConstructor(int.class);
        Map<Groundhog, Prediction> map = new HashMap<>();
        for (int i = 0; i < 10; i++) {
            map.put(ghog.newInstance(i), new Prediction());
        }
        System.out.println("map = " + map);
        Groundhog gh = ghog.newInstance(3);
        if (map.containsKey(gh)) {
            System.out.println(map.get(gh));
        }
    }

public class Groundhog {
    protected int number;

    public Groundhog(int number) {
        this.number = number;
    }

    @Override
    public String toString() {
        return "Groundhog #" + number;
    }

    @Override
    public boolean equals(Object o) {
        return number == ((Groundhog) o).number;
    }

    @Override
    public int hashCode() {
        return number;
    }
}

public final boolean equals(Object var1) {
            if (var1 == this) {
                return true;
            } else {
                if (var1 instanceof Entry) {
                    Entry var2 = (Entry)var1;
                    if (Objects.equals(this.key, var2.getKey()) && Objects.equals(this.value, var2.getValue())) {
                        return true;
                    }
                }

                return false;
            }
        }

public class SlowMap<K, V> extends AbstractMap<K, V> {
    private List<K> keys = new ArrayList<>();
    private List<V> values = new ArrayList<>();

    public V put(K key, V value) {
        V oldValue = get(key);
        if (!keys.contains(key)) {
            keys.add(key);
            values.add(value);
        } else {
            values.set(keys.indexOf(value), value);
        }
        return oldValue;
    }

    public V get(Object key) {
        if (!keys.contains(key))
            return null;
        else
            return values.get(keys.indexOf(key));
    }

    @Override
    public Set<Map.Entry<K, V>> entrySet() {
        Set<Map.Entry<K, V>> set = new HashSet<>();
        Iterator<K> ki = keys.iterator();
        Iterator<V> vi = values.iterator();
        while (ki.hasNext()) {
            set.add(new MapEntry<K, V>(ki.next(), vi.next()));
        }
        return null;
    }
}

class MapEntry<K, V> implements Map.Entry<K, V> {
    private K key;
    private V value;

    public MapEntry(K key, V value) {
        this.key = key;
        this.value = value;
    }

    @Override
    public K getKey() {
        return key;
    }

    @Override
    public V getValue() {
        return value;
    }

    @Override
    public V setValue(V v) {
        V oldValue = value;
        value = v;
        return oldValue;
    }
}

SimpleHashMap.java
public class SimpleHashMap<K, V> extends AbstractMap<K, V> {
    static final int SIZE = 997;
    LinkedList<MapEntry<K, V>>[] buckets = new LinkedList[SIZE];

    @Override
    public Set<Map.Entry<K, V>> entrySet() {
        Set<Map.Entry<K, V>> set = new HashSet<>();
        for (LinkedList<MapEntry<K, V>> bucket : buckets) {
            if (bucket == null) continue;
            for (MapEntry<K, V> pair : bucket) {
                set.add(pair);
            }
        }
        return set;
    }

    public V put(K key, V value) {
        V oldValue = null;
        int index = Math.abs(key.hashCode()) % SIZE;
        if (buckets[index] == null) {
            buckets[index] = new LinkedList<>();
        }
        MapEntry<K, V> pair = new MapEntry<>(key, value);
        LinkedList<MapEntry<K, V>> bucket = buckets[index];
        ListIterator<MapEntry<K, V>> iterator = bucket.listIterator();
        boolean hasfound = false;
        while (iterator.hasNext()) {
            MapEntry<K, V> iPair = iterator.next();
            if (iPair.getKey().equals(key)) {
                oldValue = iPair.getValue();
                hasfound = true;
                break;
            }
        }
        if (!hasfound) {
            buckets[index].add(new MapEntry<>(key, value));
        }
        return oldValue;

    }

    public V get(Object key) {
        int index = Math.abs(key.hashCode()) % 997;
        for (MapEntry<K, V> iPair : buckets[index]) {
            if (iPair.getKey() == key)
                return iPair.getValue();
        }
        return null;
    }

    public static void main(String[] args) {
        SimpleHashMap<String, String> map = new SimpleHashMap<>();
        map.put("key0", "value0");
        map.put("key1", "value1");
        System.out.println(map);
    }
}

MapEntry.java
public class MapEntry<K, V> implements Map.Entry<K, V> {
    private K key;
    private V value;

    public MapEntry(K key, V value) {
        this.key = key;
        this.value = value;
    }

    @Override
    public K getKey() {
        return key;
    }

    @Override
    public V getValue() {
        return value;
    }

    @Override
    public V setValue(V v) {
        V oldValue = value;
        value = v;
        return oldValue;
    }

    @Override
    public boolean equals(Object o) {
        if (!(o instanceof MapEntry)) return false;
        MapEntry me = (MapEntry) o;
        return (key == null ?
                me.getKey() == null : key.equals(me.getKey())) &&
                (value == null ?
                        me.getValue() == null : value.equals(me.getValue()));
    }

    @Override
    public int hashCode() {
        return (key == null ? 0 : key.hashCode()) ^ (value == null ? 0 : value.hashCode());
    }
}