标签：
一、散列表
1.容量：散列表中的散列数组大小
2.散列运算：key->散列值的算法
3.散列桶：散列值相同的元素的“线性集合”
4.加载因子：就是散列数组加载率，就是元素数量/散列数组大小
5.散列查找：根据key计算散列值，找到散列桶，在散列桶中顺序比较key，如果一样就返回value
6.散列表中key不同，value可以重复
例子：
<span style="white-space:pre"> </span>User u1=new User(1,"tom","123");
User u2=new User(2,"jerry","123");
User u3=new User(3,"john","123");
User u4=new User(4,"robin","123");
User u5=new User(5,"gg","123");
User u6=new User(6,"mm","123");
User u7=new User(7,"dd","123");
User[] us={u1,u2,u3,u4,u5,u6,u7};
//login
String name="mm";
String pwd="123";
User u=null;
for(int i=0;i<us.length;i++){
if(us[i].getName().equals(name)){
u=us[i];
}
}
二、异常
1.行为的意外结果
2.一个方法如果抛出了异常，这个方法就必须声明异常的抛出
异常的声明：在方法上声明方法的意外结果，如：
User reg(String name,String pwd,String email)throws UserExistException;
User login(String name,String pwd)throws NameOrPwdException;
3.异常类一般继承于Exception
4.调用抛出异常的方法必须处理异常
4.1调用try,catch,finally捕获
4.2直接再抛出异常
4.3捕获，再抛出
处理方式依赖于具体逻辑
5.如果代码有异常发生，异常以后的代码将不再执行
6.try,catch,finally
try是尝试运行代码块，如果有异常会被随后的catch捕获，异常发生后代码不再执行
catch代码块是异常处理代码。需要提供合理的处理，异常的处理是与具体业务逻辑有关的，可以写多个catch处理一系列异常，但要注意：异常的大小关系，大类型的放到后面处理。有时候catch（Exception）粗粒度处理异常，代码简洁语义含糊，根据业务逻辑适当选用
finally代码块，不管是否出现异常，总会执行的代码块，经常用来处理现场的清理，比如：可靠地数据路连接关闭
7.异常有一个基本原则：能够底层处理的尽量处理，但如果不能处理，必须抛出到调用者（方法）。不应该简单地抛弃
8.异常捕获再抛出，是一种把底层异常进行封装，转换为另一种异常类型
9.建议在捕获到异常时使用e.printStackTrace();
10.异常的分类
Throwable
Error是系统不可恢复的错误，由JVM发生
OutOfMemoryError堆内存溢出
StackOverflowError栈内存溢出
Exception程序可以检查处理的异常
java.text.parseException format解析对象时
RuntimeException非检查异常，javac忽略对这类异常的语法检查，如：异常抛出
IllegalArgumentException
NullPointerException
ArrayIndexOutOfBoundsException
ClassCastException
NumberFormatException
11.软件中会大量使用自定义类，一般从Exception继承
异常类命名要有实际意义
例子：
public class ExceptionDemo {
User u1=new User(1,"tom","123");
User u2=new User(2,"jerry","123");
User u3=new User(3,"john","123");
User u4=new User(4,"robin","123");
User u5=new User(5,"gg","123");
User u6=new User(6,"mm","123");
User u7=new User(7,"dd","123");
User[] us={u1,u2,u3,u4,u5,u6,u7};
List<User> users=Arrays.asList(us);
public static void main(String[] args) {
ExceptionDemo demo=new ExceptionDemo();
try{
User u=demo.findByName("mm");
// User u=demo.findByName("mmm");
// User u0=demo.findByName0("mmm");
System.out.println(u.getName());
u=demo.login("abc", "123");
}catch(UserNotFoundException e){//异常捕获
e.printStackTrace();
System.out.println(e.getMessage());//异常处理
}catch(NameOrPasswordException e){
e.printStackTrace();
}
}
public User login2(String name,String pwd)
throws PasswordException,UserNotFoundException{
User u=findByName(name);//异常直接再抛出
if(u.getPwd().equals(pwd)){
return u;
}
throw new PasswordException("Pwd");
}
public User login(String name,String pwd)//异常捕获包装再抛出
throws NameOrPasswordException{
try{
User u=findByName(name);
if(u.getPwd().equals(pwd)){
return u;
}
throw new NameOrPasswordException("pwd Wrong");
}catch(UserNotFoundException e){
throw new NameOrPasswordException(e);
}
}
public User findByName(String name)
throws UserNotFoundException{//异常声明
for(int i=0;i<us.length;i++){
User u=us[i];
if(u.getName().equals(name)){
return u;
}
}
throw new UserNotFoundException("没有呀");//异常处理
}
public User findByName0(String name)//使用迭代器来实现的遍历
throws UserNotFoundException{
Iterator<User> ite=users.iterator();
User u0;
while(ite.hasNext()){
u0=ite.next();
if(u0.getName().equals(name)){
return u0;
}
}
throw new UserNotFoundException("没有呀0");
}
}
三、IO
1.java.io
2.File类，代表文件、文件夹（目录）
a.查看文件/目录属性，目录是相对目录是javavm启动的目录，Eclipse默认的是相对目录
b.创建文件/目录
c.访问文件系统（目录系统），列文件/目录/过滤列目录
例子：
public static void main(String[] args) {
File bin=new File("bin");
System.out.println(bin.getAbsolutePath());
System.out.println(bin.isDirectory());
System.out.println(bin.canRead());
long time=bin.lastModified();
// System.out.println(DateFormatUtils.format(time,"yyyy-MM-dd"));
SimpleDateFormat fmt=
new SimpleDateFormat("yyyy-MM-dd");
System.out.println(fmt.format(new Date(time)));
long size=bin.length();
//文件属性
File file=new File("src/day16/FileDemo.java");
// File file=new File("src\\day16\\FileDemo.java");//两种/\，java都支持，不过\要记得转译哦
System.out.println(file.isDirectory());
System.out.println(file.isFile());
//管理文件、目录，创建，改名，删除文件或文件夹
File dir=new File("demo");
System.out.println(dir.exists());//false
if(!dir.exists()){<span style="white-space:pre"> </span>//如果文件或目录不存在就创建
dir.mkdir();
//dir.createNewFile();//touch
}
System.out.println(dir.exists());//true
dir.delete();<span style="white-space:pre"> </span>//删除文件或目录
//dir.renameTo(dest)改名
System.out.println(dir.exists());//false
File test=new File("test");
dir.renameTo(test);<span style="white-space:pre"> </span>//对文件或目录重命名
//访问文件系统
File work=new File(".");//当前目录，也就是项目文件夹
String[] list=work.list();//与Linux ls命令相同
System.out.println("Content in "+<span style="white-space:pre"> </span>//显示相对路径
work.getAbsolutePath());
for(int i=0;i<list.length;i++){
String name=list[i];
System.out.println(name);
}
}例子：显示一个含有目录的大文件夹中的所有的文件public class ListAllDemo {
public static void main(String[] args) {
File src=new File("src");
list(src,".java");//列出src中的所有子文件
}
/**
* 显示指定文件夹的指定类型的文件
* 递归处理子文件
* @param dir
* @param ext
*/
public static void list(File dir,String ext){
//显示当前目录中所有的文件
System.out.print("-----------------");
System.out.println(dir.getAbsolutePath());
System.out.print("-----------------");
listFile(dir,ext);
//获得当前目录的所有子目录
File[] all=dir.listFiles();
for(int i=0;i<all.length;i++){
File d=all[i];
if(d.isDirectory()){
list(d,ext);
}
}
//遍历子目录,列出每个子目录的文件
}
public static void listFile(File dir,String ext){
File[] all=dir.listFiles(new Filter(ext));
for(int i=0;i<all.length;i++){
File f=all[i];
System.out.println(f.getName());
}
}
static class Filter implements FilenameFilter{<span style="white-space:pre"> </span>//实现FilenameFilter接口，实现对文件的过滤
private String ext;<span style="white-space:pre"> </span>//增加一个属性，这样就没有把要过滤的文件类型写死，比较灵活
public Filter(String ext) {
this.ext=ext;
}
public boolean accept(File dir,String name){
return name.endsWith(ext);
}
}
}
标签：
原文地址：http://blog.csdn.net/u014596135/article/details/51335286
