传智播客 2015年 刘意_Java基础视频-深入浅出精华版 笔记(day21~day23)(2016年4月8日13:25:18)
day21
1.编码表概述和常见编码表
计算机只能识别二进制数据，早期由来是电信号。
为了方便应用计算机，让它可以识别各个国家的文字。
就将各个国家的文字用数字来表示，并一一对应，形成一张表。
ASCII：美国标准信息交换码。
用一个字节的7位可以表示。
ISO8859-1：拉丁码表。欧洲码表
用一个字节的8位表示。
GB2312：中国的中文编码表。
GBK：中国的中文编码表升级，融合了更多的中文文字符号。
GB18030：GBK的取代版本
BIG-5码 ：通行于台湾、香港地区的一个繁体字编码方案，俗称“大五码”。
Unicode：国际标准码，融合了多种文字。
所有文字都用两个字节来表示,Java语言使用的就是unicode
UTF-8：最多用三个字节来表示一个字符。
UTF-8不同，它定义了一种“区间规则”，这种规则可以和ASCII编码保持最大程度的兼容：
它将Unicode编码为00000000-0000007F的字符，用单个字节来表示它将Unicode编码为00000080-000007FF的字符用两个字节表示
它将Unicode编码为00000800-0000FFFF的字符用3字节表示
2.String类中的编码和解码问题
String(byte[] bytes, String charsetName):通过指定的字符集解码字节数组
byte[] getBytes(String charsetName):使用指定的字符集合把字符串编码为字节数组
编码:把看得懂的变成看不懂的
* String -- byte[]
*
* 解码:把看不懂的变成看得懂的
* byte[] -- String
*
* 举例：谍战片(发电报，接电报)
*
* 码表：小本子
* 字符 数值
*
* 要发送一段文字：
* 今天晚上在老地方见
*
* 发送端：今 -- 数值 -- 二进制 -- 发出去
* 接收端：接收 -- 二进制 -- 十进制 -- 数值 -- 字符 -- 今
*
* 今天晚上在老地方见
*
* 编码问题简单，只要编码解码的格式是一致的。
public static void main(String[] args) throws UnsupportedEncodingException {
String s = "你好";
// String -- byte[]
byte[] bys = s.getBytes(); // [-60, -29, -70, -61]
// byte[] bys = s.getBytes("GBK");// [-60, -29, -70, -61]//证明默认是GBK编码
// byte[] bys = s.getBytes("UTF-8");// [-28, -67, -96, -27, -91, -67]
System.out.println(Arrays.toString(bys));
// byte[] -- String
String ss = new String(bys); // 你好
// String ss = new String(bys, "GBK"); // 你好
// String ss = new String(bys, "UTF-8"); // ???
System.out.println(ss);
}
=======================================
utf-8三个字节为一组，GBK两个字节为一组，如果解码编码不一致会有分组上的问题
3.转换流OutputStreamWriter的使用
转换的意思就是利用编码进行数据转换
OutputStreamWriter(OutputStream out):根据默认编码把字节流的数据转换为字符流
OutputStreamWriter(OutputStream out,String charsetName):根据指定编码把字节流数据转换为字符流
把字节流转换为字符流。
字符流 = 字节流 +编码表。
==================分割线===================
public static void main(String[] args) throws IOException {
// 创建对象
// OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
// "osw.txt")); // 默认GBK
// OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
// "osw.txt"), "GBK"); // 指定GBK
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
"osw.txt"), "UTF-8"); // 指定UTF-8
// 写数据,这个方法可以直接写字符串，实在太方便了！！
osw.write("中国");
// 释放资源
osw.close();
}
4.转换流InputStreamReader的使用
InputStreamReader(InputStream is):用默认的编码读取数据
InputStreamReader(InputStream is,String charsetName):用指定的编码读取数据
public static void main(String[] args) throws IOException {
// 创建对象
// InputStreamReader isr = new InputStreamReader(new FileInputStream(
// "osw.txt"));
InputStreamReader isr = new InputStreamReader(new FileInputStream(
"osw.txt"), "UTF-8");
// 读取数据
// 一次读取一个字符//注意，这是字符流！！！不再是一次读一个字节！！！应该是一次读一个字符
int ch = 0;
while ((ch = isr.read()) != -1) {
System.out.print((char) ch);
}
// 释放资源
isr.close();
}
5.字符流的5种写数据的方式
首先一个要注意的问题,flush问题
===============================
// 创建对象
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
"osw2.txt"));
// 写数据
// public void write(int c):写一个字符
// osw.write('a');
// osw.write(97);
// 为什么数据没有进去呢?(在没写close之前数据没办法显示在txt文件中)
// 原因是：字符 = 2字节
// 文件中数据存储的基本单位是字节。(一个一个字节,停留在缓冲)
//但是，如果没有flush，但有close的话，字符还是可以正常输出的
// void flush()
// 刷新缓冲区
osw.flush();
===============================
close()方法强制刷新(完成了先刷新后关闭的功能)
OutputStreamWriter的方法：
* public void write(int c):写一个字符(可以传'a',也可以传97)
* public void write(char[] cbuf):写一个字符数组
* public void write(char[] cbuf,int off,int len):写一个字符数组的一部分
* public void write(String str):写一个字符串
* public void write(String str,int off,int len):写一个字符串的一部分
面试题：close()和flush()的区别?
* A:close()关闭流对象，但是先刷新一次缓冲区。关闭之后，流对象不可以继续再使用了。
* B:flush()仅仅刷新缓冲区,刷新之后，流对象还可以继续使用。(用于数据量大时刷新)
6.字符流的2种读数据的方式
InputStreamReader的方法：
int read():一次读取一个字符
int read(char[] chs):一次读取一个字符数组
public static void main(String[] args) throws IOException {
// 创建对象
InputStreamReader isr = new InputStreamReader(new FileInputStream(
"StringDemo.java"));
// 一次读取一个字符
// int ch = 0;
// while ((ch = isr.read()) != -1) {
// System.out.print((char) ch);
// }
// 一次读取一个字符数组
char[] chs = new char[1024];
int len = 0;
while ((len = isr.read(chs)) != -1) {
System.out.print(new String(chs, 0, len));
}
// 释放资源
isr.close();
}
7.字符流复制文本文件案例1----copyfile
需求：把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
数据源：
a.txt -- 读取数据 -- 字符转换流 -- InputStreamReader
目的地：
b.txt -- 写出数据 -- 字符转换流 -- OutputStreamWriter
==========================================
public static void main(String[] args) throws IOException {
// 封装数据源
InputStreamReader isr = new InputStreamReader(new FileInputStream(
"a.txt"));
// 封装目的地
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
"b.txt"));
// 读写数据
// 方式1
// int ch = 0;
// while ((ch = isr.read()) != -1) {
// osw.write(ch);
// }
// 方式2
char[] chs = new char[1024];
int len = 0;
while ((len = isr.read(chs)) != -1) {
osw.write(chs, 0, len);//注意这里
// osw.flush();//可选动作
}
// 释放资源
osw.close();
isr.close();
}
=============================================
8.转换流的简化写法
解析：InputStreamReader，OutputStreamWriter 充当桥梁的作用(连接字节流和字符流)
而有时候写起来很麻烦，因此借用一个便捷子类来简化书写
InputStreamReader isr = new InputStreamReader(new FileInputStream(
"a.txt"));
等价于 FileReader fr = new FileReader("a.txt");
而
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
"b.txt"));
等价于 FileWriter fw = new FileWriter("b.txt");
代码被简化
====================================================
需求：把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
数据源：
a.txt -- 读取数据 -- 字符转换流 -- InputStreamReader -- FileReader
目的地：
b.txt -- 写出数据 -- 字符转换流 -- OutputStreamWriter -- FileWriter
public static void main(String[] args) throws IOException {
// 封装数据源
FileReader fr = new FileReader("a.txt");
// 封装目的地
FileWriter fw = new FileWriter("b.txt");
// 一次一个字符
// int ch = 0;
// while ((ch = fr.read()) != -1) {
// fw.write(ch);
// }
// 一次一个字符数组
char[] chs = new char[1024];
int len = 0;
while ((len = fr.read(chs)) != -1) {
fw.write(chs, 0, len);
fw.flush();
}
// 释放资源
fw.close();
fr.close();
}
==================================================
9.字符缓冲输出流BufferedWriter的使用
字符流为了高效读写，也提供了对应的字符缓冲流。
BufferedWriter:字符缓冲输出流
BufferedReader:字符缓冲输入流
BufferedWriter:字符缓冲输出流
将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。
public static void main(String[] args) throws IOException {
// BufferedWriter(Writer out)
// BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
// new FileOutputStream("bw.txt")));//原始写法,带转换流
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
bw.write("hello");
bw.write("world");
bw.write("java");
bw.flush();
bw.close();
}
10.字符缓冲输入流BufferedReader的使用
BufferedReader
从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。
BufferedReader(Reader in)
public static void main(String[] args) throws IOException {
// 创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("bw.txt"));
// 方式1
// int ch = 0;
// while ((ch = br.read()) != -1) {
// System.out.print((char) ch);
// }
// 方式2
char[] chs = new char[1024];
int len = 0;
while ((len = br.read(chs)) != -1) {
System.out.print(new String(chs, 0, len));
}
// 释放资源
br.close();
}
11.字符缓冲流复制文本文件案例1
需求：把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
数据源：
a.txt -- 读取数据 -- 字符转换流 -- InputStreamReader -- FileReader -- BufferedReader
目的地：
b.txt -- 写出数据 -- 字符转换流 -- OutputStreamWriter -- FileWriter -- BufferedWriter
public static void main(String[] args) throws IOException {
// 封装数据源
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
// 封装目的地
BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
// 两种方式其中的一种一次读写一个字符数组
char[] chs = new char[1024];
int len = 0;
while ((len = br.read(chs)) != -1) {
bw.write(chs, 0, len);
bw.flush();
}
// 释放资源
bw.close();
br.close();
}
12.字符缓冲流的特殊功能---换行问题
字符缓冲流的特殊方法：
BufferedWriter:
public void newLine():根据系统来决定换行符
BufferedReader:
public String readLine()：一次读取一行数据
包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null
/ public String readLine()：一次读取一行数据
// String line = br.readLine();
// System.out.println(line);//必须手动加换行ln才可以换行，读数据的时候可以识别换行符但并不会添加换行符
// line = br.readLine();
// System.out.println(line);//必须手动加换行ln才可以换行，读数据的时候可以识别换行符但并不会添加换行符
文件本身的内容(也就是说，文件本身有换行符)
public static void main(String[] args) throws IOException {
// write();
read();
}
private static void read() throws IOException {
// 创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("bw2.txt"));
// public String readLine()：一次读取一行数据
// String line = br.readLine();
// System.out.println(line);
// line = br.readLine();
// System.out.println(line);
// 最终版代码
String line = null;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
//释放资源
br.close();
}
private static void write() throws IOException {
// 创建字符缓冲输出流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("bw2.txt"));
for (int x = 0; x < 10; x++) {
bw.write("hello" + x);
// bw.write("\r\n");
bw.newLine();
bw.flush();
}
bw.close();
}
输出示例
13.字符缓冲流复制文本文件案例2
需求：把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
public static void main(String[] args) throws IOException {
// 封装数据源
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
// 封装目的地
BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
// 读写数据
String line = null;
while ((line = br.readLine()) != null) {
bw.write(line);
bw.newLine();//一定要记得换行
bw.flush();
}
// 释放资源
bw.close();
br.close();
}
================================================
14.IO流小结图解
15.复制文本文件的5种方式案例
复制文本文件
分析：
复制数据，如果我们知道用记事本打开并能够读懂，就用字符流，否则用字节流。
通过该原理，我们知道我们应该采用字符流更方便一些。
而字符流有5种方式，所以做这个题目我们有5种方式。推荐掌握第5种。
数据源：
c:\\a.txt -- FileReader -- BufferdReader
目的地：
d:\\b.txt -- FileWriter -- BufferedWriter
=======================================
public static void main(String[] args) throws IOException {
String srcString = "c:\\a.txt";
String destString = "d:\\b.txt";
// method1(srcString, destString);
// method2(srcString, destString);
// method3(srcString, destString);
// method4(srcString, destString);
method5(srcString, destString);
}
// 字符缓冲流一次读写一个字符串
private static void method5(String srcString, String destString)
throws IOException {
BufferedReader br = new BufferedReader(new FileReader(srcString));
BufferedWriter bw = new BufferedWriter(new FileWriter(destString));
String line = null;
while ((line = br.readLine()) != null) {
bw.write(line);
bw.newLine();
bw.flush();
}
bw.close();
br.close();
}
// 字符缓冲流一次读写一个字符数组
private static void method4(String srcString, String destString)
throws IOException {
BufferedReader br = new BufferedReader(new FileReader(srcString));
BufferedWriter bw = new BufferedWriter(new FileWriter(destString));
char[] chs = new char[1024];
int len = 0;
while ((len = br.read(chs)) != -1) {
bw.write(chs, 0, len);
}
bw.close();
br.close();
}
// 字符缓冲流一次读写一个字符
private static void method3(String srcString, String destString)
throws IOException {
BufferedReader br = new BufferedReader(new FileReader(srcString));
BufferedWriter bw = new BufferedWriter(new FileWriter(destString));
int ch = 0;
while ((ch = br.read()) != -1) {
bw.write(ch);
}
bw.close();
br.close();
}
// 基本字符流一次读写一个字符数组
private static void method2(String srcString, String destString)
throws IOException {
FileReader fr = new FileReader(srcString);
FileWriter fw = new FileWriter(destString);
char[] chs = new char[1024];
int len = 0;
while ((len = fr.read(chs)) != -1) {
fw.write(chs, 0, len);
}
fw.close();
fr.close();
}
// 基本字符流一次读写一个字符
private static void method1(String srcString, String destString)
throws IOException {
FileReader fr = new FileReader(srcString);
FileWriter fw = new FileWriter(destString);
int ch = 0;
while ((ch = fr.read()) != -1) {
fw.write(ch);
}
fw.close();
fr.close();
}
16.复制图片的4种方式案例
复制图片
分析：
复制数据，如果我们知道用记事本打开并能够读懂，就用字符流，否则用字节流。
通过该原理，我们知道我们应该采用字节流。
而字节流有4种方式，所以做这个题目我们有4种方式。推荐掌握第4种。
数据源：
c:\\a.jpg -- FileInputStream -- BufferedInputStream
目的地：
d:\\b.jpg -- FileOutputStream -- BufferedOutputStream
==========================================
public static void main(String[] args) throws IOException {
// 使用字符串作为路径
// String srcString = "c:\\a.jpg";
// String destString = "d:\\b.jpg";
// 使用File对象做为参数
File srcFile = new File("c:\\a.jpg");
File destFile = new File("d:\\b.jpg");
// method1(srcFile, destFile);
// method2(srcFile, destFile);
// method3(srcFile, destFile);
method4(srcFile, destFile);
}
// 字节缓冲流一次读写一个字节数组
private static void method4(File srcFile, File destFile) throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
srcFile));
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(destFile));
byte[] bys = new byte[1024];
int len = 0;
while ((len = bis.read(bys)) != -1) {
bos.write(bys, 0, len);
}
bos.close();
bis.close();
}
// 字节缓冲流一次读写一个字节
private static void method3(File srcFile, File destFile) throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
srcFile));
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(destFile));
int by = 0;
while ((by = bis.read()) != -1) {
bos.write(by);
}
bos.close();
bis.close();
}
// 基本字节流一次读写一个字节数组
private static void method2(File srcFile, File destFile) throws IOException {
FileInputStream fis = new FileInputStream(srcFile);
FileOutputStream fos = new FileOutputStream(destFile);
byte[] bys = new byte[1024];
int len = 0;
while ((len = fis.read(bys)) != -1) {
fos.write(bys, 0, len);
}
fos.close();
fis.close();
}
// 基本字节流一次读写一个字节
private static void method1(File srcFile, File destFile) throws IOException {
FileInputStream fis = new FileInputStream(srcFile);
FileOutputStream fos = new FileOutputStream(destFile);
int by = 0;
while ((by = fis.read()) != -1) {
fos.write(by);
}
fos.close();
fis.close();
}
==============================================
17.把集合中的数据存储到文本文件案例 ArrayListToFile
需求：把ArrayList集合中的字符串数据存储到文本文件
分析：
通过题目的意思我们可以知道如下的一些内容，
ArrayList集合里存储的是字符串。
遍历ArrayList集合，把数据获取到。
然后存储到文本文件中。
文本文件说明使用字符流。
数据源：
ArrayList<String> -- 遍历得到每一个字符串数据
目的地：
a.txt -- FileWriter -- BufferedWriter
=================================================
public static void main(String[] args) throws IOException {
// 封装数据与(创建集合对象)
ArrayList<String> array = new ArrayList<String>();
array.add("hello");
array.add("world");
array.add("java");
// 封装目的地
BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));
// 遍历集合
for (String s : array) {
// 写数据
bw.write(s);
bw.newLine();
bw.flush();
}
// 释放资源
bw.close();
}
======================================
18.把文本文件中的数据存储到集合中案例 FileToArrayList
需求：从文本文件中读取数据(每一行为一个字符串数据)到集合中，并遍历集合
*
* 分析：
* 通过题目的意思我们可以知道如下的一些内容，
* 数据源是一个文本文件。
* 目的地是一个集合。
* 而且元素是字符串。
*
* 数据源：
* b.txt -- FileReader -- BufferedReader
* 目的地：
* ArrayList<String>
======================================
public static void main(String[] args) throws IOException {
// 封装数据源
BufferedReader br = new BufferedReader(new FileReader("b.txt"));
// 封装目的地(创建集合对象)
ArrayList<String> array = new ArrayList<String>();
// 读取数据存储到集合中
String line = null;
while ((line = br.readLine()) != null) {
array.add(line);
}
// 释放资源
br.close();//别忘记这一步
// 遍历集合
for (String s : array) {
System.out.println(s);
}
}
===========================================
19.随机获取文本文件中的姓名案例
需求：我有一个文本文件中存储了几个名称，请大家写一个程序实现随机获取一个人的名字。
分析：
A:把文本文件中的数据存储到集合中
B:随机产生一个索引
C:根据该索引获取一个值
public static void main(String[] args) throws IOException {
// 把文本文件中的数据存储到集合中
BufferedReader br = new BufferedReader(new FileReader("b.txt"));
ArrayList<String> array = new ArrayList<String>();
String line = null;
while ((line = br.readLine()) != null) {
array.add(line);
}
br.close();
// 随机产生一个索引
Random r = new Random();
int index = r.nextInt(array.size());
// 根据该索引获取一个值
String name = array.get(index);
System.out.println("该幸运者是：" + name);
}
==========================================
20.复制单级文件夹案例
/*
* 需求：复制单极文件夹
*
* 数据源：e:\\demo
* 目的地：e:\\test
*
* 分析：
* A:封装目录
* B:获取该目录下的所有文本的File数组
* C:遍历该File数组，得到每一个File对象
* D:把该File进行复制
*/
public class CopyFolderDemo {
public static void main(String[] args) throws IOException {
// 封装目录
File srcFolder = new File("e:\\demo");
// 封装目的地
File destFolder = new File("e:\\test");
// 如果目的地文件夹不存在，就创建(一定要注意这个问题)
if (!destFolder.exists()) {
destFolder.mkdir();
}
// 获取该目录下的所有文本的File数组
File[] fileArray = srcFolder.listFiles();
// 遍历该File数组，得到每一个File对象
for (File file : fileArray) {
// System.out.println(file);
// 数据源：e:\\demo\\e.mp3
// 目的地：e:\\test\\e.mp3
String name = file.getName(); // e.mp3
File newFile = new File(destFolder, name); // e:\\test\\e.mp3
copyFile(file, newFile);
}
}
private static void copyFile(File file, File newFile) throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
file));
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(newFile));
byte[] bys = new byte[1024];
int len = 0;
while ((len = bis.read(bys)) != -1) {
bos.write(bys, 0, len);
}
bos.close();
bis.close();
}
}
=====================================================
注意：文件不存在可以自动创建，但是文件夹不存在不会自动创建,因此
if (!destFolder.exists()) {
destFolder.mkdir();
}
21.复制指定目录下指定后缀名的文件并修改名称案例
数据源
/*
* 需求：复制指定目录下的指定文件，并修改后缀名。
* 指定的文件是：.java文件。
* 指定的后缀名是：.jad
* 指定的目录是：jad
*
* 数据源：e:\\java\\A.java
* 目的地：e:\\jad\\A.jad
*
* 分析：
* A:封装目录
* B:获取该目录下的java文件的File数组
* C:遍历该File数组，得到每一个File对象
* D:把该File进行复制
* E:在目的地目录下改名
*/
public class CopyFolderDemo {
public static void main(String[] args) throws IOException {
// 封装目录
File srcFolder = new File("e:\\java");
// 封装目的地
File destFolder = new File("e:\\jad");
// 如果目的地目录不存在，就创建
if (!destFolder.exists()) {
destFolder.mkdir();
}
// 获取该目录下的java文件的File数组
File[] fileArray = srcFolder.listFiles(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
return new File(dir, name).isFile() && name.endsWith(".java");
}
});
// 遍历该File数组，得到每一个File对象
for (File file : fileArray) {
// System.out.println(file);
// 数据源：e:\java\DataTypeDemo.java
// 目的地：e:\\jad\DataTypeDemo.java
String name = file.getName();
File newFile = new File(destFolder, name);
copyFile(file, newFile);
}
// 在目的地目录下改名
File[] destFileArray = destFolder.listFiles();
for (File destFile : destFileArray) {
// System.out.println(destFile);
// e:\jad\DataTypeDemo.java
// e:\\jad\\DataTypeDemo.jad
String name =destFile.getName(); //DataTypeDemo.java
String newName = name.replace(".java", ".jad");//DataTypeDemo.jad
File newFile = new File(destFolder,newName);
destFile.renameTo(newFile);
}
}
private static void copyFile(File file, File newFile) throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
file));
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(newFile));
byte[] bys = new byte[1024];
int len = 0;
while ((len = bis.read(bys)) != -1) {
bos.write(bys, 0, len);
}
bos.close();
bis.close();
}
}
==================================
运行后示例
而本人先前自己模仿了一个，功能略微不一样
数据源
/*
* 需求：复制指定目录下的指定文件，并修改后缀名
* 这个文件是我本人做的，问题是：文件夹复制没处理好(copyDirectory方法略繁琐 )
*
* 数据源：g：\\java\\A.java
* 目的地：f:\\jad\\A.jad
*/
public class CopyFolderDemo2 {
public static void main(String[] args) throws IOException {
// 封装目录
File srcFolder = new File("g:\\java");
File desFolder = new File("f:\\jad");
if (!desFolder.exists()) {
desFolder.mkdir();
}
File[] files = srcFolder.listFiles();
for (File f : files) {
if (!f.isDirectory()) {
String name = f.getName();
File newFile = new File(desFolder, name);
copyFile(f, newFile);
modifyFile(desFolder);
} else {
String folderName = f.getName();
String desFolderName = desFolder.getName();
copyDirectory(desFolder, folderName);
}
}
}
private static void copyDirectory(File desFolder, String folderName) {
File newFolder = new File(desFolder, folderName);
newFolder.mkdirs();
}
private static void modifyFile(File desFolder) {
File[] files = desFolder.listFiles();
for (File f : files) {
if (!f.isDirectory()) {
String name = f.getName();
if (name.endsWith(".java")) {
int index = name.indexOf(".");
String fileNameString = name.substring(0, index);
String newNameString = fileNameString.concat(".jad");
File newFile = new File(desFolder, newNameString);
f.renameTo(newFile);
}
}
}
}
private static void copyFile(File f, File newFile) throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(f));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(newFile));
byte[] bys = new byte[1024];
int len = 0;
while ((len = bis.read(bys)) != -1) {
bos.write(bys, 0, len);
}
bis.close();
bos.close();
}
}
运行示例
22.复制多级文件夹案例
/*
* 需求：复制多极文件夹
*
* 数据源：E:\JavaSE\day21\code\demos
* 目的地：E:\\
*
* 分析：
* A:封装数据源File
* B:封装目的地File
* C:判断该File是文件夹还是文件
* a:是文件夹
* 就在目的地目录下创建该文件夹
* 获取该File对象下的所有文件或者文件夹File对象
* 遍历得到每一个File对象
* 回到C
* b:是文件
* 就复制(字节流)
*/
public class CopyFoldersDemo {
public static void main(String[] args) throws IOException {
// 封装数据源File
File srcFile = new File("E:\\JavaSE\\day21\\code\\demos");
// 封装目的地File
File destFile = new File("E:\\");
// 复制文件夹的功能
copyFolder(srcFile, destFile);
}
private static void copyFolder(File srcFile, File destFile)
throws IOException {
// 判断该File是文件夹还是文件
if (srcFile.isDirectory()) {
// 文件夹
File newFolder = new File(destFile, srcFile.getName());
newFolder.mkdir();
// 获取该File对象下的所有文件或者文件夹File对象
File[] fileArray = srcFile.listFiles();
for (File file : fileArray) {
copyFolder(file, newFolder);
}
} else {
// 文件
File newFile = new File(destFile, srcFile.getName());
copyFile(srcFile, newFile);
}
}
private static void copyFile(File srcFile, File newFile) throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
srcFile));
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(newFile));
byte[] bys = new byte[1024];
int len = 0;
while ((len = bis.read(bys)) != -1) {
bos.write(bys, 0, len);
}
bos.close();
bis.close();
}
}
23.键盘录入学生信息按照总分排序并写入文本文件案例
Student类如下
===================
public class Student {
// 姓名
private String name;
// 语文成绩
private int chinese;
// 数学成绩
private int math;
// 英语成绩
private int english;
public Student() {
super();
}
public Student(String name, int chinese, int math, int english) {
super();
this.name = name;
this.chinese = chinese;
this.math = math;
this.english = english;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getChinese() {
return chinese;
}
public void setChinese(int chinese) {
this.chinese = chinese;
}
public int getMath() {
return math;
}
public void setMath(int math) {
this.math = math;
}
public int getEnglish() {
return english;
}
public void setEnglish(int english) {
this.english = english;
}
public int getSum() {
return this.chinese + this.math + this.english;
}
}
==========================================
测试类
=====
public class StudentDemo {
public static void main(String[] args) throws IOException {
// 创建集合对象
TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
int num = s2.getSum() - s1.getSum();
int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;
int num3 = num2 == 0 ? s1.getMath() - s2.getMath() : num2;
int num4 = num3 == 0 ? s1.getEnglish() - s2.getEnglish() : num3;
int num5 = num4 == 0 ? s1.getName().compareTo(s2.getName())
: num4;
return num5;
}
});
// 键盘录入学生信息存储到集合
for (int x = 1; x <= 5; x++) {
Scanner sc = new Scanner(System.in);
System.out.println("请录入第" + x + "个的学习信息");
System.out.println("姓名：");
String name = sc.nextLine();
System.out.println("语文成绩：");
int chinese = sc.nextInt();
System.out.println("数学成绩：");
int math = sc.nextInt();
System.out.println("英语成绩：");
int english = sc.nextInt();
// 创建学生对象
Student s = new Student();
s.setName(name);
s.setChinese(chinese);
s.setMath(math);
s.setEnglish(english);
// 把学生信息添加到集合
ts.add(s);
}
// 遍历集合，把数据写到文本文件
BufferedWriter bw = new BufferedWriter(new FileWriter("students.txt"));
bw.write("学生信息如下：");
bw.newLine();
bw.flush();
bw.write("姓名,语文成绩,数学成绩,英语成绩");
bw.newLine();
bw.flush();
for (Student s : ts) {
StringBuilder sb = new StringBuilder();
sb.append(s.getName()).append(",").append(s.getChinese())
.append(",").append(s.getMath()).append(",")
.append(s.getEnglish());
bw.write(sb.toString());
bw.newLine();
bw.flush();
}
// 释放资源
bw.close();
System.out.println("学习信息存储完毕");
}
}
24.把一个文件中的字符串排序后再写入另一个文件案例
已知s.txt文件中有这样的一个字符串：“hcexfgijkamdnoqrzstuvwybpl”
请编写程序读取数据内容，把数据排序后写入ss.txt中。
分析：
A:把s.txt这个文件给做出来
B:读取该文件的内容，存储到一个字符串中
C:把字符串转换为字符数组
D:对字符数组进行排序
E:把排序后的字符数组转换为字符串
F:把字符串再次写入ss.txt中
public static void main(String[] args) throws IOException {
// 读取该文件的内容，存储到一个字符串中
BufferedReader br = new BufferedReader(new FileReader("s.txt"));
String line = br.readLine();
br.close();
// 把字符串转换为字符数组
char[] chs = line.toCharArray();
// 对字符数组进行排序
Arrays.sort(chs);
// 把排序后的字符数组转换为字符串
String s = new String(chs);
// 把字符串再次写入ss.txt中
BufferedWriter bw = new BufferedWriter(new FileWriter("ss.txt"));
bw.write(s);
bw.newLine();
bw.flush();
bw.close();
}
//注意一下readLine(无需flush) 和 newLine，还有字符数组转换为字符串
25.自定义类模拟BufferedReader的readLine()功能案例(有一定难度)
先写MyBufferedReader类
================================================================
/*
* 用Reader模拟BufferedReader的readLine()功能
*
* readLine():一次读取一行，根据换行符判断是否结束，只返回内容，不返回换行符
*/
public class MyBufferedReader {
private Reader r;
public MyBufferedReader(Reader r) {
this.r = r;
}
/*
* 思考：写一个方法，返回值是一个字符串。
*/
public String readLine() throws IOException {
/*
* 我要返回一个字符串，我该怎么办呢? 我们必须去看看r对象能够读取什么东西呢? 两个读取方法，一次读取一个字符或者一次读取一个字符数组
* 那么，我们要返回一个字符串，用哪个方法比较好呢? 我们很容易想到字符数组比较好，但是问题来了，就是这个数组的长度是多长呢?
* 根本就没有办法定义数组的长度，你定义多长都不合适。 所以，只能选择一次读取一个字符。
* 但是呢，这种方式的时候，我们再读取下一个字符的时候，上一个字符就丢失了 所以，我们又应该定义一个临时存储空间把读取过的字符给存储起来。
* 这个用谁比较和是呢?数组，集合，字符串缓冲区三个可供选择。
* 经过简单的分析，最终选择使用字符串缓冲区对象。并且使用的是StringBuilder
*/
StringBuilder sb = new StringBuilder();
// 做这个读取最麻烦的是判断结束，但是在结束之前应该是一直读取，直到-1
/*
hello
world
java
104101108108111
119111114108100
1069711897
*/
int ch = 0;
while ((ch = r.read()) != -1) { //104,101,108,108,111
if (ch == '\r') {
continue;//必须\r\n同时存在的时候才算换行，因此这里继续
}
if (ch == '\n') {
return sb.toString(); //hello
} else {
sb.append((char)ch); //hello//必须转换，不然就会104,101,108,108,111
}
}
// 为了防止数据丢失，判断sb的长度不能大于0//反正就是无论如何，只要有数据了，最后都来拼一下反正数据丢失
if (sb.length() > 0) {
return sb.toString();
}
return null;
}
/*
* 先写一个关闭方法
*/
public void close() throws IOException {
this.r.close();//表面上调用Buffered……的方法，实际上还是用r自身的close方法
}
}
============================================================
但是的话，，
下面是测试类
===========================================
/*
* 测试MyBufferedReader的时候，你就把它当作BufferedReader一样的使用
*/
public class MyBufferedReaderDemo {
public static void main(String[] args) throws IOException {
MyBufferedReader mbr = new MyBufferedReader(new FileReader("my.txt"));
String line = null;
while ((line = mbr.readLine()) != null) {
System.out.println(line);
}
mbr.close();
// System.out.println('\r' + 0); // 13//通过加0的方法可以查看字符对应的数字编码
// System.out.println('\n' + 0);// 10
}
}
==============================
26.LineNumberReader的使用案例
由上图可知，其父类是BufferedReader
BufferedReader
|--LineNumberReader
public int getLineNumber()获得当前行号。
public void setLineNumber(int lineNumber)
public static void main(String[] args) throws IOException {
LineNumberReader lnr = new LineNumberReader(new FileReader("my.txt"));
// 从10开始才比较好
// lnr.setLineNumber(10);
// System.out.println(lnr.getLineNumber());
// System.out.println(lnr.getLineNumber());
// System.out.println(lnr.getLineNumber());
String line = null;
while ((line = lnr.readLine()) != null) {
System.out.println(lnr.getLineNumber() + ":" + line);
}
lnr.close();
}
默认
set之后
(自定义类模拟LineNumberReader的获取行号功能案例省略==)
day21笔记补充
IO流小结(掌握)
IO流
|--字节流
|--字节输入流
InputStream
int read():一次读取一个字节
int read(byte[] bys):一次读取一个字节数组
|--FileInputStream
|--BufferedInputStream
|--字节输出流
OutputStream
void write(int by):一次写一个字节
void write(byte[] bys,int index,int len):一次写一个字节数组的一部分
|--FileOutputStream
|--BufferedOutputStream
|--字符流
|--字符输入流
Reader
int read():一次读取一个字符
int read(char[] chs):一次读取一个字符数组
|--InputStreamReader
|--FileReader
|--BufferedReader
String readLine():一次读取一个字符串
|--字符输出流
Writer
void write(int ch):一次写一个字符
void write(char[] chs,int index,int len):一次写一个字符数组的一部分
|--OutputStreamWriter
|--FileWriter
|--BufferedWriter
void newLine():写一个换行符
void write(String line):一次写一个字符串
今天写过的案例(理解 练习一遍)
A:复制文本文件 5种方式(掌握)
B:复制图片(二进制流数据) 4种方式(掌握)
C:把集合中的数据存储到文本文件
D:把文本文件中的数据读取到集合并遍历集合
E:复制单级文件夹
F:复制单级文件夹中指定的文件并修改名称
回顾一下批量修改名称
G:复制多级文件夹
H:键盘录入学生信息按照总分从高到低存储到文本文件
I:把某个文件中的字符串排序后输出到另一个文本文件中
J:用Reader模拟BufferedReader的特有功能
K:模拟LineNumberReader的特有功能
day22
1.登录注册案例IO版实现
简要给代码，具体自己排错，敲。
与集合的注册案例想比，UserDaoImpl不一样，其余的都一样。
=========================================
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import cn.itcast.dao.UserDao;
import cn.itcast.pojo.User;
/**
* 这是用户操作的具体实现类(IO版)
*
* @author 风清扬
* @version V1.1
*
*/
public class UserDaoImpl implements UserDao {
// 为了保证文件一加载就创建，在这里下面的红色部分使用了static静态代码块，类一加载就执行而且只执行一次
private static File file = new File("user.txt");
static {
try {
file.createNewFile();
} catch (IOException e) {
System.out.println("创建文件失败");
// e.printStackTrace();
}
}
@Override
public boolean isLogin(String username, String password) {
boolean flag = false;
BufferedReader br = null;
try {
// br = new BufferedReader(new FileReader("user.txt"));
br = new BufferedReader(new FileReader(file));
String line = null;
while ((line = br.readLine()) != null) {
// 用户名=密码
String[] datas = line.split("=");//利用了字符串的方法，利用正则表达式拆分字符串
if (datas[0].equals(username) && datas[1].equals(password)) {
flag = true;
break;
}
}
} catch (FileNotFoundException e) {//本类所有的异常只能try……catch处理，因为抛(throws)的话会比较麻烦而且影响其它的类，违背了独立修改且不影响其它类的初衷
System.out.println("用户登录找不到信息所在的文件");
// e.printStackTrace();
} catch (IOException e) {
System.out.println("用户登录失败");
// e.printStackTrace();
} finally {
if (br != null) {
try {
br.close();
} catch (IOException e) {
System.out.println("用户登录释放资源失败");
// e.printStackTrace();
}
}
}
return flag;
}
@Override
public void regist(User user) {
/*
* 为了让注册的数据能够有一定的规则，我就自己定义了一个规则： 用户名=密码
*/
BufferedWriter bw = null;
try {
// bw = new BufferedWriter(new FileWriter("user.txt"));
// bw = new BufferedWriter(new FileWriter(file));
// 为了保证数据是追加写入，必须加true
bw = new BufferedWriter(new FileWriter(file, true));//不加true的话，重新创建文件会造成上一次的注册信息丢失
bw.write(user.getUsername() + "=" + user.getPassword());
bw.newLine();
bw.flush();
} catch (IOException e) {
System.out.println("用户注册失败");
// e.printStackTrace();
} finally {
if (bw != null) {
try {
bw.close();
} catch (IOException e) {
System.out.println("用户注册释放资源失败");
// e.printStackTrace();
}
}
}
}
}
附：String的split方法以及user.txt里面保存的信息
注册信息保存在文件中，不会丢失。
2.数据输入输出流
可以读写基本数据类型的数据
数据输入流：DataInputStream
DataInputStream(InputStream in)
数据输出流：DataOutputStream
DataOutputStream(OutputStream out)
===================================
public static void main(String[] args) throws IOException {
// 写
// write();
// 读
read();
}
private static void read() throws IOException {
// DataInputStream(InputStream in)
// 创建数据输入流对象
DataInputStream dis = new DataInputStream(
new FileInputStream("dos.txt"));
// 读数据
byte b = dis.readByte();
short s = dis.readShort();
int i = dis.readInt();
long l = dis.readLong();
float f = dis.readFloat();
double d = dis.readDouble();
char c = dis.readChar();
boolean bb = dis.readBoolean();
// 释放资源
dis.close();
System.out.println(b);
System.out.println(s);
System.out.println(i);
System.out.println(l);
System.out.println(f);
System.out.println(d);
System.out.println(c);
System.out.println(bb);
}
private static void write() throws IOException {
// DataOutputStream(OutputStream out)
// 创建数据输出流对象
DataOutputStream dos = new DataOutputStream(new FileOutputStream(
"dos.txt"));
// 写数据了
dos.writeByte(10);
dos.writeShort(100);
dos.writeInt(1000);
dos.writeLong(10000);
dos.writeFloat(12.34F);//有一个类型转换
dos.writeDouble(12.56);
dos.writeChar('a');
dos.writeBoolean(true);
// 释放资源
dos.close();
}
==========================================
注意一个问题，如果只有DataOutputStream来写文件，直接双击打开文件，读到的数据是乱码
3.内存操作流的概述和讲解
内存操作流：用于处理临时存储信息的，程序结束，数据就从内存中消失。
字节数组：
ByteArrayInputStream
ByteArrayOutputStream
字符数组：
CharArrayReader
CharArrayWriter
字符串：
StringReader
StringWriter
对于ByteArrayOutputStream：
此类实现了一个输出流，其中的数据被写入一个 byte 数组。缓冲区会随着数据的不断写入而自动增长。可使用toByteArray() 和 toString() 获取数据。
关闭 ByteArrayOutputStream 无效。此类中的方法在关闭此流后仍可被调用，而不会产生任何 IOException。(说白了就是不用close方法了)
对于ByteArrayInputStream ：
ByteArrayInputStream 包含一个内部缓冲区，该缓冲区包含从流中读取的字节。内部计数器跟踪 read 方法要提供的下一个字节。
关闭 ByteArrayInputStream 无效。此类中的方法在关闭此流后仍可被调用，而不会产生任何 IOException。
public static void main(String[] args) throws IOException {
// 写数据
// ByteArrayOutputStream()
ByteArrayOutputStream baos = new ByteArrayOutputStream();
// 写数据
for (int x = 0; x < 10; x++) {
baos.write(("hello" + x).getBytes());
}
// 释放资源
// 通过查看源码我们知道这里什么都没做，所以根本需要close()
// baos.close();
// public byte[] toByteArray()
byte[] bys = baos.toByteArray();
// 读数据
// ByteArrayInputStream(byte[] buf)
ByteArrayInputStream bais = new ByteArrayInputStream(bys);
int by = 0;
while ((by = bais.read()) != -1) {
System.out.print((char) by);
}
// bais.close();//不需要close
}
4.打印流的概述和特点
打印流
字节流打印流 PrintStream
字符打印流 PrintWriter
打印流的特点：
A:只有写数据的，没有读取数据。只能操作目的地，不能操作数据源。
B:可以操作任意类型的数据。
C:如果启动了自动刷新，能够自动刷新。(如果不启动的话，不刷新文件(就是flush或者close)里面是没有数据的)
D:该流是可以直接操作文本文件的。
哪些流对象是可以直接操作文本文件的呢?
FileInputStream
FileOutputStream
FileReader
FileWriter
PrintStream
PrintWriter
看API,查流对象的构造方法，如果同时有File类型和String类型的参数，一般来说就是可以直接操作文件的。
流：
基本流：就是能够直接读写文件的
高级流：在基本流基础上提供了一些其他的功能
==========================================
public static void main(String[] args) throws IOException {
// 作为Writer的子类使用
PrintWriter pw = new PrintWriter("pw.txt");
pw.write("hello");
pw.write("world");
pw.write("java");
pw.close();//没有这句话不出数据，因为这不是自动刷新的(或者)
}
5.PrintWriter实现自动刷新和换行
可以操作任意类型的数据。
print()
println()
public static void main(String[] args) throws IOException {
PrintWriter pw = new PrintWriter("pw2.txt");
pw.print("hello");//print方法可接受任意类型的数据
pw.print(100);
pw.print(true);
pw.close();
}
但以上的方法并没有实现自动刷新
要实现自动刷新的话，
启动自动刷新
PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true);//要设置true
还是应该调用println()的方法才可以(调用print自动刷新不了)
这个时候不仅仅自动刷新了，还实现了数据的换行。
public static void main(String[] args) throws IOException {
// 创建打印流对象
// PrintWriter pw = new PrintWriter("pw2.txt");
PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true);
// write()是搞不定的，怎么办呢?
// 我们就应该看看它的新方法
// pw.print(true);
// pw.print(100);
// pw.print("hello");
pw.println("hello");
pw.println(true);
pw.println(100);
pw.close();
}
注意：println()
其实等价于于：
bw.write();
bw.newLine();
bw.flush();
一句顶三句
6.打印流改进复制文本文件案例
需求：DataStreamDemo.java复制到Copy.java中
数据源：
DataStreamDemo.java -- 读取数据 -- FileReader -- BufferedReader
目的地：
Copy.java -- 写出数据 -- FileWriter -- BufferedWriter -- PrintWriter
public static void main(String[] args) throws IOException {
//以前的版本
// 封装数据源
BufferedReader br = new BufferedReader(new FileReader(
"DataStreamDemo.java"));
//封装目的地
BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));
String line = null;
while ((line = br.readLine()) != null) {
bw.write(line);
bw.newLine();
bw.flush();
}
bw.close();
br.close();
}
===============================================
public static void main(String[] args) {
// 打印流的改进版
// 封装数据源
BufferedReader br = new BufferedReader(new FileReader(
"DataStreamDemo.java"));
// 封装目的地
PrintWriter pw = new PrintWriter(new FileWriter("Copy.java"), true);
String line = null;
while((line=br.readLine())!=null){
pw.println(line);
}
pw.close();
br.close();
}=============================================
7.标准输入输出流概述和输出语句的本质------System.out
标准输入输出流
System类中的两个成员变量：
public static final InputStream in “标准”输入流。
public static final PrintStream out “标准”输出流。
InputStream is = System.in;
PrintStream ps = System.out;
public static void main(String[] args) {
// 有这里的讲解我们就知道了，这个输出语句其本质是IO流操作，把数据输出到控制台。
System.out.println("helloworld");
// 获取标准输出流对象
PrintStream ps = System.out;
ps.println("helloworld");
ps.println();
// ps.print();//这个方法不存在
// System.out.println();
// System.out.print();
}
8.标准输入输出流概述和输出语句的本质------System.in
public static void main(String[] args) throws IOException {
//获取标准输入流
InputStream is = System.in;
//我要一次获取一行行不行呢?
//行。
//怎么实现呢?
//要想实现，首先你得知道一次读取一行数据的方法是哪个呢?
//readLine()
//而这个方法在哪个类中呢?
//BufferedReader
//所以，你这次应该创建BufferedReader的对象，但是底层还是的使用标准输入流
// BufferedReader br = new BufferedReader(is);
//按照我们的推想，现在应该可以了，但是却报错了
//原因是：字符缓冲流只能针对字符流操作，而你现在是字节流，所以不能是用?
//那么，我还就想使用了，请大家给我一个解决方案?
//把字节流转换为字符流，然后在通过字符缓冲流操作
// InputStreamReader isr = new InputStreamReader(is);
// BufferedReader br= new BufferedReader(isr);
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
//注意这里的字节流转换成字符流，利用了InputStreamReader转换流
System.out.println("请输入一个字符串：");
String line = br.readLine();
System.out.println("你输入的字符串是：" + line);
System.out.println("请输入一个整数：");
// int i = Integer.parseInt(br.readLine());
line = br.readLine();
int i = Integer.parseInt(line);
System.out.println("你输入的整数是：" + i);
}
//利用上述代码模仿了Scanner的键盘录入功能
注意以下方法
9.输出语句用字符缓冲流改进
public static void main(String[] args) throws IOException {
// 获取标准输入流
// // PrintStream ps = System.out;
// // OutputStream os = ps;//这个就是多态
//上面两句简化为一句---- OutputStream os = System.out; // 多态
// // 我能不能按照刚才使用标准输入流的方式一样把数据输出到控制台呢?
// OutputStreamWriter osw = new OutputStreamWriter(os);
// BufferedWriter bw = new BufferedWriter(osw);
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
System.out));//合并为一句
bw.write("hello");
bw.newLine();
// bw.flush();
bw.write("world");
bw.newLine();
// bw.flush();
bw.write("java");
bw.newLine();
bw.flush();
bw.close();
}
10.随机访问流概述和写出数据
随机访问流：
RandomAccessFile类不属于流，是Object类的子类。
但它融合了InputStream和OutputStream的功能。
支持对文件的随机访问读取和写入。
public RandomAccessFile(String name,String mode)：第一个参数是文件路径，第二个参数是操作文件的模式。
模式有四种，我们最常用的一种叫"rw",这种方式表示我既可以写数据，也可以读取数据
这个RandomAccessFile类还可以读和写
11.随机访问流读取数据和操作文件指针
===========================================
public static void main(String[] args) throws IOException {
read();
}
private static void read() throws IOException {
// 创建随机访问流对象
RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw");
int i = raf.readInt();
System.out.println(i);
// 该文件指针可以通过 getFilePointer方法读取，并通过 seek 方法设置。
System.out.println("当前文件的指针位置是：" + raf.getFilePointer());//4
char ch = raf.readChar();
System.out.println(ch);
System.out.println("当前文件的指针位置是：" + raf.getFilePointer());//6
String s = raf.readUTF();
System.out.println(s);
System.out.println("当前文件的指针位置是：" + raf.getFilePointer());//14(本来是12的，多出来两个字节的原因可以看API,其实是识别UTF编码的两个字节)
// 我不想重头开始了，我就要读取a，怎么办呢?
raf.seek(4);//从0开始计算
ch = raf.readChar();
System.out.println(ch);
}
======================================================
输出示例
12.合并流读取两个文件的内容复制到一个文件中
合并流就是按顺序读取两个文件然后合并到一个新的文件中
public static void main(String[] args) throws IOException {
InputStream is1 = new FileInputStream("pw.txt");
InputStream is2 = new FileInputStream("pw2.txt");
// SequenceInputStream(InputStream s1, InputStream s2)
SequenceInputStream sis = new SequenceInputStream(is1, is2);
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.txt"));
// 如何写读写呢，其实很简单，你就按照以前怎么读写，现在还是怎么读写
byte[] bys = new byte[1024];
int len = 0;
while ((len = sis.read(bys)) != -1) {
bos.write(bys, 0, len);
}
sis.close();
bos.close();
=============================================
运行示例
运行前
运行后
13.合并流读取多个文件的内容复制到一个文件中
public static void main(String[] args) throws IOException {
// 需求：把下面的三个文件的内容复制到pwsum.txt中
// SequenceInputStream(Enumeration e)
// 通过简单的回顾我们知道了Enumeration是Vector中的一个方法的返回值类型。
// Enumeration<E> elements()
Vector<InputStream> v = new Vector<InputStream>();
InputStream is1 = new FileInputStream("pw.txt");
InputStream is2 = new FileInputStream("pw2.txt");
InputStream is3 = new FileInputStream("pw3.txt");
v.add(is1);
v.add(is2);
v.add(is3);
Enumeration<InputStream> e = v.elements();
SequenceInputStream sis = new SequenceInputStream(e);//接收一个参数
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("pwsum.txt"));
byte[] bys = new byte[1024];
int len = 0;
while ((len = sis.read(bys)) != -1) {
bos.write(bys, 0, len);
}
sis.close();
bos.close();
}
14.序列化流和反序列化流的概述和使用
序列化流 ObjectOutputStream
反序列化流 ObjectInputStream
序列化流：把对象按照流一样的方式存入文本文件或者在网络中传输。对象 -- 流数据(ObjectOutputStream)
反序列化流:把文本文件中的流对象数据或者网络中的流对象数据还原成对象。流数据 -- 对象(ObjectInputStream)
首先，写序列化流Demo的write方法。
public static void main(String[] args) throws IOException,
ClassNotFoundException {
// 由于我们要对对象进行序列化，所以我们先自定义一个类
// 序列化数据其实就是把对象写到文本文件
write();
}
private static void write() throws IOException {
// 创建序列化流对象
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(
"oos.txt"));
// 创建对象
Person p = new Person("林青霞", 27);
// public final void writeObject(Object obj)
oos.writeObject(p);
// 释放资源
oos.close();
}
======================================================
然后，创建一个Person类
import java.io.Serializable;
public class Person implements Serializable {
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
============================
要说明的是，在Person类还没实现 Serializable 这个接口的时候，运行会有异常
NotSerializableException:未序列化异常
查API
因此，要想没报错，必须在Person类中实现 Serializable 这个接口
但是：你会发现，没有重写任何方法啊！！！
没错，因为，本来就不用重写任何的方法！
解析如下：
类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。
该接口居然没有任何方法，类似于这种没有方法的接口被称为标记接口。
然后，再次运行没报错后，直接打开文件是看不懂的
序列化的流必须要反序列的流"解锁"才可以啊
最后，加入反序列流的代码如下
运行(不报错了)toString方法在Person类中已经重写
注意这一步
// 还原对象
Object obj = ois.readObject();
obj虽然是Object类型，但是其实是Person对象
但是，还有一个小问题
如何解决序列化时候的黄色警告线问题
当Person类进行了改动的时候(比如private int age 改为 int age)把代码保存再次运行(只执行读操作而不进行第二次写入)会报错产生异常
产生的原因：
为什么会有问题呢?
Person类实现了序列化接口，那么它本身也应该有一个标记值。
这个标记值假设是100。
开始的时候：
Person.class -- id=100
wirte数据： oos.txt -- id=100
read数据: oos.txt -- id=100
现在：
Person.class -- id=200
wirte数据： oos.txt -- id=100
read数据: oos.txt -- id=100
解决这个问题的办法：
我们在实际开发中，可能还需要使用以前写过的数据，不能重新写入。怎么办呢?
回想一下原因是因为它们的id值不匹配。
每次修改java文件的内容的时候,class文件的id值都会发生改变。
而读取文件的时候，会和class文件中的id值进行匹配。所以，就会出问题。
但是呢，如果我有办法，让这个id值在java文件中是一个固定的值，这样，你修改文件的时候，这个id值还会发生改变吗?
不会。现在的关键是我如何能够知道这个id值如何表示的呢?
不用担心，你不用记住，也没关系，点击鼠标即可。
你难道没有看到黄色警告线吗?
在Person类中加一下语句
private static final long serialVersionUID = -2071565876962058344L;
还有一个要注意的问题：
注意：
我一个类中可能有很多的成员变量，有些我不想进行序列化。请问该怎么办呢?
使用transient关键字声明不需要序列化的成员变量
也就是用transient关键字
把private int age修改为
private transient int age;
然后运行会发现age的值为0了，也就是说，age的值将不被记住是27了
15.Properties的概述和作为Map集合的使用(注意：Properties并没有泛型)
Properties:属性集合类。是一个可以和IO流相结合使用的集合类。
Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。
是Hashtable的子类，说明是一个Map集合。
public static void main(String[] args) {
// 作为Map集合的使用
// 下面这种用法是错误的，一定要看API，如果没有<>，就说明该类不是一个泛型类,在使用的时候就不能加泛型
// Properties<String, String> prop = new Properties<String, String>();
Properties prop = new Properties();
// 添加元素
prop.put("it002", "hello");
prop.put("it001", "world");
prop.put("it003", "java");
// System.out.println("prop:" + prop);
// 遍历集合,注意红字是Object而不是String,因为上面的put方法本来就是接受Object参数
Set<Object> set = prop.keySet();
for (Object key : set) {
Object value = prop.get(key);
System.out.println(key + "---" + value);
}
}
16.Properties的特殊功能使用
特殊功能：
public Object setProperty(String key,String value)：添加元素
public String getProperty(String key):获取元素
public Set<String> stringPropertyNames():获取所有的键的集合
=========================
public static void main(String[] args) {
// 创建集合对象
Properties prop = new Properties();
// 添加元素
prop.setProperty("张三", "30");
prop.setProperty("李四", "40");
prop.setProperty("王五", "50");
// public Set<String> stringPropertyNames():获取所有的键的集合
Set<String> set = prop.stringPropertyNames();
for (String key : set) {
String value = prop.getProperty(key);
System.out.println(key + "---" + value);
}
}
================================================
17.Properties的load()和store()功能
这里的集合必须是Properties集合：
public void load(Reader reader):把文件中的数据读取到集合中
public void store(Writer writer,String comments):把集合中的数据存储到文件
=================================================
public static void main(String[] args) throws IOException {
myLoad();
myStore();
}
private static void myStore() throws IOException {
// 创建集合对象
Properties prop = new Properties();
prop.setProperty("林青霞", "27");
prop.setProperty("武鑫", "30");
prop.setProperty("刘晓曲", "18");
//public void store(Writer writer,String comments):把集合中的数据存储到文件
Writer w = new FileWriter("name.txt");
prop.store(w, "helloworld");//这个helloworld只是注释的作用。。。
w.close();
}
private static void myLoad() throws IOException {
Properties prop = new Properties();
// public void load(Reader reader):把文件中的数据读取到集合中
// 注意：这个文件的数据必须是键值对形式
Reader r = new FileReader("prop.txt");
prop.load(r);
r.close();
System.out.println("prop:" + prop);
}
运行打开name.txt文件
18.判断文件中是否有指定的键如果有就修改值的案例
我有一个文本文件(user.txt)，我知道数据是键值对形式的，但是不知道内容是什么。
请写一个程序判断是否有“lisi”这样的键存在，如果有就改变其实为”100”
分析：
A:把文件中的数据加载到集合中
B:遍历集合，获取得到每一个键
C:判断键是否有为"lisi"的，如果有就修改其值为"100"
D:把集合中的数据重新存储到文件中
========================================
public static void main(String[] args) throws IOException {
// 把文件中的数据加载到集合中
Properties prop = new Properties();
Reader r = new FileReader("user.txt");
prop.load(r);
r.close();
// 遍历集合，获取得到每一个键
Set<String> set = prop.stringPropertyNames();
for (String key : set) {
// 判断键是否有为"lisi"的，如果有就修改其值为"100"
if ("lisi".equals(key)) {
prop.setProperty(key, "100");
break;
}
}
// 把集合中的数据重新存储到文件中
Writer w = new FileWriter("user.txt");
prop.store(w, null);//这里设为null,不用附加东西了
w.close();
}
=============================================
user.txt
运行后
19.如何让猜数字小游戏只能玩5次案例
我有一个猜数字小游戏的程序，请写一个程序实现在测试类中只能用5次，超过5次提示：游戏试玩已结束，请付费。
初始化：手动建一个文件保存玩游戏的次数(不需要写代码创建文件)
public static void main(String[] args) throws IOException {
// 读取某个地方的数据，如果次数不大于5，可以继续玩。否则就提示"游戏试玩已结束，请付费。
// 把数据加载到集合中
Properties prop = new Properties();
Reader r = new FileReader("count.txt");
prop.load(r);
r.close();//别忘记关闭流
// 我自己的程序，我当然知道里面的键是谁
String value = prop.getProperty("count");
int number = Integer.parseInt(value);//String转换为int
if (number > 5) {
System.out.println("游戏试玩已结束，请付费。");
System.exit(0);//别漏了这一步退出！！
} else {
number++;
prop.setProperty("count", String.valueOf(number));//int转为String
Writer w = new FileWriter("count.txt");
prop.store(w, null);
w.close();//别忘记关闭流
GuessNumber.start();//这个猜数字的小游戏代码省略
}
}
注意几个问题：别忘记关闭流，注意字符串与Integer的转换.别漏了 System.exit(0)
==================================================
20.NIO的介绍和JDK7下NIO的一个案例
NIO:就是New IO
nio包在JDK4出现，提供了IO流的操作效率。但是目前还不是大范围的使用。
有空的话了解下，有问题再问我。
JDK7的之后的nio：
Path:路径
Paths:有一个静态方法返回一个路径
public static Path get(URI uri)//返回值为Path
Files:提供了静态方法供我们使用
public static long copy(Path source,OutputStream out):复制文件
public static Path write(Path path,Iterable<? extends CharSequence> lines,Charset cs,OpenOption... options)//后面那个可变参数就忽略不理，只接受3个参数
===================================================
以下为课后阅读资料
1：JDK4新IO要了解的类(自己看)
Buffer(缓冲),Channer(通道)
2：JDK7要了解的新IO类
Path:与平台无关的路径。
Paths:包含了返回Path的静态方法。
public static Path get(URI uri):根据给定的URI来确定文件路径。
Files:操作文件的工具类。提供了大量的方法，简单了解如下方法
public static long copy(Path source, OutputStream out) :复制文件
public static Path write(Path path, Iterable<? extends CharSequence> lines, Charset cs, OpenOption... options):
把集合的数据写到文件。
//复制文件
Files.copy(Paths.get("Demo.java"), newFileOutputStream("Copy.Java"));
//把集合中的数据写到文件
List<String> list = new ArrayList<String>();
list.add("hello");
list.add("world");
list.add("java");
Files.write(Paths.get("list.txt"), list, Charset.forName("gbk"));
=================================================================================================
注意：ArrayList实现了Iterable接口
因此Iterable<? extends CharSequence> lines对应的参数可以是ArrayList的对象
先测试copy功能
然后测试write功能
public static void main(String[] args) throws IOException {
ArrayList<String> array = new ArrayList<String>();
array.add("hello");
array.add("world");
array.add("java");
Files.write(Paths.get("array.txt"), array, Charset.forName("GBK"));
}
====================================================
以下是自己写的代码
Charset.forName("GBK")是设置编码的
===========
源
运行后
运行后
===================================================
day22 笔记补充
登录注册IO版本案例(掌握)
要求，对着写一遍。
写的顺序参考：
cn.itcast.pojo User
cn.itcast.dao UserDao
cn.itcast.dao.impl UserDaoImpl(实现可以是集合版或者IO版)
cn.itcast.game GuessNumber
cn.itcast.test UserTest
===============================================
内存操作流(理解)
(1)有些时候我们操作完毕后，未必需要产生一个文件，就可以使用内存操作流。
(2)三种
A:ByteArrayInputStream,ByteArrayOutputStream
B:CharArrayReader,CharArrayWriter
C:StringReader,StringWriter
===============================================
打印流(掌握)
(1)字节打印流，字符打印流
(2)特点：
A:只操作目的地,不操作数据源
B:可以操作任意类型的数据
C:如果启用了自动刷新，在调用println()方法的时候，能够换行并刷新
D:可以直接操作文件
问题：哪些流可以直接操作文件呢?
看API，如果其构造方法能够同时接收File和String类型的参数，一般都是可以直接操作文件的
(3)复制文本文件
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
PrintWriter pw = new PrintWriter(new FileWriter("b.txt"),true);
String line = null;
while((line=br.readLine())!=null) {
pw.println(line);
}
pw.close();
br.close();
===============================================
5:标准输入输出流(理解)
(1)System类下面有这样的两个字段
in 标准输入流
out 标准输出流
(2)三种键盘录入方式
A:main方法的args接收参数
B:System.in通过BufferedReader进行包装
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
C:Scanner
Scanner sc = new Scanner(System.in);
(3)输出语句的原理和如何使用字符流输出数据
A:原理
System.out.println("helloworld");
PrintStream ps = System.out;//PrintStream 属于字节流
ps.println("helloworld");
B:把System.out用字符缓冲流包装一下使用
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
============================================================
序列化流(理解)
(1)可以把对象写入文本文件或者在网络中传输
(2)如何实现序列化呢?
让被序列化的对象所属类实现序列化接口。
该接口是一个标记接口。没有功能需要实现。
(3)注意问题：
把数据写到文件后，在去修改类会产生一个问题。
如何解决该问题呢?
在类文件中，给出一个固定的序列化id值。
而且，这样也可以解决黄色警告线问题
(4)面试题：
什么时候序列化?
如何实现序列化?
什么是反序列化?
========================================================
NIO(了解)
(1)JDK4出现的NIO，对以前的IO操作进行了优化，提供了效率。但是大部分我们看到的还是以前的IO
(2)JDK7的NIO的使用
Path:路径
Paths:通过静态方法返回一个路径
Files:提供了常见的功能
复制文本文件
把集合中的数据写到文本文件
=============================================================
day23
1.多线程程序的引入
红色代表一个执行的流程，线程
2.进程概述及多进程的意义
A:要想了解多线程，必须先了解线程，而要想了解线程，必须先了解进程，因为线程是依赖于进程而存在。
B:什么是进程?
通过任务管理器我们就看到了进程的存在。
而通过观察，我们发现只有运行的程序才会出现进程。
进程：就是正在运行的程序。
进程是系统进行资源分配和调用的独立单位。每一个进程都有它自己的内存空间和系统资源。
C:多进程有什么意义呢?
单进程的计算机只能做一件事情，而我们现在的计算机都可以做多件事情。
举例：一边玩游戏(游戏进程)，一边听音乐(音乐进程)。
也就是说现在的计算机都是支持多进程的，可以在一个时间段内执行多个任务。
并且呢，可以提高CPU的使用率。
问题：
一边玩游戏，一边听音乐是同时进行的吗?
不是。因为单CPU在某一个时间点上只能做一件事情。
而我们在玩游戏，或者听音乐的时候，是CPU在做着程序间的高效切换让我们觉得是同时进行的。
================================
单进程：例如windows下cmd的dos命令
多进程：例如我们的计算机
================================
3.线程概述及多线程的意义
A:什么是线程呢?
在同一个进程内又可以执行多个任务，而这每一个任务我就可以看出是一个线程。
线程：是程序的执行单元，执行路径。是程序使用CPU的最基本单位。
单线程：如果程序只有一条执行路径。
多线程：如果程序有多条执行路径。
B:多线程有什么意义呢?
多线程的存在，不是提高程序的执行速度。其实是为了提高应用程序的使用率。
程序的执行其实都是在抢CPU的资源，CPU的执行权。
多个进程是在抢这个资源，而其中的某一个进程如果执行路径比较多，就会有更高的几率抢到CPU的执行权。
我们是不敢保证哪一个线程能够在哪个时刻抢到，所以线程的执行有随机性。
4.多线程举例及并行和并发的区别
进程：
正在运行的程序，是系统进行资源分配和调用的独立单位。
每一个进程都有它自己的内存空间和系统资源。
线程：
是进程中的单个顺序控制流，是一条执行路径
一个进程如果只有一条执行路径，则称为单线程程序。
一个进程如果有多条执行路径，则称为多线程程序。
举例：
扫雷程序，迅雷下载
大家注意两个词汇的区别：并行和并发。
前者是逻辑上同时发生，指在某一个时间内同时运行多个程序。
后者是物理上同时发生，指在某一个时间点同时运行多个程序。
5.Java程序运行原理和JVM的启动是否是多线程的
Java程序的运行原理：
由java命令启动JVM，JVM启动就相当于启动了一个进程。
接着有该进程创建了一个主线程去调用main方法。
思考题：
jvm虚拟机的启动是单线程的还是多线程的?
多线程的。
原因是垃圾回收线程也要先启动，否则很容易会出现内存溢出。
现在的垃圾回收线程加上前面的主线程，最低启动了两个线程，所以，jvm的启动其实是多线程的。
JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的。
6.多线程方式1的代码实现
需求：我们要实现多线程的程序。
如何实现呢?
由于线程是依赖进程而存在的，所以我们应该先创建一个进程出来。
而进程是由系统创建的，所以我们应该去调用系统功能创建一个进程。
Java是不能直接调用系统功能的，所以，我们没有办法直接实现多线程程序。
但是呢?Java可以去调用C/C++写好的程序来实现多线程程序。
由C/C++去调用系统功能创建进程，然后由Java去调用这样的东西，
然后提供一些类供我们使用。我们就可以实现多线程程序了。
那么Java提供的类是什么呢?
Thread
通过查看API，我们知道了有2中方式实现多线程程序。
方式1：继承Thread类。
步骤
A:自定义类MyThread继承Thread类。
B:MyThread类里面重写run()?
为什么是run()方法呢?
C:创建对象
D:启动线程
==============================================================
以下为注意事项
直接调用run()方法并没有启动一个新的线程，只是执行了这个方法的内容
my.run();
my.run();
调用run()方法为什么是单线程的呢?
因为run()方法直接调用其实就相当于普通的方法调用,所以你看到的是单线程的效果
要想看到多线程的效果，就必须说说另一个方法：start()
要想看到多线程的效果，必须调用start()方法
以下为错误示例
IllegalThreadStateException:非法的线程状态异常
为什么呢?因为这个相当于是my线程被调用了两次。而不是两个线程启动。
面试题：run()和start()的区别?
run():仅仅是封装被线程执行的代码，直接调用是普通方法
start():首先启动了线程，然后再由jvm去调用该线程的run()方法。
最终版代码
MyThread类(继承父类Thread)
/*
* 该类要重写run()方法,为什么呢?
* 不是类中的所有代码都需要被线程执行的。
* 而这个时候，为了区分哪些代码能够被线程执行，java提供了Thread类中的run()用来包含那些被线程执行的代码。
*/
public class MyThread extends Thread {
@Override
public void run() {
// 自己写代码
// System.out.println("好好学习，天天向上");//一般不会那么无聊为了输出一句话而重新开一个线程(浪费)
// 一般来说，被线程执行的代码肯定是比较耗时的。所以我们用循环改进
for (int x = 0; x < 200; x++) {//不一定是200.可能需要更大才能看到效果
System.out.println(x);
}
}
}
============================================
测试类
public class MyThreadDemo {
public static void main(String[] args) {
// 创建两个线程对象
MyThread my1 = new MyThread();
MyThread my2 = new MyThread();
my1.start();
my2.start();
}
===================================================
运行示例(x<900)
可以看到两个0~899的输出过程互相抢夺资源，并不是输出0~899了再输出0~899的
7.获取和设置线程对象名称
如何获取线程对象的名称呢?
public final String getName():获取线程的名称。
如何设置线程对象的名称呢?
public final void setName(String name):设置线程的名称
设置线程的名称(如果不设置名称的话，默认是Thread-? 编号)
在测试类中：
方法一：无参构造+setXxx()
// 创建线程对象
MyThread my1 = new MyThread();
MyThread my2 = new MyThread();
//调用方法设置名称
my1.setName("林青霞");
my2.setName("刘意");
my1.start();
my2.start();
前提是MyThread类要改一下run()方法(getName()就是用来获取线程名字的)
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println(getName() + ":" + x);
}
}
方法二(稍微麻烦,要手动写MyThread的带参构造方法,方法一不用)：
public class MyThread extends Thread {
public MyThread() {
}
public MyThread(String name){
super(name);//直接调用父类的就好
}
@Override
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println(getName() + ":" + x);//红字相当于this.getName()
}
}
}
====================================
然后在测试类中：
//带参构造方法给线程起名字
MyThread my1 = new MyThread("林青霞");
MyThread my2 = new MyThread("刘意");
my1.start();
my2.start();
=====================================
还有一个问题：我要获取main方法所在的线程对象的名称，该怎么办呢?
这时候注意：main方法所在的测试类并不继承Thread类，因此并不能直接使用getName()方法来获取名称。
//遇到这种情况,Thread类提供了一个很好玩的方法:
//public static Thread currentThread():返回当前正在执行的线程对象,返回值是Thread,而Thread恰巧可以调用getName()方法
System.out.println(Thread.currentThread().getName());
运行输出main
8.线程调度及获取和设置线程优先级
线程调度
==========================================================
我们的线程没有设置优先级,肯定有默认优先级。
那么，默认优先级是多少呢?
如何获取线程对象的优先级?
public final int getPriority():返回线程对象的优先级
如何设置线程对象的优先级呢?
public final void setPriority(int newPriority)：更改线程的优先级。
注意：
线程默认优先级是5。
线程优先级的范围是：1-10。
线程优先级高仅仅表示线程获取的 CPU时间片的几率高，但是要在次数比较多，或者多次运行的时候才能看到比较好的效果。
IllegalArgumentException:非法参数异常。
抛出的异常表明向方法传递了一个不合法或不正确的参数。
==========================================================
线程优先级：最大为10，最小为1，默认为5
public static void main(String[] args) {
ThreadPriority tp1 = new ThreadPriority();
ThreadPriority tp2 = new ThreadPriority();
ThreadPriority tp3 = new ThreadPriority();
tp1.setName("东方不败");
tp2.setName("岳不群");
tp3.setName("林平之");
//设置正确的线程优先级
tp1.setPriority(10);
tp2.setPriority(1);
tp1.start();
tp2.start();
tp3.start();
}
9.线程控制之休眠线程
线程休眠(静态方法)
public static void sleep(long millis)
======================================
代码
主要在ThreadSleep中改动
public class ThreadSleep extends Thread {
@Override
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println(getName() + ":" + x + ",日期：" + new Date());
// 睡眠
// 困了，我稍微休息1秒钟
try {//只能用try catch，不能throws，因为父类没抛这个异常，子类也不能抛
Thread.sleep(1000);//其实在这里也可以直接写sleep(1000);而省略Thread
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
==============================
再写一个类测试一下
public static void main(String[] args) {
ThreadSleep ts1 = new ThreadSleep();
ThreadSleep ts2 = new ThreadSleep();
ThreadSleep ts3 = new ThreadSleep();
ts1.setName("林青霞");
ts2.setName("林志玲");
ts3.setName("林志颖");
ts1.start();
ts2.start();
ts3.start();
}
10.线程控制之加入线程
join()方法(非静态方法)
public final void join():等待该线程终止。
=================================
代码
ThreadJoin类
public class ThreadJoin extends Thread {
@Override
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println(getName() + ":" + x);
}
}
}
===============================
以下为测试类
public class ThreadJoinDemo {
public static void main(String[] args) {
ThreadJoin tj1 = new ThreadJoin();
ThreadJoin tj2 = new ThreadJoin();
ThreadJoin tj3 = new ThreadJoin();
tj1.setName("李渊");
tj2.setName("李世民");
tj3.setName("李元霸");
tj1.start();
try {
tj1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
tj2.start();
tj3.start();
}
}
==========================================
以下是本人写的测试类以及运行情况
11.线程控制之礼让线程
yield()----静态方法
public static void yield():暂停当前正在执行的线程对象，并执行其他线程。
让多个线程的执行更和谐，但是不能靠它保证一人一次。(理论上是一人执行一次，轮流来，也就是一个线程执行一次后，等待下一个线程执行，然后第一个线程再执行第二次，……实际上可能有"误差")
代码
ThreadYield类
public class ThreadYield extends Thread {
@Override
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println(getName() + ":" + x);
Thread.yield();
}
}
}
=====================================
测试类
public class ThreadYieldDemo {
public static void main(String[] args) {
ThreadYield ty1 = new ThreadYield();
ThreadYield ty2 = new ThreadYield();
ty1.setName("林青霞");
ty2.setName("刘意");
ty1.start();
ty2.start();
}
}
=========================================
可以看见上面 刘意进程与林青霞进程相互交替进行，但不保证一定这样。
12.线程控制之守护线程
setDaemon---非静态
public final void setDaemon(boolean on):将该线程标记为守护线程或用户线程。
当正在运行的线程都是守护线程时，Java 虚拟机退出。 该方法必须在启动线程前调用。
ThreadDaemon类
public class ThreadDaemon extends Thread {
@Override
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println(getName() + ":" + x);
}
}
}
==================================
测试类
public class ThreadDaemonDemo {
public static void main(String[] args) {
ThreadDaemon td1 = new ThreadDaemon();
ThreadDaemon td2 = new ThreadDaemon();
td1.setName("关羽");
td2.setName("张飞");
// 设置守护线程(注意：必须在start()方法之前设置，否则会有异常！！)
td1.setDaemon(true);//true代表线程设置为"守护"
td2.setDaemon(true);//设置后，当主线程执行结束(主线程名字为刘备),td1,td2线程也结束了(守护任务已完成)
td1.start();
td2.start();
Thread.currentThread().setName("刘备");//改一改main线程的名字
for (int x = 0; x < 5; x++) {
System.out.println(Thread.currentThread().getName() + ":" + x);
}
}
}
================================================
13.线程控制之中断线程
public final void stop():让线程停止，过时了，但是还可以使用。(不建议使用,太暴力)
public void interrupt():中断线程。 把线程的状态终止，并抛出一个InterruptedException。
ThreadStop 类
public class ThreadStop extends Thread {
@Override
public void run() {
System.out.println("开始执行：" + new Date());
// 我要休息10秒钟，亲，不要打扰我哦
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
// e.printStackTrace();
System.out.println("线程被终止了");
}
System.out.println("结束执行：" + new Date());
}
}
============================================
测试类
public class ThreadStopDemo {
public static void main(String[] args) {
ThreadStop ts = new ThreadStop();
ts.start();
// 你超过三秒不醒过来，我就干死你
try {
Thread.sleep(3000);
// ts.stop();
ts.interrupt();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
================================================
几个问题：
14.线程生命周期图解
15.多线程方式2的思路及代码实现
方式2：实现Runnable接口
步骤：
A:自定义类MyRunnable实现Runnable接口
B:重写run()方法
C:创建MyRunnable类的对象
D:创建Thread类的对象，并把C步骤的对象作为构造参数传递
MyRunnable 类
public class MyRunnable implements Runnable {
@Override
public void run() {
for (int x = 0; x < 100; x++) {
// 由于实现接口的方式就不能直接使用Thread类的方法了,但是可以间接的使用
System.out.println(Thread.currentThread().getName() + ":" + x);
}
}
}
测试类
public class MyRunnableDemo {
public static void main(String[] args) {
// 创建MyRunnable类的对象
MyRunnable my = new MyRunnable();//多个相同程序的代码去处理同一个资源
//注意：MyRunnable对象只需要创建一个即可，多个Thread对象可以接收同一个MyRunnable对象
// 创建Thread类的对象，并把C步骤的对象作为构造参数传递
// Thread(Runnable target)
// Thread t1 = new Thread(my);
// Thread t2 = new Thread(my);
// t1.setName("林青霞");
// t2.setName("刘意");
// Thread(Runnable target, String name)
Thread t1 = new Thread(my, "林青霞");//同一个对象my，而不需要my1，my2，……
Thread t2 = new Thread(my, "刘意");//同一个对象my 而不需要my1，my2，……
t1.start();
t2.start();
}
}
//注意红字
=============================================================
16.多线程两种方式的图解比较及区别
如何理解------可以避免由于Java单继承带来的局限性
比如说，某个类已经有父类了，而这个类想实现多线程，但是这个时候它已经不能直接继承Thread类了(接口可以多实现implements，但是继承extends只能单继承)，它的父类也不想继承Thread因为不需要实现多线程。
17.两种方式实现卖电影票案例
方式一：继承Thread类的方式卖电影票案例
某电影院目前正在上映贺岁大片(红高粱,少林寺传奇藏经阁)，共有100张票，而它有3个售票窗口售票，请设计一个程序模拟该电影院售票。
继承Thread类来实现。
=====================================
SellTicket类(注意tickets变量是static的！)
public class SellTicket extends Thread {
// 定义100张票
// private int tickets = 100;
// 为了让多个线程对象共享这100张票，我们其实应该用静态修饰
private static int tickets = 100;
@Override
public void run() {
// 定义100张票
// 每个线程进来都会走这里，这样的话，每个线程对象相当于买的是自己的那100张票，这不合理，所以应该定义到外面
// int tickets = 100;
// 是为了模拟一直有票
while (true) {
if (tickets > 0) {
System.out.println(getName() + "正在出售第" + (tickets--) + "张票");
}
}
}
}
===========================================================
测试类SellTicketDemo
public class SellTicketDemo {
public static void main(String[] args) {
// 创建三个线程对象
SellTicket st1 = new SellTicket();
SellTicket st2 = new SellTicket();
SellTicket st3 = new SellTicket();
// 给线程对象起名字
st1.setName("窗口1");
st2.setName("窗口2");
st3.setName("窗口3");
// 启动线程
st1.start();
st2.start();
st3.start();
}
}
============================================================
说明的是，通过继承Thread类来实现题中的需求并不是很好(tickets要用static修饰，并不太好)，其实用Runnable接口更好地进行数据分离
以下为方式2---实现Runnable接口的方式卖电影票案例
SellTicket 类
public class SellTicket implements Runnable {
// 定义100张票
private int tickets = 100;
@Override
public void run() {
while (true) {
if (tickets > 0) {
System.out.println(Thread.currentThread().getName() + "正在出售第"
+ (tickets--) + "张票");
}
}
}
}
=================================================
测试类
/*
* 实现Runnable接口的方式实现
*/
public class SellTicketDemo {
public static void main(String[] args) {
// 创建资源对象
SellTicket st = new SellTicket();
// 创建三个线程对象
Thread t1 = new Thread(st, "窗口1");
Thread t2 = new Thread(st, "窗口2");
Thread t3 = new Thread(st, "窗口3");
// 启动线程
t1.start();
t2.start();
t3.start();
}
}
=====================================================
18.买电影票出现了同票和负数票的原因分析
首先在SellTicket类中添加sleep方法，延迟一下线程，拖慢一下执行的速度
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
降低速度之后出现了问题
通过加入延迟后，就产生了连个问题：
A:相同的票卖了多次
CPU的一次操作必须是原子性的(在读取tickets--的原来的数值和减1之后的中间挤进了两个线程而出现重复)
B:出现了负数票
随机性和延迟导致的(三个线程同时挤进一个循环里，tickets--的减法操作有可能在同一个循环中被执行了多次而出现越界的情况，比如说tickets要大于0却越界到了-1)
也就是说，线程1执行的同时线程2也可能在执行，而不是线程1执行的时候线程2不能执行。
19.线程安全问题的产生原因分析
如何解决线程安全问题呢?
要想解决问题，就要知道哪些原因会导致出问题:(而且这些原因也是以后我们判断一个程序是否会有线程安全问题的标准)
A:是否是多线程环境
B:是否有共享数据
C:是否有多条语句操作共享数据
我们来回想一下我们的程序有没有上面的问题呢?
A:是否是多线程环境 是
B:是否有共享数据 是
C:是否有多条语句操作共享数据 是
由此可见我们的程序出现问题是正常的，因为它满足出问题的条件。
20.同步代码块的方式解决线程安全问题
接下来才是我们要想想如何解决问题呢?
A和B的问题我们改变不了，我们只能想办法去把C改变一下。
思想：
把多条语句操作共享数据的代码给包成一个整体，让某个线程在执行的时候，别人不能来执行。
问题是我们不知道怎么包啊?其实我也不知道，但是Java给我们提供了：同步机制。
同步代码块：
synchronized(对象){
需要同步的代码;
}
A:对象是什么呢?
我们可以随便创建一个对象试试。
B:需要同步的代码是哪些呢?
把多条语句操作共享数据的代码的部分给包起来
注意：
同步可以解决安全问题的根本原因就在那个对象上。该对象如同锁的功能。
多个线程必须是同一把锁。
在SellTicket类中改写如下
public class SellTicket implements Runnable {
// 定义100张票
private int tickets = 100;
//创建锁对象
private Object obj = new Object();//把这个关键的锁对象定义到run方法(独立于线程之外)之外。造成同一把锁
// @Override
// public void run() {
// while (true) {
// synchronized(new Object()){//这里用new Object是不对的，因为这会导致不是同一把锁
// if (tickets > 0) {
// try {
// Thread.sleep(100);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// System.out.println(Thread.currentThread().getName() + "正在出售第"
// + (tickets--) + "张票");
// }
// }
// }
// }
@Override
public void run() {
while (true) {
synchronized (obj) {//obj相当于一把锁，把synchroned包含的代码锁住
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "正在出售第" + (tickets--) + "张票");
}
}
}
}
}
=====================================================
再运行就没有问题了
21.同步代码块解决线程安全问题的解释
public class SellTicket implements Runnable {
// 定义100张票
private int tickets = 100;
// 定义同一把锁
private Object obj = new Object();
@Override
public void run() {
while (true) {
// t1,t2,t3都能走到这里
// 假设t1抢到CPU的执行权，t1就要进来
// 假设t2抢到CPU的执行权，t2就要进来,发现门是关着的，进不去。所以就等着。
// 门(开,关)
synchronized (obj) { // 发现这里的代码将来是会被锁上的，所以t1进来后，就锁了。(关)
if (tickets > 0) {
try {
Thread.sleep(100); // t1就睡眠了
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "正在出售第" + (tickets--) + "张票 ");
//窗口1正在出售第100张票
}
} //t1就出来可，然后就开门。(开)(门开后，三个线程又开始抢占)
}
}
}
22.同步的特点及好处和弊端
举例：
火车上厕所。
同步的特点：
前提：
多个线程
解决问题的时候要注意：
多个线程使用的是同一个锁对象
同步的好处
同步的出现解决了多线程的安全问题。
同步的弊端
当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。
23.同步代码快的锁及同步方法应用和锁的问题
概述：
A:同步代码块的锁对象是谁呢?
任意对象。
B:同步方法的格式及锁对象问题?
把同步关键字加在方法上。
同步方法的锁对象是谁呢?
this
C:静态方法及锁对象问题?
静态方法的锁对象是谁呢?
类的字节码文件对象。(反射会讲)
========================================================
分部解析(测试类都一样，下面是SellTicket类的代码变化)
同步代码块的锁对象是任意对象。
public class SellTicket implements Runnable {
// 定义100张票
private int tickets = 100;
// 定义同一把锁
private Object obj = new Object();
private Demo d = new Demo();//任意对象
//同步代码块用obj做锁
@Override
public void run() {
while (true) {
synchronized (obj) {
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "正在出售第" + (tickets--) + "张票 ");
}
}
}
}
//同步代码块用任意对象做锁
@Override
public void run() {
while (true) {
synchronized (d) {
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "正在出售第" + (tickets--) + "张票 ");
}
}
}
}
class Demo {
}
=============================================================
同步方法的格式及锁对象问题?
把同步关键字加在方法上。( sellTicket()方法)
同步方法的锁对象是---------------------- this
// 定义100张票
private int tickets = 100;
// 定义同一把锁
private Object obj = new Object();
private int x = 0;
@Override
public void run() {
while (true) {
if(x%2==0){
synchronized (this) {//注意，这里必须用this对象而不能用其它锁对象，否则同步功能会失败
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "正在出售第" + (tickets--) + "张票 ");
}
}
}else {
sellTicket();//用方法代替
}
x++;
}
}
private void sellTicket() {
synchronized (d) {
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "正在出售第" + (tickets--) + "张票 ");
}
}
}
=================================================================
静态方法及锁对象问题?
静态方法的锁对象是谁呢?
类的字节码文件对象。(Xxx.class文件)
public class SellTicket implements Runnable {
// 定义100张票
private static int tickets = 100;//使用了静态方法，所以变量也要改为static
// 定义同一把锁
private Object obj = new Object();
private int x = 0;
@Override
public void run() {
while (true) {
if(x%2==0){
synchronized (SellTicket.class) {
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "正在出售第" + (tickets--) + "张票 ");
}
}
}else {
sellTicket();
}
x++;
}
}
}
private static synchronized void sellTicket() {
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "正在出售第" + (tickets--) + "张票 ");
}
}
回顾以前线程安全的类
// 线程安全的类,效率低
StringBuffer sb = new StringBuffer();
Vector<String> v = new Vector<String>();
Hashtable<String, String> h = new Hashtable<String, String>();
注意
// Vector是线程安全的时候才去考虑使用的，但是我还说过即使要安全，我也不用你
// 那么到底用谁呢?
// public static <T> List<T> synchronizedList(List<T> list)
List<String> list1 = new ArrayList<String>();// 线程不安全
List<String> list2 = Collections
.synchronizedList(new ArrayList<String>()); // 线程安全
Collections.synchronizedList(接收List对象)
示例
day23笔记补充
Java程序的运行原理及JVM的启动是多线程的吗?
A:Java命令去启动JVM，JVM会启动一个进程，该进程会启动一个主线程。
B:JVM的启动是多线程的，因为它最低有两个线程启动了，主线程和垃圾回收线程。
多线程的实现方案(掌握)
A:继承Thread类
B:实现Runnable接口
以前的线程安全的类
A:StringBuffer
B:Vector
C:Hashtable
D:如何把一个线程不安全的集合类变成一个线程安全的集合类
用Collections工具类的方法即可。
