第二章　Java基本语法
Java常量　-　固定不变值
Java变量　-　在内存中分配一块内存,用于保存数据
空:　　　　　　null
基本数据类型
布尔值:　　boolean
字符:　　　　char
整形:　　　　byte,short,int,long
浮点型:　　float,double
引用数据类型
类:　　　　　　String
数组:　　　　int[]
类型转换
自动转换　-　低字节类型数据和高字节类型数据参与运算会自动提升类型
强制转换　-　将高字节数据强制转换成低字节数据,会丢失精度或者结果错误

第三章　运算符与逻辑判断循环
算数运算符　+　-　*　/　%　++　--
赋值运算符　=　+=　-=　*=　/=　%=
比较运算符　==　!=　<　>　<=　>=　instanceof
逻辑运算符　&　|　^　!　&&　||
位运算符　&　|　^　<<　>>　>>>
三元运算符　boolean?"":"";
选择结构　if…else　switch
循环结构　for　while　do…while
控制循环　continue　break　return
在不知道x和y值的情况下,交换这个两个变量中的值
int　x=10,　y=6;　x+=y;　y-=x;　x+=y;　y*=(-1);　System.out.println(x+"　"+y);
int　a=10,　b=6;　a+=b;　b=a-b;　a-=b;　System.out.println(a+"　"+b);
int　i=10,　j=6;　i^=j;　j=i^j;　i^=j;　System.out.println(i+"　"+j);
在三个数中找到最大的那个数
int　x=10,y=20,z=30;
int　max　=　x>y?(x>z?x:z):(y>z?y:z);
System.out.println(max);
计算1+2+3+…+100的和
int　sum=0,i=0;
for(;i<=100;sum+=i++);
System.out.println(sum);
sum=0;i=0;
while(i<=100)sum+=i++;
System.out.println(sum);
sum=0;i=0;
do{sum+=i++;}while(i<=100);
System.out.println(sum);
public　static　int　sum　=　sum(100);
public　static　int　sum(int　num)　{return　num==1?1:num+sum(num-1);}
将十进制转换成二进制
StringBuilder　sb　=　new　StringBuilder();
System.out.println("请输入一个10进制数:　");
int　num　=　new　Scanner(System.in).nextInt();
while　(num>0)　{
sb.append(num%2);
num/=2;
}
sb.reverse();
System.out.println(sb);

第四章　函数和数组
函数　-　代码在程序中需要多次使用,就可以定义成函数,在需要使用的时候调用
函数的重载　-　函数名称相同,参数列表不同,返回值不同
数组　-　类型一致长度不可变通过索引操作元素的容器
数组相关函数
Arrays.toString()　数组转换成字符串
System.arraycopy()　数组深拷贝
将数组中所有元素打印成一行并以逗号分割
private　static　String　arrayToString(int[]　array)　{
if　(array!=null　&&　array.length>0)　{
String　s　=　array[0]+"";
for　(int　i　=　1;　i　<　array.length;　i++)　{
s+=",　"+array[i];
}
return　s;
}
return　"";
}
对数组进行排序　–　冒泡/选择
private　static　int[]　bubbleSort(int[]　array)　{
int　temp　=　0;
for　(int　i　=　0;　i　<　array.length-1;　i++)　{
for　(int　j　=　i;　0　<　j+1;　j--)　{
if　(array[j]<array[j+1])　{
temp　=　array[j];
array[j]　=　array[j+1];
array[j+1]　=　temp;
}
}
}
return　array;
}
private　static　int[]　selectSort(int[]　array)　{
int　temp　=　0;
for　(int　i　=　0;　i　<　array.length-1;　i++)　{
for　(int　j　=　i+1;　j　<　array.length;　j++)　{
if　(array[i]<array[j])　{
temp　=　array[i];
array[i]　=　array[j];
array[j]　=　temp;
}
}
}
return　array;
}
对有序数组进行二分查找
private　static　int　binarySearch(int[]　array,　int　key)　{
int　start　=　0;
int　end　=　array.length　-　1;
while　(start　<=　end)　{
int　middle　=　(start+end)/2;
if　(key　>　array[middle])　{
start　=　middle　+　1;
}else　if　(key　<　array[middle])　{
end　=　middle　-　1;
}else　{
return　middle;
}
}
return　-1;
}
获取键盘输入的最大数
public　static　void　main(String[]　args)　throws　Exception　{
int　number　=　0;
System.out.println("请输入三个数字:　");
BufferedReader　br　=　new　BufferedReader(new　InputStreamReader(System.in));
for　(int　i　=　0;　i　<　3;　i++)　{
int　line　=　Integer.parseInt(br.readLine());
number　=　line>number?line:number;
}
System.out.println(number);
}
递归求1+2+...
public　static　int　getSum(int　n)　{
return　n==1?1:getSum(n-1)+n;
}

