Boom.Tan个人空间

public static Boolean valueOf(boolean b){
  return b ? Boolean.TRUE : Boolean.FALSE;
}

public class NutritionFacts {
  private final int servingSize;
  private final int servings;
  private final int calories;
  private final int fat;
  private final int sodium;
  private final int carbohydrate;

  public static class Builder {
    private final int servingSize;
    private final int servings;
    private final int calories = 0;
    private final int fat= 0;
    private final int sodium= 0;
    private final int carbohydrate= 0;

    public Builder(int ser,int servings){
      this.servingSize = ser;
      this.servings = servings;
    }
    public Builder calories(int val){calories = val;return this;}
    public Builder fat(int val){fat= val;return this;}
    public Builder sodium(int val){sodium= val;return this;}
    public Builder carbohydrate(int val){carbohydrate= val;return this;}
  }
    public NutritionFacts build(){return new NutritionFacts(this);}

    private NutritionFacts (Builder builder){
	    servingSize  = builder.servingSize ;
        servings = builder.servings ;
        calories = builder.calories ;
        fat= builder.fat;
        sodium= builder.sodium;
        carbohydrate= builder.carbohydrate;
}
}

NutritionFacts obj = new NutritionFacts.Builder(240,8).calories(100)
  .sodium(33).carbohydrate(22).build();

public class Elvis {
  private static final Elvis INSTANCE = new Elvis();
  private Elvis () {...}
  public static Elvis getInstance() {return INSTANCE ;}

//枚举
private Object readRssolve() {
  return INSTANCE ;
}
public enum Elvis {
  INSTANCE ;
}
}

public calss UtilityClass{
  private UtilityClass(){
    //error
  }
  public static void doSomething(){
    //...
  }
}

//bad DON'T DO THIS!
public class Person{
  private final Date birthDate;
  public boolean isBabyBoomer(){
    //分配了不必要的强度对象
    Calendar gmtCal = 
        Calendar.getInstance(TimeZone.getTimeZone("GMT"));
    gmtCal .set(1946,Calendar.JANUARY,1,0,0,0);
    Date boomStart = gmtCal .getTime();
    gmtCal .set(1965,Calendar.JANUARY,1,0,0,0);
    Date boomEnd = gmtCal .getTime();
    return birthDate.compareTo(boomStart) >= 0 
      && birthDate.compareTo(boomEnd) < 0;
  }

}

//good
class Person{
	private final Date birthDate;
	private static final Date BOOM_START;
	private static final Date BOOM_END:
	
	static {
		Calendar gmtCal = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
		gmtCal.set(1946,Calendar.JANUARY,1,0,0,0);
		BOOM_START = gmtCal.getTime();
		gmtCal.set(1946,Calendar.JANUARY,1,0,0,0);
		BOOM_END = gmtCal.getTime();
	}
	
	public boolean isBabyBoomer(){
		return birthDate.compareTo(BOOM_START) >= 0 
          && birthDate.compareTo(BOOM_END) < 0;
	}
}

public class Stack {
	private Object[] elements;
	private int size = 0;
	private static final int DEFAULT_SIZE = 16;
	
	public Stack(){
		elements = new Object[DEFAULT_SIZE];
	}
	
	public void push(Object e){
		ensureCapacity();
		elements[size++] = e;
	}
	
	public Object pop(){
		if(size == 0)
			throw new EmptyStackException();
		return elements[--size];
	}
	
	private void ensureCapacity(){
		if(elements.length == size)
			elements = Arrays.copyOf(elements,2 * size + 1);
	}
}

public Object pop(){
		if(size == 0)
			throw new EmptyStackException();
		Object result = elements[--size];
		elements[size] = null;//清理过时的对象
		return result;
	}

for (Element e : c) {
	doSomething(e);
}

//before JDK1.5
for (Iterator i = c.iterator(); i.hasNext(); ) {
	doSomething((Element) i.next());
}

//bad
Iterator<Element> i = c.iterator();
while (i.hasNext()) {
	doSomething(i.next());
}
...
Iterator<Element> i2 = c2.iterator();
while (i.hasNext()) { // BUG! 应该是i2
	doSomethingElse(i2.next());
}

for (Iterator<Element> i = c.iterator(); i.hasNext(); ) {
	doSomething(i.next());
}
 ...
// Compile-time error - cannot find symbol i
for (Iterator<Element> i2 = c2.iterator(); i.hasNext(); ) {
	doSomething(i2.next());
}

