strictfp关键字  # 可修饰类或方法 将使用严格的浮点计算

int[] a;                # 仅仅是声明 并未真正创建
int[] a = new int[10];

C/C++中使用const关键字定义常量

StringBuilder  # 非线程安全
StringBuffer   # 线程安全

if (condition1) statement1 else if (condition2) statement2 else statement3
while (condition) statement
do statement while(condition);
for (variable : collection) statement # collection必须是数组或者实现Iterable接口的对象
switch(choice) {
    case label1: ...
    case label2: ...
    default: ...
}
case标签的取值:
* 类型为char、byte、short或int的常量表达式
* 枚举常量
* 从Java7开始，可以是字符串字面量
break [label];
continue;

class ClassName {
    field1
    field2
    ...
    
    constructor1
    constructor2
    ...
    
    method1
    method2
    ...
}

package
import
import static

java -classpath
环境变量 CLASSPATH

class Employee {
    public Employee getBuddy() {}
}
class Manager extends Employee {
    public Manager getBuddy() {}
}
子类覆写父类的方法，且子类的返回值为父类返回值的子类型。在覆写方法时，子类的可见性不能低于父类的可见性。

public static max(double ... values) {
    double largest = Double.MIN_VALUE;
    for (dboule v : values) if (v > largest) largest = v;
    return largest;
}
double m = max(3.1, 4.2, 5)

public enum Size {
    SMALL(1, "S"),
    MEDIUM(2, "M"),
    LARGE(3, "L"),
    EXTRA_LARGE(4, "XL");
    private int num;
    private String des;
    Size(int num, String des) {
        this.num = num;
        this.des = des;
    }
    public String toString() {
        return des;
    }
}

# 实现超类的匿名类
new SuperType(construction parameters) {
    inner class methods and data
}
# 实现接口的匿名类
new InterfaceType() {
    methods and data
}

Manifest-Version: 1.0
Sealed: true          # 密封包
Name: Woozle.class
Name: com/mycompany/mypkg/
Main-Class: com.mycompany.mypkg.MainAppClass  # 程序的入口点
                                      # 最后一行必须以换行符结束

assert condition;
assert condition: expression;
# 启动断言
java -enableassertions MyApp
java -ea:MyClass MyApp
# 禁用断言
java -disableassertions MyApp
java -da:MyClass MyApp

public class Pair<T, U> {
    private T first;
    private U second;
    
    public Pair() {first=null; second=null;}
    public Pair(T first, U second) {
        this.first = first;
        this.second = second;
    }
    
    public T getFirst() {return first}
    public U getSecond() {return second}
    
    public void setFirst(T first) {
        this.first = first;
    }
    
    public void setSecond(U second) {
        this.second = second;
    }
}

class ArrayAlg {
    public static <T> T getMiddle(T ... a) {
        return a[a.length/2];
    }
}

<T extends BoundingType1 &BoudingType2>  # 表明T应该是绑定类型的子类型
限定类型可以是接口也可以是类。接口可以多个，类只能有一个，且必须在限定列表中的第一个

为了提高效率应该将标签接口(即没有方法的接口)放在边界列表的末尾。

       Iterable
          |
      Collection                Map        Iterable    RandomAccess
          |                      |            |
 -------------------             |            |
 |        |        |             |            |
List     Set     Queue       SortedMap   ListIterable
          |         |            |
      SortedSet  Deque      NavigableMap
          |
     NavigableSet

         AbstractCollection
                 |
   ---------------------------------------------
   |                 |             |           |
AbstractList     AbstractSet  AbstractQueue    |                      AbstractMap
   |                 |             |           |                           |
 ---------------  --------         |           |                      -----------
   |           |  |      |         |           |                      |         |
Abstract       |HashSet TreeSet PriorityQueue ArrayDequeue          HashMap  TreeMap
SequentialList |
   |           |
LinkedList ArrayList