第五章　面向对象
封装　–　对内部变量私有化,对外部提供公有方法
代码块　-　在创建对象时代码块会自动运行
构造函数　–　函数名与类名相同没有返回值类型
this　-　那个对象调用该方法,this就代表那个对象
static　-　内存中对象是唯一的
extends　-　子类继承父类的方法和属性
super　-　子类调用父类的方法和属性
向上转型　-　子类当做父类使用,不能调用子类特有的方法
向下转型　-　子类当做父类使用,需要调用子类特有的方法,需要将父类强制转化成子类
方法重写　-　子类必须与父类具有相同函数名,参数列表和返回值
多态　–　将函数的形参定义为父类类型,传入不同的子类而实现不同的功能
abstract　–　父类定义抽象方法,需要在子类实现该方法
final　–　对象不能继承,方法不能重写,变量不能修改
interface　–　接口中所有的方法都需要在子类中实现
implements　–　一个类实现接口
内部类　–　在一个类中嵌套另一个类
package　–　定义类所属的包
import　–　导入包中的类
定义对象
public　class　Person　{
private　String　name;
private　Integer　age;
}
创建对象
public　static　void　main(String[]　args)　{
Person　p　=　new　Person();
}

模拟电脑开/关机
public　class　ComputerDemo　{
private　static　class　Computer　{
private　String　name;
private　MainBoard　mainBoard;
private　Boolean　state;
public　Computer(){}
public　Computer(String　name,　MainBoard　mainBoard)　{
this.name　=　name;
this.mainBoard　=　mainBoard;
this.state　=　false;
}
public　void　trunOn(){
if(mainBoard==null){
System.out.println(name+"　没有安装主板不能开机");
}else{
if　(state)　{
return;
}
mainBoard.run();
System.out.println(name+"　开机成功");
state　=　true;
}
}
public　void　trunOff(){
if　(state)　{
mainBoard.stop();
System.out.println(name+"　关机成功");
state　=　false;
}else　{
System.out.println("电脑还没有开机");
}
}
}
private　static　class　MainBoard　{
private　String　name;
public　MainBoard(){}
public　MainBoard(String　name)　{
this.name　=　name;
}
public　void　run(){
System.out.println(name+"　已启动");
}
public　void　stop()　{
System.out.println(name+"　停止运行");
}
}
public　static　void　main(String[]　args)　{
Computer　c　=　new　Computer("ThinkPad　T420",　new　MainBoard("华硕主板"));
c.trunOn();
c.trunOff();
}
}

new　Demo2().test();
}
}
装饰模式　-　对某个对象功能进行增强
public　class　Wrapper　{
private　interface　Person　{
void　run();
void　eat();
void　sleep();
}
private　static　class　Man　implements　Person　{
public　void　run()　{
System.out.print("男人跑步!");
}
public　void　eat()　{
System.out.print("男人吃饭!");
}
public　void　sleep()　{
System.out.print("男人睡觉!");
}
}
private　static　class　SuperMan　implements　Person　{
private　Man　man;
public　SuperMan(Man　man)　{
this.man　=　man;
}
public　void　run()　{
man.run();
System.out.println("健步如飞!");
}
public　void　eat()　{
man.eat();
System.out.println("狼吞虎咽!");
}
public　void　sleep()　{
man.sleep();
System.out.println("鼾声如雷!");
}
}
public　static　void　main(String[]　args)　{
Person　person　=　new　SuperMan(new　Man());
person.run();
person.eat();
person.sleep();
}
}
适配器模式
public　class　Adapter　{
public　interface　A　{
void　a();
void　b();
}
public　abstract　static　class　B　implements　A　{
public　void　a()　{}
public　void　b()　{}
}
public　static　void　main(String[]　args)　{
B　b　=　new　B(){
public　void　a()　{
System.out.println("Adapter");
}
};
b.a();
}
}

