if( ... ) {}
else if( ... ) {}
else {}

while( true ) 
{
	break;
	continue;
}

do {} while( true );

for( int i=0; i < l; i++ ) {}

switch(i) {
  case 1 : ...; break; 
  case 2 : ...; break;
  case 3 : ...; break;
  case 4 : ...; break;
  default: ...; 
}

label1: 
outer-iteration {
  inner-iteration {
    //...
    break; // 1
    //...
    continue;  // 2
    //...
    continue label1; // 3
    //...
    break label1;  // 4
  }
}

• 1, break прерывает внутреннюю итерацию и вы выходите во внешнюю итерацию.
• 2, continue перемещает к началу внутренней итерации.
• 3, continue label1 прерывает внутреннюю итерацию и внешнюю итерацию, все пути ведут к label1. Затем фактически продолжаются итерации, но начиная со внешней итерации.
• 4, break label1 также прерывает все пути к метке label1, но не происходит повторного входа в итерацию. Реально происходит прерывание обеих итераций.

interface I1 {
  int i = 5; // static & final
  void play(); 
}

abstract Class C2 
{
  private int m_var;

  public C2()
  {
  	m_var = 0;
  }

  public C2( int i )
  {
  	m_var = i;
  }
  
  public void set(int v)
  {
    m_var = v;  
  }
  
// Абстрактный метод  
  abstract public void move(); 
}

public Class C1 
	extends C2 
	implements I1
{
  private int m_t; 
  
// Инициализация статических членов  
  private static IsaLocation log;
  static
  {
    log = IsaLocation.getInstance( Z_Log.class.getName() );
  }
// Вызов конструктора из конструктора  		
  public C1()
  {
  	this(10);
  }	
// Вызов конструктора базового класса  
  public C1( int i )
  {
  	super(i);
  	m_t = i;
  }
// Замещение метода C2  	
  public void set(int v) 
  {
  	if( v >  5 ) super.set(v);
    m_t= v;
  }
// Реализация абстрактного метода C2
  public void move()
  {
    m_t+=50;
  }
// Реализация метода интерфейса I1  
  public void play()
  {
  	System.out.println(m_t);
  }
}

if(x instanceof Dog) ((Dog)x).bark();

if(Dog.class.isInstance(x)) ((Dog)x).bark();

try 
{
Class[] petTypes = {
        Class.forName("Dog"),
        Class.forName("Pug"),
        Class.forName("Cat"),
        Class.forName("Rodent"),
        Class.forName("Gerbil"),
        Class.forName("Hamster"),
      };
	  
      for(int i = 0; i < 15; i++)
        pets.add(
          petTypes[
            (int)(Math.random()*petTypes.length)]
            .newInstance());
} 
catch(InstantiationException e) {
      System.err.println("Cannot instantiate");
      throw e;
    } catch(IllegalAccessException e) {
      System.err.println("Cannot access");
      throw e;
    } catch(ClassNotFoundException e) {
      System.err.println("Cannot find class");
      throw e;
}

      
Class c = Class.forName(args[0]);
Method[] m = c.getMethods();
Constructor[] ctor = c.getConstructors();

public interface Destination {
  String readLabel();
}

public interface Contents {
  int value();
}

public class Parcel3 {
  private class PContents implements Contents {
    private int i = 11;
    public int value() { return i; }
  }
  protected class PDestination
      implements Destination {
    private String label;
    private PDestination(String whereTo) {
      label = whereTo;
    }
    public String readLabel() { return label; }
  }
  public Destination dest(String s) {
    return new PDestination(s);
  }
  public Contents cont() { 
    return new PContents(); 
  }
}

class Test {
  public static void main(String[] args) {
    Parcel3 p = new Parcel3();
    Contents c = p.cont();
    Destination d = p.dest("Tanzania");
    // Незаконно - нельзя получить доступ к  private классу:
    //! Parcel3.PContents pc = p.new PContents();
  }
}

