List<String> list = List.of("apple", "orange", "banana");
Set<String> set = Set.of("aggie", "alley", "steely");
Map<String, String> map = Map.of("A", "Apple", "B", "Boy", "C", "Cat");

/**
 * Returns a fixed-size list backed by the specified array.  (Changes to
 * the returned list "write through" to the array.)  This method acts
 * as bridge between array-based and collection-based APIs, in
 * combination with {@link Collection#toArray}.  The returned list is
 * serializable and implements {@link RandomAccess}.
 *
 * <p>This method also provides a convenient way to create a fixed-size
 * list initialized to contain several elements:
 * <pre>
 *     List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");
 * </pre>
 *
 * @param <T> the class of the objects in the array
 * @param a the array by which the list will be backed
 * @return a list view of the specified array
 */
@SafeVarargs
@SuppressWarnings("varargs")
public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
}

private static class ArrayList<E> extends AbstractList<E>
    implements RandomAccess, java.io.Serializable
{
    private static final long serialVersionUID = -2764017481108945198L;
    private final E[] a;

    ArrayList(E[] array) {
        a = Objects.requireNonNull(array);
    }

    ......

}

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {

    public void add(int index, E element) {
        throw new UnsupportedOperationException();
    }
    
    public E remove(int index) {
        throw new UnsupportedOperationException();
    }

}

Collections.unmodifiableCollection
Collections.unmodifiableSet
Collections.unmodifiableSortedSet
Collections.unmodifiableNavigableSet
Collections.unmodifiableList
Collections.unmodifiableMap
Collections.unmodifiableSortedMap
Collections.unmodifiableNavigableMap	

static class UnmodifiableCollection<E> implements Collection<E>, Serializable {
    private static final long serialVersionUID = 1820017752578914078L;

    final Collection<? extends E> c;

    UnmodifiableCollection(Collection<? extends E> c) {
        if (c==null)
            throw new NullPointerException();
        this.c = c;
    }

    public boolean add(E e) {
        throw new UnsupportedOperationException();
    }
    public boolean remove(Object o) {
        throw new UnsupportedOperationException();
    }
    public boolean addAll(Collection<? extends E> coll) {
        throw new UnsupportedOperationException();
    }
    public boolean removeAll(Collection<?> coll) {
        throw new UnsupportedOperationException();
    }
    public boolean retainAll(Collection<?> coll) {
        throw new UnsupportedOperationException();
    }
    public void clear() {
        throw new UnsupportedOperationException();
    }

    ......

}

List<String> list = List.of("apple", "orange", "banana");
Set<String> set = Set.of("aggie", "alley", "steely");
Map<String, String> map = Map.of("A", "Apple", "B", "Boy", "C", "Cat");

List<String> list = ImmutableList.of("apple", "orange", "banana");
Set<String> set = ImmutableSet.of("aggie", "alley", "steely");
Map<String, String> map = ImmutableMap.of("A", "Apple", "B", "Boy", "C", "Cat");

List<String> list = ImmutableList.of("apple", "orange", "banana");
Set<String> set = ImmutableSet.of("aggie", "alley", "steely");
Map<String, String> map = ImmutableMap.of("A", "Apple", "B", "Boy", "C", "Cat");

log.info("list={}, set={}, map={}", fruits, marbles, map);  // list=[apple, orange, banana], set=[aggie, alley, steely], map={A=Apple, B=Boy, C=Cat}

Triple.of("left", "middle", "right")
Pair.of("left", "right")

public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key) {
    if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)
        return Collections.indexedBinarySearch(list, key);
    else
        return Collections.iteratorBinarySearch(list, key);
}

public void test4() {
    List<Integer> intList = Lists.newArrayList(1, 2, 3);
    add(intList);
    
    // 循环到第四个元素时，报错：java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
    for (int item : intList) {
        log.info("result is {}", item);
    }
}

private void add(List list) {
    list.add("4");
}

Collections.checkedCollection
Collections.checkedQueue
Collections.checkedSet
Collections.checkedSortedSet
Collections.checkedNavigableSet
Collections.checkedList
Collections.checkedMap
Collections.checkedSortedMap
Collections.checkedNavigableMap

static class CheckedCollection<E> implements Collection<E>, Serializable {
    private static final long serialVersionUID = 1578914078182001775L;

    final Collection<E> c;
    final Class<E> type;