enum Suit { CLUB, DIAMOND, HEART, SPADE }
enum Rank { ACE, DEUCE, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT,
 NINE, TEN, JACK, QUEEN, KING }
...
Collection<Suit> suits = Arrays.asList(Suit.values());
Collection<Rank> ranks = Arrays.asList(Rank.values());
List<Card> deck = new ArrayList<Card>();
for (Iterator<Suit> i = suits.iterator(); i.hasNext(); )
	for (Iterator<Rank> j = ranks.iterator(); j.hasNext(); )
		deck.add(new Card(i.next(), j.next()));

for (Iterator<Suit> i = suits.iterator(); i.hasNext(); ){
    Suit suit = i.next();
	for (Iterator<Rank> j = ranks.iterator(); j.hasNext(); )
		deck.add(new Card(suit, j.next()));
}

for (Suit suit : suits)
	for (Rank rank : ranks)
		deck.add(new Card(suit, rank));

String compoundKey = className + "#" + i.next();//bad

static class CompoundKey{
    private String className;
    private String next;
    ...
}

//方式一
public String statement() {
	String result = "";
	for (int i = 0; i < numItems(); i++)
		result += lineForItem(i); // String concatenation
	return result;
}

//方式二
public String statement() {
	StringBuilder b = new StringBuilder(numItems() * LINE_WIDTH);
	for (int i = 0; i < numItems(); i++)
		b.append(lineForItem(i));
	return b.toString();
}

// Good - uses interface as type
List<Subscriber> subscribers = new Vector<Subscriber>();

// Bad - uses class as type!
Vector<Subscriber> subscribers = new Vector<Subscriber>();

//bad
public class Point {
  public int x;
  public int y;
}

//good
class Point {
	private double x;
	private double y;
	public Point(double x, double y) {
		this.x = x;
		this.y = y;
	}
	public double getX() { return x; }
	public double getY() { return y; }
	public void setX(double x) { this.x = x; }
	public void setY(double y) { this.y = y; }
}

//bad
public interface PhysicalConstants {
	// Avogadro's number (1/mol)
	static final double AVOGADROS_NUMBER = 6.02214199e23;
	// Boltzmann constant (J/K)
	static final double BOLTZMANN_CONSTANT = 1.3806503e-23;
	// Mass of the electron (kg)
	static final double ELECTRON_MASS = 9.10938188e-31;
}

// bad Tagged class - vastly inferior to a class hierarchy!
class Figure {
	enum Shape { RECTANGLE, CIRCLE };
	// Tag field - the shape of this figure
	final Shape shape;
	// These fields are used only if shape is RECTANGLE
	double length;
	double width;
	// This field is used only if shape is CIRCLE
	double radius;
	// Constructor for circle
	Figure(double radius) {
		shape = Shape.CIRCLE;
		this.radius = radius;
	}
	// Constructor for rectangle
	Figure(double length, double width) {
		shape = Shape.RECTANGLE;
		this.length = length;
		this.width = width;
	}
	double area() {
		switch(shape) {
		case RECTANGLE:
			return length * width;
		case CIRCLE:
			return Math.PI * (radius * radius);
		default:
			throw new AssertionError();
		}
	}
}  

//Class hierarchy replacement for a tagged class
abstract class Figure {
	abstract double area();
}
class Circle extends Figure {
	final double radius;
	Circle(double radius) { this.radius = radius; }
	double area() { return Math.PI * (radius * radius); }
}

class Rectangle extends Figure {
	final double length;
	final double width;
	Rectangle(double length, double width) {
		this.length = length;
		this.width = width;
	}
	double area() { return length * width; }
} 

// The int enum pattern - severely deficient!
public static final int APPLE_FUJI = 0;
public static final int APPLE_PIPPIN = 1;
public static final int APPLE_GRANNY_SMITH = 2;
public static final int ORANGE_NAVEL = 0;
public static final int ORANGE_TEMPLE = 1;
public static final int ORANGE_BLOOD = 2;

public enum Apple { FUJI, PIPPIN, GRANNY_SMITH }
public enum Orange { NAVEL, TEMPLE, BLOOD }