原子类型　–　数据在操作的过程中不会执行其他线程
import　java.util.concurrent.atomic.AtomicInteger;
public　class　Exercise　{
private　static　class　Service　{
private　AtomicInteger　integer　=　new　AtomicInteger();
public　void　increment()　{
System.out.println(Thread.currentThread().getName()+"　incr,x　=　"+integer.addAndGet(3));
}
public　void　decrement()　{
System.out.println(Thread.currentThread().getName()+"　decr,x　=　"+integer.addAndGet(-3));
}
}
public　static　void　main(String[]　args)　{
final　Service　service　=　new　Service();
for　(int　i　=　0;　i　<　2;　i++)　{
new　Thread(){
public　void　run()　{
while　(true)　{
service.increment();
}
}
}.start();
}
for　(int　i　=　0;　i　<　2;　i++)　{
new　Thread(){
public　void　run()　{
while　(true)　{
service.decrement();
}
}
}.start();
}
}
}
线程池
import　java.util.concurrent.ExecutorService;
import　java.util.concurrent.Executors;
import　java.util.concurrent.ScheduledExecutorService;
import　java.util.concurrent.TimeUnit;
public　class　ThreadPool{
public　static　void　main(String[]　args)　{
ExecutorService　fixedThreadPool　=　Executors.newFixedThreadPool(3);
ExecutorService　cachedThreadPool　=　Executors.newCachedThreadPool();
ExecutorService　singleThreadExecutor　=　Executors.newSingleThreadExecutor();
ScheduledExecutorService　scheduledThreadPool　=　Executors.newScheduledThreadPool(3);
scheduledThreadPool.schedule(new　Runnable()　{
public　void　run()　{
System.out.println("计时器线程开始");
}
},　3000,　TimeUnit.MILLISECONDS);
for　(int　i　=　0;　i　<　10;　i++)　{
final　int　task　=　i;
fixedThreadPool.execute(new　Runnable()　{
public　void　run()　{
for　(int　i　=　0;　i　<　3;　i++)　{
System.out.println(Thread.currentThread().getName()+":　任务"+task+",　循环"+i);
try　{
Thread.sleep(1000);
}　catch　(Exception　e)　{
throw　new　RuntimeException(e.getMessage(),e);
}
}
}
});
}
fixedThreadPool.shutdown();
}
}

