创建文件

File a=new File("d:/a/bb
标记: 常用方法

参见: 不是创建一个文件 a.createNewFile() 才是创建一个文件 也可以理解为new 只是在内存中创建一个文件 后者是把文件放到磁盘上

delete() 删除此抽象路径名表示的文件或目录。

equals(Object obj) 测试此抽象路径名与给定对象是否相等
标记: 被重写了 只要路径 文件名相同 就是相等

isDirectory() 测试是否是一个目录。

isFile() 测试此抽象路径名表示的文件是否是一个标准文件。

exists() 测试此抽象路径名表示的文件或目录是否存在

renameTo(File dest) 重新命名此抽象路径名表示的文件。

getName() 返回由此抽象路径名表示的文件或目录的名称。

canWrite() 测试应用程序是否可以修改此抽象路径名表示的文件。

isHidden() 测试此抽象路径名指定的文件是否是一个隐藏文件。

list(FilenameFilter filter) 返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。

过滤器Filefilter 如果符合条件 则返回真ture 否则返回假flase

当出现空指针异常时要检查返回数组是否为空

listFiles(FileFilter filter) 返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。
标记: 也可以用于返回所有文件和目录 主要看过滤器怎么写

list() 返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。

mkdirs() 创建 指定的目录。所需路径的多个目录

mkdir() 创建 指定的目录。 只能创建一个所需路径的目录

getName() 返回由此抽象路径名表示的文件或目录的名称。

createNewFile() 当且仅当不存在具有此抽象路径名指定名称的文件时，创建一个新的空文件。

java .lang.Class 反射
标记: 通过反射访问属性 调用方法

package com.fs;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Test2 {

public static void main(String[] args) {
//通过反射产生实例
try {
Class c = Person.class; //Class c =Class.forName("包名.类名"); Class c = new String().getClass();
c.newInstance();

//通过反射或者类的信息
System.out.println(c.getPackage()+" "+c.getName());
//通过反射或者字段信息
Field f = c.getField("age");
Person p = new Person();
//通过反射给对象属性赋值
f.set(p, 44);

//通过反射调用对象的方法
Method m = c.getMethod("show",int.class,String.class );
m.invoke(p,44,"lisi");
} catch (Exception e) {
e.printStackTrace();
} //得到实例

}

}

反射机制的作用：
1、反编译：.class-->.java
2、通过反射机制访问java对象的属性，方法，构造方法等；

得到反射实例的方法

Class c =Class.forName("包名.类名");

Class c = new String().getClass();

Class c = Person.class;

主要是指程序可以访问、检测和修改它本身状态或行为的一种能力，并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义

常用方法

getAnnotations() 返回此元素上存在的所有注释。

getFields() 返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段。
标记: 返回全部的

getInterfaces() 确定此对象所表示的类或接口实现的接口。

getMethods() 返回一个包含某些 Method 对象的数组，这些对象反映此 Class 对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共 member 方法。

getMethod(String name, Class<?>... parameterTypes)
返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。

getField(String name) 返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段。
标记: 返回指定的字段

newInstance() 创建此 Class 对象所表示的类的一个新实例。
标记: 默认调用无参构造方法

反射调用有参构造的方法 getConstructor

Constructor t=U.getConstructor(String.class,String.class,String.class);
User n = t.newInstance(us,ag,c);

注释 也叫注解
标记: 注解是代码里的特殊标记，这些标记可以在编辑、类加载、运行时被读取，并执行相应的处理。

package meiju;

public enum Season3 implements Rizi{
chun("春天","3月-5月 ，温度适宜，植物发芽的季节"){

@Override
public void guorizi() {
System.out.println("多出去踏青。。。。。");
}

}
,xia("夏天","6月-8月 ，温度热，植物开花的季节"){

@Override
public void guorizi() {
// TODO Auto-generated method stub
System.out.println("多出去游泳。。。。。");
}}
,qiu("秋天","9月-11月 ，温度凉爽，植物收获的季节"){

@Override
public void guorizi() {
// TODO Auto-generated method stub
System.out.println("多出去爬山。。。。。");
}}
,dong("冬天","12月-2月 ，温度冷，下雪的季节") {
@Override
public void guorizi() {
// TODO Auto-generated method stub
System.out.println("多出去滑雪。。。。。");
}
};
String name;
String description;
Season3(String name,String description){
this.name = name;
this.description = description;
}
public void show(){
System.out.println(name+" "+description);
}

指示注释类型的注释要保留多久。如果注释类型声明中不存在 Retention 注释，则保留策略默认为 RetentionPolicy.CLASS

类型声明是用 Documented 来注释的，则其注释将成为注释元素的公共 API 的一部分。

指示注释类型所适用的程序元素的种类。如果注释类型声明中不存在 Target 元注释，

指示注释类型被自动继承。如果在注释类型声明中存在 Inherited 元注释，

类加载

类加载器（class loader）：加载类的工具

基本上所有的类加载器都是 java.lang.ClassLoader类的实例
系统类加载器实例对象可以通过 ClassLoader.getSystemClassLoader()来获取

加载类的方式有以下几种：
1）从本地系统直接加载
2）通过网络下载.class文件
3）从zip，jar等归档文件中加载.class文件
4）从专有数据库中提取.class文件

类加载就是JVM(Java虚拟机)将Java源文件编译后的字节码.class文件加载至Java虚拟机中的过程，它是Java程序运行的第一步。

2) 类加载步骤类加载过程分为三个步骤：装载（Load），链接（Link）和初始化(Initialize)

枚举类 Enum java.lang
标记: 可以在类属性 最前面

枚举类里可以放抽象方法 也可以实现接口 但在枚举类字段中用匿名内部类方法实现抽象方法

package meiju;

public enum Season3 implements Rizi{
chun("春天","3月-5月 ，温度适宜，植物发芽的季节"){

@Override
public void guorizi() {
System.out.println("多出去踏青。。。。。");
}

}
,xia("夏天","6月-8月 ，温度热，植物开花的季节"){

@Override
public void guorizi() {
// TODO Auto-generated method stub
System.out.println("多出去游泳。。。。。");
}}
,qiu("秋天","9月-11月 ，温度凉爽，植物收获的季节"){

@Override
public void guorizi() {
// TODO Auto-generated method stub
System.out.println("多出去爬山。。。。。");
}}
,dong("冬天","12月-2月 ，温度冷，下雪的季节") {
@Override
public void guorizi() {
// TODO Auto-generated method stub
System.out.println("多出去滑雪。。。。。");
}
};
String name;
String description;
Season3(String name,String description){
this.name = name;
this.description = description;
}
public void show(){
System.out.println(name+" "+description);
}

//public abstract void guorizi();
}
//public static final Season3 chun = new Season3();

可以理解为在普通类的最前面 加了一些字段
标记: 信息

所有的枚举字段相当于 实例化一个 静态 常量 的实例对象

Enum(String name, int ordinal) 单独的构造方法。当不写修饰符时 默认私有
标记: 默认无参 私有多的构造方法 可以重载

在JDK 1.5之后，对于Set和Map接口而言又增加了两个新的子类：EnumSet、EnumMap两个类 所以遍历集合的时候迭代器也可以用枚举代替

EnumMap(Class<K> keyType) 创建一个具有指定键类型的空枚举映射。

java.util
接口 Enumeration<E> *相当于枚举集合中的迭代器

hasMoreElements() 测试此枚举是否包含更多的元素。

nextElement() 如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。

枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则编译器就会报错，枚举可以让编译器在编译时就可以控制源程序赋给的非法值，使用普通变量的方式在开发阶段无法实现这一目标。

代码实例

带非无参构造方法的枚举举例

public enum Color {
RED(10),BLUE(10);
private Color() {}
private int color;
private Color(int color){
this.color = color;
}
}

如果是无参构造函数，则枚举属性后小括号可以省略 有参的一定要加（）并写入参数

在枚举中定义抽象方法

public enum Color{
RED {
public String getColor() {return "红色";}
},
GREEN {
public String getColor() {return "绿色";}
},
BLUE {public String getColor() {return "蓝色";}
};
public abstract String getColor();
}

让枚举实现接口

interface Info {
public String getColor();
}
public enum Color implements Info {
RED {
public String getColor() {return "红色";}
},
GREEN {
public String getColor() {return "绿色";}
},
BLUE {
public String getColor() {return "蓝色";}
};
}

单例模式

默认的构造函数是共有的 所以如果想返回一个空的单例 必须显示的提供私有的构造函数

具体实现方式 可以把构造函数权限设置为私有private 提供一个静态方法返回在 类属性实例化好的实例

因为存在 类名.属性 的调用方法 所以为了严谨属性必须是静态常量 或者用私有修饰 （其实还有静态保证只有一个对象）

该类在内存中只存在一个实例

线程与进程

进程

进程是出于运行过程中的程序，并且具有一定的独立功能，进程是系统进行资源分配和调度的一个独立单位。一般而言，进程包含如下三个特性：
标记: 线程，有时被称为轻量级进程(Lightweight Process，LWP），是程序执行流的最小单元。上发生地方

public class ThreadOne extends Thread {
public void run(){
System.out.println("继承Thread类");
}
}

public class ThreadTwo implements Runnable{
public void run() {
System.out.println("实现Runnable接口！");
}
}

public class ThreadTest {
public static void main(String[] args) {
//第一种方式
ThreadOne to = new ThreadOne();
to.start();
//第二种方式
ThreadTwo tt = new ThreadTwo();
Thread th = new Thread(tt);
th.start();
}
}

独立性： 进程是系统中的独立存在的实体，它可以拥有自己独立的资源，每一个进程都拥有自己私有的地址空间。在没有经过进程本身允许的情况下，一个用户进程不可以直接访问其他进程的地址空间。

2) 动态性：进程与程序的区别在于，程序只是一个静态的指令集合，而进程是一个正在系统中活动的指令集合。在进程中加入了时间的概念。进程具有自己的生命周期和各种不同的状态，这些概念在程序中都是不具备的

3) 并发性：多个进程可以在单个处理器上并发执行，多个进程之间不会互相影响。

