java学习

JAVA学习：

【【输入】】：
Scanner scan = new Scanner(System.in);
scan.next/nextLine两种输入字符串的方式，当nextXxx出现时，键盘等待输入流，回车结束。输入流内容可以由nextXxx()获得。
两种方式不同的是，next允许用空格分割，分割后数据在输入流中排队出现，有几个数据就可以用几个next()获得。直到最后一个数据获得后，若还有next语句，界面才会等待键盘再次输入。nextLine读取回车键之前的所有语句，不允许分割，当前已经有被next分割的输入流存在【譬如分割了三个，只有第一个被接收，剩下两个仍然等待】，且未被next()语句接收时，若用nextline接收，将接收剩下的全部数据。
注意：nextline不能跟在nextXX之后，因为后者按回车后，前者会默认把回车读入，所以看似会被跳过。如果确实要再读取一个字符串，这时应该SCN.nextline先跳过一个。
hasnext/hasnextline 两者区别不大，判断当前有无键盘输入流，如果当前已经有被next分隔的输入流队列，则返回TRUE，若没有，则等待输入，再返回TRUE。其输入模式同next一直，也可以被空格分割。分割后内容可以被next或nextline读取。

sc.nextInt(); 方式同next， 得到整形。在接收前可以用hasNextInt来判断输入的是否是整形。 if(scan.hasNextInt()){ i = scan.nextInt() ; ｝
sc.nextFloat(); 方式同next， 得到浮点型。在接收前可以用hasNextFloat来判断输入的是否是浮点型。 if(scan.hasNextFloat()){ f = scan.nextFloat() ;｝

注意：使用while(hasnext)时，不管是连续输入多个整数还是连续输入直到输入了整数，while循环中都需要执行next这类函数，如果把next这类函数去掉，那么输入流根本不会变化，hasNextInt的判断结果总是一样，这不小心就会导致死循环。

【【输出：】】
system.out.println( object arges) 括号类的类型是任意数据类型。

【【主函数：】】
public static void main(String []args)
public：公有的，代表可以被外界（外类外包）访问的。
static：静止的，类函数，预编译，可以被JDK通过运行类来执行而不用创建对象后才能执行的。
void： 不需要返回值的。
main：主函数，主方法，非关键字。
string[] args: 字符串数组类型的参数，实际上是一个零长字符串，在DOS下运行时，可以给该参数输入，大多数情况下并没有特殊意义。

【【class类:】】
public class FreshJuiceTest {｝
java允许自定义的数据类型，且所有函数、方法、成员都必须包含在类中，该类型称为类。
类成员主要有变量、方法（函数）、代码块三种。
【变量】：局部变量、类变量（静态变量）、成员变量（非静态变量、实例变量、对象变量）。局部变量声明在方法、构造方法或者语句块中，只在其中有效，当它们执行完成后，变量将会被销毁，局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。。类变量和实例变量的区别是，类变量是该类中唯一的。用static修饰，被修饰后唯一存在，且先于实例对象存在。通常可以用来制造静态的工具类函数。
【方法（函数）】：主要有静态方法（类方法）、普通方法、构造方法三种。方法可以被重载，即同名方法根据不同的参数，实现不同的功能。如print（）、print（a1）、print（a1,a2）。
静态方法不涉及成员变量，通常是一些共用的功能，它可以先于实例对象存在，因此可以直接被类名引用，所有又称为类方法。如common类下有一个方法：static void print(Object arg0) ，该print就不用新建对象后使用，可以直接被common.print调用。
普通方法则必须被相应对象调用，通常涉及对象特有的成员。
构造方法是该类新建对象的方法，通常可给对象成员赋初值，若构造方法私有化，则禁止新建实例对象。如 common类的构造方法即为[public] common([arges]、[arges]…)｛｝,若public换位private，这该类不可以使用该构造方法创建对象。所有类的第一行默认隐藏一个无参的构造方法。构造方法同样可以被重载。构造方法互相调时要用this（），且只能在方法的第一行使用。
方法及变量有四种访问权限，权限大小从左到右依次增大:private只能类中访问，类外无法访问。 default缺省状态下，可以同包异类间访问。protected 可以同包异类访问，同时允许子类继承后访问使用。public 允许异包访问，也是最大的权限，所有接口内的方法默认都是该权限。

【代码块】分为构造代码块和静态代码块，前者当类实例化对象时即触发，实例化多少次即触发多少次，后者仅当类被加载时触发，只触发一次。通常用来初始化类的成员变量。
扩展如下：
【抽象类】抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。一个类不能同时被abstract和final修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。抽象类可以包含抽象方法和非抽象方法。abstract class Caravan{public abstract void goFast()；｝
【抽象方法】抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。抽象方法不能被声明成final和static。任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。例如：public abstract sample();

【【数据类型和对象】】：
Java的两大数据类型：内置数据类型、引用数据类型
Java语言提供了八种基本类型。六种数字类型（四个整数型byte/short/int/long，两个浮点型float/double），一种字符类型char，还有一种布尔型boolean。
类实例化即为对象，譬如 scanner sca= new scanner(system.in)，sca即为对象。
对象、数组都是引用类型，指向的是内存中的一连串数据的地址，因此它们作为传参时，是传地址而非值的。所有引用类型的默认值都是null。

【【关键字和运算符】】
static ：和VB定义不同，该关键字不能修饰普通变量，只能修饰类成员和类方法，被修饰后唯一存在，且先于实例对象存在。通常可以用来制造静态工具类函数。
tostring：object基态方法，返回字符串，通常用来被继承的子类重写函数。
equal：object基态方法，返回布尔值，判断两个变量的内存地址是否相同，通常用来被继承的子类重写函数。
final：修饰变量时，表示不可被修改，即常量。修饰方法时，表示不可被重写。修饰类时，表示不可被继承。
Abstract修饰符，用来创建抽象类和抽象方法。
instanceof：object instanceof class判断左边的对象是否为右边类或其子类的实例，即左边是否右边的儿子，左边级别必须比右边低。如果是返回TRUE。
import：import java.io.; 访问某个包中的类。
Enum：public enum color｛a，b,c｝
\n： 换行。(0x0a)
\r 回车 (0x0d)
\f 换页符(0x0c)
\b 退格 (0x08)
\s 空格 (0x20)
\t 制表符
" 双引号
’ 单引号
\ 反斜杠
\ddd 八进制字符 (ddd)
\uxxxx 16进制Unicode字符 (xxxx)
toString() 返回字符串
String.trim() 去掉首尾空格
str（对象）.replaceAll(" “, “”) 去空格
.replaceAll(”\s", “”); 去空白符
字符串对象.split("/"[,i]); 分割成为字符串数组
String.join("// ",数组); 合并为字符串
xxxValue() 将number对象转换为xxx数据类型的值并返回。
Math.abs() 求绝对值
ceil() 向左取整，返回类型为double型。
rint() 向右去整，返回类型为double。
round() 返回一个最接近的int、long型值。
min() 返回两个参数中的最小值。
Math.max() 返回两个参数中的最大值。
Math.random() 返回一个随机数。
length() 返回字符串的长度
concat() string1.concat(string2);返回string2连接string1的新字符串。
format() 格式化数字或日期
charAt(int index) 返回指定索引处的 char 值。
int indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。
int indexOf(int ch, int fromIndex)返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
Thread.sleep(); util包，休眠毫秒。
getYear()、getMonth()、getDate()、getHours()、getMinutes()、getSeconds()、getDay() 取得一个日期中相应的年月日
new Data（）；获取当前日期；
new Date().getTime();System.currentTimeMillis();Calendar.getInstance().getTimeInMillis();获取当前日期的LONG值

算术运算符：+、-、、/、%、++、-- 分别为加减乘除，取模，自增和自减
关系运算符：==、!=、> 、<、>=、<=、分别为分别为等于、不等于、大于、小于、大于等于、小于等于
逻辑运算符：&&、||、！ 与或非
赋值运算符：=、+ =（加和运算，A=A+B）、- =（A=A-B）、 =、/ =、（％）=（A=A%B）
条件运算符：?: Y?C:D =if(y,c,d)

【【循环及分支结构】】
循环：
while( 布尔表达式 ) {
//循环内容
}
do {
//代码语句
}while(布尔表达式);
for(初始化; 布尔表达式; 更新) { 如：for(int x = 10; x < 20; x = x+1)｛ 语句｝
//代码语句
}

for(局部变量 : 数组名) 主要用于数组，等价于 for each i in number：如 for(int x : numbers ){语句}注意，当数组为零长时，该语句不遍历，该语句只能看不能改
{
//代码句子
}
限制场景：
1、使用foreach来遍历集合时，集合必须实现Iterator接口，foreach就是使用Iterator接口来实现对集合的遍历的.
2、在用foreach循环遍历一个集合时不能向集合中增加元素，不能从集合中删除元素，否则会抛出ConcurrentModificationException异常。注意，这里的删增包括线程异步操作。所以需要在线程中经常删增元素时，尽量用List 配合for循环,可以随便删增。如果实在要使用set或map，使用iterator.move 和备份集合.add。
3、循环中局部变量是一个指向数组/集合内部的一个指针，不能整体改变这个引用，否则只会指向别的数据，而数组元素本身不变。但可以修改该引用的成员变量数值。

【break】主要用在循环语句或者switch语句中，用来跳出整个语句块。跳出最里层的循环，并且继续执行该循环下面的语句。
【continue】适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。在for循环中，continue语句使程序立即跳转到更新语句。在while或者do…while循环中，程序立即跳转到布尔表达式的判断语句。
分支：
if(布尔表达式)
{
//如果布尔表达式为true将执行的语句
}
if(布尔表达式){
//如果布尔表达式的值为true
}else{
//如果布尔表达式的值为false
}
if(布尔表达式 1){
//如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
//如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
//如果布尔表达式 3的值为true执行代码
}else {
//如果以上布尔表达式都不为true执行代码
}
switch(expression){
case value :
//语句
break; //可选
case value :
//语句
break; //可选
//你可以有任意数量的case语句
default : //可选
//语句
}switch语句中的变量类型只能为byte、short、int或者char。

【【数据转换和格式、日期】】
【各类数据类型转换函数】
byte、int、short、long之间可以从低换到高，直接赋值即可，另外char可以自由转化为int。
若要从高到低，Double D1=new Double(double i);int i1=D1.intValue();将需要转换的高位类型装箱，然后使用该对象的XXvalue功能即可。
1、字符串转整形：Integer.parseInt（）其他Long、Float等类似。
2、整形族转字符串：String.valueOf(int i); Integer.toString(int i);“” + i ;
【DATE类型】
java 不支持直接输入DATE类型，只能通过date date=new DATE（）获取当前时间。
要得到一个固定的日期，只能通过自定义一个字符串，然后用simpledateformat 类的parse方法转化成日期格式。sdf.parse(“2015-10-23”)
或者使用 SQL类的timestamp Date date=Timestamp.valueOf(“2015-12-13 0:0:0:0”);
DATE类方法如下：
MYDATE.gettime（）long类型，返回日期代表的整数值。
MYDATE.getXX（）int类型，获取当前日期的年月日时分秒（XX代表相应字段）
若要计算两日期之间的差值，需要换算为整数值，然后相减，得到毫秒数，然后再转换成固定单位。
long ii =sdf.parse(“2015-10-23”).getTime();
long bb=sdf.parse(“2015-10-03”).getTime();
double x=(ii-bb)/1000/3600/24;
【Calendar】：
Calendar cal = Calendar.getInstance()；得到一个当前日期的日历格式，月份默认是0-11
字段值包括：DAY_OF_MONTH DAY_OF_WEEK DAY_OF_WEEK_IN_MONTH DAY_OF_YEAR YEAR NONTH time 等
方法：
add(int field, int amount) 日历增减添加
after(Object when) before(Object when) 是否在object之后或之前
compareTo(Calendar anotherCalendar) 比较两个日期，相同返回0
get(int field) 返回给定日历字段的值。
getActualMaximum(Calendar.DAY_OF_MONTH); 求当月最大日
getActualMinimum()
getTime() 返回对应的DATE对象
set(int field, int value) set(int year, int month, int date)
set(int year, int month, int date, int hourOfDay, int minute, int second) 设置当前日期时间
setTime(Date date) setTimeInMillis(long millis) 使用给定的日期或毫秒日期设置时间
另外，它还可以由子类复制Calendar calendar=new GregorianCalendar(2007, 11, 25,0,0,0);直接给定时间

【string.format函数】：
string format(String format, Object)
常规类型、字符类型和数值类型的占位符格式： %[index$][标识][最小宽度][.精度]转换符日期和时间类型的占位符格式：$][标识][最小宽度]转换符
与参数不对应的占位符格式： %[标识][最小宽度]转换符

转换符% b n f a e g s c d x % tx
含义 布尔类型 换行符 9位浮点数型 十六进制浮点 指数类型 6位浮点数型 字符串类型 字符类型 整数类型 16进制 百分比 时间日期

标识 含义

• 在最小宽度内左对齐，不可与0标识一起使用
  0 若内容长度不足最小宽度，则在左边用0来填充

对8进制和16进制，8进制前添加一个0,16进制前添加0x

• 结果总包含一个+或-号
  空格 正数前加空格，负数前加-号
  , 只用与十进制，每3位数字间用,分隔
  ( 若结果为负数，则用括号括住，且不显示符号
  如：String.format("%06.2f", 55.2); 显示055.20

【SimpleDateFormat】：
SimpleDateFormat format = new SimpleDateFormat(format str for:yyyy-MM-dd E hh:mm:ss );
format.format(date); format.parse()能够将字符串转为日期，需要注意的是，日期格式必须与转换符严格匹配，并且必须带上try cacth或抛出异常才能成功。
格式化字符：
y M d H/h m s E a
年 月 日 24或12小时 小时中的分钟数 分钟中的秒数 星期 AM/PM标记
w W D F
年中的周数 月份中的周数 年中的天数 月份中的星期
【DecimalFormat】：
DecimalFormat format = DecimalFormat.getCurrencyInstance(format str for："#\u2030"/"##.##"/“0000.00”);
format.format(i)；
0 表示一个数字，被格式化数值不够的位数会补0

表示一个数字，被格式化数值不够的位数会忽略

. 小数点分隔符的占位符
, 分组分隔符的占位符

• 缺省负数前缀
  % 将数值乘以100并显示为百分数
  \u2030 将数值乘以1000并显示为千分数
  该函数在显示位数之外的小数将进行超五进位。

【【File类】】
java.io.File
file f=new file(filename);
canExecute()、canRead()、canWrite() 是否可执行；是否可读，是否可写
isAbsolute() 、isDirectory() 、isFile() 、isHidden() 是否绝对路径名；是否路径；是否文件；是否隐藏
setReadable(boolean readable)、setWritable(boolean writable)、setExecutable(boolean executable) 设置是否可读、可写、可执行
getName() 、getPath() 、getParentFile 取得文件名、路径名、父目录的字符串或FILE形式（若父目录不存在，返回null）
length() 大小，返回LONG
exists() 是否存在 返回TRUE OR FALSE
createNewFile() 当文件不存在时，创建它
mkdir()/ mkdirs() 当创建该文件夹及其子文件夹
delete() 删除该文件夹或文件
getAbsoluteFile() getCanonicalFile() 返回绝对、规范路径名形式，返回file对象
getAbsolutePath() getCanonicalPath() 返回绝对、规范路径的字符串
list([filter]) 返回子文件及子路径的字符串数组形式，可以使用筛选字符进行筛选
listFiles([filenamefilter][filter]) 返回子文件及子路径的file数组形式，可以使用筛选字符进行筛选
可以自定义实现filenamefilter接口，如：
class DirFilter implements FilenameFilter{
private Pattern pattern;

public DirFilter(String regex){
    pattern=Pattern.compile(regex);
}

public boolean accept(File dir, String name) {    
    return pattern.matcher(name).matches();
}

或用匿名类方式实现filer接口
public boolean accept(File pathname) {
if( pathname.isDirectory()) return true;
else
return pathname.getName().matches(".*txt");
}
注意：
当前filename 是一个文件时，getname表示文件带扩展名的名称；path表示filename，它是相对路径时，表示其相对路径形式；abrolutepath表示当前目录的路径+path，相对路径的./也会存在。而Cannoicalpath表示规范的，识别出所有./的文件形式。
当前filename是一个目录时，getname、path都只能读出/前的.或…或…\文件夹 ，绝对路径简单的把当前路径名称+path：D:\Users\yang\eclipse-workspace\Mytest…\Jtest；只有规范路径能读出完整路径名称。

【【继承、多态、接口】】
【继承】：public class B extends A {} 称B继承A，B为A的子类、延伸类，A为父类、超类、基类，B类的对象可以调用A类允许使用的所有成员、方法、代码块。我们通常将多种类共用的一些属性、功能抽取出来，以使共用。这个共用的类就是父类。instanceof 当左边的对象是右边类的实例或其子类的实例时，返回TRUE。继承只能单一继承。
【重写】：当子类和父类拥有同名的方法时（权限（非pirate）名称参数数量都要完全相同），默认调用子类的变量或方法，这种覆盖称为重写。若确实要调用父类而非子类的方法，必须使用super关键字进行指定。当子类中的某些功能未确定或经常要改变时，可以交由继承的子类去实现，使其可以很方便的替换或覆盖这个原始的功能。譬如一个测量某语句块运行时间的方法函数，就可以把具体的语句块封装成为一个函数，由继承的子类去随时更改。
【抽象方法及抽象类】：public abstract class Employee{ public abstract double computePay();｝
被abstract修饰的类即抽象类，抽象类可以包含抽象方法，也可以包含普通方法。但定义成抽象类后就不能实例化对象，所以抽象类必须被继承，才能被使用。父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。如上例的测量语句运行时间中，父类的函数实际上必定被重写，所以可以不必实体存在，只需抽象表示即可，所以该方法可以定位为抽象方法，那么包括抽象方法的类就必定要是抽象类了。
抽象方法自己不能实现，所以必然要被继承的子类重写实现。换句话说，任何子类必须重写父类的抽象方法，或者声明自身为抽象类。
【多态】：当一个父类被多个子类继承时，该父类对象的引用可以用来表示所有子类，譬如class man extends human human类型的对象可以用来表示一个man对象，当然又有woman继承human时，human也可以用来表示一个human对象，这就是父类对象的多态特性。一个子类对象被转型成一个父类对象被称为向上转型，这是java允许的，而一个父类对象转型为子类对象时，则要通过instanceof判断该父类是否实际是一个子类引用，才可以“还原”。
Human man=new Man()； 当一个父类引用man指向一个Man类型的变量时，它只可以调用属于human父类对象的所有方法，但因为实际指向的是子类变量的内存地址，所以实际运行时调用的是子类Man类型的方法，这种方法调用称为虚方法。这样，我们就可以通过一个父类变量来使用同名但是完全不同的方法功能了，这就是所谓多态的特性。
需要注意两点：
1、父类引用指向子类变量时，虽然在编译器看来他是一个父类对象，只能访问父类特有的方法和变量，这时访问子类变量会发生编译错误。但是，其本身还是一个子类变量没有变，如果调用的父类方法被子类重写过，调用的仍旧是子类重写后的方法功能。
2、多态特性是不包括成员变量的，同名的父类成员变量只是被隐藏。多态的父类对象访问同名成员变量，访问的仍旧是父类而非子类。但在调用被重写的方法时，可以允许使用子类的成员变量。
3、静态方法除外，由于静态方法先于对象存在，所以无论对象如何指向，哪种类的实例对象调用的静态方法仍旧是该类的方法，这个地址块是唯一的。
总结如下：
1、多态对象调用的方法是其未转型或传入前原本的方法，而非转型后对象类的方法。
2、多态对象无法调用本身类没有的方法，除非转型回去。
3、多态对象的同名成员变量不会被重写，父类对象访问的仍旧是父类的成员变量，但它的方法允许访问子类存储的同名成员变量，而非使用父类的。
4、调用静态方法时例外。
【接口】：[可见度] interface 接口名称 [extends 其他的类名] {//抽象常量或抽象方法｝如：public interface NameOfInterface
接口类似抽象类，但它其中全是抽象成员，即是抽象方法的集合。
1、一个类通过继承接口的方式，从而来继承接口的抽象方法，因为接口不能实例化使用，必须由继承的类实现，所以这种继承专称为“实现”implements。
2、一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。
3、接口可以多实现，即一个类可以实现多个接口的功能。
4、接口中的变量是公有、抽象的。即其方法即使不写，也会默认添加abstract、public字样。这意味着实现它方法的类也必须是public权限的。
5、接口可以继承接口，并且可以多继承。
很显然，接口很容易用来实现多态特性，它虽然不包含一个具体方法，但却可以用来使用被实现的子类的多种方法。

【【异常处理】】
try
{
// 程序代码
}catch(Exception e)
{
//Catch 块
}
说明，try catch内的代码可正常运行，若其中有异常，会直接略过，同时运行catch内的语句。结构中的 e 是 Exception类的对象，包括了异常类型，描述等信息。
根据括号内需要匹配的Exception类型的不同，也可以根据异常的类型进行不同的分支处理，这就是多重捕获。
try{
// 程序代码
}catch(异常类型1 异常的变量名1){
// 程序代码
}catch(异常类型2 异常的变量名2){
// 程序代码
}catch(异常类型2 异常的变量名2){
// 程序代码
}
在方法名的右边，也可以用throws Exception关键字抛出异常，使方法可以顺利运行下去，将异常交给上级处理。如果在主方法也使用，java虚拟机将会结束程序。（用来防止崩溃和死机）
Exception分为两大类：IOException类 RuntimeException类。以下列举一些异常类型：
ArithmeticException 整数"除以零"
ArrayIndexOutOfBoundsException 数组引用超出边界。
ClassCastException 对象转型错误，不是匹配类

try catch finally执行顺序为：
1、try 中语句一旦发生异常，不执行发生异常的那一句，立即跳到catch，然后执行finally，相当于on error goto catch；
2、不管有没有异常，即使try/catch中有return时，finally都会执行。
3、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的；
4、如果finally中有return，该return会覆盖前面的return，返回值以finally为准，所以尽量不要把return放到finally中。

【【数据结构和集合类】】
java内置了几种数据结构，预先实现了删增改查等功能。
ArrayList线性表：
调用：arraylist rng =new arraylist();可以用泛型指定集合类的类名 arraylist<类型名>
新增：rng.add(加入的对象)；rng.add(i,rng)添加到固定i（从0到size-1）后面的位置
查询：rng.get（i）;i是索引，大小从0到rng.size()-1;
修改：rng.get(i).属性=新属性/rng.set(i,obj)
删除：rng.remove(i)
数量：rng.size()
其他：.isEmpty()是否是空表 Clear()清除所有
LinkedList链表:
删增改查所有功能和线性表相同，作为链表，容易对表头和表尾进行访问，它提供了一些新的方法：
.addFirst() 首位新增一个
.addLast() 末尾新增一个
.removeFirst()/.removeLast() 首尾删除一个
线性表和链表的数据结构特征导致优缺点分明：
链表优点：新增和删除操作效率高，表越长，访问和修改操作的耗时越长。
线性表：按索引访问和修改效率高，在表中间进行删增操作效率极低。

Stack栈：
arraylist 所有功能Stack 全都有，它完全可以当成普通线性表使用，但它通常用来实现堆栈的特有功能，即后进先出。
.push() 把项压入堆栈顶部
.pop() 移除堆栈顶部的对象，并作为此函数的值返回该对象。
.empty() 是否空栈
.peek() 查看堆栈顶部的对象，但不从堆栈中移除它。
. search() 查找对象在堆栈中的位置

Vector向量：
功能大概与arraylist相同，区别在于vector是同步工作的，安全高但是效率较低。

HashMap哈希表：
提供的键值的线性表，键可以删除不可以修改。键对应的值可以通过重新覆盖来修改。
Object put(Object key, Object value)，当key相同时，会覆盖前一个数据，不同时，新建一个数据。
boolean containsKey(Object key)，查询键值是否重复，用来配合新增或查找数据。
boolean contains(Object value)，查询该值是否有配合的键
Object get(Object key)，根据键取得值，若不是合法键，返回null
boolean isEmpty( )，是否为空
Object put(Object key, Object value)，新增键值数据
Object remove(Object key)，根据键删除数据
void clear( ) 清空
int size( ) 大小

Set<Map.Entry<K,V>> entrySet() 根据该map映射返回一个对应的 set集合，集合中装载对象的类型为map.entry接口类型
Map.entry：所有map有一个嵌套的内部类/接口，为该类型，它是一对键值映射集合，修改后map同步修改。它具有getKey() 、getValue() 、setValue(V value) 等方法
Set keySet() 根据该map返回一个对应所有Key值的set集合。
Collection values() 根据该map返回一个对应所有value的collection集合。
注意：entryset、kyset返回的 set视图是和map绑定的，values 返回的collecttion也是。双方的修改会互相反映出来通过 Iterator.remove、Set.remove、removeAll、retainAll 和 clear 操作可从映射中移除相应的映射关系。它不支持 add 或 addAll 操作。

Iterator it=Rng1.keySet().iterator(); it 是哈希表的遍历类型，他可以遍历所有键值
it.hasNext() 遍历完所有键值后返回FALSE
it.next().tostring() 返回键的字符串表达
for(Map.Entry<String,Student> entry : students.entrySet() ) 最方便的map遍历

结构图如下：
collection：add[all] clear contains[all] equals hashcode isempty iterator remove[all] retainall size toarry
list:成员有顺序，可重复。add(i,obj) get indexof remove(index) set sort sublist(i,j)
linkedlist:链表，删增快，改查慢。不同步
arrylist：线性表，删增慢，改查快。不同步
vector：向量表，同arrylist，同步，效率较低。
stack：栈，具体方法见上。
set：成员无顺序，不重复。e1.equals(e2) 则不添加。有add，remove。但是没有个get（）set。只可用iterator遍历取得。
hashset
LinkedHashSet
treeset
map：键值映射 put方法，key重复则覆盖。有get、remove。没有set。
hashtable 同步
hashmap 非同步
两大接口，所有实现了iterator方法的类，都可以用迭代器的hasnext next remove来进行访问和删除操作。
注意：list类的iterator实现了add、remove方法，所以可以在for（i;i++）循环中随意删增，而其他set/map则没有实现，只能使用itreator.remove方法。增加只能先增加到备用容器，遍历完毕之后再一次性addall。
collections 类提供了一些静态方法可以对集合类进行操作：
addAll（c） binarySearch(list,obj) copy(list,list) max/min© reverse(list) sort(list) swap(list,i,j)
所有集合类，设计到查找，覆盖的操作，关键都是装载的实体对象的equal方法、hashcode方法，默认调用该方法来进行判断是否一致，所以如果需要自定义对象进行覆盖，必须重写自定义类的equal方法。
如果需要对自定义对象进行排序，则必须实现compareable接口的compareto方法。

【【IO流】】
基本接口：
inputstream：字节输入/Reader 字符输入
void mark(int readlimit) 标记当前位置
特】：int read() 读取下一字节，没有下一输入返回-1。注意input的返回值是由int装载的一个字节，而Reader这是一个字符，要用到该字节或字符时，需要强制转换为CHAR。
long skip(long n) 跳过N个字节
void reset() 重新定位到上次的MARK位置
int read(byte[] b) /int read(char[] cbuf) 直接将一个字节/字符数组读写。对于机器码和输出流转化十分有用
int read(byte[] b, int off, int len) /read(char[] cbuf, int off, int len) 重复调用底层的read存入数组b，返回存储的字节/字符数，到末尾返回-1
void close()
int available() 返回可读的字节数目（stream专有）
Reader专有： boolean ready() 判断是否准备读取此流。int read(CharBuffer target) 试图将字符读入指定的字符缓冲区。
outputsteam：字节输出/Writer 字符输出
特】：void write(int b) 将指定字节写入输出流。注意，output写入b的8个低位，24高位会被忽略，即一个字节。Writer写入b的16个低位，后16高位被忽略，即一个字符。
当使用Wirter时，输出的是存储在变量中的字节/字符，而非整形b代表的ASCII码，所以不用强制转化为CHAR，实际上JAVA中CHAR可以自由转化为int，所以该方法也可以字节输出字符。
void write(byte[] b) /write(char[] cbuf)
void write(byte[] b, int off, int len) /write(char[] cbuf, int off, int len)
void flush() 刷新此输出流并强制写出所有缓冲的输出字节。
void close() 关闭此输出流并释放与此流有关的所有系统资源。
Writer专有：
特】：void write(String str) 写入字符串。
void write(String str, int off, int len) 写入字符串的某一部分。
Writer append(char c) 将指定字符添加到此 writer。
字符流适合操作文本文件。字节流适合操作非文本文件。

【节点流-最基础获得流的实现类】：
1、File(xx):xx=outputstream/inputstream/writer/reader
InputStream f = new FileInputStream(“C:/java/hello”);
OutputStream f = new FileOutputStream(“C:/java/hello”[, boolean append])。如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处。
2、ByteArray(input/out)
字节数组输入流在内存中创建一个字节数组缓冲区，从输入流读取的数据保存在该字节数组缓冲区中。
ByteArrayInputStream bArray = new ByteArrayInputStream(byte [] a);该流能帮助程序读取一个字节数组a，即起到读取识别机器码的作用。
OutputStream bOut = new ByteArrayOutputStream([int size]) 该流可以将字符串、java类型、对象等输出成为字节数组（bout.tobytearray）,即起到转制机器码的作用。当不指定默认的内置内存数组大小时，缓冲区最初为32字节，当然，也可以通过int size来制定其初始字节数。
【处理流-用于特殊处理的包装类】：
1、Buffered(xx)输入一个节点流，按回车分割读取，达到读取行的作用。一般用来处理字符数据。
外接一个具有缓冲区的流，能够减少对硬盘的读写次数，并增加效率。
BufferedReader 有一个独有方法：
String readLine() 读取一个文本行。通过下列字符之一即可认为某行已终止：换行 (’\n’)、回车 (’\r’) 或回车后直接跟着换行。如果已到达流末尾，则返回 null

BufferedWriter(Writer out) 独有方法：
void newLine() 写入一个行分隔符。

2、Data(out/imput) 输入一个节点流，使用readint等方法直接读写基本类型。
DataInputStream(InputStream in)/ DataOutputStream(OutputStream out)
read/write+四类八种 读或写基本 Java 数据类型。
String readUTF() 从流 in 中读取用 UTF-8 修改版格式编码的 Unicode 字符格式的字符串；然后以 String 形式返回此字符串。
void writeUTF(String str)以与机器无关方式使用 UTF-8 修改版编码将一个字符串写入基础输出流。
int size() 返回计数器 written 的当前值，即到目前为止写入此数据输出流的字节数。
该流输出/读取的都是储存好的二进制代码，机器可读而人不可读。

3、OutputStreamWriter /InputStreamReader 输入一个节点流，刻意使用指定字符集来读写文字。
OutputStreamWriter(OutputStream out,String charsetName)创建使用指定字符集的 OutputStreamWriter，如UTF-8/UTF-16LE/US-ASII等。
InputStreamReader(InputStream in, String charsetName) 创建使用指定字符集的 InputStreamReader。
String getEncoding() 返回此流使用的字符编码的名称。

4、print(stream/writer)只能输出，将内存数据打印成字符串
PrintStream(File file) 创建具有指定文件且不带自动行刷新的新打印流。
PrintStream(String fileName, String csn) 创建具有指定文件名称和字符集且不带自动行刷新的新打印流。
PrintStream(OutputStream out, boolean autoFlush, String encoding)
包含所有print、printf、println、format方法 输出的全部都是字符串，原始数据不再可读。
printWriter和printStream都属于输出流，分别针对字符和字节，其余方面没有太大的区别，且都有自动的flush功能。

5、object(xx) 序列化内存数据到文件，逆序列化文件到内存
需要打印的对象，定义类时需要实现Serializable或Exernalisable接口
ObjectInputStream(InputStream in) 构造对象时，如果要读取的文件或内存数组为空，会返回EOF错误。
public class tt implement Serializable｛｝
tt t=new tt();
os.writeobiect(t);t=(tt) os.redobject();
Object readObject() 从 ObjectInputStream 读取对象 会返回
它会抛出以下异常：
ClassNotFoundException - 找不到序列化对象的类。
InvalidClassException - 序列化使用的类出了问题。
StreamCorruptedException - 流中的控制信息不一致。
OptionalDataException - 在流中找到基本类型数据而非对象。
IOException - 任何常规的输入/输出相关的异常。

writeObject(Object obj) 将指定的对象写入 ObjectOutputStream。
Java序列化中需要注意:
1、当一个对象被序列化时，只保存对象的非静态成员变量，不能保存任何的成员方法,静态的成员变量（但不会出错）和transient标注的成员变量。
2、如果一个对象的成员变量是一个对象，那么这个对象的数据成员也会被保存还原，而且会是递归的方式。 （做为成员变量的对象的类必须也实现Serializable接口）
3、如果一个可序列化的对象包含对某个不可序列化的对象的引用，那么整个序列化操作将会失败，并且会抛出一个NotSerializableException。可以将这个引用标记transient,那么对象仍然可以序列化。
4、在节点流为文件流的情况下，如果文件为空，会抛EOF异常。
5、TCP、socket通信情况下，客户端和服务端不可都先建立输入流，否则产生死锁。

【包装类总结】：
1、需要处理文本数据时，用writer/reader，处理非文本数据时，务必用stream。
2、内存输出：需要将内存中的字符串输出到文件时，使用print。需要将内存中的基本类型输出时，使用data。将内存中的类输出时，使用object。
3、外界文件复制或转化:原则为将外界文件读取到程序变量中，然后使用read方法一个接一个读取。在处理文本文件时，可以使用buffered的readline，一行一行读取后输出。否则，必须使用最基础的read功能，而且底层必须为字节流。

小贴士：对于非read和readline方法，可用以下方法判断是否读到文件结尾。
try{
}
读取方法
catch(EOFException){
break；
}

【commons-IO.FileUtils】
deleteDirectory：删除文件夹
readFileToString：以字符形式读取文件内容
deleteQueitly：删除文件或文件夹且不会抛出异常
copyFile：复制文件
writeStringToFile：把字符写到目标文件，如果文件不存在，则创建
forceMkdir：强制创建文件夹，如果该文件夹父级目录不存在，则创建父级
write：把字符写到指定文件中
listFiles：列举某个目录下的文件(根据过滤器)
copyDirectory：复制文件夹
forceDelete：强制删除文件

【IOUtils】
IOUtils.toString( in )
closeQuietly：关闭一个IO流、socket、或者selector且不抛出异常，通常放在finally块
toString：转换IO流、 Uri、 byte[]为String，常用于读取字符文件。
copy：IO流数据复制，从输入流写到输出流中，最大支持2GB，输入输出传输，列入内存字节数组输出到文件等。
toByteArray：从输入流、URI获取byte[]，从输入流获取字节数组，常用于读取字节数据。
write：把字节. 字符等写入输出流。
toInputStream：把字符转换为输入流
readLines：从输入流中读取多行数据，返回List
copyLarge：同copy，支持2GB以上数据的复制
lineIterator：从输入流返回一个迭代器，根据参数要求读取的数据量，全部读取，如果数据不够，则失败

【FilenameUtils】
getExtension：返回文件后缀名
getBaseName：返回文件名，不包含后缀名
getName：返回文件全名
concat：按命令行风格组合文件路径(详见方法注释)
removeExtension：删除后缀名
normalize：使路径正常化
wildcardMatch：匹配通配符
seperatorToUnix：路径分隔符改成unix系统格式的，即/
getFullPath：获取文件路径，不包括文件名
isExtension：检查文件后缀名是不是传入参数(List)中的一个

【【线程】】
创造线程的两种方法：
1、继承Thread类，然后将线程要运行的代码重写在run方法里。调用thread类的start方法即可运行一个线程。
class PrimeThread extends Thread {
public void run() {
// compute primes larger than minPrime
. . .
}
｝
PrimeThread p = new PrimeThread(143);
p.start();
2、创建线程的另一种方法是声明实现 Runnable 接口的类，实现 run 方法。然后可以分配该类的实例，在创建 Thread 时作为一个参数来传递并启动。
class PrimeRun implements Runnable {
public void run() {
// compute primes larger than minPrime
. . .
}
}
PrimeRun p = new PrimeRun(143);
new Thread§.start();
静态方法集：
int activeCount() 返回当前线程的线程组中活动线程的数目
Thread currentThread() 返回对当前正在执行的线程对象的引用。
boolean interrupted() 测试当前线程是否已经中断。
sleep(long millis) 当前正在执行的线程休眠
yield() 暂停当前正在执行的线程对象，并执行其他线程。
重要方法集：
getid/name/priority/state 取得该线程的ID名称优先级状态
isAlive() 该线程是否处于非结束状态。
join() 合并该线程，即等待该线程中止才运行其他线程。
setname/priority 修改线程名称、优先级
默认字段：NORM_PRIORITY MIN_PRIORITY MAX_PRIORITY
wait(), notify()和notifyAll()
【synchronized】：
同步关键字，可用来锁定一个方法或在一段代码块中锁定某个对象属性（包括自身this）,它能防止多个线程同时执行同一个对象的同步代码段。
所谓同步：是指两个特定步骤中不能允许其他用户或线程同时操作访问，例如取款和账户减少。
public synchronized void test() { }或 synchronized(this){//代码块}。
当某一个线程访问到一个带锁的同步方法时，该对象即被锁定，其他线程在此段时间访问该对象的所有同步方法（带互斥锁）的方法时，需要等待该线程执行完该同步方法或语句才能继续访问。
注意：使用第一种继承法创造线程时，多起线程访问的往往是多新建的对象，而不是同一个对象，这时最好用类的构造方法，先新建一个对象，再传导进去。这样synchronized才能有效。
如：Sync sync = new Sync(); new MyThread(sync).start; new MyThread(sync).start; 两个新起线程访问的都是一个Sync对象。
第二种实现接口的方法，由于传导的都是同一个接口多态对象，所以不存在这种情况。
同步方法的原则：
1、所有涉及读取对象的方法可以不带锁。
2、所有涉及修改对象的方法必须都是同步方法，都必须带锁。
3、如果方法的运行时间太长，建议只锁定关键修改数据的步骤，减小锁的粒度，使代码更大程度的并发，增加其效率。

【【GUI】】
【component】：组建，所有可视化图形。
其主要方法如下：
setLocation(int x, int y) 设置组建的位置
setSize(int width, int height) 设置组建的宽高
setBounds(int x, int y, int width, int height) 设置组建位置和宽高
setBackground(Color c) 设置组建的背景色。注意：在设置窗体背景色时，没有任何绘图或组建的空白窗体是不启用的
setVisible(boolean b) 设置组建是否可见
setEnabled(boolean b) 根据参数 b 的值启用或禁用此组件。
setFont(Font f) 设置组件的字体。
setForeground(Color c) 设置前景色
setBackground(Color c) 设置背景色
setCursor(Cursor cursor) 为指定的光标设置光标图像 Cursor(int type) Cursor(String name)
addXXListener 添加某种监听器
boolean contains(int x, int y) 检查组件是否“包含”指定的点
getX() getY() getWidth() 返回组建的大小宽高等
boolean hasFocus() 是否获得焦点
paint(Graphics g) 绘制此组件。paintAll(Graphics g) 绘制此组件及其所有子组件。
repaint() 重绘此组件。

container：容器，用来装载组建，组建必须装载在组建中才能使用。包括window（自由停泊的主窗口）、panel（非自由停泊的主窗口）。
主要方法如下：
add(Component comp[, int index]) 添加组建,可通过布局管理器的相应整形常量指定添加的给定位置。如边界布局的borderlayout.CENTER/EAST/NORTH 等。
remove(Component comp) 删除组建
setLayout(LayoutManager mgr) 设置此容器的布局管理器。

color：颜色对象，用来表示某种颜色。
Color(int rgb) /Color(int r, int g, int b)color有很多静态方法，都是返回color对象的，如color.black cyan 等
ImageIcom(string path) 图标类型
frame/JFrame：框架，window的子类。
主要方法如下：
setTitle(String title) 设置标题
setResizable(boolean resizable) 设置此窗体是否可由用户调整大小。
setDefaultCloseOperation(f.EXIT_ON_CLOSE);
setIconImage(Image image) 设置左上角图标
pack() 自动匹配大小

【Layout】：
borderlayout】：边界布局，frame的默认布局 容器若不指定
BorderLayout(int hgap, int vgap) 创建指定水平和垂直间隙的布局管理器，缺省为5像素。
该布局为东南西北中布局，每个部位只能放一个控件。中间最大，且永远不被覆盖，其他任意一方缺失，将由中部和其接壤部位覆盖。容器添加时不指定方位，默认添加在中部。
flowlayout】：流式布局，panel的默认布局
FlowLayout(int align, int hgap, int vgap) 创建一个新的流布局管理器，它具有指定的对齐方式以及指定的水平和垂直间隙。
align默认字段有 CENTER 中心对齐 LEFT左对齐 RIGHT 右对齐 缺省对齐方式为居中，缺省行间距列间距为5像素。
gridlayout】：表格布局。
GridLayout(int rows, int cols, int hgap, int vgap) 创建具有指定行数和列数，指定行间距和列间距的网格布局。
当控件数目超出表格数目时，布局管理器会在保持行数的情况下增加列数。
布局管理器：

【SWING包控件】
Jframe、JPanel。
JSplitPane 拆分窗口
JSplitPane(int newOrientation,[ boolean newContinuousLayout, ]Component newLeftComponent, Component newRightComponent)
创建一个具有指定方向、重绘方式和指定组件的新 JSplitPane。
newOrientation：HORIZONTAL_SPLIT左右排列 VERTICAL_SPLIT 上下排列
setOneTouchExpandable 设置是否可左右扩展
按钮：
JToggleButton：切换按钮，分为按下或没有按下
JRadioButton:单选按钮，多个单选按钮需要添加在ButtonGrop 按钮组中，才能执行单选操作。但添加到容器中仍然需要一一添加。
JCheckbox：复选按钮
JButton:按钮
有settooltiptext(string a)方法，设置鼠标移动上去显示的文字

文本框：
JLabel 标签 JLabel(Icon image) JLabel(String text, Icon icon, int horizontalAlignment{对齐方式})
JTextField 文本框
JPasswordField 密码框
JTextArea 文本域
有setfont 方法 如：setfont(new font(“宋体”,font.plain,16）
Font(String name, int style, int size)
style：.BOLD粗体样式 .ITALIC斜体样式 .PLAIN 普通样式

菜单：
JMenuBar:菜单条
JMemu 有下级项目的非端点条目
JMemuItem 没有下级项目的端点条目 实例化时可以添加"新建(E)"
方法：setmnemonic(char a) 设置快捷键
new menu.addseparator 添加分隔符

下拉条表格滚动条等：
JComboBox 下拉框 实例化时传入字符串数组。 new JComboBox(String[] i)
JList 表格 和下拉框一样，有一个setvisiblerowcount(int i)，默认显示行数
JToolBar 工具条 它的子项目是JButton
JScrollBar、JScrollPane 滚动条，new JScrollPane(new JTextArea)构造带有文本域的滚动视图。
JTabbedPane 选项卡
子项目是 JPanel，需要使用ADD方法加入，如：.add(“项目一”,JPanel1）;

外置窗口：
【JFileChooser】 文件对话框
JFileChooser fc=new JFileChooser(new File("./"));
int showDialog(Component parent, String approveButtonText) parent设置其父级组件，对话框在夫组件上居中。
弹出具有自定义 approve 按钮的自定义文件选择器对话框。
int showOpenDialog(Component parent)
弹出一个 “Open File” 文件选择器对话框。
int showSaveDialog(Component parent)
弹出一个 “Save File” 文件选择器对话框。
setCurrentDirectory(File dir)
返回值：.CANCEL_OPTION .APPROVE_OPTION .ERROR_OPTION
设置当前目录
setDialogTitle(String dialogTitle)
设置显示在 JFileChooser 窗口标题栏的字符串。
setFileFilter(FileFilter filter)
设置当前文件过滤器。FileNameExtensionFilter进行构造：FileNameExtensionFilter(String description, String… extensions) 如(“请选择图片文件”, “png”, “jpg”)不支持通配符
setFileHidingEnabled(boolean b)
设置是否实现文件隐藏。
setFileSelectionMode(int mode) mode:FILES_ONLY/DIRECTORIES_ONLY/FILES_AND_DIRECTORIES
设置 JFileChooser，以允许用户只选择文件、只选择目录，或者可选择文件和目录，默认只选择文件
setMultiSelectionEnabled(boolean b)
设置文件选择器，以允许选择多个文件。
File getCurrentDirectory()
返回当前目录。
File getSelectedFile()
返回选中的文件。
File[] getSelectedFiles()
如果将文件选择器设置为允许选择多个文件，则返回选中文件的列表。
【JOptionPane】：警告提示输入错误对话框
parentComponent message title optionType messageType icon initialSelectionValue selectionValues options
父组件 提示消息 标题 按钮类型 消息类型 自定义图标 默认选项或信息 输入框的可选项 选择框的自定义按钮
optiontype：
DEFAULT_OPTION、YES_NO_OPTION、YES_NO_CANCEL_OPTION、OK_CANCEL_OPTION
-1 0 1 2
确定、是否、是否取消、确定取消
messageType：
ERROR_MESSAGE、INFORMATION_MESSAGE、WARNING_MESSAGE、QUESTION_MESSAGE、PLAIN_MESSAGE
0 1 2 3 4 错认警问
红色叉、黄色叹号、蓝色叹号、问号、无图标
返回值：
YES_OPTION、NO_OPTION、CANCEL_OPTION、OK_OPTION、CLOSED_OPTION
0 1 2 0 -1
options：
showConfirmDialog()：确认对话框 常规3+选择两项+图标 5
int showConfirmDialog(Component parentComponent, Object message, String title, int optionType, int messageType, Icon icon)
默认标题：选择一个选项；默认按钮类型：YES_NO_CANCEL_OPTION 默认消息类型：question问号

showInputDialog()：输入对话框 没有必要设置按钮，所以共有常规3+消息样式+图标+可选项+默认值
String showInputDialog(Component parentComponent, Object message, String title, int messageType) 返回值为字符串的输入框
String showInputDialog(Object message, Object initialSelectionValue) 返回值为字符串，有默认值的输入框
Object showInputDialog(Component parentComponent, Object message, String title, int messageType, Icon icon, Object[] selectionValues, Object initialSelectionValue)
默认标题：输入；无自定义按钮类型；默认消息类型：问号：实际返回类型：字符串
建议采用第二种方式使用

showMessageDialog()：消息对话框 因为没有必要设置按钮，所以共有常规3+消息样式+图标 5
void showMessageDialog(Component parentComponent, Object message, String title, int messageType, Icon icon)
标题：消息；按钮：default-1只确定 图标：NFORMATION确认形蓝色叹号

showOptionDialog()：选择对话框 常规三项+选择两项+图标+按钮数组+默认值 8
int showOptionDialog(Component parentComponent, Object message, String title, int optionType, int messageType, Icon icon, Object[] options, Object initialValue)
该对话框没有简略选项，只能输入所有参数，返回值为数组下标，取消返回-1，即CLOSED_OPTION

【listener】：
基本实现方式：
new component.addXXlistener（mymoniter）;
class mymoniter implements xxlistener{
void actionPerformed(ActionEvent e){
//动作语句
}
}implements xxlistener 也可以改成：XXadapter
EventObject所有事件状态对象都将从其派生的根类。
一个控件可以添加多个监听器，事件顺序按主函数中添加监听器的顺序。
Object getSource() 最初发生 Event 的对象。

各类监听器和监听事件如下：
【ActionListener】接口：
actionPerformed方法() 按钮动作时发生

ActionEvent 事件可通过以下方法传递事件信息：
String getActionCommand() 返回与此动作相关的命令字符串。
int getModifiers() 返回发生此动作事件期间按下的修改键。
long getWhen() 返回发生此事件时的时间戳。
String paramString() 返回标识此动作事件的参数字符串

【ComponentListener】接口:ComponentAdapter类
方法摘要
void componentHidden(ComponentEvent e)
组件变得不可见时调用。
void componentMoved(ComponentEvent e)
组件位置更改时调用。
void componentResized(ComponentEvent e)
组件大小更改时调用。
void componentShown(ComponentEvent e)
组件变得可见时调用。
ComponentEvent：
Component getComponent() 返回事件的始发者。
String paramString() 返回标识此事件的参数字符串。

【ItemListener】接口：
itemStateChanged(ItemEvent e) 在用户已选定或取消选定某项时调用。
ItemEvent：略

【KeyListener】接口：KeyAdapter类
void keyPressed(KeyEvent e)
按下某个键时调用此方法。注意：中文状态下进行输入时，此方法不启用。即拼音选词时是没有反应的，非拼音选词状态，输入其他不会产生输入的键例如方向删除，则会有反应。
void keyReleased(KeyEvent e)
释放某个键时调用此方法。注意：中文状态下，该方法仍旧可用。
void keyTyped(KeyEvent e)
键入某个键时调用此方法。
键入：产生【一个】Unicode字符输入时。例如英文状态下输入a 按SHIFT+a输入A 或中文状态下输入“啊”，都产生一个键入事件。中文输入“你好吗”时，产生三个键入事件。
KeyEvent：
char getKeyChar()
返回键入事件产生的一个Unicode字符，若此时没有产生任何字符（如在kypressed方法内调用，但只是按了一个左方向键时），返回CHAR_UNDEFINED。
int getKeyCode()
返回与此事件中的键关联的整数 keyCode。
static String getKeyModifiersText(int modifiers)
返回描述修改键的 String，如 “Shift” 或 “Ctrl+Shift”。
static String getKeyText(int keyCode)
返回描述 keyCode 的 String，如 “HOME”、“F1” 或 “A”。

【EventListener】接口：MouseAdapter类
void mouseClicked(MouseEvent e)
鼠标按键在组件上单击（按下并释放）时调用。
void mouseEntered(MouseEvent e)
鼠标进入到组件上时调用。
void mouseExited(MouseEvent e)
鼠标离开组件时调用。
void mousePressed(MouseEvent e)
鼠标按键在组件上按下时调用。
void mouseReleased(MouseEvent e)
鼠标按钮在组件上释放时调用。
MouseEvent：
int getClickCount()
返回与此事件关联的鼠标单击次数。
Point getLocationOnScreen()
返回事件的绝对 x, y 坐标。
Point getPoint()
返回事件相对于源组件的 x, y 坐标。
int getX()
返回事件相对于源组件的水平 x 坐标。
int getY()
返回事件相对于源组件的垂直 y 坐标。
int getXOnScreen()
返回事件的绝对水平 x 坐标。
int getYOnScreen()
返回事件的绝对垂直 y 坐标。

【MouseMotionListener】接口：MouseMotionAdapter
void mouseDragged(MouseEvent e)
鼠标按键在组件上按下并拖动时调用。
void mouseMoved(MouseEvent e)
鼠标光标移动到组件上但无按键按下时调用。
MouseEvent：见上一个接口
【MouseWheelListener】接口：
mouseWheelMoved(MouseWheelEvent e) 鼠标滚轮旋转时调用。
MouseWheelEvent：
int getScrollAmount()
返回每转动一下鼠标滚轮应该滚动的单位数。
int getScrollType()
返回响应此事件时应该发生的滚动类型。

【TextListener】接口：
textValueChanged(TextEvent e) 文本的值已改变时调用。
TextEvent：略

【WindowListener 】接口：WindowAdapter
void windowActivated(WindowEvent e)
将 Window 设置为活动 Window 时调用。
void windowClosed(WindowEvent e)
因对窗口调用 dispose 而将其关闭时调用。
void windowClosing(WindowEvent e)
用户试图从窗口的系统菜单中关闭窗口时调用。
void windowDeactivated(WindowEvent e)
当 Window 不再是活动 Window 时调用。
void windowDeiconified(WindowEvent e)
窗口从最小化状态变为正常状态时调用。
void windowIconified(WindowEvent e)
窗口从正常状态变为最小化状态时调用。
void windowOpened(WindowEvent e)
窗口首次变为可见时调用。
WindowEvent：
int getNewState()
对于 WINDOW_STATE_CHANGED 事件，返回新的窗口状态。
int getOldState()
对于 WINDOW_STATE_CHANGED 事件，返回以前的窗口状态。
Window getOppositeWindow()
返回在此焦点或活动性变化中所涉及的其他 Window。
Window getWindow()
返回事件的发起方。

【paint】方法：
每次容器发生变化时，会默认调用此重画方法。也可以通过repaint()方法手动重画。
public void paint(Graphics g)
Graphics：
drawLine(int x1, int y1, int x2, int y2)
在此图形上下文的坐标系中，使用当前颜色在点 (x1, y1) 和 (x2, y2) 之间画一条线。
drawOval(int x, int y, int width, int height)
绘制椭圆的边框。
drawRect(int x, int y, int width, int height)
绘制指定矩形的边框。
fillRect(int x, int y, int width, int height)
填充指定的矩形。XY是矩形的左上角点坐标
fillOval(int x, int y, int width, int height)
使用当前颜色填充外接指定矩形框的椭圆。
drawString(String str, int x, int y)
使用此图形上下文的当前字体和颜色绘制由指定 string 给定的文本。
drawImage(Image img, int x, int y, ImageObserver observer)
绘制指定图像中当前可用的图像。
drawImage(Image img, int x, int y, int width, int height, ImageObserver observer)
绘制指定图像中已缩放到适合指定矩形内部的图像。
getColor()
获取此图形上下文的当前颜色。
getFont()
获取当前字体。
setColor(Color c)
将此图形上下文的当前颜色设置为指定颜色。
setFont(Font font)
将此图形上下文的字体设置为指定字体。

碰撞检测问题：
判断两封闭图形的外置方块是否相交即可。
Rectangle(int x, int y, int width, int height)
构造一个新的 Rectangle，其左上角被指定为 (x,y)，其宽度和高度由同名的参数指定。
boolean intersects(Rectangle r)
确定此 Rectangle 是否与指定的 Rectangle 相交。

屏幕双缓冲问题：
每次repaint时，会先后调用update和paint，update清空屏幕，paint重画。如果重绘的面积较大的话，在已经清空的屏幕上会留下大片空白，这就是闪烁出现的原因。而解决办法就是update清空屏幕时，先绘制好图形，再一次性覆盖，因为是在虚拟图片上绘制，速度很快。而每一次覆盖的都是绘制完好的胶片，所以可以很有效环节闪烁现象。
注意：repaint update paint 三者关系为： 1、case轻量级组件（swring包），如swing组件，直接调用paint；2、case重量级组件（awt包），调用update，再调用paint。
所以如果使用Jframe作为容器，因为直接调用paint方法，update双缓冲是不启用的。
注意：可以使用Jpanel作为容器，重写paintComponent方法，这样就可以不用双缓冲了。
https://blog.csdn.net/sangjinchao/article/details/53052897
private Image iBuffer;
public void update(Graphics scr)
{
if(iBuffer==null)
{
iBuffer=createImage(this.getSize().width,this.getSize().height);

}
 Graphics gBuffer=iBuffer.getGraphics();
 gBuffer.setColor(getBackground());
 gBuffer.fillRect(0,0,this.getSize().width,this.getSize().height);
   gBuffer.setColor(getBackground());
   gBuffer.fillRect(0,0,this.getSize().width,this.getSize().height);
   paint(gBuffer);
   scr.drawImage(iBuffer,0,0,this);

｝
该函数需要写在窗体内。

【【网络编程】】
服务器端：
两种有用的DOS命令：
ping 查看是否能联通某个IP地址或某个域名
netstat -an 查看本机所有端口号
本机IP代码：127.0.0.1
serversoket
ServerSocket(int port)构造方法
Socket accept()
侦听并接受到此套接字的连接。
void close()
关闭此套接字。
boolean isClosed()
返回 ServerSocket 的关闭状态

常用代码：
serversoket=new serversocket(9999);
socket s=ss.accept(); 阻塞性方法，此方法在连接传入之前一直阻塞，必须等待返回。
bufferedreader br=new bufferedreader(new inputstreamreader(s.getinputstream);
string str=br.readline();
printwriter pw=new printwriter(s.getoutputstream());
pw.println(str);
注意：多人互发信息时，服务器只做转发功能，即做一死循环，一直等待客户端输入流，一旦接收到客户端的信息，立即执行转发的打印输出操作。如果是多个客户端，则需要起多个线程，每个线程都执行死循环等待客户端输入再转发的操作。
另外，文字互发时，使用print等处理流，其他非文字操作时，建议使用如Object、data等相应的处理流。

客户端：
soket
Socket(InetAddress address, int port)
创建一个流套接字并将其连接到指定 IP 地址的指定端口号。
void close()
关闭此套接字。关闭此套接字也将会关闭该套接字的 InputStream 和 OutputStream。
void connect(SocketAddress endpoint)
将此套接字连接到服务器。
void connect(SocketAddress endpoint, int timeout)
将此套接字连接到服务器，并指定一个超时值。
InetAddress getInetAddress()
返回套接字连接的地址
getLocalAddress()
获取套接字绑定的本地地址。
getInputStream()
返回此套接字的输入流。
getOutputStream()
返回此套接字的输出流。
getLocalPort()
返回此套接字绑定到的本地端口
isClosed()
返回套接字的关闭状态。
isConnected()
返回套接字的连接状态。
shutdownInput()
此套接字的输入流置于“流的末尾”。
shutdownOutput()
禁用此套接字的输出流。
setSoTimeout(int timeout)throws SocketException read() 将只阻塞此时间长度。如果超过超时值，将引发 java.net.SocketTimeoutException
。

socket s=new socet(“127.0.0.1”,9999);
printwriter pw=new printwriter(s.getoutputstream());
bufferedreader br=new bufferedreader(new inputstreamreader(s.getinputstream);
注意：图形化界面互发信息时，输出放在按键监听事件中，相当于另起一线程，而read线程则死循环等待接收，一旦接收立即打印在显示界面上。
注意：根据socket获取输入输出流时，服务器客户端两边不能都先获取输入流，否则会产生死锁卡死。可以都先获取输出，也可以互相错开。
注意：使用readobject时，该方法固然为阻塞方法，但是当服务器没有等待在readobject时，客户端执行readobject会读到EOF标志。

【socket的关闭】
socket 有close dateinputstream.close shutinput shutoutput 等关闭方法，其中：
close关闭连接，不可以再打开，只能新建一个socket。
外置的处理流buffered、data、object等，无论输入输出，关闭的效果等同于socket obj.close
要单独关闭输入或输出，应该使用shut方法。程序内查看自己的流是否关闭，可以使用isclose/isshutinput等命令。
正常关闭：
1、双方正常协商关闭时，有两种方法。1）一方进行.close操作，本机相应输入输出流均被关闭，等待的read报socketexception,最好把相应变量都设为null，放置再用已关闭的输出流进行输出；客户端close后，会发送EOF标记，此时服务端一直等在read方法的对方连接会报EOF异常，根据该情况处理即可。
2、双方约定关闭标记，根据约定标记来进行while（标记==true）｛read｝的死循环，如果读到了false标记，则证明线程结束，进行相应关闭操作后退出。

当远端连接的对象意外关闭时，有两种情况：
1、关闭前已经发送了关闭标志，此时本端的input会读取到一个EOF标志位，处理EOF异常即可关闭本端相应连接。
2、因为是意外关闭，因此完全可能没有发送关闭标志，此时如果有一个线程停止在read方法，则有可能会一直停止，占用资源。解决方法有：1）如果程序决定偶尔要对该连接进行输出操作，则等待下次输出产生的socket异常进行处理即可。2）如果程序两三天都不会进行输出，这要考虑对连接设置定时心跳测试。可以设置一个监听线程，也可以设置read的超时值，一旦超时处理超时异常，在异常中进行心跳测试，如果连接已经挂起，处理socket异常即可。
3、对已经挂起的连接进行写入或心跳测试，都会产生socket异常，此时处理异常，remove掉集合中的soket，close掉本地socket的同时，所有等待在该socket read的线程都会报socket异常，此时需要进行处理，但先要用isclose分析是否是输出端的测试结果，如果是，因为关闭操作已经进行，不用再次关闭；如果不是，这要再进行关闭操作。
总结：对于输入输出的异常处理，通常重点在输出端，如果正常退出，input读到eof异常退出即可。如果非正常挂起，则要进行输出测试，而输入端会因为已关闭产生socket异常，相应处理即可。

【UDP连接】
datagrampaket：
DatagramPacket(byte[] buf, int length, InetAddress address, int port)
构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。
DatagramPacket(byte[] buf, int length, SocketAddress address)
构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。
DatagramPacket(byte[] buf, int offset, int length)
构造 DatagramPacket，用来接收长度为 length 的包，在缓冲区中指定了偏移量。

缓冲区的最大容量仅受限于允许的数据报包大小，这个限制位于比64KB稍小的地方。也就是说UDP数据包最大能接收到的数据大小为64K。
主要方法：
setSocketAddress(SocketAddress address)
设置要将此数据报发往的远程主机的 SocketAddress（通常为 IP 地址 + 端口号）。
getSocketAddress()
获取要将此包发送到的或发出此数据报的远程主机的 SocketAddress（通常为 IP 地址 + 端口号）。
DatagramSocket：
DatagramSocket(int port)
创建数据报套接字并将其绑定到本地主机上的指定端口。
receive(DatagramPacket p)
从此套接字接收数据报包。
send(DatagramPacket p)
从此套接字发送数据报包。

【地址】
InetSocketAddress
InetSocketAddress(InetAddress addr, int port)
InetAddress InetAddress 的实例包含 IP 地址，还可能包含相应的主机名
static InetAddress getByName(String host)
在给定主机名的情况下确定主机的 IP 地址。
static InetAddress getLocalHost()
返回本地主机。

【【数据库连接】】
1、下载相应数据库的JDBC连接包。
2、将连接包导入到工程的buildpath下。
3、使用 new 或Class.forname（）向drivermanager注册。
4、使用drivermanager.getconnecttion方法得到连接。
5、使用connection的createStatement()、preparestatement（）等方法得到语句对象。
6、使用statement的execute系列方法执行SQL、MDL语句。

各类数据库的连接报和连接字符串如下：
1、access
Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);
DriverManager.getConnection(“jdbc:odbc:test”,user,Pwd );//其中test是配置好的ODBC数据源名称
2、sql2000：mssqlserver.jar包
Class.forName(“com.microsoft.jdbc.sqlserver.SQLServerDriver”);
DriverManager.getConnection(“jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=news”,user,Pwd );
3、sql2005：sqljdbc.jar包
Class.forName(“com.microsoft.sqlserver.jdbc.SQLServerDriver”);
DriverManager.getConnection(“jdbc:sqlserver://localhost;database=news”,user,Pwd );
4、mysql：mysql-connector-java-8.0.12
Class.forName(“com.mysql.cj.jdbc.Driver” );
DriverManager.getConnection(“jdbc:mysql://MyDbComputerNameOrIP:3306/myDatabaseName?useSSL=false”, user,Pwd );
5、Oracle
Class.forName( “oracle.jdbc.driver.OracleDriver” );
DriverManager.getConnection( “jdbc:oracle:thin:@MyDbComputerNameOrIP:1521:ORCL”, user,Pwd );
连接例子如下：
public static void main(String[] args) {
final String CONNECTONSTRING=“jdbc:mysql://192.168.31.128:3306/mytest?useSSL=false”;
Connection c = null;
Statement s = null;
ResultSet rs = null;
PreparedStatement ps=null;
try {

		Class.forName("com.mysql.cj.jdbc.Driver");

		c = DriverManager.getConnection(CONNECTONSTRING,"sqluser","JIANGkui1");
		String sql="insert into student values(null,?,?,?,?)";
		ps=c.prepareStatement(sql);
		ps.setObject(1, "黄慧");
		ps.setObject(2, "三年二班");
		ps.setObject(3, 15);
		ps.setObject(4, "女");
		ps.executeUpdate();		
		
		
		s = c.createStatement();
		rs = s.executeQuery("select * from student");
		
		int cols=rs.getMetaData().getColumnCount();
		while(rs.next()) {
			for(int i=1;i<=cols;i++) {
				System.out.print(rs.getString(i)+" ");
			}
			System.out.println();
		}
		
		
	} catch (ClassNotFoundException e) {
		e.printStackTrace();
	} catch (SQLException e) {
		e.printStackTrace();
	}finally {
		try {
			if(rs!=null)rs.close();
			if(ps!=null)ps.close();
			if(s!=null)s.close();
			if(c!=null)c.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}

}

【connection方法】
Statement createStatement()
创建一个 Statement 对象来将 SQL 语句发送到数据库。结果集只能读取一次，不能够来回的滚动读取。
Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability)
创建一个 Statement 对象，该对象将生成具有给定类型、并发性和可保存性的 ResultSet 对象。
参数 int type
ResultSet.TYPE_FORWORD_ONLY 结果集的游标只能向下滚动。
ResultSet.TYPE_SCROLL_INSENSITIVE 结果集的游标可以上下移动，当数据库变化时，当前结果集不变。
ResultSet.TYPE_SCROLL_SENSITIVE 返回可滚动的结果集，当数据库变化时，当前结果集同步改变。
参数 int concurrency
ResultSet.CONCUR_READ_ONLY 只读属性，不能用结果集更新数据库中的表。
ResultSet.CONCUR_UPDATETABLE 能用结果集更新数据库中的表。
参数 int resultsetholdability 这种功能只是在JDBC3.0的驱动下才能成立。
ResultSet.HOLD_CURSORS_OVER_COMMIT 表示修改提交时ResultSet不关闭，可以用容器存储多个结果集.
ResultSet.CLOSE_CURSORS_AT_COMMIT 表示修改提交时ResultSet关闭，所有结果集都只是最后一个.

DatabaseMetaData getMetaData()
获取一个 DatabaseMetaData 对象，该对象包含关于此 Connection 对象所连接的数据库的元数据。
boolean isClosed()
查询此 Connection 对象是否已经被关闭。
boolean isReadOnly()
查询此 Connection 对象是否处于只读模式。
boolean isValid(int timeout)
如果连接尚未关闭并且仍然有效，则返回 true。
PreparedStatement prepareStatement(String sql)
创建一个 PreparedStatement 对象来将参数化的 SQL 语句发送到数据库。
该对象统一可以设置int resultSetType, int resultSetConcurrency, int resultSetHoldability三个参数。
CallableStatement prepareCall(String sql)
创建一个 CallableStatement 对象来调用数据库存储过程。
rollback()
取消在当前事务中进行的所有更改，并释放此 Connection 对象当前持有的所有数据库锁。
注意：一个事务的过程为
try｛
conn.setautocommit(false);
do somthing;
conn.commit();

｝catch（sqlexception）｛
if(cnn!=null) cnn.rollback;
｝finally{
conn.setautocommit(true);
things.close;
}

【statement方法】
boolean execute(String sql)
执行给定的 SQL 语句，该语句可能返回多个结果。
如果第一个结果为 ResultSet 对象，则返回 true；如果其为更新计数或者不存在任何结果，则返回 false
ResultSet executeQuery(String sql)
执行给定的 SQL 语句，通常为静态 SQL SELECT 语句
int executeUpdate(String sql)
执行给定 SQL 语句，该语句可能为DML INSERT、UPDATE 或 DELETE 语句，或者不返回任何内容的 SQL 语句（如 SQL DDL 语句）。

【prepareStatement方法】
sql="insert into student values(?,?,?)"或sql = “select * from people p where p.id = ? and p.name = ?”;
prepareStatement(String sql) 中已经设置了准备好的SQL语句，可用?占位符来代替相应参量，此时我们可以设置占位符参数：
SetInt(int parameterIndex, int x)
将指定参数设置为给定 Java int 值。index从1开始
setLong(int parameterIndex, long x)
将指定参数设置为给定 Java long 值。
setString(int parameterIndex, String x)
将指定参数设置为给定 Java String 值
以此类推，包括settime、setfloat、setdouble、setdate等。
然后再使用execute系列方法来执行。
注意：setObject可以自动类型转换，代替其他方法，但会增加一些执行时间。

【ResultSet】
ResultSet 对象具有指向其当前数据行的光标。最初，光标被置于第一行之前。next 方法将光标移动到下一行；因为该方法在 ResultSet 对象没有下一行时返回 false，所以可以在 while 循环中使用它来迭代结果集。
默认的 ResultSet 对象不可更新，仅有一个向前移动的光标。因此，只能迭代它一次，并且只能按从第一行到最后一行的顺序进行。
使用相应参数，可以得到可滚动，可更新的结果集。
Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE);
// rs will be scrollable, will not show changes made by others,
// and will be updatable
如果可以滚动，可以使用如下方法：
rs.last;rs.first; rs.previous; absolute(int row) ;afterLast() ;beforeFirst() ;moveToCurrentRow() ;moveToInsertRow() ;relative(int rows按相对行数（或正或负）移动光标));isAfterLast() ;isBeforeFirst(); isFirst();isLast()
如果结果集可更新，可以使用如下方法：
updateString/int/float/time/object(“ename”/1,“AAAA”)
updateRow()
cancelRowUpdates()
rs.moveToInsertRow();
rs.updateInt(1, 9999);
rs.insertRow();
rs.moveToCurrentRow();
rs.deleteRow();
boolean rowDeleted()
boolean rowInserted()
boolean rowUpdated()
不管是否可滚动可更新，resultset常用方法如下：
Array getArray(int columnIndex)
Object getObject(int columnIndex)
int getRow()
boolean next()

【【正则表达式】】

java 正则表达式调用方法：
Pattern reg=Pattern.compile(String regex, int flags) regex:字符串模型；flags，模式，最常用为CASE_INSENSITIVE 不区分大小写。
static boolean matches(String regex, CharSequence input) 编译给定正则表达式并尝试将给定输入与其匹配。等价于 string obj.matches(string reg)。
该方法通常可以和字符串类型的几类方法配合使用：endsWith(String suffix) startsWith(String prefix)
Matcher match= reg.matcher(CharSequence input) input通常可以为字符串类型，因为字符串都实现了该接口。

针对于Mather对象，有如下方法：
boolean find()
尝试查找与该模式匹配的输入序列的下一个子序列。
String group()
返回由以前匹配操作所匹配的输入子序列。
String group(int group)
返回在以前匹配操作期间由给定组捕获的输入子序列
int groupCount()
返回此匹配器模式中的捕获组数。
boolean matches()
尝试将整个区域与模式匹配。
Pattern pattern()
返回由此匹配器解释的模式
String replaceAll(String replacement)
替换模式与给定替换字符串相匹配的输入序列的每个子序列。
String replaceFirst(String replacement)
替换模式与给定替换字符串匹配的输入序列的第一个子序列。
Matcher reset()
重置匹配器
int start()
返回以前匹配的初始索引。
int end()
返回最后匹配字符之后的偏移量。
boolean lookingAt()
尝试将从区域开头开始的输入序列与该模式匹配
Matcher appendReplacement(StringBuffer sb, String replacement)
实现非终端添加和替换步骤。即原字符串找到的第一个子串按照位置添加到SB中。
StringBuffer appendTail(StringBuffer sb)
实现终端添加和替换步骤。
基本使用形式：
Pattern reg=Pattern.compile("(?<=tool.)\S+(?=\|888)");
Matcher m=reg.matcher(“tool.chinaz.com|888”);
if(m.find()) println(m.group());
打印结果为：chinaz.com
【regexp字符串】
字符：
\t 制表符 (’\u0009’)
\n 新行（换行）符 (’\u000A’)
\r 回车符 (’\u000D’)
\f 换页符 (’\u000C’)
\a 报警 (bell) 符 (’\u0007’)
\e 转义符 (’\u001B’)
\cx 对应于 x 的控制符
字符类
[abc] a、b 或 c（简单类）
[^abc] 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[a-d[m-p]] a 到 d 或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]] d、e 或 f（交集）
[a-z&&[^bc]] a 到 z，除了 b 和 c：[ad-z]（减去）
[a-z&&[^m-p]] a 到 z，而非 m 到 p：[a-lq-z]（减去）
预定义字符类
. 任何字符（与行结束符可能匹配也可能不匹配）
\d 数字：[0-9]
\D 非数字： [^0-9]
\s 空白字符：[ \t\n\x0B\f\r]
\S 非空白字符：[^\s]
\w 单词字符：[a-zA-Z_0-9]
\W 非单词字符：[^\w]
POSIX 字符类（仅 US-ASCII）
\p{Lower} 小写字母字符：[a-z]
\p{Upper} 大写字母字符：[A-Z]
\p{ASCII} 所有 ASCII：[\x00-\x7F]
\p{Alpha} 字母字符：[\p{Lower}\p{Upper}]
\p{Digit} 十进制数字：[0-9]
\p{Alnum} 字母数字字符：[\p{Alpha}\p{Digit}]
\p{Punct} 标点符号：!"#$%&’()+,-./:;<=>?@[]^_`{|}~
\p{Graph} 可见字符：[\p{Alnum}\p{Punct}]
\p{Print} 可打印字符：[\p{Graph}\x20]
\p{Blank} 空格或制表符：[ \t]
\p{Cntrl} 控制字符：[\x00-\x1F\x7F]
\p{XDigit} 十六进制数字：[0-9a-fA-F]
\p{Space} 空白字符：[ \t\n\x0B\f\r]
边界匹配器
^ 行的开头
$ 行的结尾
\b 单词边界
\B 非单词边界
\A 输入的开头
\G 上一个匹配的结尾
\Z 输入的结尾，仅用于最后的结束符（如果有的话）
\z 输入的结尾
Greedy 数量词
X? X，一次或一次也没有
X X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超过 m 次
注意：量词之后可以加符号来决定匹配模式，默认为贪婪模式，从最大开始查找匹配；?表示懒惰模式，从最小开始；+表示正好，从最大开始，但不回溯。
特殊构造（非捕获）
(?:X) X，作为非捕获组
(?=X) X，通过零宽度的正 lookahead 零宽断言，锚定X的左边空白处。
(?!X) X，通过零宽度的负 lookahead 锚定所有不是X的左边空白处。
(?<=X) X，通过零宽度的正 lookbehind 锚定X的右边空白处。
(?<!X) X，通过零宽度的负 lookbehind 锚定不是X的右边空白处。
(?>X) X，作为独立的非捕获组

【【便捷方式】】
【toolkit类】调用系统的工具功能。
Toolkit tk=Toolkit.getdefaultTookit();取得当前系统默认的工具包。
常用功能：
Image getImage(String filename)
返回一幅图像，该图像从指定文件中获取像素数据，图像格式可以是 GIF、JPEG 或 PNG。
Image getImage(URL url)
返回一幅图像，该图像从指定 URL 获取像素数据。
第二个功能，配合getclassloader.getresouce()功能，可以轻松取得图片流。
实现如下：
private static Toolkit tk= Toolkit.getDefaultToolkit();
private static ClassLoader mycl=Explode.class.getClassLoader();
private static Image[] img= {
tk.getImage(mycl.getResource(“images/0.gif”)),
tk.getImage(mycl.getResource(“images/1.gif”)),
tk.getImage(mycl.getResource(“images/2.gif”)),
tk.getImage(mycl.getResource(“images/3.gif”)),
tk.getImage(mycl.getResource(“images/4.gif”)),

};

这样，只要文件是放在classpath 的文件夹中（bin中），就可以管理它而不依赖整体文件的相对或绝对路径。
特殊说明：class.getClassLoader().getResource 方法识别bin（jar包最外层，因打包后不存在bin文件夹）中的文件或文件夹。
class.getResource（） 方法识别bin中包文件位置的文件或文件夹。因而无法识别jar包中的文件。字符串前面加一个“/”才可以从最外层搜起。
注意：getimage是一个异步方法，读取图片之后并不会立即记载，如果想要等待图片加载完成再继续，可以使用以下方法。
所以，所有图片、文件资源尽量放在bin中，不要放到包中。
1、boolean x=drawimage，根据返回值判断是否加载完成。
2、MediaTracker(Component comp) 对象
addImage(Image image, int id)
boolean checkID(int id,boolean load)/checkAll(boolean load)如果load设置为TRUE，此方法将开始加载任何尚未加载的图像。
Object[] getErrorsAny()返回所有出错媒体的列表。
Object[] getErrorsID(int id)返回具有出错的指定 ID 的媒体列表
waitForAll() 开始加载由此媒体跟踪器跟踪的所有图像
waitForID(int id) 开始加载由此媒体跟踪器跟踪且具有指定标识符的所有图像。

【java目录详解】
1、在eclipse工程中新建文件。
1.1如果在工程下新建文件，文件在工程的文件夹中。
1.2如果在src目录下新建文件，文件在src和bin中都有。
1.3如果在包中新建文件，文件在src和bin目录的包文件夹中都有。
2、相对目录和根目录
2.1在eclipse工程中的情况：
相对目录相对于project的工程文件夹，即new File("")和new File("./")都是工程文件夹。
根目录是文件夹所在硬盘的目录，如果工程放在D盘，则new File("/")是D:
2.2在jar包中的情况：
此时相对目录是调用jar包程序所在目录，如果是可执行jar包，则相对目录就是它存放的目录，如果是控制台调用它，则是控制台当前目录，如果是 eclipse程序调用它，则是调用它程序的所在的工程目录。
根目录即相对目录所在目录的根磁盘目录。
2.3在web工程中的情况：
此时相对路径情况多变，非常不稳定，一种情况是./文件夹是eclipse目录，根目录是它的根磁盘。
3、.class.getResource() 类路径
3.1在工程中，class.getResource("")是编译完成的class文件所在路径，即bin下的包文件夹(最里层）。
class.getResource("/")是类路径的根路径，即bin文件夹。但它是以file:/开头的，如：file:/D:/Users/yang/eclipse-workspace/Mytest/bin/
注意，"“中非空字符串的情况，查找到的文件或文件夹一般也是以file:/开头的。
3.2在可执行jar包中，class.getResource(”")和("/")都不可用，是null；但可以以"str""/str"的形式查找，查找的文件夹是包最外层和存放class文件的那个文件夹。
3.3在引用的jar中，class.getResource("")不可用，/可用，但它指向的是调用它的class的根路径(即bin/包路径）。同样，搜索文件时搜索的也是调用它的程序所在的class路径或class根路径。事实上完全可以把引用jar包中的this等价于引用它类的this。
3.4在web工程中，"“指向工程下/WEB-INF/classes/helloweb/的工程文件夹，即存放class文件的文件夹。”/“指向classes文件夹。
4、.class.getClassLoader().getResource
它完全等价于3中的.getResource(”/"),指向根目录，引用包中指向引用类的根目录，而非自己jar包的最外层目录。
在web工程中，它同样指向class根文件夹，即wtpwebapps/helloweb/WEB-INF/classes/文件夹。
5、System.getProperty(“user.dir”)
5.1工程中情况，指向工程文件夹路径。D:\Users\yang\eclipse-workspace\Mytest
5.2可执行jar包情况，指向存放jar包路径。C:\Users\yang\Desktop
5.3引用包情况，指向引用该包的类所在工程路径。D:\Users\yang\eclipse-workspace\Mytest
5.4web工程情况，不稳定，测试由eclipse发起web服务时指向了eclipse根目录，由tomcat发起服务时指向tomcat\bin目录。
总结：
关于相对路径，相对路径是由jre控制的，相对的参照物是变化的，不应该用来在多个环境下定位。
System.getProperty(“user.dir”)的效果和相对路径./基本一致。
关于类路径，.class.getResource()定位良好，基本能定位到存放class文件的路径，而.class.getClassLoader().getResource也能定位到工程下的bin/classes/包路径。
在可执行包定位到包外情况，使用相对路径./和user.dir都可以。

新版解释：
ClassLoader.getResource(“test.txt”);
不能带“/”，相对src/bin/resouces文件开始找。
Class.getResource()
两种用法：
1、getResource("")/"./“相对路径，相对位置为当前类所在包。
2、Class.getResource(”/")和类加载器方法一直。

【配置文件】
如果将一个文件放在java classpath 的文件夹中（bin/src中），就可以通过类管理器来查找它，用它来生成URL或输入流。
PropMgr.class.getClassLoader().getResourceAsStream(“tank.properties”)
this.getclass.getClassLoader().getResourceAsStream(“tank.properties”)
然后再通过Properties 的string getProperty(str)即可管理它。
配置文件格式 变量名=值 一行一个 如：
temp=50
casscount=“47”
实现如下：
class PropMgr{

static Properties propertiesfire= new Properties();
static {
	try {
		propertiesfire.load(PropMgr.class.getClassLoader().getResourceAsStream("myprp.properties"));
	} catch (IOException e) {
		e.printStackTrace();
	}
}
private PropMgr() {}

public static int getpropint(String str) {
	
	return Integer.parseInt(propertiesfire.getProperty(str));
	
}
public static String getpropstr(String str) {
	return propertiesfire.getProperty(str);
	
}

}
另外：：

读取jar包外配置文件：
String filePath = System.getProperty(“user.dir”) + “/conf/configfilename.properties”;
InputStream in = new BufferedInputStream(new FileInputStream(filePath));

【操作系统相关信息】
System.getProperty(string str)
user.name 用户的账户名称
user.home 用户的主目录
user.dir 程序当前运行的工作目录
os.name 操作系统的名称
os.arch 操作系统的架构
os.version 操作系统的版本
java.home Java 安装目录（jdk目录）
java.class.path Java 类路径（当前文件的bin目录）

获取本地IP InetAddress.getLocalHost().getHostAddress();
获取计算机名 InetAddress.getLocalHost().getHostName()

【api文档制作】
1、打开java代码，编写JavaDoc 注释，只有按照java的规范编写注释，才能很好的生成API文档，javadoc注释与普通注释的区别为多一个*（星号）。普通代码注释为/XXX/，而javadoc的注释为/*XXX/
2、javadoc注释要尽量写的详细，这样别人在没有源码的情况下才知道如何使用您的代码。
3、点击eclipse的【Project】菜单，选择【Generate JavaDoc】选项。D:\Program Files\Java\jdk-10.0.1\bin\javadoc.exe
4.　（1）选择您要生成JavaDoc的工程

（2）选择哪些级别的内容生成JavaDoc，默认为public，如果选择private则会全部内容都生成。

（3）选择doc的生成位置，默认为工程目录下，建议不要修改

（4）点击【Next】按钮
5.（1）勾选Document Title，然后填写文档标题。

（2）点击【Next】按钮
6、（1）选择使用的JDK版本

（2）点击【Finish】按钮
7、可以看到控制台输出生成javadoc的信息。
8、项目下生成一个【doc】的目录，里面存放着javadoc文档。
9、打开doc目录，用浏览器打开index.html
10、可以看到一个完整的API文档、javadoc就生成了。

【导出可执行JAR包】
1、在 Eclipse 工作空间右键项目 — Export — 在弹出的对话框中选择 jar file — 然后点击 next
2、选择要打包的文件，不需要的文件不必打包，减小打包后的jar文件大小，并进行选项配置如下

• Export generated class files and resources 表示只导出生成的.class文件和其他资源文件
• Export all output folders for checked projects 表示导出选中项目的所有文件夹
• Export java source file and resouces 表示导出的jar包中将包含你的源代码*.java，如果你不想泄漏源代码，那么就不要选这项了
• Export refactorings for checked projects 把一些重构的信息文件也包含进去
  3、选择我们在第一步中自定义的配置文件路径，这一步很重要，不能采用默认选项
• Generate the manifest file：是系统帮我们自动生成MANIFEST.MF文件，如果你的项目没有引用其他class-path，那可以选择这一项。
• Use existing mainfest from workspace：这是可以选择我们自定义的.MF文件，格式如上所写，引用了第三方包时选用。
• Seal content：要封装整个jar或者指定的包packet。
• Main class：这里可以选择你的程序入口，将来打包出来的jar就是你这个入口类的执行结果。
  常规操作：在”Specify the manifest:(指定声明)” 这一栏选择“Generate the manifest file (生成声明文件)”,下边的两项”Seal contents”和”Main class”不用管,然后直接点击”finish”完成。
  其他扩展操作：https://blog.csdn.net/Mrqiang9001/article/details/75193862
  https://blog.csdn.net/tobetheender/article/details/52670732

【eclipse快捷方式】
鼠标选中变量-右键-refactor-rename 批量修改变量名
鼠标选中变量-右键-soundwith 快捷添加for while try catch等。
在语句末尾ctrl+1 可以快速添加赋值变量、for each for i等方法。
alt+向上/向下箭头，语句位置上下移动。
ctrl+alt+向上/向下箭头，复制改行语句。
ctrl+shift+向左向右肩头，选中最近的单词。
ctrl+T 显示类的继承结构
Ctrl+K 参照选中的Word快速定位到下一个
Ctrl+/(小键盘) 折叠当前类中的所有代码
Ctrl+×(小键盘) 展开当前类中的所有代码
Ctrl+Shift+F 格式化当前代码

Alt+Shift+R 重命名
Alt+Shift+M 抽取方法
Alt+Shift+Z 重构的后悔药undo
Alt+Shift+C 修改函数结构 修改方法的变量参数后
Alt+Shift+L 抽取本地变量
Alt+Shift+F 把Class中的local变量变为field变量

【动态代理】
1、接口代理，要求必须实现某个接口。增强的对象必须是final的。
Object newAc = Proxy.newProxyInstance(as.getClass().getClassLoader(), new Class[]{IAccountService.class}, new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//befor(); 方法前做一些事情
Object r = method.invoke(as, args);
// if (method.getName().equals(“xx”)){
// //指定某个方法进行增强
// }
//after(); 方法后做一些事情
return r;
}
});
loader 用来去加载代理对象的类加载器
interfaces 动态代理类需要实现的接口集合
h 可以理解为监听动态代理方法的调用。
返回值 根据上面三个参数生成的代理实例

proxy 调用方法的代理实例
method 代理实例上调用的接口方法，包括若有父类，父类中声明的接口方法
args 传入代理实例上调用的接口方法的参数
返回值 就是上述的method的返回值。如果是基本数据类型，则返回的是其包装类的类型

2、继承代理，需要导入第三方的cglib包。

cglib
cglib
2.1_3

Object o = Enhancer.create(as.getClass(), new MethodInterceptor() {
/**
*
* @param o 调用方法的代理实例
* @param method 代理实例上调用的接口方法
* @param objects 传入代理实例上调用的接口方法的参数
* @param methodProxy 当前执行方法的代理对象
* @return
* @throws Throwable
*/
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
return null;
}

【长循环下根据时间运行】
class WaitTime{
private long oldcurrent;
private boolean first=true;
private RunWT runwt;

	public WaitTime() {}

	public WaitTime(RunWT runwt) {
		this.runwt = runwt;
	}


	public void setinit() {
		first=true;
	}

	public long getinterval() {
		if(first) {
			first=false;
			this.oldcurrent =System.currentTimeMillis();
			
		}
		return System.currentTimeMillis()-oldcurrent;
	}
	public void run(long time) {
		if(getinterval()>=time) {
			runwt.runprgram();
			setinit();
		}
		
	}

}

interface RunWT{
void runprgram();
}

【输入输出优化】
class Dio{
static private Scanner sc=new Scanner(System.in) ;

	public Dio() {}
	public static int nextInt() {
		while (!sc.hasNextInt()) {
			sc.nextLine();
			PS.println("输入错误，请重新输入一个int！");
			
		}
		int tem=sc.nextInt();
		sc.nextLine();
		return tem;
		
	}
	public static double nextDouble() {
		while (!sc.hasNextDouble()) {
			sc.nextLine();
			PS.println("输入错误，请重新输入一个double！");
			
		}
		double tem=sc.nextDouble();
		sc.nextLine();
		return tem;
		
	}
	public static String nextLine() {
		return sc.nextLine();
	}
	public static void println(Object o) {
		System.out.println(o);
	}
	public static void print(Object o) {
		System.out.print(o);
	}
	
}