线程未完成,阻塞线程等待线程完成
import　java.util.concurrent.Callable;
import　java.util.concurrent.ExecutionException;
import　java.util.concurrent.ExecutorService;
import　java.util.concurrent.Executors;
import　java.util.concurrent.Future;
public　class　ThreadPool　{
public　static　void　main(String[]　args)　throws　Exception　{
ExecutorService　cachedThreadPool　=　Executors.newCachedThreadPool();
final　Future<String>　submit　=　cachedThreadPool.submit(new　Callable<String>()　{
public　String　call()　throws　Exception　{
System.out.println("任务开始");
Thread.sleep(3000);
System.out.println("任务结束");
return　"result";
}
});
cachedThreadPool.execute(new　Runnable()　{
public　void　run()　{
try　{
System.out.println("等待结果");
System.out.println("执行成功:"+submit.get());
}　catch　(InterruptedException　e)　{
e.printStackTrace();
}　catch　(ExecutionException　e)　{
e.printStackTrace();
}
}
});
cachedThreadPool.shutdown();
System.out.println("执行其他任务");
}
}
批量添加任务之后获取最先完成的任务的返回结果
import　java.util.Random;
import　java.util.concurrent.Callable;
import　java.util.concurrent.ExecutorCompletionService;
import　java.util.concurrent.ExecutorService;
import　java.util.concurrent.Executors;
public　class　ThreadPool　{
public　static　void　main(String[]　args)　throws　Exception　{
ExecutorService　executorService　=　Executors.newCachedThreadPool();
ExecutorCompletionService<String>　completionService　=　new　ExecutorCompletionService<String>(executorService);
for　(int　i　=　0;　i　<　10;　i++)　{
final　int　task　=　i;
completionService.submit(new　Callable<String>()　{
public　String　call()　throws　Exception　{
int　ms　=　new　Random().nextInt(3000);
System.out.println("任务"+task+",　需要"+ms+"毫秒");
Thread.sleep(ms);
return　"任务"+task+"已完成";
}
});
}
for　(int　i　=　0;　i　<　10;　i++)　{
System.out.println(completionService.take().get());
}
}
}
读取和写入锁
import　java.util.concurrent.locks.ReadWriteLock;
import　java.util.concurrent.locks.ReentrantReadWriteLock;
public　class　ReadWriteLockDemo　{
private　static　class　PWLService　{
private　ReadWriteLock　rw　=　new　ReentrantReadWriteLock();
public　void　read()　{
rw.readLock().lock();
System.out.println("读取操作");
rw.readLock().unlock();
}
public　void　write()　{
rw.writeLock().lock();
System.out.println("写入操作");
rw.writeLock().unlock();
}
}
}
数据缓存　–　模拟hibernate获取元素的方法
import　java.util.concurrent.locks.ReadWriteLock;
import　java.util.concurrent.locks.ReentrantReadWriteLock;
public　class　CacheContainer　{
private　ThreadLocal<Object>　tl　=　new　ThreadLocal<Object>();
private　ReadWriteLock　rw　=　new　ReentrantReadWriteLock();
public　Object　get()　{
rw.readLock().lock();
Object　obj　=　tl.get();
rw.readLock().unlock();
if　(obj==null)　{
rw.writeLock().lock();
obj　=　tl.get();
if　(obj==null)　{
obj　=　new　Object();
tl.set(obj);
}
rw.writeLock().unlock();
}
return　obj;
}
}

}
模拟田径赛跑　–　裁判鸣枪
import　java.util.Random;
import　java.util.concurrent.CountDownLatch;
public　class　CountDownLatchDemo　{
public　static　void　main(String[]　args)　{
final　CountDownLatch　startLatch　=　new　CountDownLatch(1);
final　CountDownLatch　endLatch　=　new　CountDownLatch(3);
for　(int　i　=　0;　i　<　3;　i++)　{
new　Thread(new　Runnable()　{
public　void　run()　{
try　{
startLatch.await();
System.out.println(Thread.currentThread().getName()+"　起跑,冲刺");
Thread.sleep(new　Random().nextInt(3000)+1000);
System.out.println(Thread.currentThread().getName()+"　到达终点");
endLatch.countDown();
}　catch　(InterruptedException　e)　{
e.printStackTrace();
}
}
}).start();
}
new　Thread(new　Runnable()　{
public　void　run()　{
try　{
Thread.sleep(3000);
System.out.println("裁判,鸣枪开始!");
startLatch.countDown();
endLatch.await();
System.out.println("裁判,比赛结束,宣布结果!");
}　catch　(InterruptedException　e)　{
e.printStackTrace();
}
}
}).start();
}
}
线程之间交换数据　–　买卖双方约定交易地点交易
import　java.util.Random;
import　java.util.concurrent.Exchanger;
public　class　ExchangerDemo　{
public　static　void　main(String[]　args)　{
final　Exchanger<String>　exchanger　=　new　Exchanger<String>();
new　Thread(new　Runnable()　{
public　void　run()　{
try　{
System.out.println("买家拿钱出发");
Thread.sleep(new　Random().nextInt(5000)+1000);
System.out.println("买家到达交易地点,等待卖家");
System.out.println("买家拿到了"+exchanger.exchange("钱"));
}　catch　(Exception　e)　{
e.printStackTrace();
}
}
}).start();
new　Thread(new　Runnable()　{
public　void　run()　{
try　{
System.out.println("卖家拿货出发");
Thread.sleep(new　Random().nextInt(5000)+1000);
System.out.println("卖家到达交易地点,等待买家");
System.out.println("卖家拿到了"+exchanger.exchange("货"));
}　catch　(Exception　e)　{
e.printStackTrace();
}
}
}).start();
}
}