public class Parcel4 {
  public Destination dest(String s) {
    class PDestination
        implements Destination {
      private String label;
      private PDestination(String whereTo) {
        label = whereTo;
      }
      public String readLabel() { return label; }
    }
    return new PDestination(s);
  }
  public static void main(String[] args) {
    Parcel4 p = new Parcel4();
    Destination d = p.dest("Tanzania");
  }
} 

public class Parcel6 {
  public Contents cont() {
    return new Contents() {
      private int i = 11;
      public int value() { return i; }
    }; // В этом случае требуется точка с запятой
  }
  public static void main(String[] args) {
    Parcel6 p = new Parcel6();
    Contents c = p.cont();
  }
}

public interface Months {
  int
    JANUARY = 1, FEBRUARY = 2, MARCH = 3, 
    APRIL = 4, MAY = 5, JUNE = 6, JULY = 7, 
    AUGUST = 8, SEPTEMBER = 9, OCTOBER = 10,
    NOVEMBER = 11, DECEMBER = 12;
}

public class Z_Order
{
    public static final int OL_OBJECT_ID = 0x0001;
    public static final int OL_DISTRIB = 0x0002;
    public static final int OL_DESCRIPTION_UC = 0x0004;

    public static final String ATTR_DISTRIBUTORS = "distributors";
    public static final String ATTR_DISTRIBUTOR_ID = "distributorId";
    public static final String ATTR_ORDER_LIST = "ordercount";
}

class Weeble {} 

public class IceCream {
// Массив констант
  static String[] flav = {
    "Chocolate", "Strawberry"
  };
// Не инициализированный массив  
  Weeble[] b = new Weeble[5];
// Возвращаю массив  
 static String[] flavorSet(int n) {
    String[] results = new String[n];
	boolean[] picked = 
      new boolean[flav.length];
    for (int i = 0; i < n; i++) 
	{
      int t;
      do 
        t = (int)(Math.random() * flav.length);
      while (picked[t]);
      results[i] = flav[t];
      picked[t] = true;
    }
    return results;
  }
  
}

int[] i = new int[25];
Arrays.fill(i, 47);

System.arraycopy(i, 0, j, 0, i.length);

Arrays.sort(a);
int loc = Arrays.binarySearch(a, r);

public class CompType implements Comparable {
  int i; int j;
  
  public CompType(int n1, int n2) { 
    i = n1; j = n2;
  }
  public int compareTo(Object rv) {
    int rvi = ((CompType)rv).i;
    return (i < rvi ? -1 : (i == rvi ? 0 : 1));
  }
  
  private static Random r = new Random();
  private static int randInt() {
    return Math.abs(r.nextInt()) % 100;
  }
  public static Generator generator() {
    return new Generator() {
      public Object next() {
        return new CompType(randInt(),randInt());
      }
    };
  }
  public static void main(String[] args) {
    CompType[] a = new CompType[10];
    Arrays2.fill(a, generator());
    Arrays.sort(a);
  }
}

public class Z_Dictionary
{
    public String value;
    public String text;

    public Z_Dictionary(String v, String t)
    {
        value = v; text = t;
    }

    // Comparators
    private static class TextComparator implements Comparator
    {
        public int compare(Object o1, Object o2)
        {
            if(!(o1.getClass().equals(Z_Dictionary.class) && 
					o2.getClass().equals(Z_Dictionary.class)))
            {
                return 0;
            }

            Z_Dictionary dic1 = (Z_Dictionary)o1;
            Z_Dictionary dic2 = (Z_Dictionary)o2;

            return dic1.text.compareToIgnoreCase(dic2.text);
        }
    }

    public static Comparator getTextComparator()
    {
        return new Z_Dictionary.TextComparator();
    }

}

java.util.ArrayList orders = new java.util.ArrayList();
orders.add(new Z_Dictionary("1","gf"));
orders.add(new Z_Dictionary("2","kk"));
Collections.sort(orders,Z_Dictionary.getTextComparator());

public class CountedString {
  private String s;
  private int id = 0;
  private static ArrayList created = 
    new ArrayList();
	