多线程

第二种方式：
public class ThreadRunnable implements Runnable {

@Override
public void run() {
for(int i = 0;i<20;i++){
try {
Thread.currentThread().sleep(100);
System.out.println(Thread.currentThread().getName()+":"+i);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}

}

public class ThreadTest {

public static void main(String[] args) {
ThreadRunnable tr = new ThreadRunnable();
Thread oneth = new Thread(tr, "线程一");
Thread twoth = new Thread(tr, "线程二");
oneth.start();
twoth.start();
}
}

线程方法

多线程，是指从软件或者硬件上实现多个线程并发执行的技术。一个程序运行后至少有一个进程，一个进程里可以包含多个线程，但至少要包含一个线程。

第一种方式：
public class ThreadOne extends Thread {
public void run() {
for(int i = 0;i<20;i++){
try {
Thread.currentThread().sleep(100);
System.out.println(Thread.currentThread().getName()+":"+i);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}
}

public class ThreadTwo extends Thread{
public void run() {
for(int i = 0;i<20;i++){
try {
Thread.currentThread().sleep(100);
System.out.println(Thread.currentThread().getName()+":"+i);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}
}

public class ThreadTest {

public static void main(String[] args) {
ThreadOne to = new ThreadOne();
to.setName("线程一");
to.start();
ThreadTwo tt = new ThreadTwo();
tt.setName("线程二");
tt.start();
}
}

方法 进程的方法

String sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。

join () 等待该线程终止
标记: 例如 在a线程中调用b线程的join方法 则a线程等待b线程执行完后再执行

setPriority(int newPriority) 更改线程的优先级。

yield() 暂停当前正在执行的线程对象，并执行其他线程。

run （） {}方法 所有线程必须重写此方法 在线程类里

getPriority() 返回线程的优先级。

Void join()等待该线程终止。

String getName() 返回该线程的名称。

优先级

每个线程执行时都具有一定的优先级，优先级高的线程获得较多的执行机会，而优先级低的线程则获得较少的执行机会。

package xc;

public class TestAB {

public static void main(String[] args) {

ThreadA t = new ThreadA( );
Thread tt1 = new Thread(t);tt1.start();
tt1.setName("A");
System.out.println(Thread.MAX_PRIORITY+" "+Thread.MIN_PRIORITY);//1---10
tt1.setPriority(10); //优先级高的线程拥有更多被CPU调度的机会

for(int i=0;i<30;i++){
System.out.println("------------------------"+i+" "+Thread.currentThread().getName());
if(i==10){
try {
//tt1.join(1); //tt1 插入到main线程中执行。tt1执行完或者执行完指定时间后 main才执行
Thread.yield(); //写在哪个线程 则哪个线程让出CPU 然后重新由CPU调度
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}

每个线程默认的优先级都与创建它的父线程的优先级相同，在默认情况下，main线程具有普通优先级，由main线程创建的子线程也具有普通优先级。

Thread类提供了setPriority(int newPriority)、getPriority()方法来设置和返回指定线程的优先级，其中setPriority()方法的参数可以是一个整数，范围是1~10之间，也可以使用

Thread类提供了setPriority(int newPriority)、getPriority()方法来设置和返回指定线程的优先级，其中setPriority()方法的参数可以是一个整数，范围是1~10之间，也可以使用Thread类的如下三个静态常量。
MAX_PRIORITY:其值是10
MIN_PRIORITY：其值是1
NORM_PRIORITY:其值是5

线程的状态

线程状态转换图

新建、就绪、运行、阻塞、死亡
标记: 在线程的生命周期中，它要经过新建(new）、就绪(Runnable)、运行(Running)、堵塞(Blocked)和死亡(Dead)5个状态。

5) 死亡：线程会以如下三种方式结束，结束后就处于死亡状态：

? 直接调用该线程的stop()方法来结束该线程—该方法容易导致死锁，通常不推荐使用。

? 线程抛出一个未捕获的Exception或Error。

? Run()或call()方法执行完成，线程正常结束

4) 阻塞：当线程调用了sleep()、wait()等方法线程进入阻塞状态

3) 运行：处于就绪状态的线程得到了CPU，开始执行run()方法的线程执行体，则该线程处于运行状态

2) 就绪：当线程对象调用了start()方法之后，该线程处于就绪状态。

1) 新建：当程序使用new关键字创建了一个线程后，该线程就处于新建状态

线程同步

所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回，同时其它线程也不能调用这个方法

在多线程编程里面，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何时刻，最多有一个线程访问，以保证数据的完整性。

同步代码块

public class Account {
private String accountNo; //账户
private double balance; //余额
public String getAccountNo() {
return accountNo;
}
public void setAccountNo(String accountNo) {
this.accountNo = accountNo;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
public Account(String accountNo, double balance) {
super();
this.accountNo = accountNo;
this.balance = balance;
}
}

public class DrawThread extends Thread{
private Account account; // 当前账户
private double amount;//要取得金额
public DrawThread(String name,Account account, double amount) {
super(name);
this.account = account;
this.amount = amount;
}
public void run(){

//判断账户余额是否大于取钱数
if(account.getBalance()>=amount){
System.out.println(Thread.currentThread().getName()+"取钱成功！吐出金额："+amount);
try {
Thread.currentThread().sleep(200);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//修改余额
account.setBalance(account.getBalance()-amount);
System.out.println("账户余额为："+account.getBalance());
}else{
System.out.println(Thread.currentThread().getName()+"取钱失败,余额不足！");
}
}
}

public class DrawTest {
public static void main(String[] args) {
Account account = new Account("6226620204031314", 1000);
new DrawThread("甲",account, 800).start();
new DrawThread("乙",account, 800).start();
}
}

加同步代码后 在同步代码块内部还需要在判断数据是否符合条件

Thread.currentThread() 是静态方法 可以类名. 调用

所谓代码块是指用“{}”括起来的一段代码，根据其位置和声明的不同，可以分为普通代码块、构造块、静态块、和同步代码块。如果在代码块前加上 synchronized关键字，则此代码块就成为同步代码块。

同步代码块的格式：synchronized(同步对象){ 需要同步的代码；}同步对象一般为当前对象，即使用this关键字。

同步方法

public class Account {
private String accountNo; //账户
private double balance; //余额
public String getAccountNo() {
return accountNo;
}
public void setAccountNo(String accountNo) {
this.accountNo = accountNo;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
public Account(String accountNo, double balance) {
super();
this.accountNo = accountNo;
this.balance = balance;
}
}

public class DrawThread implements Runnable {
private Account account; // 当前账户
private double amount;// 要取得金额

public DrawThread(Account account, double amount) {
this.account = account;
this.amount = amount;
}

public void run() {
draw();
}

public synchronized void draw() {
// 判断账户余额是否大于取钱数
if (account.getBalance() >= amount) {
System.out.println(Thread.currentThread().getName() + "取钱成功！吐出金额："
+ amount);
try {
Thread.currentThread().sleep(200);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// 修改余额
account.setBalance(account.getBalance() - amount);
System.out.println("账户余额为：" + account.getBalance());
} else {
System.out.println(Thread.currentThread().getName() + "取钱失败,余额不足！");
}

}

}

public class DrawTest {

public static void main(String[] args) {
Account account = new Account("6226620204031314", 1000);
DrawThread dt = new DrawThread(account,800);
Thread th1 = new Thread(dt, "甲");
Thread th2 = new Thread(dt, "乙");
th1.start();
th2.start();

}

}}

同步方法：使用synchronized关键字来修饰某个方法，则该方法称为同步方法。

同步代码块 可以和同步方法替换 但是要注意锁的一致性（ 即用继承+静态方式不能用同步方法代替）

同步锁

Java提供了一种功能更强大的线程同步机制—通过显示定义同步锁对象来实现同步，在这种机制下，同步锁由Lock对象充当。

锁要注意唯一性 把this作为锁 很有可能不是一个锁

死锁
标记: 互相持有对方需要的锁而处于互相等待的状态

当两个线程相互等待对方释放同步监视器时就会放生死锁，Java虚拟机没有检测，也没有采取措施来处理死锁情况，所以多线程编程时应该采取措施避免死锁出现。一旦出现死锁，整个程序既不会发生任何异常，也不会给出任何提示，只是所有线程处于阻塞状态，无法继续。

线程间通讯

wait 导致当前线程等待，直到其他线程调用该同步监视器的notify()方法或者notifyAll()方法来唤醒该线程。
标记: 调用wait()方法的当前线程会释放对该同步监视器的锁定。

无时间参数的wait(一直等待，直到其他线程通知)

微秒参数的wait()

带毫秒参数的wait()

notify 唤醒在此同步监视器上等待的单个线程。如果所有线程都在此同步监视器上等待，则会选择唤醒其中一个线程。选择是任意性的。

只有当前线程放弃对该同步监视器的锁定后(使用wait()方法)，才可以执行被唤醒的线程

notifyAll方法
唤醒在此同步监视器上等待的所有线程。只有当前线程放弃对该同步监视器的锁定后，才可以执行被唤醒的线程。

流 可以将文件写入磁盘 从磁盘读取文件 等操作
标记: 流用完要关闭

参见: Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。 (方便把集合内容输出到文件)

也可以分为 字节流和过滤流 （高级流）
标记: 红色

高级流的构造需要传入一个流作为参数

输出流

输出流 字符流 Writer
标记: 数据粒度为两个字节 对字符 常用

FileWriter

参见: 常用方法

BufferedWriter 带缓冲的字符写入流

输出流 字节流 OutputStream
标记: 数据粒度为一个字节 写入视频 图片 等常用 抽象类

常用方法

参见: FileWriter, BufferdedOutputStream 带缓冲的输出流

close() 关闭此输出流并释放与此流有关的所有系统资源。

flush() 刷新此输出流并强制写出所有缓冲的输出字节。
标记: 所有输出流中都有的方法

write(int b) 将指定的字节写入此输出流。

write(byte[] b) 将 b.length 个字节从指定的 byte 数组写入此输出流。

FileOutputStream 文件输出流
标记: 继承关系 只列出特有方法

FileOutputStream(String name, boolean append) 创建一个向具有指定 name 的文件中写入数据的输出文件流。
标记: 即追加信息到文件末尾

getFD() 返回与此流有关的文件描述符。

finalize() 清理到文件的连接，并确保在不再引用此文件输出流时调用此流的 close 方法。

BufferdedOutputStream 带缓冲的输出流

参见: 常用方法

BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流，以将数据写入指定的底层输出流。

System.out

标准输出流 或者叫打印流

ObjectOutptStream 对象序列化 流
标记: 优先级 1, 可以实现对象的持久存储

一个对象如果要实例化 必须先实现Serializable接口标记

虽然集合实现了该接口 但放入集合的对象也必须实现该接口才能序列化

writeObject(Object obj) 将指定的对象写入 ObjectOutputStream。

flush() 刷新该流的缓冲。

write(int val) 写入一个字节。方法被重载 可以是任何基本类型
标记: 例如 writeboolean 是写布尔类型的方法

ObjectOutputStream(OutputStream out) 创建写入指定 OutputStream 的 ObjectOutputStream。
标记: 构造方法

桥梁流
标记: 任务完成, 刷新, 信息, 构造函数可以指定编码 可以解决乱码问题

OutptStreamWriter 输出桥梁流

flush() 刷新该流的缓冲。

OutputStreamWriter(OutputStream out)
创建使用默认字符编码的 OutputStreamWriter。
标记: 构造方法 可以把字节输出流转换为字符输出流

InputStreamReader 输入桥梁流

InputStreamReader(InputStream in) 创建一个使用默认字符集的 InputStreamReader。
标记: 构造方法 可以把一个字节输入流转换为字符输入流

输入流

输入流 字节流 IntputStream
标记: 数据粒度为一个字节 读视频 图片 等常用 抽象类

常用方法

参见: FileReader

close() 关闭此输入流并释放与该流关联的所有系统资源。

read() 从输入流中读取数据的下一个字节。

read(byte[] b, int off, int len) 将输入流中最多 len 个数据字节读入 byte 数组。

skip(long n) 跳过和丢弃此输入流中数据的 n 个字节。

void reset() 将此流重新定位到最后一次对此输入流调用 mark 方法时的位置。

FileInputStream 文件输入流
标记: 继承关系 只列出特有方法

getFD() 返回表示到文件系统中实际文件的连接的 FileDescriptor 对象，该文件系统正被此 FileInputStream 使用。

FileInputStream(File file) 通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
标记: 构造方法

finalize() 确保在不再引用文件输入流时调用其 close 方法。

System.in
标记: 可以从控制台输入

标准输入流

PrintStream 打字节输出流 PrintWriter 打印字符输出流
标记: 高级流 字节流只能包含字节流 字符流只能包含字符流

PrintStream(File file) 创建具有指定文件且不带自动行刷新的新打印流。

PrintStream(OutputStream out) 构造方法

print 有多种重载方法 可以方便把内容写入文件
标记: 微笑

println 可以方便的是文本换行

BufferedInputStream 带缓存的输入流
标记: 可以读取一行内容

available() 返回可以从此输入流读取（或跳过）、且不受此输入流接下来的方法调用阻塞的估计字节数。

BufferedInputStream(InputStream in) 创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
标记: 构造函数

ObjectInputStream 对象反序列化
标记: 优先级 1

ObjectInputStream(InputStream in) 创建从指定 InputStream 读取的 ObjectInputStream。
标记: 构造函数

read 方法有很多种 可以读取任意类型的数据
标记: 例如 readboolean 读取一个布尔类型的值

读的顺序类型一定和写入顺序类型一样 否则会报异常

readObject() 从 ObjectInputStream 读取对象。
标记: 对象的反序列化 但一定和放入的对象一致

返回值类型是object 类型 需要强制转换

skipBytes(int len) 跳过字节。

输入流 字符流 Reader
标记: 数据粒度为两个字节 对字符 常用

FileReader

参见: 常用方法

BufferedReader 带缓冲的字符读取流

不是创建一个文件 a.createNewFile() 才是创建一个文件 也可以理解为new 只是在内存中创建一个文件 后者是把文件放到磁盘上
标记: 问号

参见: File a=new File("d:/a/bb

Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。
标记: 可以用hashmap里的方法 但是仅限字符串

参见: 流 可以将文件写入磁盘 从磁盘读取文件 等操作 (方便把集合内容输出到文件)

如果一个文件不是properties 后缀名的 但是文件内容是***=***格式 同样可以用properties读取内容
标记: 大笑

storeToXML(OutputStream os, String comment, String encoding) 使用指定的编码发出一个表示此表中包含的所有属性的 XML 文档。

load(InputStream inStream) 从输入流中读取属性列表（键和元素对）。
标记: 绑定到输入流 只有绑定才能读取到文件的数据

list(PrintStream out) 将属性列表输出到指定的输出流。

getProperty(String key) 用指定的键在此属性列表中搜索属性。
标记: 集合持久化

store(OutputStream out, String comments) 以适合使用 load(InputStream) 方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。
标记: 和 save 一样 save 已过时 只有保存才能写入到文件 如果要追加模式 则传入追加模式的输出流

java知识总结-1