第七章　常用类
Object类
finalize()
垃圾回收器
toString()
返回该对象字符串表示
equals(obj)
比较两个对象是否相等
System类
gc()
运行垃圾回收器
currentTimeMillis()
返回当前时间(毫秒)
arraycopy(s,sP,d,dP,l)
源数组复制到另一个数组
getProperties()
获取系统属性
Thread类
currentThread()
当前线程
getName()
获取名称
setName(name)
设置名称
sleep(millis)
等待线程
setDaemon(on)
守护线程
join()
加入线程
Math类
PI
圆周率
abs(a)
绝对值
max(a,　b)
比较最大值
min(a,　b)
比较最小值
pow(a,　b)
n次幂
sqrt(a)
求平方根
cbrt(a)
求立方根
floor(a)
向下取整
ceil(a)
向上取整
round(a)
最接近的整数
random()
随机值
String类
getBytes()
转换字节数组
charAt(index)
获取下标上的字符
compareTo(obj)
比较字符串
endsWith(s)
结尾是否包含
replace(a,　b)
替换字符串
contains(s)
是否包含
startsWith(p)
开头是否包含
concat(str)
连接字符串
indexOf(ch)
出现的下标位置
length()
字符串长度
split(regex)
正则拆分
substring(int)
切割字符串
toCharArray()
转换为字符数组
toLowerCase()
转换为小写
toUpperCase()
转换为小写
trim()
忽略空格
StringBuffer类
append(obj)
追加
insert(offset,　obj)
插入
reverse()
反转字符串
delete(start,　end)
删除
Collection接口　->　ArrayList　->　Vector　->　LinkedList　->　HashSet　->　TreeSet
add(obj)
添加元素
size()
元素数量
get(index)
获取元素
clear()
清空所有元素
remove(obj)
删除指定元素
iterator()
**迭代
Map接口　->　HashMap　->　Hashtable
put(key,value)
添加元素
get(key)
根据键返回值
keySet()
返回所有的键
entrySet()
返回键值对
values()
返回所有的值
Arrays类
sort(obj[])
排序
binarySearch(obj[],key)
二分查找
copyOf(obj[],Leng)
拷贝并创建一个新长度数组
copyOfRange(obj[],s,e)
拷贝截取创建新的数组
fill(obj[],val)
填充数组
asList(T..)
数组转成list
Collections类
sort(list)
排序
inarySearch(list,key)
二分查找
swap(list,i,j)
交换**中的元素
synchronizedCollection
使**线程安全
BigDecimal类
add(augend)
加法/减法
remainder(divisor)
取模
multiply(multiplicand)
乘法
divide(divisor)
除法
File类
exists()
判断文件是否存在
createNewFile()
创建新文件
getParentFile()
获得文件所在的目录
mkdirs()
创建目录
getAbsoluteFile()
获取文件绝对路径
getPath()
获得文件参数路径
getName()
获得文件/文件夹名称
isDirectory()
判断路径是否是目录
isFile()
判断路径是否是文件
lastModified()
返回文件最后修改时间
listFiles()
列出所有文件
delete()
删除文件
第八章　Eclipse　and　MyEclipse