  public CountedString(String str) {
    s = str;
    created.add(s);
    Iterator it = created.iterator();
    // Id - это полное число экземпляров
    // строки, используемой CountedString:
    while(it.hasNext())
      if(it.next().equals(s))
        id++;
  }
  public String toString() {
    return "String: " + s + " id: " + id +
      " hashCode(): " + hashCode() + "\n";
  }
  public int hashCode() { 
    return s.hashCode() * id;
  }
  public boolean equals(Object o) {
    return (o instanceof CountedString)
      && s.equals(((CountedString)o).s)
      && id == ((CountedString)o).id;
  }
  public static void main(String[] args) {
    HashMap m = new HashMap();
    CountedString[] cs = new CountedString[10];
    for(int i = 0; i < cs.length; i++) {
      cs[i] = new CountedString("hi");
      m.put(cs[i], new Integer(i));
    }
    System.out.println(m);
    for(int i = 0; i < cs.length; i++) {
      System.out.print("Looking up " + cs[i]);
      System.out.println(m.get(cs[i]));
    }
  }
} 

public class MouseList {
  private ArrayList list = new ArrayList();
  public void add(Mouse m) {
    list.add(m);
  }
  public Mouse get(int index) {
    return (Mouse)list.get(index);
  }
  public int size() { return list.size(); }
}

Collection

boolean add(Object)	Гарантирует, что контейнер содержит аргумент. Возвращает false, если не может добавить аргумент. (Это “необязательный” метод описывается позже в этой главе.)
boolean addAll(Collection)	Добавляет все элементы аргумента. Возвращает true, если любые элементы были добавлены. (“Необязательно”)
void clear( )	Удаляет все элементы контейнера. (“Необязательно”)
boolean contains(Object)	true, если контейнер содержит аргумент.
boolean containsAll(Collection)	true, если контейнер содержит все элементы аргумента.
boolean isEmpty( )	true, если контейнер не имеет элементов.
Iterator iterator( )	Возвращает Iterator, который вы можете использовать для обхода элементов контейнера.
boolean remove(Object)	Если аргумент присутствует в контейнере, один экземпляр этого элемента будет удален. Возвращает true, если произошло удаление. (“Необязательно”)
boolean removeAll(Collection)	Удаляет все элементы, содержащиеся в аргументе. Возвращает true, если произошло любое удаление. (“Необязательно”)
boolean retainAll(Collection)	Остаются только те элементы, которые содержатся в аргументе (в теории множеств называется “пересечением”). Возвращает true, если произошли любые изменения. (“Необязательно”)
int size( )	Возвращает число элементов контейнера.
Object[] toArray( )	Возвращает массив, содержащий все элементы контейнера.
Object[] toArray(Object[] a)	Возвращает массив, содержащий все элементы контейнера, чей тип, скорее массив, а не простой Object (вы должны привести массив к правильному типу).

List

List (интерфейс)	Порядок - наиболее важная особенность для List; он обещает, что элементы будут храниться в определенной последовательности. List добавляет несколько методов к набору Collection, которые позволяют вставку и удаление элементов в середине списка List. (Это рекомендуется только для LinkedList.) List производит ListIterator, и, используя его, вы можете пройти весь List в обоих направлениях, а также вставлять и извлекать элементы из середины списка List.
ArrayList*	List реализуется массивом. Позволяет быстрый доступ в случайном порядке к элементами, но медленный, когда вставляются и удаляются элементы из середины списка. ListIterator должен использоваться только для прямого и обратного движения по ArrayList, но не для вставления и удаления элементов, что является очень дорогим, по сравнению с LinkedList.
LinkedList	Обеспечивает оптимальный доступ к последовательности, который недорогой при вставках и удаленьях из середины списка List. Относительно медленный при случайном выборе элементов. (Используйте для этого ArrayList.) Также имеются методы addFirst( ), addLast( ), getFirst( ), getLast( ), removeFirst( ) и removeLast( ) (которые не определены во всех интерфейсах или базовых классах), позволяющие использовать связанный список как стек, очередь и двойную очередь.

Type	Get	Iteration	Insert	Remove
Массив	1430	3850	нет	нет
ArrayList	3070	12200	500	46850
LinkedList	16320	9110	110	60
Vector	4890	16250	550	46850