public enum Planet {
	MERCURY(3.302e+23, 2.439e6),
	VENUS (4.869e+24, 6.052e6),
	EARTH (5.975e+24, 6.378e6),
	MARS (6.419e+23, 3.393e6),
	JUPITER(1.899e+27, 7.149e7),
	SATURN (5.685e+26, 6.027e7),
	URANUS (8.683e+25, 2.556e7),
	NEPTUNE(1.024e+26, 2.477e7);
	private final double mass; // In kilograms
	private final double radius; // In meters
	private final double surfaceGravity; // In m / s^2
	// Universal gravitational constant in m^3 / kg s^2
	private static final double G = 6.67300E-11;
	// Constructor
	Planet(double mass, double radius) {
		this.mass = mass;
		this.radius = radius;
		surfaceGravity = G * mass / (radius * radius);
	}
	public double mass() { return mass; }
	public double radius() { return radius; }
	public double surfaceGravity() { return surfaceGravity; }
	public double surfaceWeight(double mass) {
		return mass * surfaceGravity; // F = ma
	}
}

public enum Operation {
	PLUS { double apply(double x, double y){return x + y;} },
	MINUS { double apply(double x, double y){return x - y;} },
	TIMES { double apply(double x, double y){return x * y;} },
	DIVIDE { double apply(double x, double y){return x / y;} };
	abstract double apply(double x, double y);
}

//bad
public enum Ensemble {
	SOLO, DUET, TRIO, QUARTET, QUINTET,
	SEXTET, SEPTET, OCTET, NONET, DECTET;
	public int numberOfMusicians() { return ordinal() + 1; }
}

public enum Ensemble {
	SOLO(1), DUET(2), TRIO(3), QUARTET(4), QUINTET(5),
	SEXTET(6), SEPTET(7), OCTET(8), DOUBLE_QUARTET(8),
	NONET(9), DECTET(10), TRIPLE_QUARTET(12);
	
	private final int numberOfMusicians;
	
	Ensemble(int size) { 
		this.numberOfMusicians = size; 
	}
	
	public int numberOfMusicians() { 
		return numberOfMusicians; 
	}
}

// Bit field enumeration constants - OBSOLETE!
public class Text {
  public static final int STYLE_BOLD = 1 << 0; // 1
  public static final int STYLE_ITALIC = 1 << 1; // 2
  public static final int STYLE_UNDERLINE = 1 << 2; // 4
  public static final int STYLE_STRIKETHROUGH = 1 << 3; // 8
  // Parameter is bitwise OR of zero or more STYLE_ constants
  public void applyStyles(int styles) { ... }
}
  //使用
  text.applyStyles(STYLE_BOLD | STYLE_ITALIC);

// EnumSet - a modern replacement for bit fields
public class Text {
	public enum Style { BOLD, ITALIC, UNDERLINE, STRIKETHROUGH }
	// Any Set could be passed in, but EnumSet is clearly best
	public void applyStyles(Set<Style> styles) { ... }
}

  //使用
  text.applyStyles(EnumSet.of(Style.BOLD, Style.ITALIC));

// Emulated extensible enum using an interface
public interface Operation {
	double apply(double x, double y);
}
public enum BasicOperation implements Operation {
	PLUS("+") {
		public double apply(double x, double y) { return x + y; }
	},
	MINUS("-") {
		public double apply(double x, double y) { return x - y; }
	},
	TIMES("*") {
		public double apply(double x, double y) { return x * y; }
	},
	DIVIDE("/") {
		public double apply(double x, double y) { return x / y; }
	};

	private final String symbol;
	BasicOperation(String symbol) {
		this.symbol = symbol;
	}
	@Override public String toString() {
		return symbol;
	}
}

// Emulated extension enum
public enum ExtendedOperation implements Operation {
	EXP("^") {
		public double apply(double x, double y) {
			return Math.pow(x, y);
		}
	},
	REMAINDER("%") {
		public double apply(double x, double y) {
			return x % y;
		}
	};
 
	private final String symbol;
	ExtendedOperation(String symbol) {
		this.symbol = symbol;
	}
	@Override public String toString() {
		return symbol;
	}
}

// 你能找到这个bug吗?
public class Bigram {
	private final char first;
	private final char second;
	public Bigram(char first, char second) {
		this.first = first;
		this.second = second;
	}
	public boolean equals(Bigram b) {
		return b.first == first && b.second == second;
	}
	public int hashCode() {
		return 31 * first + second;
	}
	
	public static void main(String[] args) {
		Set<Bigram> s = new HashSet<Bigram>();
		for (int i = 0; i < 10; i++)
			for (char ch = 'a'; ch <= 'z'; ch++)
			  s.add(new Bigram(ch, ch));
		System.out.println(s.size());
	}
}

   @Override public boolean equals(Bigram b) {
	return b.first == first && b.second == second;
}
@Override public int hashCode() {
	return 31 * first + second;
}