New --> Runnable --> Blocked/Waiting/Timed waiting --> Terminated
New: new Thread(r)
Runnable: start()  可运行的线程可能处于运行状态也可能没有运行
Blocked: 当一个线程试图获取一个内部的对象锁(而不是java.util.concurrent库中的锁)，而该锁被其它线程持有，该线程进入阻塞状态
Waiting: 当线程等待另一个线程通知调度器一个条件时，它自己进入等待状态。在调用Object.wait方法或Thread.join方法，或者是等待java.util.concurrent库中的Lock或Condition时，就会出现这种情况。
Timed waiting: 调用带有超时参数的方法导致线程进入计时等待状态。
Terminated: 正常或异常退出。

# Lock
lock()
unlock()
# Condition
await()
signalAll()
signal()

await()
notify()
notifyAll()

//synchronized
public synchronized void method() {
    method body
}
// ReentrantLock
myLock = new ReentrantLock();
myLock.lock()
try {
    critical section;
} finally {
    myLock.unlock();
}

Object obj = new Object()
synchronized (obj) {
    critical section;
}

final Map<String, Double> accounts = new HashMap();

private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
private Lock readLock = rwl.readLock();
private Lock writeLock = rwl.writeLock();
public double getTotalBalance() {
    readLock.lock();
    try {}
    finally {
        readLock.unlock();
    }
}
public void transfer() {
    writeLock.lock();
    try {}
    finally {
        writeLock.unlock();
    }
}

ConcurrentHashMap
ConcurrentSkipListMap
ConcurrentSkipListSet
ConcurrentLinkedQueue
CopyOnWriteArrayList
CopyOnWriteArraySet

List<E> synchArrayList = Collections.synchronizedList(new ArrayList<E>());
对于该集合的迭代，需要使用客户端锁定
synchronized(synchArrayList) {
    迭代代码;
}

try/except/else/finally     # 捕获异常并恢复 没发生异常时执行else 无论是否发生异常都执行finally
raise               # 手动在代码中触发异常
assert              # 有条件的在程序中触发异常

列表推导式
[x+1 for x in [1, 2]]
字典推导式
{x: x+1 for x in range(10)}

if <test> then:
    <statements>
elif <test>:
    <statements>
else:
    <statements>
    
三元表达式: A = "x" if True else "y"
A = True and "x" or "y"
while <test>:
    <statements>
else:   # 只有当循环正常离开时才会执行(即没有碰到break语句)
    <statements>    
    
    
for <target> in <object>:
    <statements>
else:   # 只有当循环正常离开时才会执行(即没有碰到break语句)
    <statements>

def <name>(arg1, arg2, arg3,... argN):
    <statements>

lambad arg1, arg2,... argN: expression using arguments

num = 1
def t1(name, count):
    def t2():
        global num
        nonlocal name, count
        name = "yyy"
        count += 1
        num += 1
        print(name, count, num)
    return t2
t1("xxx", 1)()

sys.path # 所有的搜索路径
内建函数:__import__ 使用时必须显式导入内建库
模块属性: __name__

内建函数super的理解与使用
各种重载运算符
descriptor对属性的访问管理
类的继承与搜索方式
@classmethod
@staticmethod
多重继承以及实际中的应用

import logging
from datetime import date
import time
from peewee import *
logger = logging.getLogger("peewee")
logger.setLevel(logging.DEBUG)
logger.addHandler(logging.StreamHandler())
db = MySQLDatabase('peewee_test', host='192.168.99.110', port=3306, user='root', passwd='xxx', charset='utf8')
class BaseModel(Model):
    class Meta:
        database = db
class Person(BaseModel):
    name = CharField(max_length=10, null=False, index=True)
    birthday = DateField(null=False, default=None)
    is_relative = BooleanField()
class Pet(BaseModel):
    owner = ForeignKeyField(Person, related_name='pets')
    name = CharField()
    animal_type = CharField()