Set

Set (интерфейс)	Каждый элемент, который вы добавляете в Set, должен быть уникальным; в противном случае Set не добавит дублирующий элемент. Object, добавляемый в Set, должен определить equals( ) для установления уникальности объектов. Set имеет точно такой же интерфейс, что и Collection. Интерфейс Set не гарантирует сохранение порядка следования элементов в определенной последовательности.
HashSet*	Для Set, в которых важно время поиска. Object должен определить hashCode( ).
TreeSet	Упорядоченный Set поддерживаемый деревом. Этим способом вы можете получить упорядоченную последовательность из Set.

Map

Map (Интерфейс)	Содержит ассоциированные пары ключ-значение, так что вы можете производить поиск значения, используя ключ.
HashMap*	Реализация, основывающая на хеш-таблице. (Используйте это вместо Hashtable.) Обеспечивает постоянную по времени производительность при вставлении и поиске пар. Производительность может регулироваться конструктором, который позволяет вам устанавливать емкость и коэффициент загрузки хеш-таблицы.
TreeMap	Реализация, основывающаяся на красно-черном дереве. Когда вы просматриваете ключи или пары, они будут упорядочены (определяется Comparable или Comparator, будет обсуждаться позднее). Преимущество TreeMap в том, что вы получаете результат отсортированным. TreeMap - это просто Map с методом subMap( ), который позволяет вам возвращать часть дерева.

 

Тип	Тестовый размер	Put	Get	Iteration
	10	143.0	110.0	186.0
TreeMap	100	201.1	188.4	280.1
	1000	222.8	205.2	40.7
	10	66.0	83.0	197.0
HashMap	100	80.7	135.7	278.5
	1000	48.2	105.7	41.4
	10	61.0	93.0	302.0
Hashtable	100	90.6	143.3	329.0
	1000	54.1	110.95	47.3