/**
* Returns a BigInteger whose value is (this mod m). This method
* differs from the remainder method in that it always returns a
* non-negative BigInteger.
*
* @param m the modulus, which must be positive
* @return this mod m
* @throws ArithmeticException if m is less than or equal to 0
*/
public BigInteger mod(BigInteger m) {
	if (m.signum() <= 0)
		throw new ArithmeticException("Modulus <= 0: " + m);
	... // Do the computation
}

// Private helper function for a recursive sort
private static void sort(long a[], int offset, int length) {
	assert a != null;
	assert offset >= 0 && offset <= a.length;
	assert length >= 0 && length <= a.length - offset;
	... // Do the computation
}

//一个不可变的周期类
// Broken "immutable" time period class
public final class Period {
	private final Date start;
	private final Date end;
	/**
	* @param start the beginning of the period
	* @param end the end of the period; must not precede start
	* @throws IllegalArgumentException if start is after end
	* @throws NullPointerException if start or end is null
	*/
	public Period(Date start, Date end) {
		if (start.compareTo(end) > 0)
			throw new IllegalArgumentException(
				start + " after " + end);
		this.start = start;
		this.end = end;
	}
	public Date start() {
		return start;
	}

	public Date end() {
		return end;
	}
	... // Remainder omitted
}

// bad
Date start = new Date();
Date end = new Date();
Period p = new Period(start, end);
end.setYear(78); // 修改了p的内部状态

// Repaired constructor - makes defensive copies of parameters
public Period(Date start, Date end) {
	this.start = new Date(start.getTime());
	this.end = new Date(end.getTime());
	if (this.start.compareTo(this.end) > 0)
		throw new IllegalArgumentException(start +" after "+ end);
}

// Repaired accessors - make defensive copies of internal fields
public Date start() {
	return new Date(start.getTime());
}
public Date end() {
	return new Date(end.getTime());
}

public class CollectionClassifier {
public static String classify(Set<?> s) {
	return "Set";
}
public static String classify(List<?> lst) {
	return "List";
}
public static String classify(Collection<?> c) {
	return "Unknown Collection";
}
public static void main(String[] args) {
	Collection<?>[] collections = {
		new HashSet<String>(),
		new ArrayList<BigInteger>(),
		new HashMap<String, String>().values()
	};
	for (Collection<?> c : collections)
	System.out.println(classify(c));
 }
}

static int sum(int... args) {
	int sum = 0;
	for (int arg : args)
		sum += arg;
	return sum;
}

//bad
private final List<Cheese> cheesesInStock = ...;
/**
 * @return an array containing all of the cheeses in the shop,
 * or null if no cheeses are available for purchase.
 */
public Cheese[] getCheeses() {
	if (cheesesInStock.size() == 0)
		return null;
	...
}	

// The right way to return an array from a collection
private final List<Cheese> cheesesInStock = ...;
private static final Cheese[] EMPTY_CHEESE_ARRAY = new Cheese[0];
/**
* @return an array containing all of the cheeses in the shop.
*/
public Cheese[] getCheeses() {
	if(cheesesInStock.size() <= 0)
		return cheesesInStock.toArray(EMPTY_CHEESE_ARRAY);
}

//or

public List<Cheese> getCheeseList() {
 if (cheesesInStock.isEmpty())
	return Collections.emptyList(); // Always returns same list
 else
	return new ArrayList<Cheese>(cheesesInStock);
}

public class Stack<E> {
	public Stack();
	public void push(E e);
	public E pop();
	public boolean isEmpty();
}
//push所有元素
public void pushAll(Iterable<E> src) {
	for (E e : src)
	push(e);
}

//使用
Stack<Number> numberStack = new Stack<Number>();
Iterable<Integer> integers = ... ;
numberStack.pushAll(integers);

// Wildcard type for parameter that serves as an E producer
public void pushAll(Iterable<? extends E> src) {
  for (E e : src)
  push(e);
}

comparator = new Comparator<RadioNode>() {
			public int compare(RadioNode s1, RadioNode s2) {
				if (s1.isFavor == s2.isFavor) {
					return s2.frequent - s1.frequent;
				}else{
					if(s1.isFavor)	return -1;
					if(s2.isFavor)	return 1;
				}
				return -1;
			}
		};

class TestAdapter{
    private List<Node> list;
    ***

    public TestAdapter(List list){
        this.list = list;
        ***
    }
}