第八章　Eclipse　and　MyEclipse
显示视图
Window　->　Show　View　->　Console　||　Package　Explorer
创建项目
File　->　New　->　Java　Project
打开项目
src　->　Class　->　Package　||　Name　->　Finish
修改字体
Windows　7　->　控制面板　->　外观和个性化　->　字体　->　Courier　New　->　常规　->　显示
　 Preferences　->　General　->　Appearance　->　Colors　and　Fonts　->　Basic　->　Text　Font　->　Courier　New
导入项目
File　->　Import　->　Existing　Projects　into　Workspace　->　Browse　||　Copy　projects　into　workspace　->　Finish
快捷方式
Ctrl+1
代码错误解决
Ctrl+2,L
代码返回值自动补全
Alt+/
代码自动补全
Ctrl+Shift+O
自动导入相关包
Alt+↓
选择代码下移
Ctrl+Alt+↓
复制选择行
Ctrl+D
删除选择行
Ctrl+Alt+Enter
插入空行
Ctrl+/
单行注释
Ctrl+Alt+/,\
多行注释,取消多行注释
Ctrl+Shift+F
格式化代码
Ctrl+F11
运行程序
Shift+Alt+C,O,S,R,V
自动生成代码
Shift+Alt+Z
环绕代码
Shift+Alt+R
重构代码
Shift+Alt+M
抽取方法
Shift+Alt+L
抽取变量
F3
查看源代码
优化程序
关闭启动项
Window　->　Preferences　->　General　->　Startup　and　Shutdown
þ　Aptana　Core
þ　MyEclipse　QuickSetup
þ　MyEclipse　EASIE　Tomcat　6
þ　MyEclipse　Memory　Monitor
þ　MyEclipse　Tapestry　Integration
þ　MyEclipse　JSP　Debug　Tooling
þ　MyEclipse　File　Creation　Wizards
þ　MyEclipse　Backward　Compatibility
þ　MyEclipse　Perspective　Plug-in
关闭自动验证
Windows　->　Perferences　->　Myeclipse　->　Validation　->　Build
关闭拼写检查
Windows　->　Perferences　->　General　->　Editors　->　Text　Editors　->　Spelling　->　Enable　spell　checking
默认Jsp编辑
Window　->　perferences　->　General　->　Editors　->　File　Associations　->　*.jsp　->　MyEclipse　JSP　Editor
Java自动补全
Windows　->　Perferences　->　Java　->　Editor　->　Content　Assist　->　Auto　activation　triggers　for　Java
XML打开错误
Window　->　perferences　->　General　->　Editors　->　File　Associations　->　*.xml　->　MyEclipse　XML　Editor
Build.xml编译错误
项目　->　Perferences　->　Builders　->　Error　->　Remove
更改快捷键
Window　->　perferences　->　General　->　Keys　->　Content　Assist　->　　Alt+/
Window　->　perferences　->　General　->　Keys　->　Word　Completion　->　　Ctrl+Alt+/
禁止Maven更新
Windows　->　Perferences　->　Myeclipse　->　Maven4Myeclipse　->　Maven　->　Download　repository　index　updates　on　startup
更改非堆内存　-　eclipse.ini
-XX:PermSize=512M　-XX:MaxPermSize=512M
关闭在线API
项目　->　Perferences　->　Java　Build　Path　->　Libraries　->　JRE　System　Library　->　rt.jar　->　Javadoc　location　->　Remove
设置虚拟机的版本
Window　->　Perferences　->　Java　->　Compiler　->　6.0
设置工程编译环境
项目　->　Perferences　->　Java　Build　Path　->　Libraries
设置JRE环境
Window　->　Perferences　->　Java　->　Installed　JREs　->　Add　->　Next　->　Directory　->　Finish
设置Tomcat编译环境
Windows　->　Perferences　->　Myeclipse　->　Servers　->　Tomcat　->　Tomcat　6.x　->　JDK

第九章　字符串和时间
获取文件扩展名
public　static　void　main(String[]　args)　{
String　str　=　"文件.txt";
String[]　suffix　=　str.split("\\.");
str　=　suffix[suffix.length-1];
System.out.println(str);
}
查找字符串出现的位置
private　static　void　findAll(String　a,String　b)　{
int　index　=　0;
while(true)　{
int　find　=　a.indexOf(b,index);
if　(find==-1)　{
break;
}
System.out.println(find);
index　=　find+1;
}
}
判断数组中指定位置上的字节是否是中文的前一半
private　static　boolean　isCnBegin(byte[]　arr,int　index)　{
boolean　flag　=　false;
for　(int　i=0;i<=index;i++){
flag=!flag&&arr[i]<0;
}
return　flag;
}
时间
import　java.text.DateFormat;
import　java.text.SimpleDateFormat;
import　java.util.Calendar;
import　java.util.Date;
public　class　dateDemo　{
public　static　void　main(String[]　args)　throws　Exception　{
Date　date　=　new　Date();
//格式化时间
String　pattern　=　"yyyy-MM-dd　HH:mm:ss";
DateFormat　sdf　=　new　SimpleDateFormat(pattern);
String　str　=　sdf.format(date);
System.out.println(str);
date　=　sdf.parse(str);
//判断2月有多少天
Calendar　c　=　Calendar.getInstance();
c.set(2013,　2,　1);
c.add(c.DAY_OF_YEAR,　-1);
System.out.println(c.get(c.DAY_OF_MONTH));
//重现开始往后100天排除周末周日
c.setTime(new　Date());
for　(int　i　=　1;　i　<=　100;　i++)　{
int　week　=　c.get(c.DAY_OF_WEEK);
if(week==1||week==7)　{
i--;
}
c.add(c.DAY_OF_YEAR,　1);
}
System.out.println(c.get(c.DAY_OF_YEAR)-Calendar.getInstance().get(c.DAY_OF_YEAR));
//打印时间
System.out.println(c.get(c.YEAR)+
"-"+(c.get(c.MONTH)+1)+
"-"+c.get(c.DAY_OF_MONTH)+
"　"+c.get(c.HOUR_OF_DAY)+
":"+c.get(c.MINUTE)+
":"+c.get(c.SECOND));
}
}

