java语言笔记io

最新推荐文章于 2022-10-23 13:29:59 发布

wangshuo（24考研上岸版）

最新推荐文章于 2022-10-23 13:29:59 发布

阅读量319

点赞数

分类专栏：网络文章标签： java

本文链接：https://blog.csdn.net/wangshuo2020/article/details/109561892

版权

网络专栏收录该内容

2 篇文章 0 订阅

订阅专栏

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;

//数据流
//写出后读取，字节流
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&copyright=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&copyright=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&copyright=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(“结束”);
}
}

wangshuo（24考研上岸版）

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java语言笔记io

java语言笔记（进阶篇）01-IO1.基本类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
复制链接

扫一扫

专栏目录