    @SuppressWarnings("unchecked")
    E typeCheck(Object o) {
        if (o != null && !type.isInstance(o))
            throw new ClassCastException(badElementMsg(o));
        return (E) o;
    }

    private String badElementMsg(Object o) {
        return "Attempt to insert " + o.getClass() +
            " element into collection with element type " + type;
    }

    CheckedCollection(Collection<E> c, Class<E> type) {
        this.c = Objects.requireNonNull(c, "c");
        this.type = Objects.requireNonNull(type, "type");
    }

    public boolean add(E e) { 
        return c.add(typeCheck(e));
    }

    ......

}

public void test() {
    List<Integer> intList = Collections.checkedList(Lists.newArrayList(1, 2, 3), Integer.class);
    add(intList);
    for (int item : intList) {
        log.info("result is {}", item);
    }
}

private void add(List list) {
    // java.lang.ClassCastException: Attempt to insert class java.lang.String element into collection with element type class java.lang.Integer
    list.add("4");
}

import com.google.common.collect.Maps;
import lombok.Getter;
import lombok.RequiredArgsConstructor;

import java.util.Arrays;
import java.util.Map;

@RequiredArgsConstructor
@Getter
public enum PayMethodEnum {

    /**
     * 卡支付
     */
    CARDS(0),

    /**
     * 借记支付
     */
    BANK_DEBITS(1),

    /**
     * 网银支付
     */
    BANK_REDIRECTS(2),

    /**
     * 银行转账
     */
    BANK_TRANSFERS(3),

    /**
     * 分期付款
     */
    PAY_LATER(4),

    /**
     * 现金支付
     */
    VOUCHERS(5),

    /**
     * 电子钱包
     */
    WALLETS(6);

    /**
     * 支付方式编码
     */
    private final int code;
    public static final Map<Integer, PayMethodEnum> MAP = Maps.newHashMapWithExpectedSize(PayMethodEnum.values().length);

    static {
        Arrays.stream(PayMethodEnum.values()).forEach(aEnum ->
                MAP.put(aEnum.getCode(), aEnum)
        );
    }

    public static PayMethodEnum valueOfCode(int code) {
        return MAP.get(code);
    }

}

ZoneId.getAvailableZoneIds().forEach(System.out::println);

// 获取服务器所在时区的 ZoneId，例如 Asia/Shanghai 为 UTC+8
ZoneId currentZone = ZoneId.systemDefault();

// 获取指定城市的 ZoneId，即 UTC+1
ZoneId zoneId = ZoneId.of("Europe/Paris");

public final class ZonedDateTime
        implements Temporal, ChronoZonedDateTime<LocalDate>, Serializable {
    /**
     * The local date-time.
     */
    private final LocalDateTime dateTime;
    /**
     * The offset from UTC/Greenwich.
     */
    private final ZoneOffset offset;
    /**
     * The time-zone.
     */
    private final ZoneId zone;
}

// 1970-01-01
LocalDate date = LocalDate.ofEpochDay(0);
// 1970-01-01T00:00
LocalDateTime dateTime = date.atStartOfDay();
// 1970-01-01T00:00:00Z
Instant instant = Instant.ofEpochSecond(0);

// 1970-01-01T00:00+01:00[Europe/Paris]，底层调用 ZonedDateTime.of(this, zoneId)
ZonedDateTime zonedDateTime = date.atStartOfDay(zoneId);
// 1970-01-01T00:00+01:00[Europe/Paris]，底层调用 ZonedDateTime.of(this, zoneId)
ZonedDateTime zonedDateTime1 = dateTime.atZone(zoneId);
// 1970-01-01T01:00+01:00[Europe/Paris]，底层调用 ZonedDateTime.ofInstant(this, zoneId)
ZonedDateTime zonedDateTime2 = instant.atZone(zoneId);
// 2015-12-03T10:15:30+08:00[Asia/Shanghai]
ZonedDateTime zonedDateTime3 = ZonedDateTime.parse("2015-12-03T10:15:30+05:30[Asia/Shanghai]");

// 东八区的 1970-01-01T00:00，等于 UTC+0 的 1969-12-31T16:00:00Z
Instant instant2 = dateTime.atZone(ZoneId.systemDefault()).toInstant();

// 1970-01-01T00:00
LocalDateTime dateTime2 = LocalDateTime.ofInstant(instant2, ZoneId.systemDefault());
// 1970-01-01T08:00
LocalDateTime dateTime3 = instant.atZone(ZoneId.systemDefault()).toLocalDateTime();