db.connect()
# ---- create table ----
db.create_tables([Person, Pet])
# ---- save ----
bob = Person(name='Bob', birthday=date(1989, 4, 17))
bob.save()
foo = Person.create(name='Foo', birthday=date(1991, 1, 6))
time.sleep(30)
foo.name = 'Fu'
foo.save()
# ---- save and delete ----
test = Person.create(name="test", birthday=date(2017, 1, 1))
time.sleep(30)
test.delete_instance()
uncle_bob = Person.create(name='Bob', birthday=date(1960, 1, 15), is_relative=True)
grandma = Person.create(name='Grandma', birthday=date(1935, 3, 1), is_relative=True)
herb = Person.create(name='Herb', birthday=date(1950, 5, 5), is_relative=False)
bob_kitty = Pet.create(owner=uncle_bob, name='Kitty', animal_type='cat')
herb_fido = Pet.create(owner=herb, name='Fido', animal_type='dog')
herb_mittens = Pet.create(owner=herb, name='Mittens', animal_type='cat')
herb_mittens_jr = Pet.create(owner=herb, name='Mittens Jr', animal_type='cat')
# ---- select ----
fu = Person.select().where(Person.name == 'Fu').get()
print(fu.birthday)
bob = Person.get(Person.name == 'Bob')
print(bob.birthday)
for person in Person.select():
    print(person.name, person.birthday)
for person in Person.select().order_by(Person.name):
    print(person.name, person.birthday)
for person in Person.select().order_by(Person.birthday.desc()):
    print(person.name, person.birthday)
for person in Person.select():
    print(person.name, person.pets.count(), 'pets')
    for pet in person.pets:
        print('    ', pet.name, pet.animal_type)
subquery = Pet.select(fn.COUNT(Pet.id)).where(Pet.owner == Person.id)
query = (Person.select(Person, Pet, subquery.alias('pet_count')).join(Pet, JOIN.LEFT_OUTER).order_by(Person.name))
for person in query.aggregate_rows():
    print(person.name, person.pet_count, 'pets')
    for pet in person.pets:
        print('    ', pet.name, pet.animal_type)
db.close()

database = SqliteDatabase(None)  # Un-initialized database.
class SomeModel(Model):
    class Meta:
        database = database
database.init(database_name, host='localhost', user='postgres')

database_proxy = Proxy()  # Create a proxy for our db.
class BaseModel(Model):
    class Meta:
        database = database_proxy  # Use proxy for our DB.
class User(BaseModel):
    username = CharField()
# Based on configuration, use a different database.
if app.config['DEBUG']:
    database = SqliteDatabase('local.db')
elif app.config['TESTING']:
    database = SqliteDatabase(':memory:')
else:
    database = PostgresqlDatabase('mega_production_db')
# Configure our proxy to use the db we specified in config.
database_proxy.initialize(database)

db = PooledMySQLDatabase(
    'peewee_test',
    max_connections=4,
    stale_timeout=300,
    host='127.0.0.1',
    port=3306,
    user='root',
    passwd='xxx',
    charset='utf8'
)

from peewee import *
from playhouse.read_slave import ReadSlaveModel
# Declare a master and two read-replicas.
master = PostgresqlDatabase('master')
replica_1 = PostgresqlDatabase('replica', host='192.168.1.2')
replica_2 = PostgresqlDatabase('replica', host='192.168.1.3')
class BaseModel(ReadSlaveModel):
    class Meta:
        database = master
        read_slaves = (replica_1, replica_2)
class User(BaseModel):
    username = CharField()

from playhouse.migrate import *
my_db = SqliteDatabase('my_database.db')
migrator = SqliteMigrator(my_db)
title_field = CharField(default='')
status_field = IntegerField(null=True)
with my_db.transaction():
    migrate(
        migrator.add_column('some_table', 'title', title_field),
        migrator.add_column('some_table', 'status', status_field),
        migrator.drop_column('some_table', 'old_column'),
    )

