java复习（六）

文件和IO流

文件和文件夹 ：File类

构造方法：

​ File (String pathname//路径名)；

​ File(String parent,String child)

	File f=new File("D:\\学习文档\\学习笔记");
		
		System.out.println(f.getAbsolutePath());//D:\学习文档\学习笔记
		System.out.println(f.getName());//D:\学习文档\学习笔记
		System.out.println(f.getPath());//D:\学习文档\学习笔记
		System.out.println(f.getTotalSpace());//132676317184
		System.out.println(f.getUsableSpace());//116146458624
		System.out.println(f.getFreeSpace());//116146458624
		System.out.println(f.getParent());//父级文件路径//D:\学习文档
		
		File f1=new File("aa\\dd\\admin");
		if(f1.exists()) {//  测试此抽象路径名表示的文件或目录是否存在。
			
		}else {
			f1.mkdirs();//创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。
		}
		
		System.out.println("================");
		String[] str=f.list();//子级文件
		for (String string : str) {
			System.out.println(string);
		}
/*
01.md
02.md
03.md
04.md
05.md
06.md
day23
*/	
		System.out.println("================");
		File[] fi=f.listFiles();//子级文件路径
		for (File file : fi) {
			System.out.println(file);
		}	
/**
D:\学习文档\学习笔记\01.md
D:\学习文档\学习笔记\02.md
D:\学习文档\学习笔记\03.md
D:\学习文档\学习笔记\04.md
D:\学习文档\学习笔记\05.md
D:\学习文档\学习笔记\06.md
D:\学习文档\学习笔记\day23
*/

IO流

流的分类

按流向

输入流：磁盘–>内存

输出流：内存–>磁盘

按数据单元

字节流：一次一个字节

字符流：一次一个字符

字符流的本质上也是字节流来交互的

综合

字节输入流：InputStream

字节输出流：OutputStream

字符输入流：Reader

字符输出流：Writer

字节流

字节输入流

InputStream

abstract int read() 从输入流中读取数据的下一个字节。 返回值：下一个数据字节；如果到达流的末尾，则返回 -1。

int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。 返回值：以整数形式返回实际读取的字节数

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

FileInputStream

FileInputStream(String name)
FileInputStream(File file)

BufferedInputStream

为另一个输入流添加一些功能,会创建一个内部缓冲区数组，默认大小8192
BufferedInputStream(InputStream in)
BufferedInputStream(InputStream in, int size)

字节输出流

OutputStream

• abstract void write(int b) 将指定的字节写入此输出流。
• void write(byte[] b) 将 b.length 个字节从指定的 byte 数组写入此输出流。
• void write(byte[] b, int off, int len) 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
• void flush() 刷新此输出流并强制写出所有缓冲的输出字节。
• void close()

FileOutputStream

​ FileOutputStream(String name)
​ FileOutputStream(File file)
​ FileOutputStream(File file, boolean append)
​ FileOutputStream(String name, boolean append)

BufferedOutputStream

​ BufferedOutputStream(OutputStream out)
​ BufferedOutputStream(OutputStream out, int size)

字符流

乱码，跟编码格式有关(编码和解码的方式不一样)，一个字符占几个字节
不同的编码格式，影响字符存储所占的字节数
常用的编码格式：
iso8859-1 1个字符占1个字节 纯英文，数字
unicode 1个字符占2个字节 支持中英文
UTF-8 最流行的编码格式，支持语言特别多，国际流行非常好
1个字符可能占1-4个字节
gbk gb2312 支持中文 1个字符占1-2个字节
big5 繁体

字符输入流

Reader

​ 读取字符流的抽象类
​ int read() 读取单个字符。
​ int read(char[] cbuf) 将字符读入数组。
​ int read(char[] cbuf, int off, int len) 将字符读入数组的某一部分。

​ void flush()

​ abstract void close()

InputStreamReader

字节流通向字符流的桥梁 使用指定的 charset 读取字节并将其解码为字符
InputStreamReader(InputStream in) 创建一个使用默认字符集的 InputStreamReader。
InputStreamReader(InputStream in, Charset cs) 创建使用给定字符集的 InputStreamReader。
InputStreamReader(InputStream in, String charsetName)

FileReader

​ 用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小8192都是适当的
​ FileReader(String fileName)
​ FileReader(File file)

BufferedReader

​ BufferedReader(Reader in)
​ BufferedReader(Reader in, int sz)
​ String readLine() 读取一个文本行。 如果已到达流末尾，则返回 null

字符写入流

Writer

​ void write(int c) 写入单个字符
​ void write(char[] cbuf) 写入字符数组。
​ void write(String str) 写入字符串。
​ void write(String str, int off, int len) 写入字符串的某一部分。
​ abstract void close() 关闭此流，但要先刷新它。
​ abstract void flush() 刷新该流的缓冲。

OutputStreamWriter

​ 是字符流通向字节流的桥梁 可使用指定的 charset 将要写入流中的字符编码成字节
​ OutputStreamWriter(OutputStream out)
​ OutputStreamWriter(OutputStream out, String charsetName) 创建使用指定字符集的 OutputStreamWriter。
​ OutputStreamWriter(OutputStream out, Charset cs)

FileWriter

​ 写入字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小
​ FileWriter(File file)
​ FileWriter(File file, boolean append)
​ FileWriter(String fileName)
​ FileWriter(String fileName, boolean append)

BufferedWriter

void newLine() 写入一个行分隔符。

/**创建一个list，存储3个学生的信息（姓名，年龄，电话号码）
1、定义一个方法，把学生的信息存储到文件中
	一个学生信息占一行：张三	21	15389454595
2、定义一个方法，把文件中的信息读出来，封装到一个List中去
    //
    
    

数据流

DataInputStream 读取基本 Java 数据类型
readXXX()
DataOutputStream 将基本 Java 数据类型写入输出流中
writeXXX()

ObjectInputStream 读基本数据和对象
readObject()
ObjectOutputStream 写入基本数据和对象
writeObjet(Object o)

序列化

序列化

对象–>字节

作用：把对象存储到文件，或者把对象通过网络传输
实现：
1、实现Serializable接口
2、自定义对象要支持序列化，要求所有的属性都要支持序列化
3、一个类的父类实现了序列化，该类可以继承，不需要再序列化
4、对不想序列化的字段，可以声明为transient
5、static类型的属性，不会序列化
综上，
方式二：实现Externalizable
相对麻烦，可以指定字段序列化

反序列化

字节–>对象

作用：恢复对象
serialVersionUID
InvalidClassException: data.Student; local class incompatible:
stream classdesc serialVersionUID = -8561853792371807620,
local class serialVersionUID = -8679988144284314721
用来类做升级的时候，判断是否要兼容之前的版本
如果要兼容，就使用之前的serialVersionUID
如果不用兼容，就使用新的serialVersionUID

//List<Student>姓名，年龄，电话号码

Properties

继承自hashtable
类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串
.properties 属性文件 url=“” database= user= pwd=

Object setProperty(String key, String value) 
String getProperty(String key) 
String getProperty(String key, String defaultValue) 
   
void load(InputStream inStream)//  从输入流中读取属性列表（键和元素对）
void load(Reader reader) //  按简单的面向行的格式从输入字符流中读取属性列表（键和元素对） 
void save(OutputStream out, String comments)  //已过时

线程

程序：有序的指令集

进程：一个应用程序的实例。当我们启动一个程序的时候，就会 创建该程序的实例，其实就是开启了一个进程。
进程是系统分配资源的基本单位。

线程：运行在进程中。进程可以创建线程。
一个进程中至少有一个线程，这个线程就是主线程。main方法就是主线程的入口
一个进程中可以有多个线程。除了主线程以外，其它的线程都是在主线程中创建的。多线程同时运行。

多线程的好处：1、CPU的利用率比较高

​ 2、用户体验比较好

​ 3、方便开发和维护

多线程的实现：
Thread
创建线程：
方式一：继承Thread,重写run()，创建子线程实例，启动线程
run()就是线程体，就是写线程的执行逻辑
start()使该线程开始执行；Java 虚拟机调用该线程的 run 方法。

​ Thread currentThread()返回对当前正在执行的线程对象的引用。

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

​ 方式二：实现 Runnable 接口，实现run()

​ Thread(Runnable target)

​ Thread(Runnable target, String name)

/**
线程的调度机制：
	根据什么规则来决定哪个线程来抢到CPU
	优先级：1-10   默认值5
		抢占到CPU的概率大一些
	static void sleep(long millis)
		调用此方法，概线程会进入休眠状态，当休眠时间结束，线程继续运行 
		引发中断异常InterruptedException
		使用场景：模拟操作消耗的时间
		 
	void join() 加队
	void join(long millis) 
		谁调用谁加队，调用者线程执行结束，其它线程才开始执行
	
	static void yield() 礼让
		写在哪个线程中，哪个线程礼让。礼让，让出这一次CPU时间片，重新再抢一次
		*/

线程的同步

同步代码块：

​ synchronized (对象){

}

同步方法：

​ synchronized void sell(){

}

同步代码块和同步方法：
1、一个方法中可以有多个同步代码块，并且同步代码可以互相嵌套。灵活
2、同步方法：重用。持有的锁是this
3、一个线程在访问一个同步方法，其它的线程无法访问所有的同步方法，但可以访问非同步方法

同步特点：1、线程安全，数据一致
2、单线程执行，效率低

线程池

字符串常量池 ，池
好处：1、减少创建和销毁的开支，提高程序效率
2、管理线程
实现：
java.util.concurrent
Executor 执行已提交的 Runnable 任务的对象
子接口ExecutorService
AbstractExecutorService
ThreadPoolExecutor 可扩展的线程池实现
ScheduledExecutorService 可安排在给定的延迟后运行或定期执行的命令
ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)

		void execute(Runnable command)  在未来某个时间执行给定的命令。 
		void shutdown()  关闭线程池

/**
            Executors 工具类，创建线程池对象
		static ExecutorService newCachedThreadPool() 可缓存的线程池
		static ExecutorService newFixedThreadPool(int nThreads)  固定数量的线程池
		static ExecutorService newSingleThreadExecutor()  单线程的线程池
		ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
 */

​

	自定义线程池
	public ThreadPoolExecutor(int corePoolSize,	//核心线程数
                       int maximumPoolSize,  //最大线程数
                       long keepAliveTime,	//存活时间
                       TimeUnit unit,	//存活时间单位
                       BlockingQueue<Runnable> workQueue, //阻塞队列
                       ThreadFactory threadFactory,  //线程工厂
                       RejectedExecutionHandler handler //拒绝策略
                       ) {}