ZoneOffset newYorkOffset = ZoneOffset.of("-05:00");

public final class OffsetDateTime
        implements Temporal, TemporalAdjuster, Comparable<OffsetDateTime>, Serializable {
    /**
     * The local date-time.
     */
    private final LocalDateTime dateTime;
    /**
     * The offset from UTC/Greenwich.
     */
    private final ZoneOffset offset;
}

// 1970-01-01T00:00-05:00
OffsetDateTime dateTimeInNewYork = OffsetDateTime.of(dateTime1, newYorkOffset); 
// 1970-01-01T00:00-05:00
OffsetDateTime dateTimeInNewYork2 = dateTime1.atOffset(newYorkOffset);

LocalDateTime localDateTime = LocalDateTime.parse(
  "2021-01-04 00:00:00", 
  DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")
);
ZonedDateTime zonedDateTime = ZonedDateTime.of(localDateTime, ZoneId.of("Asia/Jakarta"));

Timestamp.from(zonedDateTime.toInstant());
Timestamp.valueOf(localDateTime);

/**
 * Returns the reference to the default TimeZone object. This
 * method doesn't create a clone.
 */
static TimeZone getDefaultRef() {
    TimeZone defaultZone = defaultTimeZone;
    if (defaultZone == null) {
        // Need to initialize the default time zone.
        defaultZone = setDefaultZone();
        assert defaultZone != null;
    }
    // Don't clone here.
    return defaultZone;
}

/**
 * Set a parameter to a java.sql.Timestamp value. The driver converts this
 * to a SQL TIMESTAMP value when it sends it to the database.
 * 
 * @param parameterIndex
 *            the first parameter is 1, the second is 2, ...
 * @param x
 *            the parameter value
 * @param tz
 *            the timezone to use
 * 
 * @throws SQLException
 *             if a database-access error occurs.
 */
private void setTimestampInternal(int parameterIndex, Timestamp x, Calendar targetCalendar, TimeZone tz, boolean rollForward) throws SQLException {
    ...
    
    x = TimeUtil.changeTimezone(this.connection, sessionCalendar, targetCalendar, x, tz, this.connection.getServerTimezoneTZ(), rollForward);

    ...
                synchronized (this) {
                    if (this.tsdf == null) {
                        this.tsdf = new SimpleDateFormat("''yyyy-MM-dd HH:mm:ss", Locale.US);
                    }

                    StringBuffer buf = new StringBuffer();
                    buf.append(this.tsdf.format(x));
                    
                    ...
                    
                    setInternal(parameterIndex, buf.toString());
                }
}

/**
 * Change the given timestamp from one timezone to another
 * 
 * @param conn
 *            the current connection to the MySQL server
 * @param tstamp
 *            the timestamp to change
 * @param fromTz
 *            the timezone to change from
 * @param toTz
 *            the timezone to change to
 * 
 * @return the timestamp changed to the timezone 'toTz'
 */
public static Timestamp changeTimezone(MySQLConnection conn, Calendar sessionCalendar, Calendar targetCalendar, Timestamp tstamp, TimeZone fromTz,
        TimeZone toTz, boolean rollForward) {
    if ((conn != null)) {
        // 开启 useTimezone=true，才能进入下面的时区转换逻辑
        if (conn.getUseTimezone()) {
            // Convert the timestamp from GMT to the server's timezone
            Calendar fromCal = Calendar.getInstance(fromTz);
            fromCal.setTime(tstamp);

            int fromOffset = fromCal.get(Calendar.ZONE_OFFSET) + fromCal.get(Calendar.DST_OFFSET);
            Calendar toCal = Calendar.getInstance(toTz);
            toCal.setTime(tstamp);

            int toOffset = toCal.get(Calendar.ZONE_OFFSET) + toCal.get(Calendar.DST_OFFSET);
            int offsetDiff = fromOffset - toOffset;
            long toTime = toCal.getTime().getTime();

            if (rollForward) {
                toTime += offsetDiff;
            } else {
                toTime -= offsetDiff;
            }

            Timestamp changedTimestamp = new Timestamp(toTime);

            return changedTimestamp;
        } else if (conn.getUseJDBCCompliantTimezoneShift()) {
            if (targetCalendar != null) {

                Timestamp adjustedTimestamp = new Timestamp(jdbcCompliantZoneShift(sessionCalendar, targetCalendar, tstamp));

                adjustedTimestamp.setNanos(tstamp.getNanos());

                return adjustedTimestamp;
            }
        }
    }

    return tstamp;
}

