java语言笔记(进阶篇)
01-IO
1.基本类
2-IO-File(文件)
File:文件和目录(文件夹)的路径
(1)IO基础
①路径
package JAVAIO1;
import java.io.File;
//路径
//File文件对象创建
public class TextPath {
public static void main(String[] args) {
String path=“E:/java语言/java语言(新)/跟着哔哩哔哩学习2/src/JAVAIO1/SS.jpg”;
System.out.println(File.separatorChar);// \ 用于动态拼接路径
//构建File对象(可以构建文件路径文件夹,无论存不存在)
File srcFile=new File(path);
System.out.println(srcFile.length());
//相对路径和绝对路径
//绝对路径:存在盘符
System.out.println(srcFile.getAbsolutePath());
//相对路径:没有盘符
System.out.println(System.getProperty("user.dir"));//当前项目所在路径
}
}
10384651
E:\java语言\java语言(新)\跟着哔哩哔哩学习2\src\JAVAIO1\SS.jpg
E:\java语言\java语言(新)\跟着哔哩哔哩学习2
②文件基本操作
package JAVAIO1;
import java.io.File;
import java.io.IOException;
//文件基本操作
public class TextFile {
public static void main(String[] args) throws IOException {
File srcFile=new File(“E:/java语言/java语言(新)/跟着哔哩哔哩学习2/src/JAVAIO1/SS.jpg”);
//文件基本信息
System.out.println("名称:"+srcFile.getName());
System.out.println("路径"+srcFile.getPath());
System.out.println("绝对路径:"+srcFile.getAbsolutePath());
System.out.println("父路径:"+srcFile.getParent());
System.out.println("父对象:"+srcFile.getParentFile().getName());
//文件的状态
System.out.println("是否存在:"+srcFile.exists());
System.out.println("是否文件:"+srcFile.isFile());
System.out.println("是否文件夹:"+srcFile.isDirectory());
//文件长度
System.out.println("文件长度"+srcFile.length());//文件夹长度为0
//创建文件
File src=new File(srcFile.getParent()+"路径实验.txt");//与后缀无关
boolean a=src.createNewFile();//不存在才创建,存在不创建
System.out.println("文件是否创建成功:"+a);
System.out.println(src.getAbsolutePath());
//删除文件
a=src.delete();
System.out.println("文件是否删除成功:"+a);
}
}
名称:SS.jpg
路径E:\java语言\java语言(新)\跟着哔哩哔哩学习2\src\JAVAIO1\SS.jpg
绝对路径:E:\java语言\java语言(新)\跟着哔哩哔哩学习2\src\JAVAIO1\SS.jpg
父路径:E:\java语言\java语言(新)\跟着哔哩哔哩学习2\src\JAVAIO1
父对象:JAVAIO1
是否存在:true
是否文件:true
是否文件夹:false
文件长度10384651
文件是否创建成功:false
E:\java语言\java语言(新)\跟着哔哩哔哩学习2\src\JAVAIO1路径实验.txt
文件是否删除成功:true
③文件夹的基本操作
package JAVAIO1;
import java.io.File;
//文件夹的基本操作
public class TextFileWenJianJia {
public static void main(String[] args) {
File src=new File(“E:/java语言/java语言(新)/跟着哔哩哔哩学习2/src/JAVAIO1/test”);
//创建目录(文件夹)
//boolean a=src.mkdir();//保证上级目录存在
boolean a=src.mkdirs();//上级目录一起创建
System.out.println("文件夹是否创建成功:"+a);
a=src.delete();
System.out.println("文件夹是否删除成功:"+a);
//列出下一级目录
File src2=new File("E:/java语言/java语言(新)/跟着哔哩哔哩学习2/src/JAVAIO1");
String namString[]=src2.list();//只返回一层
for(String s:namString)
{
System.out.println(s);
}
//返回下一层对象
File FileName[]=src2.listFiles();
for(File s:FileName)
{
System.out.println(s.getAbsolutePath());//返回绝对路径
}
//列出所有盘符
File rootFile[]=src2.listRoots();
for(File s:rootFile)
{
System.out.println(s.getAbsolutePath());//返回绝对路径
}
//遍历文件夹(目录)
File sr=new File("E:/java语言/java语言(新)/跟着哔哩哔哩学习2/src/JAVAIO1");
printName(sr,0);
//统计文件夹的大小
count(sr);
System.out.println(len);
}
public static void printName(File src,int ceng)//遍历文件夹递归方法
{
for(int i=0;i<ceng;i++)
{
System.out.print(" ");
}
System.out.println(src.getName());
if(null==src||!src.exists())//递归头
return;
else if(src.isDirectory())//目录
{
for(File s:src.listFiles())
{
printName(s,ceng+1);//递归体
}
}
}
private static long len=0;
public static void count(File src)//遍历文件夹,统计大小
{
if(src!=null&&src.exists())
{
if(src.isFile())
{
len+=src.length();
}
else if(src.isDirectory())
{
for(File s:src.listFiles())
{
count(s);
}
}
}
}
}
文件夹是否创建成功:true
文件夹是否删除成功:true
SS.jpg
TextFileWenJian.java
TextFileWenJianJia.java
TextPath.java
E:\java语言\java语言(新)\跟着哔哩哔哩学习2\src\JAVAIO1\SS.jpg
E:\java语言\java语言(新)\跟着哔哩哔哩学习2\src\JAVAIO1\TextFileWenJian.java
E:\java语言\java语言(新)\跟着哔哩哔哩学习2\src\JAVAIO1\TextFileWenJianJia.java
E:\java语言\java语言(新)\跟着哔哩哔哩学习2\src\JAVAIO1\TextPath.java
C:
D:
E:
JAVAIO1
SS.jpg
TextFileWenJian.java
TextFileWenJianJia.java
TextPath.java
10388392
④字符集编码
package JAVAIO1;
import java.io.UnsupportedEncodingException;
//字符串->字节 编码
//字节->字符串 解码
public class TextBianMa {
public static void main(String[] args) throws UnsupportedEncodingException {
String string=“你好hello”;
//编码
byte data[]=string.getBytes();//默认工程编码
System.out.println(data.length);
//编码其他字符集
data=string.getBytes("UTF-16LE");
System.out.println(data.length);
//解码
//乱码:
//1)、字节数不够
string=new String(data, 0,data.length,"UTF-16LE");
System.out.println(string);
//2)、字符集不统一
string=new String(data, 0,data.length,"GBK");
System.out.println(string);
}
}
9
14
你好hello
`O}Yh
(2)IO流
①IO-标准操作步骤
package JAVAIO2;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
//io流的标准操作步骤
//1、创建源
//2、选择流
//3、操作
//4、释放资源
public class IOBiaoZhun {
public static void main(String[] args) {
//1、创建源
File file=new File(“E:\java语言\java语言(新)\跟着哔哩哔哩学习2\src\JAVAIO2\abc.txt”);
//2、选择流
InputStream is = null;
try
{
is=new FileInputStream(file);
//3、操作
int temp;
try
{
while((temp=is.read())!=-1)
{
System.out.print((char)temp);
}
System.out.println();
}
catch (IOException e1)
{
e1.printStackTrace();
}
}
catch (IOException e)
{
e.printStackTrace();
}
finally
{
//4、释放资源
try {
is.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
hello word
②IO-文件字节流
package JAVAIO2;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
//来源:文件
//文件字节流
//中间容器==缓冲
public class IOWenJian {
public static void main(String[] args) {
//1、创建源
File file1=new File(“E:\\java语言\\java语言(新)\\跟着哔哩哔哩学习2\\src\\JAVAIO2\\abc.txt”);
//2、选择流
OutputStream os=null;
try
{
os=new FileOutputStream(file1,true);//追加
//3、操作(写出)
String string1=“wgukshaudgkasnkjasbda\n”;//写入内容
byte data1[]=string1.getBytes();//编码
//用流写入
try {
os.write(data1,0,data1.length);
os.flush();//挤缓冲
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
catch (FileNotFoundException e1)
{
// TODO Auto-generated catch block
e1.printStackTrace();
}
finally
{
if(os!=null)
{
//4、释放资源
try {
os.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
//缓冲
//1、创建源
File file=new File("E:\\java语言\\java语言(新)\\跟着哔哩哔哩学习2\\src\\JAVAIO2\\abc.txt");
//2、选择流
InputStream is = null;
try
{
is=new FileInputStream(file);//可以读取所有类型的文件
//3、操作(分段读取)
byte car[]=new byte[5];//缓冲容器
int len=-1;//接受长度
try
{
while((len=is.read(car))!=-1)//读取
{
//字节数组==>字符串(解码)
String str=new String(car, 0,len);
System.out.print(str);
}
System.out.println();
}
catch (IOException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
}
catch (FileNotFoundException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
③文件的拷贝
输入流+输出流
④IO-文件字符流
package JAVAIO2;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
//来源:文件
//仅适用于字符
//文件字符流
public class IOWenJianZiFu {
public static void main(String[] args) {
//输入
File file=new File("E:\\\\java语言\\\\java语言(新)\\\\跟着哔哩哔哩学习2\\\\src\\\\JAVAIO2\\\\abc.txt");
//2、选择流
Reader reader=null;
try
{
reader=new FileReader(file);
//3、操作
char open[]=new char[1024];//缓冲容器
int len=-1;//接受长度
try
{
while((len=reader.read(open))!=-1)
{
//字符数组==>字符串
String string=new String(open, 0, len);
System.out.print(string);
}
System.out.println();
}
catch (IOException e1)
{
e1.printStackTrace();
}
}
catch (IOException e)
{
e.printStackTrace();
}
finally
{
//4、释放资源
try {
if(reader!=null)
reader.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//输出
File file2=new File("E:\\java语言\\java语言(新)\\跟着哔哩哔哩学习2\\src\\JAVAIO2\\abc.txt");
//2、选择流
Writer writer=null;
try
{
writer=new FileWriter(file2,true);//追加
//3、操作
String string2="我在写入";
//写法:
//1、
//char data[]=string2.toCharArray();//字符串==>字符数组
//writer.write(data, 0, data.length);
//writer.flush();//清空缓存
//2、
//writer.write(string2);
//3、
writer.append(string2);
writer.flush();
}
catch (IOException e)
{
e.printStackTrace();
}
finally
{
//4、释放资源
try {
if(writer!=null)
writer.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
⑤IO-字节数组流
package JAVAIO2;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
//字节数组流
//来源:内存、网络等
//特点:方便网络传输、任何东西都可转成字节数组、不用关闭、多态通用、不关连源
public class IONeiCunZiJieShuZu {
public static void main(String[] args) {
//输出流
//1、创建源(可以不创建)
byte src1[]=null;
//2、选择流
ByteArrayOutputStream os=null;
try {
os=new ByteArrayOutputStream();
//3、操作
String string="我写入";
//字符串==>字节数组
byte data[]=string.getBytes();
os.write(data, 0, data.length);
os.flush();
//输出
System.out.println(new String(os.toByteArray(),0,os.size()));
}
catch (IOException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
/*finally
{
if(is!=null)
{
try {
is.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
*/
//输入流
//1、创建源
byte src[]="hello word".getBytes();//字节数组
//2、选择流
InputStream is=null;
try {
is=new ByteArrayInputStream(src);
//3、操作
byte open[]=new byte[5];//缓冲容器
int len=-1;//接收长度
while((len=is.read(open))!=-1)
{
String string=new String(open, 0,len);
System.out.print(string);
}
System.out.println();
}
catch (IOException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
/*finally
{
if(is!=null)
{
try {
is.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
*/
}
}
(3)对接流(综合)
package JAVAIO2;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
//对接流
//综合
//图片字节数组写到文件==还原
public class DuiJeiLiu {
public static void main(String[] args) {
//图片转字节数组
byte datas[]=TuPianByteArray(“E:/java语言/java语言(新)/跟着哔哩哔哩学习2/src/JAVAIO1/SS.jpg”);
//字节数组转图片
BytetoTuPianArray(datas,“E:\java语言\java语言(新)\跟着哔哩哔哩学习2\bin\JAVAIO2\p-byte.jpg”);
}
//图片==字节数组
public static byte[] TuPianByteArray(String fileString)
{
File file=new File(fileString);
byte src1[]=null;
//2、选择流
InputStream is = null;
ByteArrayOutputStream os=null;
try
{
os=new ByteArrayOutputStream();
is=new FileInputStream(file);
//3、操作
byte open[]=new byte[1024];//缓冲容器
int len=-1;//接受长度
try
{
while((len=is.read(open))!=-1)
{
os.write(open, 0, open.length);//写出到字节数组中
}
os.flush();
return os.toByteArray();
}
catch (IOException e1)
{
e1.printStackTrace();
}
}
catch (IOException e)
{
e.printStackTrace();
}
finally
{
//4、释放资源
try {
is.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return null;
}
//字节数组==图片
public static void BytetoTuPianArray(byte src[],String filePath)
{
//2、选择流
InputStream is=null;
File file=new File(filePath);
OutputStream os=null;
try {
is=new ByteArrayInputStream(src);
os=new FileOutputStream(file);
//3、操作
byte open2[]=new byte[5];//缓冲容器
int len=-1;//接收长度
while((len=is.read(open2))!=-1)
{
os.write(open2, 0, open2.length);//写出
}
os.flush();
}
catch (IOException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
finally
{
if(os!=null)
{
//4、释放资源
try {
os.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
(4)封装
package JAVAIO2;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
//封装拷贝
//封装释放资源
public class DuiJeiLiu2 {
public static void main(String[] args) {
byte data2[]=null;
//文件到文件
try {
InputStream is=new FileInputStream(“E:\java语言\java语言(新)\跟着哔哩哔哩学习2\src\JAVAIO2\abc.txt”);
OutputStream os=new FileOutputStream(“E:\java语言\java语言(新)\跟着哔哩哔哩学习2\src\JAVAIO2\abc-copy.txt”);
copy(is, os);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//文件到字节数组
try {
InputStream is=new FileInputStream("E:/java语言/java语言(新)/跟着哔哩哔哩学习2/src/JAVAIO1/SS.jpg");
ByteArrayOutputStream os=new ByteArrayOutputStream();
copy(is, os);
data2=os.toByteArray();
System.out.println(data2);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//字节数组到文件
try {
InputStream is=new ByteArrayInputStream(data2);
OutputStream os=new FileOutputStream("E:\\java语言\\java语言(新)\\跟着哔哩哔哩学习2\\src\\JAVAIO2\\abc-copy.jpg");
copy(is, os);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//对接输入输出流
public static void copy(InputStream is,OutputStream os)
{
try(InputStream iso = is; OutputStream oso = os)//里面声明,自动抛出new
{
byte data[]=new byte[1024*2];//缓冲容器
int len=-1;//接受长度
while((len=is.read(data))!=-1)//读取
{
//字节数组==>字符串(解码)
os.write(data,0,data.length);
}
os.flush();//挤缓冲
}
catch (IOException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
catch (Exception e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
//finally
//{
//close(is, os);
//close();
//}
}
/*public static void close(InputStream is,OutputStream os)
{
if(os!=null||is!=null)
{
//4、释放资源
try {
os.close();
is.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
*/
public static void close(Cloneable...ios)
{
for(Cloneable io:ios)
{
if(null!=io)
{
try {
((ByteArrayInputStream) io).close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
(5)设计模式-装饰器模式
//装饰器:装饰类,使之实现功能
//实现接口
//装饰流==处理流
①IO-字节缓冲流
package JAVAIO3;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.security.PublicKey;
import javax.imageio.spi.IIOServiceProvider;
//装饰器:装饰类,使之实现功能
//实现接口
//装饰流==处理流
//字节缓冲流
//套在字节流上、释放外边的装饰流自动释放里面的
public class TextBuffered {
public static void main(String[] args) {
long t1=System.currentTimeMillis();
copy(“E:\历史于我眼前\710302733\1\710302733_1_0.flv”, “E:\java语言\java语言(新)\跟着哔哩哔哩学习2\bin\JAVAIO3\视频.fiv”);
long t2=System.currentTimeMillis();
System.out.println(t2-t1);
}
public static void copy(String iString,String osString)
{
//1、创建源
File src=new File(iString);
File file=new File(osString);
//2、选择流
InputStream is=null;
OutputStream os=null;
try {
is=new BufferedInputStream(new FileInputStream(src));
os=new BufferedOutputStream(new FileOutputStream(file));
//3、操作
byte open[]=new byte[1024];//缓冲容器
int len=-1;//接收长度
while((len=is.read(open))!=-1)
{
os.write(open, 0, len);
}
os.flush();
}
catch (IOException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
finally
{
if(is!=null||os!=null)
{
try {
is.close();
os.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
②IO-字符缓冲流
package JAVAIO3;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
//文件字符流,加装饰
//纯文本
public class TextBufferedFile {
public static void main(String[] args) {
copy(“E:\java语言\java语言(新)\跟着哔哩哔哩学习2\bin\JAVAIO3\abc.txt”,“E:\java语言\java语言(新)\跟着哔哩哔哩学习2\bin\JAVAIO3\abc-copy.txt” );
}
public static void copy(String srcString,String deString)
{
File file=new File(srcString);
File file2=new File(deString);
//2、选择流
BufferedReader reader=null;
BufferedWriter writer=null;
String lineString=null;
try
{
reader=new BufferedReader(new FileReader(file)) ;
writer=new BufferedWriter(new FileWriter(file2,true)) ;//追加
//3、操作
try
{
while((lineString=reader.readLine())!=null)
{
writer.write(lineString);
writer.newLine();//换行
}
System.out.println();
}
catch (IOException e1)
{
e1.printStackTrace();
}
}
catch (IOException e)
{
e.printStackTrace();
}
finally
{
//4、释放资源
try {
if(reader!=null||writer!=null)
{
reader.close();
writer.close();
}
//writer.flush();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
③IO-转换流-字符集
字符到字节的桥梁
package JAVAIO3;
import java.io.BufferedReader;//缓冲字符
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;//字符流
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.URL;
//字节到字符的桥梁
//InputStreamReader OutputStreamWriter
public class TextZhuanHuan {
public static void main(String[] args) {
//字符加字符缓冲
/*BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
BufferedWriter writer=new BufferedWriter( new OutputStreamWriter(System.out));
String magString="";
while(!magString.equalsIgnoreCase(“exit”))
{
try {
magString=reader.readLine();
writer.write(magString);
writer.newLine();
writer.flush();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
*/
try {
BufferedReader is=
new BufferedReader(
new InputStreamReader(
new URL("http://www.baidu.com").openStream(),"UTF-8")) ;
BufferedWriter os=
new BufferedWriter(
new OutputStreamWriter(
new FileOutputStream("E:\\java语言\\java语言(新)\\跟着哔哩哔哩学习2\\src\\JAVAIO3\\baidu.html"),"UTF-8"));
String temp;
while((temp=is.readLine())!=null)
{
os.write(temp);
os.newLine();
}
os.flush();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
private static OutputStream FileOutputStream(String string, String string2) {
// TODO Auto-generated method stub
return null;
}
}
④IO-数据流
package JAVAIO3;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
//数据流
//写出后读取,字节流
public class TextShuJuliu {
public static void main(String[] args) throws IOException {
//先写出
ByteArrayOutputStream ba=new ByteArrayOutputStream();
DataOutputStream dos=new DataOutputStream(new BufferedOutputStream(ba));
//读取
dos.writeUTF(“输出实验”);
dos.flush();
byte data[]=ba.toByteArray();
//读取
DataInputStream dis=new DataInputStream(new BufferedInputStream(new ByteArrayInputStream(data)) );
String msg=dis.readUTF();
System.out.println(msg);
}
}
⑤IO-对象流
package JAVAIO3;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
//对象流,序列化
//带认证的空接口
//读取顺序保持一致
//加密
public class TextDuiXiangliu {
public static void main(String[] args) throws IOException, ClassNotFoundException {
//序列化
//ByteArrayOutputStream ba=new ByteArrayOutputStream();//写到缓存里
ObjectOutputStream dos=new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(“E:\java语言\java语言(新)\跟着哔哩哔哩学习2\src\JAVAIO3\obj.txt”)));
//操作数据
dos.writeUTF(“输出实验”);
dos.writeObject(“字符串对象”);
Em em=new Em(“实验对象”,1);
dos.writeObject(em);
dos.flush();
dos.close();
//byte data[]=ba.toByteArray();//内存读字节
//读取
//反序列化
ObjectInputStream dis=new ObjectInputStream(new BufferedInputStream(new FileInputStream("E:\\java语言\\java语言(新)\\跟着哔哩哔哩学习2\\src\\JAVAIO3\\obj.txt")) );
//对象数据还原,顺序与写入一样
String msg=dis.readUTF();
System.out.println(msg);
Object string=dis.readObject();
Object dataObject=dis.readObject();
if(string instanceof String)
{
String strObj=(String)string;
System.out.println(strObj);
}
if(dataObject instanceof Em)
{
Em dataString=(Em)dataObject;
System.out.println(dataString.getNameString()+"\n"+dataString.getSalary());
}
}
}
class Em implements Serializable//认证的空接口
{
private transient String nameString;//透明化,数据不需要序列化
private double salary;
public Em() {
}
public Em(String nameString, double salary) {
super();
this.nameString = nameString;
this.salary = salary;
}
public String getNameString() {
return nameString;
}
public void setNameString(String nameString) {
this.nameString = nameString;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
}
⑥IO-打印流
package JAVAIO3;
import java.io.BufferedOutputStream;
import java.io.FileDescriptor;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
//打印流
public class TextDayinLiu {
public static void main(String[] args) throws FileNotFoundException {
//还有ptintwriter
PrintStream printStream=System.out;//默认输出控制台
printStream.println(“打印流”);
printStream.flush();
//自动刷新
printStream=new PrintStream(new BufferedOutputStream(new FileOutputStream("E:\\java语言\\java语言(新)\\跟着哔哩哔哩学习2\\src\\JAVAIO3\\print.txt")),true);
//重定向输出端
System.setOut(printStream);
System.out.println("实验改变输出");
printStream.close();
System.setOut(new PrintStream(new BufferedOutputStream(new FileOutputStream(FileDescriptor.out)),true));
System.out.println("返回控制台");
}
}
(6)IO-CommonsIO
就是一个关于流操作的jar包
package JAVAIO4.lib;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.filefilter.DirectoryFileFilter;
import org.apache.commons.io.filefilter.FileFilterUtils;
import org.apache.commons.io.filefilter.SuffixFileFilter;
//流jar包的使用
public class Text01 {
public static void main(String[] args) throws IOException {
//文件大小
long len=FileUtils.sizeOf(new File(“E:\java语言\java语言(新)\跟着哔哩哔哩学习2\src\JAVAIO3\print.txt”));
System.out.println(len);
//子孙集
Collection file=FileUtils.listFiles(
new File(“E:\java语言\java语言(新)\跟着哔哩哔哩学习2\src”),
FileFilterUtils.or(new SuffixFileFilter(“java”),new SuffixFileFilter(“class”)),
DirectoryFileFilter.INSTANCE);
for(File file2:file)
{
System.out.println(file2.getAbsolutePath());
}
//写出内容
FileUtils.write(new File("E:\\java语言\\java语言(新)\\跟着哔哩哔哩学习2\\src\\JAVAIO3\\print.txt"),"尝试利用包导入" ,true);
ArrayList<String> list=new ArrayList<String>();
list.add("输入1");
list.add("输入2");
FileUtils.writeLines(new File("E:\\java语言\\java语言(新)\\跟着哔哩哔哩学习2\\src\\JAVAIO3\\print.txt"), list,true);
//读取文件
String msg=FileUtils.readFileToString(new File("E:\\java语言\\java语言(新)\\跟着哔哩哔哩学习2\\src\\JAVAIO3\\print.txt"));
System.out.println(msg);
//拷贝
//FileUtils.copyFile(new File("E:\\java语言\\java语言(新)\\跟着哔哩哔哩学习2\\src\\JAVAIO1\\SS.jpg"), new File("E:\\java语言\\java语言(新)\\跟着哔哩哔哩学习2\\src\\JAVAIO4\\lib\\copy.jpg"));
//复制文件到目录
//FileUtils.copyFileToDirectory(new File("E:\\java语言\\java语言(新)\\跟着哔哩哔哩学习2\\src\\JAVAIO3\\obj.txt"), new File("lib"));
//复制目录到目录
//FileUtils.copyDirectoryToDirectory(new File(""), new File(""));
//内容打开拷贝
//FileUtils.copyDirectory(new File(""), new File(""));
//拷贝URL内容
//FileUtils.copyURLToFile(new URL(""), new File(""));
//获取网络内容
//String datas=IOUtils.toString(new URL("http://www.baidu.com"),"UTF-8");
//System.out.println(datas);
}
}
02-线程
1.多线程基本格式
extnex Thread/implements Runnabe
重写run方法
创建线程并启动
package 线程1;
//线程创建
/*
- 1.创建:继承Thread重写run()
- 2.启动子类对象
*/
public class TextThread {
public static void main(String[] args) {
//创建对象
A a=new A();
//启动线程
Thread aa=new Thread(a);
aa.start();
for(int i=0;i<20;i++)
{
System.out.println(“程序”);
}
}
}
class A implements Runnable
{
public void run()
{
//线程的主函数
for(int i=0;i<20;i++)
{
System.out.println(“线程”);
}
}
}
package 线程1;
//线程创建
/*
- 1.创建:继承Thread重写run()
- 2.启动子类对象
*/
public class TextThread {
public static void main(String[] args) {
//创建对象
A a=new A();
//启动线程
a.start();
for(int i=0;i<20;i++)
{
System.out.println(“程序”);
}
}
}
class A extends Thread
{
public void run()
{
//线程的主函数
for(int i=0;i<20;i++)
{
System.out.println(“线程”);
}
}
}
2.多线程图片下载
package 线程1;
//线程创建
/*
- 1.创建:继承Thread重写run()
- 2.启动子类对象
*/
public class TextThreadjichu {
public static void main(String[] args) {
//创建对象
A a=new A();
//启动线程
a.start();
for(int i=0;i<20;i++)
{
System.out.println(“程序”);
}
}
}
class A extends Thread
{
public void run()
{
//线程的主函数
for(int i=0;i<20;i++)
{
System.out.println(“线程”);
}
}
}
package 线程1;
/*
- 创建:实现Runnable重写run()
- 启动:创建实现类对象Thread对象+start
*/
import java.io.File;
import java.io.IOException;
import java.net.URL;
import org.apache.commons.io.FileUtils;
//多线程图片下载类
public class TextRunnabletupian
{
//复制方法
public void download(String url,String name)
{
try
{
FileUtils.copyURLToFile(new URL(url), new File(name));
}
catch (IOException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//主函数
public static void main(String[] args)
{
Downloader2 a1=new Downloader2("https://image.baidu.com/search/detail?ct=503316480&z=0&ipn=d&word=%E7%99%BE%E5%BA%A6%E7%BF%BB%E8%AF%91&step_word=&hs=0&pn=0&spn=0&di=3410&pi=0&rn=1&tn=baiduimagedetail&is=0%2C0&istype=0&ie=utf-8&oe=utf-8&in=&cl=2&lm=-1&st=undefined&cs=2057814800%2C3463233292&os=8375223%2C1827180303&simid=4205767217%2C676622381&adpicid=0&lpn=0&ln=1073&fr=&fmq=1599648675321_R&fm=&ic=undefined&s=undefined&hd=undefined&latest=undefined©right=undefined&se=&sme=&tab=0&width=undefined&height=undefined&face=undefined&ist=&jit=&cg=&bdtype=0&oriquery=&objurl=http%3A%2F%2Fh.hiphotos.baidu.com%2Fbaike%2Fw%3D268%3Bg%3D0%2Fsign%3D82f53a4c38f33a879e6d071cfe677705%2F34fae6cd7b899e51587f836840a7d933c9950ddc.jpg&fromurl=ippr_z2C%24qAzdH3FAzdH3Fkwthj_z%26e3Bkwt17_z%26e3Bv54AzdH3FetjoAzdH3F8800ln8m_z%26e3Bip4&gsm=1&rpstart=0&rpnum=0&islist=&querylist=&force=undefined",
"E:\\java语言\\java语言(新)\\跟着哔哩哔哩学习2\\src\\线程1\\copy1.jpg");
Downloader2 a2=new Downloader2("https://image.baidu.com/search/detail?ct=503316480&z=0&ipn=d&word=%E7%99%BE%E5%BA%A6%E7%BF%BB%E8%AF%91&step_word=&hs=0&pn=2&spn=0&di=13750&pi=0&rn=1&tn=baiduimagedetail&is=0%2C0&istype=0&ie=utf-8&oe=utf-8&in=&cl=2&lm=-1&st=undefined&cs=3237142625%2C2861832411&os=2413790528%2C2948132794&simid=4136351527%2C711245784&adpicid=0&lpn=0&ln=1073&fr=&fmq=1599648675321_R&fm=&ic=undefined&s=undefined&hd=undefined&latest=undefined©right=undefined&se=&sme=&tab=0&width=undefined&height=undefined&face=undefined&ist=&jit=&cg=&bdtype=0&oriquery=&objurl=http%3A%2F%2Fimg.9553.com%2Fupload%2F2013%2F8%2F9%2F2013080950589565.jpg&fromurl=ippr_z2C%24qAzdH3FAzdH3Fooo_z%26e3Blccn_z%26e3Bv54AzdH3Ff5upAzdH3Fda998_z%26e3Bip4&gsm=1&rpstart=0&rpnum=0&islist=&querylist=&force=undefined",
"E:\\java语言\\java语言(新)\\跟着哔哩哔哩学习2\\src\\线程1\\copy2.jpg");
Downloader2 a3=new Downloader2("https://image.baidu.com/search/detail?ct=503316480&z=0&ipn=d&word=%E7%99%BE%E5%BA%A6%E7%BF%BB%E8%AF%91&step_word=&hs=0&pn=3&spn=0&di=660&pi=0&rn=1&tn=baiduimagedetail&is=0%2C0&istype=0&ie=utf-8&oe=utf-8&in=&cl=2&lm=-1&st=undefined&cs=2229338826%2C655571233&os=2935840866%2C2483743035&simid=0%2C0&adpicid=0&lpn=0&ln=1073&fr=&fmq=1599648675321_R&fm=&ic=undefined&s=undefined&hd=undefined&latest=undefined©right=undefined&se=&sme=&tab=0&width=undefined&height=undefined&face=undefined&ist=&jit=&cg=&bdtype=0&oriquery=&objurl=http%3A%2F%2Fpics3.baidu.com%2Ffeed%2Ffcfaaf51f3deb48fd2991ae8b1385f2f2cf578c5.jpeg%3Ftoken%3D40d9c94c6ed752d9fb45a45b722106d1&fromurl=ippr_z2C%24qAzdH3FAzdH3Fkwt3twiw5_z%26e3Bkwt17_z%26e3Bv54AzdH3Ff%3Ft1%3D8mm8b9cm8ll89bamnl8%26ou6%3Dfrt1j6%26u56%3Drv&gsm=1&rpstart=0&rpnum=0&islist=&querylist=&force=undefined",
"E:\\java语言\\java语言(新)\\跟着哔哩哔哩学习2\\src\\线程1\\copy3.jpg");
//启动线程
Thread aa1=new Thread(a1);
Thread aa2=new Thread(a2);
Thread aa3=new Thread(a3);
aa1.start();
aa2.start();
aa3.start();
}
}
//线程类
class Downloader2 implements Runnable
{
private String url;
private String name;
public Downloader2(String url, String name)
{
super();
this.url = url;
this.name = name;
}
//线程分时间执行此代码
public void run()
{
TextThreadtupian a=new TextThreadtupian();
a.download(url, name);
}
}
3-Runable线程资源共享
package 线程1;
//Runnable线程资源共享
public class TextRunnableqingpiao {
public static void main(String[] args) {
//一份资源
Web12306 a1=new Web12306();
//多个代理
new Thread(a1,“第一人”).start();
new Thread(a1,“第二人”).start();
new Thread(a1,“第三人”).start();
}
}
class Web12306 implements Runnable
{
private int sum=99;
@Override
public void run() {
while(true)
{
if(sum<0)
{
break;
}
System.out.println(Thread.currentThread().getName()+"==>"+sum–);
}
}
}
4.Callable线程implements
可以抛出错误
5.静态代理
package 线程1;
//静态代理
/*
- 公共接口
- 1.真实角色
- 2.代理角色
*/
public class TextJingTaiDaiLi {
public static void main(String[] args) {
new Tuo(new One()).prin();//代理角色
}
}
//接口
interface Marry
{
void prin();
}
//真实角色
class One implements Marry
{
@Override
public void prin() {
System.out.println(“真实角色”);
}
}
//代理角色
class Tuo implements Marry
{
//真实角色
private Marry a;
public Tuo(Marry a)
{
this.a=a;
}
@Override
public void prin() {
System.out.println(“代理角色”);
this.a.prin();
read();
}
private void read()
{
System.out.println(“在一个接口里调用另一个接口”);
}
}
6.简化线程lambda推导
package 线程1;
/*
-
简化线程
-
lambda简化推导
*/
public class Textlambda
{
//静态内部类,不用不用编译
static class Text implements Runnable
{
private int sum=99;
@Override
public void run()
{
while(true)
{
if(sum<0)
{
break;
}
System.out.println(Thread.currentThread().getName()+"==>"+sum–);
}
}
}
public static void main(String[] args) {
//new Thread(new Text()).start();//局部内部类 class Text2 implements Runnable { public void run() { for(int i=0;i<20;i++) { System.out.println("内部方法"+i); } } } new Thread(new Text2()).start(); //匿名内部类 //必须借助接口或者父类 new Thread(new Runnable() { @Override public void run() { for(int i=0;i<20;i++) { System.out.println("匿名内部类"+i); } } }).start(); //jdk8简化lambda //只能是一个方法 new Thread(()-> { for(int i=0;i<20;i++) { System.out.println("lambda简化"+i); } }).start();
}
}
7.线程状态
8.多线程终止
package 线程1;
/*
-
终止线程
-
1,线程正常执行完毕
-
2.外部干涉-》加入标识
*/
public class Textzhongduan implements Runnable
{
//1.加入标识 标记线程体是否可以运行
private boolean flag=true;
private String name;public Textzhongduan(String name)
{
super();
this.name = name;
}
@Override
public void run()
{
//2.关联标识,true–>运行 flase–>停止
int i=0;
while(flag)
{
System.out.println(“name”+i++);
}}
//3.对外提供方法改变标识
public void terminate()
{
this.flag=false;
}public static void main(String[] args)
{
Textzhongduan tt=new Textzhongduan(“mingzi”);
new Thread(tt).start();for(int i=0;i<20;i++) { if(i==19) { tt.terminate(); System.out.println("线程终止"); } System.out.println("主程序-->"+i); }
}
}
9.多线程暂停sleep
package 线程1;
/*
- 线程暂停
*sleep占住位置休眠 - 存在异常
- 从新进入队列
*/
public class Textsleep {
public static void main(String[] args) {
//一份资源
Web12306 a1=new Web12306();
//多个代理
new Thread(a1,“第一人”).start();
new Thread(a1,“第二人”).start();
new Thread(a1,“第三人”).start();
}
}
class Web12306 implements Runnable
{
private int sum=99;
@Override
public void run() {
while(true)
{
if(sum<0)
{
break;
}
//模拟网络延时
System.out.println(Thread.currentThread().getName()+"==>"+sum–);
try {
Thread.sleep(200);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
10.多线程礼让yiele
package 线程1;
/*
-
运行进入就绪状态,不是堵塞状态
-
线程暂停,让出线程
*/
public class Textyield {
public static void main(String[] args) {
My my=new My();
new Thread(my,“a”).start();
new Thread(my,“b”).start();new Thread(()->{ for(int i=0;i<30;i++) { System.out.println("内部。。。"); } }).start(); for(int i=0;i<40;i++) { if(i%20==0) { Thread.yield();//主函数礼让 } System.out.println("主函数。。。"); }
}
}
class My implements Runnable
{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+“第一个命令”);
Thread.yield();//让出线程
System.out.println(Thread.currentThread().getName()+“第二个命令”);
}
}
11.多线程插队join
package 线程1;
/*
-
join
-
合并线程
-
插队线程
-
此线程完成后再执行其他线程,阻塞其他线程
/
public class Textjoin {
public static void main(String[] args) throws InterruptedException {
Thread t=new Thread(()->{
for(int i=0;i<30;i++)
{
System.out.println(“内部”+i);
}
});
t.start();
for(int i=0;i<40;i++)
{
if(i==20)
{
t.join();//内部插队,主函数被阻塞
}
System.out.println(“主函数”+i);
}
}
}
12.多线程优先级priority
package 线程1;
/ -
线程优先级1-10
-
默认是5
-
概率,不代表绝对的先后顺序
*/
public class Textpriority {
public static void main(String[] args) {
System.out.println(Thread.currentThread().getPriority());
Ma ma=new Ma();
Thread t1=new Thread(ma);
Thread t2=new Thread(ma);
Thread t3=new Thread(ma);
Thread t4=new Thread(ma);
//设置优先级
t1.setPriority(3);
t2.setPriority(5);
t3.setPriority(8);
t4.setPriority(10);t1.start(); t2.start(); t3.start(); t4.start();
}
}
class Ma implements Runnable
{
@Override
public void run() {
System.out.println(Thread.currentThread().getPriority());
}
}
13.守护线程
package 线程1;
/*
- 守护线程:为用户服务,不会等待守护线程执行完毕
- 默认都是用户线程,等待所有用户线程执行完毕才停
- 线程常用方法
*/
public class TextShouHuXianCheng {
public static void main(String[] args) {
You you=new You();
T t2=new T();
Thread t=new Thread(you);
t.setDaemon(true);//设置为守护线程
t.setName(“线程名字”);
t.start();
new Thread(t2).start();
}
}
class You implements Runnable
{
@Override
public void run() {
for(int i=0;i<20;i++)
{
System.out.println(“线程”);
System.out.println(Thread.currentThread().getName());//获取线程名字
}
}
}
class T implements Runnable
{
@Override
public void run() {
System.out.println(“守护”);
System.out.println(Thread.currentThread().isAlive());//判断是否活着
}
}
14.多线程同步(解决并发)synchronized
package 线程2;
import 线程1.Textzhongduan;
/*
-
线程同步(解决并发)
-
多人使用就会排队(队列)
-
对象的锁,表示资源被占用,别人不能用synchronized
*/
public class TextTongbu implements Runnable
{
//1.加入标识 标记线程体是否可以运行
private boolean flag=true;
private String name;public TextTongbu(String name)
{
super();
this.name = name;
}
@Override
public void run()
{
//2.关联标识,true–>运行 flase–>停止
int i=0;
while(flag)
{
System.out.println(“name”+i++);
}}
//3.对外提供方法改变标识
public synchronized void terminate()
{
this.flag=false;
}public static void main(String[] args)
{
Textzhongduan tt=new Textzhongduan(“mingzi”);
new Thread(tt).start();synchronized (tt) { try { System.out.println("在这里锁住tt3000ms"); //锁住时的操作(有用的就进不去) Thread.sleep(3000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } for(int i=0;i<20;i++) { if(i==19) { tt.terminate(); System.out.println("线程终止"); } System.out.println("主程序-->"+i); }
}
}
15.锁的应用
package 线程2;
/*
- 锁的使用synchronized
*/
public class TextSuo02 {
public static void main(String[] args) {
Cinema cinema=new Cinema(3, “开心影院”);
new Thread(new GuKe(cinema, 4),“顾客1”).start();
new Thread(new GuKe(cinema, 4),“顾客2”).start();
}
}
//顾客
class GuKe implements Runnable
{
Cinema cinema;
int weizhi;
public GuKe(Cinema cinema, int weizhi) {
super();
this.cinema = cinema;
this.weizhi = weizhi;
}
@Override
public void run() {
synchronized (cinema)//锁住影院
{
boolean flag=cinema.book(weizhi);
if(flag)
{
System.out.println("出票成功"+Thread.currentThread().getName()+"位置为:"+weizhi);
}
else
{
System.out.println("出票失败"+Thread.currentThread().getName()+"位置不够");
}
}
}
}
//影院
class Cinema
{
int weizhi;//可用的位置
String nameString;//名称
public Cinema(int weizhi, String nameString) {
super();
this.weizhi = weizhi;
this.nameString = nameString;
}
//购票
public boolean book(int seats)
{
System.out.println("可用位置为:"+weizhi);
if(seats>weizhi)
{
return false;
}
weizhi-=seats;
return true;
}
}
16.死锁
两个锁,互相等待,互相锁
不要再一个代码块里拥有两个锁
17.线程协作,生产者消费者模式
①管程法:
生产者:产生数据
消费者:处理数据
缓冲区:暂存数据
package 线程2;
/*
- 生产者消费者模式
- ①管程法
- 缓冲区容器:
- 不够等待,够取
- 缓冲池
*/
public class TextGuanChengfa
{
public static void main(String[] args) {
HuanChong huanChong=new HuanChong();
new ShengChan(huanChong).start();
new XiaoFei(huanChong).start();
}
}
//生产者
class ShengChan extends Thread
{
HuanChong shengcanhuanchong;
public ShengChan(HuanChong shengcanhuanchong) {
super();
this.shengcanhuanchong = shengcanhuanchong;
}
@Override
public void run() {
//生产
for(int i=0;i<50;i++)
{
System.out.println("生产第"+i+"个商品");
shengcanhuanchong.push(new ShangPin(i));
}
}
}
//消费者
class XiaoFei extends Thread
{
HuanChong xiaofeohuanchong;
public XiaoFei(HuanChong xiaofeohuanchong) {
super();
this.xiaofeohuanchong = xiaofeohuanchong;
}
@Override
public void run() {
//消费
for(int i=0;i<50;i++)
{
System.out.println("消费第"+xiaofeohuanchong.pop().id+"个商品");
}
}
}
//缓冲区
class HuanChong
{
ShangPin shangPin[]=new ShangPin[10];
int count=0;//计数器
//存储 生产
public synchronized void push(ShangPin shang)
{
//容器有空间就生产
if(countshangPin.length)
{
try {
this.wait();//消费者通知生产就解除
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
shangPin[count]=shang;
count++;
//存在数据,可以进行消费
this.notifyAll();
}
//获取 消费
public synchronized ShangPin pop()
{
//容器中有数据可以消费,没有就等
if(count0)
{
try {
this.wait();//线程堵塞 生产通知消费解除
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//存在数据可以消费
count--;
ShangPin shangpin2=shangPin[count];
this.notifyAll();//存在空间可以唤醒对方
return shangpin2;
}
}
//商品
class ShangPin
{
int id;
public ShangPin(int id) {
super();
this.id = id;
}
}
②信号灯法:
等待和唤醒
package 线程2;
/*
*
- 协作模型,信号灯法
*/
public class TextXinhaodengfa {
public static void main(String[] args) {
Tv tv=new Tv();
new Player(tv).start();
new Watcher(tv).start();
}
}
//生产者 演员
class Player extends Thread
{
Tv tv;
public Player(Tv tv) {
super();
this.tv = tv;
}
@Override
public void run() {
for(int i=0;i<20;i++)
{
if(i%2==0)
{
this.tv.play("奇葩说");
}
else
{
this.tv.play("广告");
}
}
}
}
//消费者 群众
class Watcher extends Thread
{
Tv tv;
public Watcher(Tv tv) {
super();
this.tv = tv;
}
@Override
public void run() {
for(int i=0;i<20;i++)
{
tv.watch();
}
}
}
//同一个资源 电视
class Tv
{
String voice;
//信号灯
//真观众等
//假演员等
boolean flag=true;
//表演
public synchronized void play(String voice)
{
//演员等待
if(!flag)
{
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//表演
System.out.println(“表演了”+voice);
this.voice=voice;
//唤醒
this.notifyAll();
this.flag=!this.flag;
}
//观看
public synchronized void watch()
{
//观众等待
if(flag)
{
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//观看
System.out.println(“听到了”+voice);
//唤醒
this.notifyAll();
//切换标志
this.flag=!this.flag;
}
}
18.任务定时调度
package 线程2;
import java.util.Timer;
import java.util.TimerTask;
/*
- 任务定时调度
- 借助Timer TimerTask
- quartz定时调动框架
*/
public class TextTimer {
public static void main(String[] args) {
Timer timer=new Timer();
//执行安排
timer.schedule(new MyTask(), 100,200);//指定运行,指定运行时间执行任务
}
}
//任务类
class MyTask extends TimerTask
{
@Override
public void run() {
for(int i=0;i<40;i++)
{
System.out.println(“运行1”);
}
System.out.println(“结束”);
}
}