第十章　**
ArrayList<String>　arrayList　=　new　ArrayList<String>();
Vector　vector　=　new　Vector();
LinkedList　linkedList　=　new　LinkedList();
HashSet　hashSet　=　new　HashSet();
TreeSet　treeSet　=　new　TreeSet();
LinkedHashSet　linkedHashSet　=　new　LinkedHashSet();
HashMap　hashMap　=　new　HashMap();
TreeMap　treeMap　=　new　TreeMap();
Hashtable　hashtable　=　new　Hashtable();
LinkedHashMap　linkedHashMap　=　new　LinkedHashMap();
Properties　properties　=　new　Properties();
equals()　//比较对象是否相等
hashCode()　//比较hashCode相等
compareTo()　//对象进行排序
自定义带泛型**类
public　class　MyCollection<T>　{
private　int　len　=　10;
private　int　pos　=　0;
private　Object[]　t　=　new　Object[len];
public　void　add(T　obj)　{
if　(pos==len)　{
this.len+=10;
T[]　newT　=　(T[])　new　Object[this.len];
for　(int　i　=　0;　i　<　t.length;　i++)　{
newT[i]　=　(T)　t[i];
}
this.t　=　newT;
}
t[pos++]　=　obj;
}
public　T　get(int　index)　{
return　(T)　this.t[index];
}
public　int　size(){
return　pos;
}
}
**出列游戏
import　java.util.Iterator;
import　java.util.LinkedList;
public　class　Game　{
public　static　void　main(String[]　args)　{
LinkedList<String>　boys　=　new　LinkedList<String>();
boys.add("张三");
boys.add("李四");
boys.add("王五");
boys.add("赵六");
boys.add("孙七");
int　count　=　0;
Iterator　iterator　=　boys.iterator();
while　(boys.size()>1)　{
count++;
String　boy　=　(String)iterator.next();
if　(count==3)　{
System.out.println("出列是:"+boy);
iterator.remove();
count　=　0;
}
if　(!iterator.hasNext())　{
iterator　=　boys.iterator();
}
}
System.out.println("幸运者:"+boys.get(0));
}
}
统计字符串中字符出现的次数
import　java.util.Comparator;
import　java.util.HashMap;
import　java.util.Iterator;
import　java.util.Map.Entry;
import　java.util.Set;
import　java.util.TreeSet;
public　class　CountCharNum　{
public　static　void　main(String[]　args)　{
String　str　=　"absadsadlihsaodlsa";
HashMap<Character,　Integer>　hashMap　=　new　HashMap<Character,　Integer>();
char[]　chars　=　str.toCharArray();
for　(char　c　:　chars)　{
if　(hashMap.containsKey(c))　{
hashMap.put(c,　hashMap.get(c)+1);
}else{
hashMap.put(c,　1);
}
}
TreeSet　treeSet　=　new　TreeSet(new　Comparator<Entry<Character,　Integer>>(){
public　int　compare(Entry<Character,　Integer>　o1,　Entry<Character,　Integer>　o2)　{
Character　c1　=　o1.getKey();
Character　c2　=　o2.getKey();
Integer　v1　=　o1.getValue();
Integer　v2　=　o2.getValue();
Integer　num　=　v1-v2;
return　num!=0?num:c1-c2;
}
});
Set　entrySet　=　hashMap.entrySet();
Iterator　iterator　=　entrySet.iterator();
while　(iterator.hasNext())　{
Entry　entry　=　(Entry)　iterator.next();
treeSet.add(entry);
}
System.out.println(treeSet);
}
}