Year              // 2007
YearMonth         // 2007-12
MonthDay          // --12-03

LocalDate         // 2007-12-03
LocalTime         // 10:15:30
LocalDateTime     // 2007-12-03T10:15:30

OffsetTime        // 10:15:30+01:00
OffsetDateTime    // 2007-12-03T10:15:30+01:00
ZonedDateTime     // 2007-12-03T10:15:30+01:00 Europe/Paris

Instant           // 以 Unix 元年时间（UTC 时区 1970-01-01T00:00:00Z，“Z” 代表 UTC 时区）开始所经历的秒数

// 格里历（公历）
LocalDate date = LocalDate.now();
// 和历
JapaneseDate japaneseDate = JapaneseDate.from(date);
// 中华民国历
MinguoDate minguoDate = MinguoDate.from(date);
// 泰国历
ThaiBuddhistDate thaiBuddhistDate = ThaiBuddhistDate.from(date);
// 伊斯兰历（回历）
HijrahDate hijrahDate = HijrahDate.from(date);

public final class LocalDate
        implements Temporal, TemporalAdjuster, ChronoLocalDate, Serializable {
    /**
     * The year.
     */
    private final int year;
    /**
     * The month-of-year.
     */
    private final short month;
    /**
     * The day-of-month.
     */
    private final short day;
}

public final class LocalTime
        implements Temporal, TemporalAdjuster, Comparable<LocalTime>, Serializable {
    /**
     * The hour.
     */
    private final byte hour;
    /**
     * The minute.
     */
    private final byte minute;
    /**
     * The second.
     */
    private final byte second;
    /**
     * The nanosecond.
     */
    private final int nano;   
}

public final class LocalDateTime
        implements Temporal, TemporalAdjuster, ChronoLocalDateTime<LocalDate>, Serializable {
    /**
     * The date part.
     */
    private final LocalDate date;
    /**
     * The time part.
     */
    private final LocalTime time;
}

// 通过静态工厂方法创建实例
LocalTime time = LocalTime.of(12, 0);
LocalDate date = LocalDate.of(2007, 12, 3);
// 1970-01-01。epoch day（历元日）是一个简单的天数递增计数，其中第 0 天表示 1970-01-01。负数代表更早的日期。
LocalDate date1 = LocalDate.ofEpochDay(0);
// 通过静态方法创建实例
LocalDate date2 = LocalDate.parse("2007-12-03");

// 合并日期和时间
LocalDateTime dateTime = date.atTime(time);
LocalDateTime dateTime1 = time.atDate(date);
LocalDateTime dateTime2 = date.atStartOfDay();
LocalDateTime dateTime3 = LocalDateTime.of(date, time);

// 获取本地时区的当前日期与时间
LocalDateTime dateTime4 = LocalDateTime.now();

// 通过 unix_timestamp 创建实例
LocalDateTime dateTime5 = LocalDateTime.ofEpochSecond(timestamp, 0, ZoneOffset.of("+08:00"));

// java.time.LocalDateTime 转 java.sql.Timestamp
Timestamp timestamp = Timestamp.valueOf(localDateTime);

// 使用 TemporalAccessor#get(TemporalField)，传入 TemporalField 接口的实现类 ChronoField
int year = date.get(ChronoField.YEAR);
int month = date.get(ChronoField.MONTH_OF_YEAR);
int dayOfMonth = date.get(ChronoField.DAY_OF_MONTH);

// LocalTime/LocalDate/LocalDateTime 各自也提供了一组 getter 快捷方法
int year1 = date.getYear();
int month1 = date.getMonthValue();
int dayOfMonth1 = date.getDayOfMonth();
boolean leapYear = date.isLeapYear();

// 使用 Temporal#with(TemporalField, long)，传入 TemporalField 接口的实现类 ChronoField
LocalDate newDate = date.with(ChronoField.YEAR, 2019);
LocalDate newDate2 = date.with(ChronoField.MONTH_OF_YEAR, 1);
LocalDate newDate3 = date.with(ChronoField.DAY_OF_MONTH, 30);