Class Appl
{

 public static void main(String[] s)
 {
    try{

    }
    catch( Exception e)
    {
      // выполняется при исклчении
    }
    finally
    {
      // выполняется всегда
    }
}

public String getLine(InputStreamReader isReader) 
		throws java.io.IOException, 
			java.text.ParseException
{
	{
	...
	}
    catch( java.io.EOFException eof )
    {
       break;
    }
	catch( Exception e )
	{
		throw new java.io.IOException("error",e);
	}
}
Печать стека исключений:
public void Read()
{
	try{
	...
	}
    catch( Exception e )
	{
      Writer wr = new StringWriter();
      PrintWriter str = new java.io.PrintWriter(wr);
      e.printStackTrace(str);
      str.flush();
      log.error("Stack trace: " + wr.toString());
	}
}

Библиотека java.lang.ref содержит множество классов, которые придают большую гибкость сборщику мусора, что особенно полезно, когда у вас есть огромные объекты, могущие стать причиной нехватки памяти. Есть три класса, наследованные от абстрактного класса Reference: SoftReference, WeakReference и PhantomReference. Каждый из них обеспечивает различный уровень обхода для сборщика мусора, если только рассматриваемый объект достижим через один из этих объектов Reference.

Вы используете объекты Reference когда хотите продолжить хранить в ссылке такой объект — вы хотите быть способны достигнуть объекта — но вы также хотите позволить сборщику мусора освободить такой объект. Таким образом, вы имеете способ перейти к использованию объекта, но если память истощится, это грозит вам тем, что объект будет освобожден.

public static void main(String[] args) {
    int size =     
     10;  //
    или выберите размер через командную строку: if(args.length
    >  0)
      size = Integer.parseInt(args[0]);    
    SoftReference[] sa =
      new SoftReference[size];
    for(int i = 0; i < sa.length; i++) {
      sa[i] = new SoftReference(
        new VeryBig("Soft " + i), rq);
      System.out.println("Just created: " +
        (VeryBig)sa[i].get());
	// вызов сборщика мусора	
      checkQueue();
}

class Data implements Serializable {
  private int i;
// запрет серилизации поля  
  private transient String password;

  Data(int x) { i = x; }
  public String toString() {
    return Integer.toString(i);
  }
}

public class Worm implements Serializable {
  // Генерируется случайно значение типа int:
  private static int r() {
    return (int)(Math.random() * 10);
  }
  private Data[] d = {
    new Data(r()), new Data(r()), new Data(r())
  };
  private Worm next;
  private char c;
  // Значение i == Номеру сегмента
  Worm(int i, char x) {
    System.out.println(" Worm constructor: " + i);
    c = x;
    if(--i > 0)
      next = new Worm(i, (char)(x + 1));
  }
  Worm() {
    System.out.println("Default constructor");
  }
  public String toString() {
    String s = ":" + c + "(";
    for(int i = 0; i < d.length; i++)
      s += d[i].toString();
    s += ")";
    if(next != null)
      s += next.toString();
    return s;
  }
  // Исключение выбрасывается на консоль:
  public static void main(String[] args) 
  throws ClassNotFoundException, IOException {
    Worm w = new Worm(6, 'a');
    System.out.println("w = " + w);
    ObjectOutputStream out =
      new ObjectOutputStream(
        new FileOutputStream("worm.out"));
    out.writeObject("Worm storage");
    out.writeObject(w);
    out.close(); // Также очищается вывод
    ObjectInputStream in =
      new ObjectInputStream(
        new FileInputStream("worm.out"));
    String s = (String)in.readObject();
    Worm w2 = (Worm)in.readObject();
    System.out.println(s + ", w2 = " + w2);
    ByteArrayOutputStream bout =
      new ByteArrayOutputStream();
    ObjectOutputStream out2 =
      new ObjectOutputStream(bout);
    out2.writeObject("Worm storage");
    out2.writeObject(w);
    out2.flush();
    ObjectInputStream in2 =
      new ObjectInputStream(
        new ByteArrayInputStream(
          bout.toByteArray()));
    s = (String)in2.readObject();
    Worm w3 = (Worm)in2.readObject();
    System.out.println(s + ", w3 = " + w3);
  }
}

class Blip3 implements Externalizable {
  int i;
  String s; // Без инициализации
  public Blip3() {
    System.out.println("Blip3 Constructor");
    // s, i не инициализируется
  }
  public Blip3(String x, int a) {
    System.out.println("Blip3(String x, int a)");
    s = x;
    i = a;
    // s & i инициализируются только в
    // конструкторе не по умолчанию.
  }
  public String toString() { return s + i; }
  public void writeExternal(ObjectOutput out)
  throws IOException {
    System.out.println("Blip3.writeExternal");
    // Вы обязаны сделать это:
    out.writeObject(s); 
    out.writeInt(i);
  }
  public void readExternal(ObjectInput in)
  throws IOException, ClassNotFoundException {
    System.out.println("Blip3.readExternal");
    // Вы обязаны сделать это:
    s = (String)in.readObject(); 
    i =in.readInt();
  }
  public static void main(String[] args)
  throws IOException, ClassNotFoundException {
    System.out.println("Constructing objects:");
    Blip3 b3 = new Blip3("A String ", 47);
    System.out.println(b3);
    ObjectOutputStream o =
      new ObjectOutputStream(
        new FileOutputStream("Blip3.out"));
    System.out.println("Saving object:");
    o.writeObject(b3);
    o.close();
    // Теперь получим обратно:
    ObjectInputStream in =
      new ObjectInputStream(
        new FileInputStream("Blip3.out"));
    System.out.println("Recovering b3:");
    b3 = (Blip3)in.readObject();
    System.out.println(b3);
  }
} 

class Line extends Shape {
  private static int color = RED;
  public static void 
  serializeStaticState(ObjectOutputStream os)
      throws IOException {
    os.writeInt(color);
  }
  public static void 
  deserializeStaticState(ObjectInputStream os)
      throws IOException {
    color = os.readInt();
  }
  public Line(int xVal, int yVal, int dim) {
    super(xVal, yVal, dim);
  }
  public void setColor(int newColor) { 
    color = newColor;
  }
  public int getColor() { 
    return color;
  }
}