传智播客 2015年 刘意_Java基础视频-深入浅出精华版 笔记(day21~day23)(2016年4月8日13:28:21)
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对象可以读取什么东西呢? 两个读取方法，一次读取一个字符或者一次读取一个字符数组
* 那么。我们要返回一个字符串。用哪个方法比較好呢? 我们非常easy想到字符数组比較好，可是问题来了。就是这个数组的长度是多长呢?
* 根本就没有办法定义数组的长度，你定义多长都不合适。 所以，仅仅能选择一次读取一个字符。
* 可是呢。这样的方式的时候。我们再读取下一个字符的时候，上一个字符就丢失了 所以，我们又应该定义一个暂时存储空间把读取过的字符给存储起来。
* 这个用谁比較和是呢?数组。集合，字符串缓冲区三个可供选择。
* 经过简单的分析。终于选择使用字符串缓冲区对象。而且使用的是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) {
// username=password
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) {
/*
* 为了让注冊的数据可以有一定的规则，我就自定义了一个规则： username=password
*/
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”));
// 怎样写读写呢。事实上非常easy。你就依照曾经怎么读写，如今还是怎么读写
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;
另一个要注意的问题：
注意：
我一个类中可能有非常多的成员变量，有些我不想进行序列化。请问该怎么办呢?
使用transientkeyword声明不须要序列化的成员变量
也就是用transientkeyword
把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虚拟机的启动是单线程的还是多线程的?
多线程的。
原因是垃圾回收线程也要先启动。否则非常easy会出现内存溢出。
如今的垃圾回收线程加上前面的主线程。最低启动了两个线程，所以。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:同步方法的格式及锁对象问题?
把同步keyword加在方法上。
同步方法的锁对象是谁呢?
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 {
}
=============================================================
同步方法的格式及锁对象问题?
把同步keyword加在方法上。( 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–) + “张票 “);
}
}
24.曾经的线程安全的类回想
回想曾经线程安全的类
// 线程安全的类,效率低
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工具类的方法就可以。
版权声明：本文为jzdwajue原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。