// LocalTime/LocalDate/LocalDateTime 各自也提供了一组 with 快捷方法
LocalDate newDate4 = date.withYear(2019);
LocalDate newDate5 = date.withMonth(1);
LocalDate newDate6 = date.withDayOfMonth(30);

// 使用 Temporal#with(TemporalAdjuster)
LocalDate newDate7 = date.with(TemporalAdjusters.nextOrSame(DayOfWeek.SUNDAY));
LocalDate newDate8 = date.with(TemporalAdjusters.lastDayOfMonth());

public final class Instant
        implements Temporal, TemporalAdjuster, Comparable<Instant>, Serializable {
    /**
     * The number of seconds from the epoch of 1970-01-01T00:00:00Z.
     */
    private final long seconds;
    /**
     * The number of nanoseconds, later along the time-line, from the seconds field.
     * This is always positive, and never exceeds 999,999,999.
     */
    private final int nanos;
}

Instant instant = Instant.now(); // 1562497662814 (2019-07-07T11:07:42.814Z)

// Instant 的设计初衷是为了便于机器使用，底层实现仅包含由秒和纳秒所构成的数字。
long seconds = instant.getEpochSecond();  // 1562497662
int nanoSeconds = instant.getNano();  // 814000000

Instant instant = Instant.now();

// // 自 1970-01-01T00:00:00Z 之后经过的秒数
// 1970-01-01T00:00:01Z
Instant instant = Instant.ofEpochSecond(1);

// 自 1970-01-01T00:00:00Z 之后经过的毫秒数
// 1970-01-01T00:00:01.000Z
Instant instant = Instant.ofEpochMilli(1000);

Instant instant = new Date().toInstant();

ZonedDateTime dt = LocalDateTime.now().atZone(zoneId);
Instant instant = Instant.from(dt);

long seconds = Instant.now().getEpochSecond();  // 秒
long milliSeconds = Instant.now().toEpochMilli();  // 毫秒

Date date = Date.from(Instant.now());

Instant instant = Instant.now(); // 1562497662814 (2019-07-07T11:07:42.814Z)

int milliOfSecond = instant.get(ChronoField.MILLI_OF_SECOND);  // 814
int microOfSecond = instant.get(ChronoField.MICRO_OF_SECOND);  // 814000
int nanoOfSecond = instant.get(ChronoField.NANO_OF_SECOND);    // 814000000

// java.time.temporal.UnsupportedTemporalTypeException: Unsupported field: DayOfMonth
Instant.now().get(ChronoField.DAY_OF_MONTH);

Instant newInstant = instant.with(ChronoField.INSTANT_SECONDS, 30);
Instant newInstant2 = instant.with(ChronoField.MILLI_OF_SECOND, 300);
Instant newInstant3 = instant.plus(30, ChronoUnit.SECONDS);
Instant newInstant4 = instant.plusSeconds(30);
Instant newInstant5 = instant.minusSeconds(30);

public final class Duration
        implements TemporalAmount, Comparable<Duration>, Serializable {
    /**
     * The number of seconds in the duration.
     */
    private final long seconds;
    /**
     * The number of nanoseconds in the duration, expressed as a fraction of the
     * number of seconds. This is always positive, and never exceeds 999,999,999.
     */
    private final int nanos;
}

public final class Period
        implements ChronoPeriod, Serializable {
    /**
     * The number of years.
     */
    private final int years;
    /**
     * The number of months.
     */
    private final int months;
    /**
     * The number of days.
     */
    private final int days;
}

// Duration 类的静态工厂方法 between 仅支持两个 LocalTime 或两个 LocalDateTime、或两个 Instant 对象之间的 duration
Duration duration = Duration.between(dateTime1, dateTime);
Duration.between(time, time);
Duration.between(instant, instant1);
// 由于 Duration 类主要用于以秒和纳秒衡量时间的长短，如果传 LocalDate 对象会抛异常：java.time.temporal.UnsupportedTemporalTypeException
// Duration.between(date1, date);

// Period 类的静态工厂方法 between 仅支持两个 LocalDates
Period period = Period.between(date1, date);

// Duration 和 Period 类都提供了很多非常方便的静态工厂方法，用于直接创建对应的实例
Duration threeDays = Duration.ofDays(3);
Duration threeHours = Duration.ofHours(3);
Duration threeMinutes = Duration.ofMinutes(3);
Duration threeMinutes2 = Duration.of(3, ChronoUnit.MINUTES);
Duration threeSeconds = Duration.ofSeconds(3);
Duration threeMillis = Duration.ofMillis(3);
Duration twoDaysThreeHoursFourMinutes = Duration.parse("P2DT3H4M");