from tornado.web import RequestHandler
db = SqliteDatabase('my_db.db')
class PeeweeRequestHandler(RequestHandler):
    def prepare(self):
        db.connect()
        return super(PeeweeRequestHandler, self).prepare()
    def on_finish(self):
        if not db.is_closed():
            db.close()
        return super(PeeweeRequestHandler, self).on_finish()

with db.execution_context() as ctx:
    # A new connection will be opened or, if using a connection pool,
    # pulled from the pool of available connections. Additionally, a
    # transaction will be started.
    user = User.create(username='charlie')
# When the block ends, the transaction will be committed and the connection
# will be closed (or returned to the pool).
@db.execution_context(with_transaction=False)
def do_something(foo, bar):
    # When this function is called, a separate connection is made and will
    # be closed when the function returns.

master = PostgresqlDatabase('master')
read_replica = PostgresqlDatabase('replica')
class Data(Model):
    value = IntegerField()
    class Meta:
        database = master
# By default all queries go to the master, since that is what
# is defined on our model.
for i in range(10):
    Data.create(value=i)
# But what if we want to explicitly use the read replica?
with Using(read_replica, [Data]):
    # Query is executed against the read replica.
    Data.get(Data.value == 5)
    # Since we did not specify this model in the list of overrides
    # it will use whatever database it was defined with.
    SomeOtherModel.get(SomeOtherModel.field == 3)

from peewee import *
from playhouse.shortcuts import RetryOperationalError
class MyRetryDB(RetryOperationalError, MySQLDatabase):
    pass
db = MyRetryDB('my_app')

# Print all queries to stderr.
import logging
logger = logging.getLogger('peewee')
logger.setLevel(logging.DEBUG)
logger.addHandler(logging.StreamHandler())

processor	: 0
vendor_id	: GenuineIntel
cpu family	: 6
model		: 69
model name	: Intel(R) Core(TM) i3-4010U CPU @ 1.70GHz
stepping	: 1
microcode	: 31
cpu MHz		: 782.000
cache size	: 3072 KB
physical id	: 0
siblings	: 4
core id		: 0
cpu cores	: 2
apicid		: 0
initial apicid	: 0
fpu		: yes
fpu_exception	: yes
cpuid level	: 13
wp		: yes
flags		: fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe syscall nx pdpe1gb rdtscp lm constant_tsc arch_perfmon pebs bts rep_good xtopology nonstop_tsc aperfmperf pni pclmulqdq dtes64 monitor ds_cpl vmx est tm2 ssse3 fma cx16 xtpr pdcm pcid sse4_1 sse4_2 x2apic movbe popcnt tsc_deadline_timer xsave avx f16c rdrand lahf_lm abm ida arat epb xsaveopt pln pts dtherm tpr_shadow vnmi flexpriority ept vpid fsgsbase bmi1 avx2 smep bmi2 erms invpcid
bogomips	: 3392.12
clflush size	: 64
cache_alignment	: 64
address sizes	: 39 bits physical, 48 bits virtual
power management:

import random
import time
def odd_f():
    count = 0
    while True:
        count += 1
        num = yield 'continue'
        print("odd: {}".format(num))
        if count >= 10:
            break
    yield 'quit'
def even_f():
    count = 0
    while True:
        count += 1
        num = yield 'continue'
        print("even: {}".format(num))
        if count >= 10:
            break
    yield 'quit'
def main():
    _callbacks = {}
    _callbacks["odd"] = odd_f()
    _callbacks["odd"].next()
    _callbacks["even"] = even_f()
    _callbacks["even"].next()
    while True:
        time.sleep(1)
        n = random.randint(0, 1000000)
        keys = _callbacks.keys()
        if n & 1:
            if "odd" in keys:
                res = _callbacks["odd"].send(n)
                if res == "quit":
                    del _callbacks["odd"]
        else:
            if "even" in keys:
                res = _callbacks["even"].send(n)
                if res == "quit":
                    del _callbacks["even"]
        if len(_callbacks) == 0:
            break
if __name__ == "__main__":
    main()