java语言笔记io

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 blocke.printStackTrace();}}catch (FileNotFoundException e){// TODO Auto-generated catch blocke.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 blocke.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 blocke.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 blocke.printStackTrace();}/*finally{if(is!=null){try {is.close();} catch (IOException e) {// TODO Auto-generated catch blocke.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 blocke.printStackTrace();}/*finally{if(is!=null){try {is.close();} catch (IOException e) {// TODO Auto-generated catch blocke.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 blocke.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 blocke.printStackTrace();}finally{if(os!=null){//4、释放资源try {os.close();} catch (IOException e) {// TODO Auto-generated catch blocke.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 blocke.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 blocke.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 blocke.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 blocke.printStackTrace();}catch (Exception e){// TODO Auto-generated catch blocke.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 blocke.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 blocke.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 blocke.printStackTrace();}finally{if(is!=null||os!=null){try {is.close();os.close();} catch (IOException e) {// TODO Auto-generated catch blocke.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 blocke.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 blocke.printStackTrace();}
}private static OutputStream FileOutputStream(String string, String string2) {// TODO Auto-generated method stubreturn 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 blocke.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() {@Overridepublic 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 blocke.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(“结束”);
}
}

java语言笔记io相关推荐

Java学习笔记-IO
IO IO流概述可以将数据传输操作,看作一种数据的流动,按照流动的方向分为输入(Input)和输出(Output) java中的IO操作主要指的是java.io包下的一些常用类的使用,通过这些常用类 ...
JAVA学习笔记—IO流
I/O 框架流的概念内存与存储设备之间传输数据的通道水(相当于数据)-> 传输水的管道(相当于流)-> 脸盆(相当于内存) 生活用水 -> 流入家庭废水 -> 流出流 ...
【java学习笔记-io流文件读写和键盘读写】带缓存的输入／输出流和数据输入／输出流
文章目录字节流类带缓存的输入/输出流 BufferedReader与BufferedWriter类下面的例子程序演示了read()方法,从控制台读取字符直到用户键入"q": ...
Java学习笔记---IO操作
一.文件的创建 ------------------------------------------------------- File类,表示磁盘上的文件或目录,可对文件或目录进行操作. * ...
java学习笔记IO之字节输入输出流
IO字节输入输出流 OutputStream:字节输出流该抽象类是所有字节输出流的超类: 定义了一些共性的成员方法: 1.写入一个字节 void write(int b);//b表示字节 2.写入字 ...
小陈java学习笔记IO
文件拷贝重点: 1.文件在读取的时候,就写到输出流的对象里,达到一边读一边写的效果 2.使用write()的时候,一定要规范使用方法,否则可能会输出无效节点流和处理流 1.节点流可以从一个特定的数 ...
java字符流输出流_JAVA语言之IO流字符串输入输出流
本文主要向大家介绍了JAVA语言之IO流字符串输入输出流,通过具体的内容向大家展示,希望对大家学习JAVA语言有所帮助. 概述 StringReader 字符输入流和CharArrayReader类 ...
Java语言基础（IO流2（字节流、字符流））
Java语言基础 IO流字节流可以读写任何类型的文件,比如:音频.视频 .文本文件字节流的抽象基类: 字节输入流:InputStream 字节输出流:OutputStream 我们发现Input ...
笔记整理2----Java语言基础（二）06 断点调试与数据加密+07 面向对象-类与对象+08 java常用API-基础+09 java集合+10 IO流-基础
06 断点调试与数据加密+07 面向对象-类与对象+08 java常用API-基础+09 java集合+10 IO流-基础第06天 java基础语法今日内容介绍  Eclipse断点调试  基 ...

java语言笔记io

java语言笔记io相关推荐

最新文章

热门文章