Period tenYears = Period.ofYears(10);
Period tenMonths = Period.ofMonths(10);
Period tenWeeks = Period.ofWeeks(10);
Period tenDays = Period.ofDays(10);
Period twoYearsSixMonthsOneDay = Period.of(2, 6, 1);
Period oneYearTwoMonthsThreeDays = Period.parse("P1Y2M3D");

// 准确获取该时段的差值：日、时、分、秒、毫秒、纳秒
long days = duration.toDays();
long hours = duration.toHours();
long minutes = duration.toMinutes();
long seconds = duration.getSeconds();
long seconds2 = duration.get(ChronoUnit.SECONDS);
long millis = duration.toMillis();
long nanos2 = duration.toNanos();

// 获取指定部分的差值
int years = period.getYears();
int months = period.getMonths();
int days1 = period.getDays();
long days2 = period.get(ChronoUnit.DAYS);

// 2021-02-01
LocalDateTime.now().format(DateTimeFormatter.ISO_DATE);
// 2021-02-01T09:55:54.846Z（注意：UTC+00:00 输出为 Z，需要自行 replace）
ZonedDateTime.now(ZoneId.of("Europe/London")).format(DateTimeFormatter.ISO_OFFSET_DATE_TIME);
// 2021-02-01T16:43:46+07:00
ZonedDateTime.now(ZoneId.of("Asia/Jakarta")).truncatedTo(ChronoUnit.SECONDS).format(DateTimeFormatter.ISO_OFFSET_DATE_TIME);

// 01/02/2021
LocalDateTime.now().format(DateTimeFormatter.ofPattern("dd/MM/yyyy"));

// 2021 2 1
LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy M d", Locale.US));
// 2021 02 1
LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy MM d", Locale.US));
// 2021 Feb 1
LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy MMM d", Locale.US));
// 2021 February 1
LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy MMMM d", Locale.US));
// 2021 F 1
LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy MMMMM d", Locale.US));

DateTimeFormatter dtf = new DateTimeFormatterBuilder().appendPattern("dd/MM/yyyy[ [HH][:mm][:ss][.SSS]]")
  .parseDefaulting(ChronoField.HOUR_OF_DAY, 0)
  .parseDefaulting(ChronoField.MINUTE_OF_HOUR, 0)
  .parseDefaulting(ChronoField.SECOND_OF_MINUTE, 0)
  .toFormatter(Locale.US);

// 1999-01-01T02:04:06
LocalDateTime.parse("01/01/1999 02:04:06", dtf);
// 1999-01-01T00:00
LocalDateTime.parse("01/01/1999", dtf);

// [a,b,c,d,e,f,g]
Arrays.asList("a", "b", "c", "d", "e", "f", "g").stream()
                .collect(Collectors.joining(",", "[", "]"));

String s1 = new Formatter().format(format, args).toString();
// or simplied
String s2 = String.format(format, args);

System.out.printf(format, args);
System.out.format(format, args);

// <span>hello world</span>
StringEscapeUtils.escapeHtml4("<span>hello world</span>");

// {hello: "world"}
StringEscapeUtils.unescapeJson("{hello: \"world\"}");

// flying saucer
ITextRenderer renderer = new ITextRenderer();

String escapedHtml = StringEscapeUtils.escapeHtml4(srcHtml);
renderer.setDocumentFromString(escapedHtml);

Integer a = 1000;
Integer b = 1000;
Integer c = 100;
Integer d = 100;
Integer e = new Integer(100);
Integer f = new Integer(100);

// 值比较
System.out.println(("a equals b is " + (a.equals(b))));  // a equals b is true

// 引用比较，结果为 false
System.out.println("a == b is " + (a == b));  // a == b is false
// 引用比较，结果意外的为 true。这是由于 Integer 自动装箱时 [-128, 127] 使用了缓存，详见其 valueOf 方法的源码实现。
System.out.println(("c == d is " + (c == d)));  // c == d is true
// 引用比较，结果为 false。因为 new Integer(int) 构造方法没有使用缓存。
System.out.println(("e == f is " + (e == f)));  // e == f is false

public static void main(String[] args) {
    Integer i = 10;
    int n = i;
}

public static void main(String args[]) {
    Integer i = Integer.valueOf(10);  // 自动装箱
    int n = i.intValue();  // 自动拆箱
}

// 程序一：包装类型
Long sum = 0L;
for (long i = 0; i < Integer.MAX_VALUE; i++) {
    sum += i;
}
System.out.println(sum);  // 耗时 10390 ms

// 程序二：基本类型
long sum = 0L;
for (long i = 0; i < Integer.MAX_VALUE; i++) {
    sum += i;
}
System.out.println(sum);  // 耗时 1101 ms

// 程序一：包装类型
Long sum = Long.valueOf(0L);
for (long i = 0L; i < 2147483647L; i++) {
    sum = Long.valueOf(sum.longValue() + i);
}
System.out.println(sum);

// 程序二：基本类型
long sum = 0L;
long i;
for (i = 0L; i < 2147483647L; i++) {
    sum += i;
}
System.out.println(sum);

Long sum = null;
for (long i = 0; i < Integer.MAX_VALUE; i++) {
    sum += i;  // java.lang.NullPointerException
}
System.out.println(sum);

// 十进制转成二进制：11111111
Integer.toBinaryString(255);
// 二进制转十进制：255
Integer.valueOf("11111111", 2);

// 十进制转成八进制：10
Integer.toOctalString(8);
// 八进制转成十进制：8
Integer.valueOf("10", 8);

// 十进制转成十六进制：F
Integer.toHexString(15);
// 十六进制转成十进制：15
Integer.valueOf("F", 16);

public final class Byte extends Number implements Comparable<Byte> {

    /**
     * The value of the {@code Byte}.
     *
     * @serial
     */
    private final byte value;

    /**
     * Returns a {@code Byte} instance representing the specified
     * {@code byte} value.
     * If a new {@code Byte} instance is not required, this method
     * should generally be used in preference to the constructor
     * {@link #Byte(byte)}, as this method is likely to yield
     * significantly better space and time performance since
     * all byte values are cached.
     *
     * @param  b a byte value.
     * @return a {@code Byte} instance representing {@code b}.
     * @since  1.5
     */
    public static Byte valueOf(byte b) {
        final int offset = 128;
        return ByteCache.cache[(int)b + offset];
    }

    /**
     * Returns the value of this {@code Byte} as a
     * {@code byte}.
     */
    public byte byteValue() {
        return value;
    }

    /**
     * Compares this object to the specified object.  The result is
     * {@code true} if and only if the argument is not
     * {@code null} and is a {@code Byte} object that
     * contains the same {@code byte} value as this object.
     *
     * @param obj       the object to compare with
     * @return          {@code true} if the objects are the same;
     *                  {@code false} otherwise.
     */
    public boolean equals(Object obj) {
        if (obj instanceof Byte) {
            return value == ((Byte)obj).byteValue();
        }
        return false;
    }
}

public final class Short extends Number implements Comparable<Short> {

    /**
     * The value of the {@code Short}.
     *
     * @serial
     */
    private final short value;

    /**
     * Returns a {@code Short} instance representing the specified
     * {@code short} value.
     * If a new {@code Short} instance is not required, this method
     * should generally be used in preference to the constructor
     * {@link #Short(short)}, as this method is likely to yield
     * significantly better space and time performance by caching
     * frequently requested values.
     *
     * This method will always cache values in the range -128 to 127,
     * inclusive, and may cache other values outside of this range.
     *
     * @param  s a short value.
     * @return a {@code Short} instance representing {@code s}.
     * @since  1.5
     */
    public static Short valueOf(short s) {
        final int offset = 128;
        int sAsInt = s;
        if (sAsInt >= -128 && sAsInt <= 127) { // must cache
            return ShortCache.cache[sAsInt + offset];
        }
        return new Short(s);
    }

    /**
     * Returns the value of this {@code Short} as a
     * {@code short}.
     */
    public short shortValue() {
        return value;
    }

    /**
     * Compares this object to the specified object.  The result is
     * {@code true} if and only if the argument is not
     * {@code null} and is a {@code Short} object that
     * contains the same {@code short} value as this object.
     *
     * @param obj       the object to compare with
     * @return          {@code true} if the objects are the same;
     *                  {@code false} otherwise.
     */
    public boolean equals(Object obj) {
        if (obj instanceof Short) {
            return value == ((Short)obj).shortValue();
        }
        return false;
    }

}