滴水穿石-08IO
1.0 File
a:构造方法
package d8; import java.io.File; public class FileGouZao {
public static void main(String[] args) {
//方式一:根据一个路径得到一个一个file对象
//File(String pathName)
File fe = new File("D:\\aaa\\a.txt"); //方式二,通过父路径的名字 + 子文件/目录得到一个File对象
//File(String parent,String child)
File fe2 = new File("D:\\aaa","a.txt"); //方式三,通过父File对象 + 子文件/目录得到一个File对象
//File(File parent,String child)
File fe3 = new File("D:\\aaa");
File fe4 = new File(fe3,"D:\\aaa");
}
}
1.0
b:创建方法
package d8; import java.io.File;
import java.io.IOException; public class FileGouAdd {
public static void main(String[] args) throws IOException {
//方式一:创建文件
//boolean createNewFile()
File fe = new File("D:\\aaa\\a.txt");
fe.createNewFile();
//方式二,创建文件夹
//boolean mkdir()
File fe2 = new File("D:\\aaa","aa");
fe2.mkdir();
//方式三, 创建文件夹们,如果父文件夹不存在就创建
//boolean mkdirs()
File fe3 = new File("D:\\aaa");
File fe4 = new File(fe3,"aa\\a");
fe4.mkdirs();
//注意如果没有写盘符,默认为项目路径
File fe5 = new File("a.txt");
fe5.createNewFile(); //如果用方式一创建时,如果父目录不存在,会出现"系统找不到指定的路径"的错误
//如果用方式二创建时,如果父目录不存在,返回false
//如果用方式三创建时,如果父目录不存在,就创建上级目录
}
}
1.0
c:删除方法
package d8; import java.io.File;
import java.io.IOException; public class FileDelete {
public static void main(String[] args) throws IOException {
//方式一:创建文件
//boolean createNewFile()
File fe = new File("D:\\aaa\\a.txt");
fe.createNewFile();
fe.delete(); File fe2 = new File("D:\\aaa");
System.out.println(fe2.delete());
//--------false---------// //注意:删除不走回收站
//如果是删除目录,则该目录必须为空才能删除 }
}
1.0
package d8; import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date; public class Filedelete2 {
public static void main(String[] args) throws IOException {
//获取F盘所有的.exe文件 File fe = new File("D:\\aaa");
deleteAllFile(fe);
/* */
}
public static void deleteAllFile(File fe) {
if( fe.isFile()|| fe==null ) {
System.out.println(fe.getPath());
fe.delete(); }else if(fe.isDirectory()&& fe.list().length<){
System.out.println(fe.getPath());
fe.delete();
}else {
File [] files = fe.listFiles();
if (files!=null) {
for (File file : files) {
deleteAllFile(file);
}
deleteAllFile(fe);
} } }
}
/*D:\aaa\a.txt
D:\aaa\aa\a
D:\aaa\aa
D:\aaa\b.txt
D:\aaa\d.txt
D:\aaa*/
2.0级联删除
d:修改方法
package d8; import java.io.File;
import java.io.IOException; public class FileRenameTo {
public static void main(String[] args) throws IOException {
//方式一:路径相同重命名
File fe = new File("D:\\aaa\\a.txt");
fe.createNewFile();
File f2 = new File("D:\\aaa\\b.txt");
fe.renameTo(f2); //方式二:路径不同,相当于剪切功能
File fe3 = new File("a.txt");//默认路径,也就是项目路径
fe3.createNewFile();
File f4 = new File("D:\\aaa\\d.txt");
fe3.renameTo(f4); //方式一:路径相同重命名
//方式二:路径不同,相当于剪切功能 }
}
1.0
e:判断功能
package d8; import java.io.File;
import java.io.IOException; public class FileJudge {
public static void main(String[] args) throws IOException { File fe = new File("D:\\aaa\\a.txt"); boolean existsB = fe.exists();// 判断文件是否是存在
boolean isFileB = fe.isFile();// 判断文件是否是一个标准文件
boolean isDirectoryB = fe.isDirectory();// 判断文件是否是一个目录
boolean isHiddenB = fe.isHidden();// 判断文件是否是隐藏
boolean canReadB = fe.canRead();// 判断文件是否可读
boolean canWriteB = fe.canWrite();// 判断文件是否是可写 System.out.println(existsB); //---true---/
System.out.println(isFileB); //---true---/
System.out.println(isDirectoryB); //---false---/
System.out.println(isHiddenB); //---false---/
System.out.println(canReadB); //---true---/
System.out.println(canWriteB); //---true---/ }
}
1.0
f:获取功能
package d8; import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date; public class FileGet {
public static void main(String[] args) throws IOException { File fe = new File("D:\\aaa\\a.txt"); String strAbsolutePath = fe.getAbsolutePath();// 获取文件绝对路径
String strPath = fe.getPath();// 获取文件路径
String strName = fe.getName();// 获取文件名
Long length = fe.length();// 获取文件大小
Long strLastModified = fe.lastModified();// 获取文件最后的修改时间
Date d = new Date(strLastModified);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String s = sdf.format(d);
System.out.println(strAbsolutePath); // ---D:\aaa\a.txt----/
System.out.println(strPath); // ---D:\aaa\a.txt----/
System.out.println(strName); // ---a.txt-----/
System.out.println(length); // ---12-----/
System.out.println(strLastModified); // ---1517184516189---/
System.out.println(s); // ---2018-01-29 20:10:41----/ }
}
1.0
package d8; import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date; public class FileGet2 {
public static void main(String[] args) throws IOException { File fe = new File("D:\\"); String [] nameArray = fe.list();
for (String s : nameArray) {
System.out.println(s);
} File [] fileArray = fe.listFiles();
for (File f : fileArray) {
System.out.println(f.getName());
} /*
$RECYCLE.BIN
00002109030000000000000000F01FEC.reg
aaa
API文档
BaiduNetdiskDownload
Config.Msi
Develop
java(1)
JavaWorkspace
LuceneNet测试文件
midnds
MyDrivers
pagefile.sys
Program Files
Program Files (x86)
StormMedia
System Volume Information
Unity3D5.0
Users
博客资料
迅雷下载
黑马JavaEE32*/
}
}
2.0
package d8; import java.io.File;
import java.io.FileFilter;
import java.io.FilenameFilter;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date; public class FileTest {
public static void main(String[] args) throws IOException {
//找出D盘下所有以.reg结尾的文件
File fe = new File("D:\\"); //方法一:取出所有文件然后筛选
File [] files = fe.listFiles();
for (File f : files) {
if (f.isFile()&&f.getName().endsWith(".reg")) {
System.out.println(f.getName());
}
}
//-----------00002109030000000000000000F01FEC.reg----------// //方法二: 通过过滤器先过滤一下 listFiles(FileFilter filter)
File [] files2 = fe.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
// TODO Auto-generated method stub
return pathname.isFile()&&pathname.getName().endsWith(".reg");
}
});
for (File f : files2) {
System.out.println(f.getName());
}
//-----------00002109030000000000000000F01FEC.reg----------// //方法三:方法二可能消耗的资源有点大 list(FilenameFilter filter)
String [] files3 = fe.list(new FilenameFilter() { @Override
public boolean accept(File dir, String name) {
if (name.endsWith(".reg")) {
File fnew = new File(dir, name);
return fnew.isFile();
}
return false;
}
});
for (String f : files3) {
System.out.println(f);
}
//-----------00002109030000000000000000F01FEC.reg----------//
}
}
3.0
递归获取4.0
2.0 IO
2.1 InputStream
2.1.1 FileInputStream
a:构造方法
package d8; import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException; public class FileInputStreamGouZao {
public static void main(String[] args) throws FileNotFoundException { // 方式一:根据一个路径得到一个读取数据的写入文件流对象
// FileOutputStream(String name)
FileInputStream fos = new FileInputStream("D:\\aaa\\a.txt"); // 方式二,通过File对象 得到一个读取数据的写入文件流对象
// FileOutputStream(File file)
File fe = new File("D:\\aaa", "a.txt");
FileInputStream fos2 = new FileInputStream(fe); }
}
1.0
b:读取方法
package d8; import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException; public class FileInputStreamRead {
public static void main(String[] args) throws IOException { // 方式一:
// read() 从此输入流中读取一个数据字节。 FileInputStream fis = new FileInputStream("D:\\aaa\\a.txt");
int b = ;
while((b=fis.read())!=-) {
System.out.println((char)b);
}
fis.close(); // 方式二
//read(byte[] b) 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
FileInputStream fis2 = new FileInputStream("D:\\aaa\\a.txt");
byte[] bs = new byte[];
while(( fis2.read(bs))!=-) {
System.out.println(new String(bs));
}
fis2.close(); // read(byte[] b, int off, int len)
// 从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
FileInputStream fis3 = new FileInputStream("D:\\aaa\\a.txt");
byte[] bs2 = new byte[];
int len = ;
while(( len = fis3.read(bs2))!=-) {
System.out.println(new String(bs2,,len));
}
fis3.close();
}
}
/* 方式一
H
e
l
l
o W
o
r
l
d j
a
v
a */ /* 方式二 Hello Wor
ld java va
*/
/* 方式三
Hello Wor
ld java
*/
1.0
2.1.2 BufferedInputStream
a:构造方法
package d8; import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException; public class BufferedInputStreamGouZao {
public static void main(String[] args) throws IOException { // 方式一:根据一个路径得到一个写入数据的输出文件流对象
//BufferedInputStream(InputStream out)
BufferedInputStream fis = new BufferedInputStream(new FileInputStream("D:\\aaa\\a.txt")); // 方式二,通过Buffered对象 得到一个写入数据的输出文件流对象
// BufferedInputStream(InputStream out, int size)
BufferedInputStream fis2 = new BufferedInputStream(new FileInputStream("D:\\aaa\\a.txt"),); }
}
1.0
b:读取方法
package d8; import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class BufferedInputStreamReade{
public static void main(String[] args) throws IOException { // 方式一
// read(int b) 将指定字节写入此文件输出流。
BufferedInputStream fis = new BufferedInputStream(new FileInputStream("D:\\aaa\\a.txt"));
int b =;
while ((b=fis.read())!=-) {
System.out.println(b);
}
/*
97
32
119
111*/ // read(byte[] b, int off, int len)
// 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
BufferedInputStream fis2 = new BufferedInputStream(new FileInputStream("D:\\aaa\\a.txt"), );
byte [] by = new byte[];
int len =;
while ((len = fis2.read(by,,))!=-) {
System.out.println(new String(by,,len));
} //------------a -----------//
//------------wo-----------//
}
}
1.0
2.2 OutPutStream
2.2.1 FileOutputStream
a:构造方法
package d8; import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream; public class FileOutputStreamGouZao {
public static void main(String[] args) throws FileNotFoundException { //创建字节输出流对象做了3件事情
//01 调用系统功能创建文件
//02 创建fos对象
//03 将字节输出流对象指向对应的文件 // 方式一:根据一个路径得到一个写入数据的输出文件流对象
// FileOutputStream(String name)
FileOutputStream fos = new FileOutputStream("D:\\aaa\\a.txt"); // 方式二,通过File对象 得到一个写入数据的输出文件流对象
// FileOutputStream(File file)
File fe = new File("D:\\aaa", "a.txt");
FileOutputStream fos2 = new FileOutputStream(fe); // 方式三:根据一个路径得到一个写入数据的输出文件流对象,如为 true,则将字节写入文件末尾处
// FileOutputStream(String name,boolean append)
FileOutputStream fos3 = new FileOutputStream("D:\\aaa\\a.txt", true); // 方式四,通过File对象 得到一个写入数据的输出文件流对象,如为 true,则将字节写入文件末尾处
// FileOutputStream((File file,boolean append)
File fe2 = new File("D:\\aaa", "a.txt");
FileOutputStream fos4 = new FileOutputStream(fe2, true);
}
}
1.0
b:写入方法
package d8; import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException; public class FileOutputStreamWrite {
public static void main(String[] args) throws IOException { // 创建字节输出流对象做了3件事情
// 01 调用系统功能创建文件
// 02 创建fos对象
// 03 将字节输出流对象指向对应的文件 // close()方法的作用
// 1:让流对象变成垃圾,方便被垃圾回收站回收
// 2:通知系统去释放掉该文件相关的资源 // 方式一:
// write(byte[] b) 根据一个路径将指定 byte 数组写入此文件输出流中 FileOutputStream fos = new FileOutputStream("D:\\aaa\\a.txt");
fos.write("Hello World !".getBytes());
fos.close();
// -------Hello World !---------// // 方式二
// write(int b) 将指定字节写入此文件输出流。
FileOutputStream fos2 = new FileOutputStream("D:\\aaa\\b.txt");
fos2.write();
fos2.close();
// -------a---------// // write(byte[] b, int off, int len)
// 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
FileOutputStream fos3 = new FileOutputStream("D:\\aaa\\c.txt");
fos3.write("Hello World !".getBytes(), , );
fos3.close();
// -------Hello---------//
}
}
1.0
package d8; import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException; public class FileOutputStreamWrite2 {
public static void main(String[] args) throws IOException { // 创建字节输出流对象做了3件事情
// 01 调用系统功能创建文件
// 02 创建fos对象
// 03 将字节输出流对象指向对应的文件 // 方式一:
// write(byte[] b) 根据一个路径将指定 byte 数组写入此文件输出流中 FileOutputStream fos = new FileOutputStream("D:\\aaa\\a.txt",true);
fos.write('\r');
fos.write('\n');
fos.write("Hello World !".getBytes());
fos.close();
//-------Hello World !---------//
//--------Hello World ! ---------//
// 方式二
// write(int b) 将指定字节写入此文件输出流。
File fe2 = new File("D:\\aaa", "b.txt");
FileOutputStream fos2 = new FileOutputStream(fe2, true); fos2.write();
fos2.close();
//-------aa---------// }
}
2.0
2.2.2 BufferedOutputStream
a:构造方法
package d8; import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException; public class BufferedOutputStreamGouZao {
public static void main(String[] args) throws IOException { // 方式一:根据一个路径得到一个写入数据的输出文件流对象
//BufferedOutputStream(OutputStream out)
BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream("D:\\aaa\\a.txt")); // 方式二,通过Buffered对象 得到一个写入数据的输出文件流对象
// BufferedOutputStream(OutputStream out, int size)
BufferedOutputStream fos2 = new BufferedOutputStream(new FileOutputStream("D:\\aaa\\a.txt"),); }
}
1.0
b:写入方法
package d8; import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException; public class BufferedOutputStreamWrite {
public static void main(String[] args) throws IOException { // 方式一
// write(int b) 将指定字节写入此文件输出流。
BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream("D:\\aaa\\a.txt"));
fos.write();
fos.close();
// -------a---------// // write(byte[] b, int off, int len)
// 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
BufferedOutputStream fos2 = new BufferedOutputStream(new FileOutputStream("D:\\aaa\\a.txt",true), );
fos2.write("hello world java".getBytes(), , );
fos2.close();
//------------a wo-----------//
}
}
1.0
练习:4钟操作的复制文件
package d8; import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream; public class CopyTest {
public static void main(String[] args) throws IOException {
Long start = System.currentTimeMillis();
method1();
Long end = System.currentTimeMillis();
System.out.println("方法一:耗时"+(end-start));
Long start2 = System.currentTimeMillis();
method2();
Long end2 = System.currentTimeMillis();
System.out.println("方法二:耗时"+(end2-start2)); Long start3 = System.currentTimeMillis();
method3();
Long end3 = System.currentTimeMillis();
System.out.println("方法三:耗时"+(end3-start3)); Long start4 = System.currentTimeMillis();
method4();
Long end4 = System.currentTimeMillis();
System.out.println("方法四:耗时"+(end4-start4));
} private static void method4() throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\aaa\\a.avi"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\aaa\\a4.avi"));
byte [] by = new byte[];
int len =;
while ((len=bis.read(by))!=-) {
bos.write(by,,len);
bos.flush();
}
bis.close();
bos.close();
}
//高效字节流,一次读写一个字节
private static void method3() throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\aaa\\a.avi"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\aaa\\a3.avi"));
int b =;
while ((b=bis.read())!=-) {
bos.write(b);
}
bis.close();
bos.close();
}
//基本字节流,一次读写一个数组长度
private static void method2() throws IOException {
FileInputStream fi2 = new FileInputStream("D:\\aaa\\a.avi");
FileOutputStream fo2 = new FileOutputStream("D:\\aaa\\a2.avi");
byte [] by = new byte[];
int len =;
while ((len=fi2.read(by))!=-) {
fo2.write(by,,len);
}
fi2.close();
fo2.close();
} //基本字节流,一次读写一个字节
private static void method1() throws IOException {
FileInputStream fi = new FileInputStream("D:\\aaa\\a.avi");
FileOutputStream fo = new FileOutputStream("D:\\aaa\\a1.avi");
int b =;
while ((b=fi.read())!=-) {
fo.write(b);
}
fi.close();
fo.close();
}
}
/*
方法一:耗时243369
方法二:耗时302
方法三:耗时416
方法四:耗时270
*/
1.0
字符流 = 字节流+编码表
3.1 Reader
3.1.1 InputStreamReader
a:构造方法
package d8; import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException; public class InputStreamReaderGouZao {
public static void main(String[] args) throws FileNotFoundException, IOException { // 字符输入流:字节输入流+编码 // 方式一:根据一个字节输入流 + 默认编码 得到一个字符输入对象
// InputStreamReader(InputStream In)
InputStreamReader isw = new InputStreamReader(new FileInputStream("D:\\aaa\\a.txt")); // 方式二:根据一个字节输入流 + 指定编码 得到一个字符输入对象
// InputStreamReader(InputStream In, String charsetName)
InputStreamReader isw2 = new InputStreamReader(new FileInputStream("D:\\aaa\\a.txt"), "utf-8"); }
}
1.0
b:read方法
package d8; import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException; public class InputStreamReaderRead {
public static void main(String[] args) throws FileNotFoundException, IOException { // 字符输入流:字节输入流+编码 // 方式一:根据一个字节输入流 + 默认编码 得到一个字符输入对象
// InputStreamReader(InputStream In)
InputStreamReader osw = new InputStreamReader(new FileInputStream("D:\\aaa\\b.txt")); int b = ;
while ((b=osw.read())!=-) {
System.out.print((char)b);
}
// 方式二:根据一个字节输入流 + 指定编码 得到一个字符输入对象
// InputStreamReader(InputStream In, String charsetName)
InputStreamReader osw2 = new InputStreamReader(new FileInputStream("D:\\aaa\\b.txt"), "utf-8");
char [] by =new char[];
int len=;
while ((len=osw2.read(by, , ))!=-) {
System.out.println(new String(by,,len));
}
}
}
/*浣犲ソ涓栫晫你好世
界*/
1.0
3.1.2 FileReader
a:构造方法
package d8; import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.FileReader;
import java.io.UnsupportedEncodingException; public class FileReaderGouZao {
public static void main(String[] args) throws FileNotFoundException, IOException { // 方式一:根据一个字节输入流 + 默认编码 得到一个字符输入对象
// FileReader(File file)
FileReader isw = new FileReader("D:\\aaa\\a.txt"); // 方式二:在给定从中读取数据的文件名的情况下创建一个新 FileReader。
// FileReader( String fileName)
FileReader isw2 = new FileReader(new File("D:\\aaa\\a.txt")); }
}
1.0
b:read方法
package d8; import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException; public class FileReaderRead {
public static void main(String[] args) throws FileNotFoundException, IOException { // 方式一:根据一个字节输入流 + 默认编码 得到一个字符输入对象
// FileReader(File file)
FileReader fr = new FileReader("D:\\aaa\\a.txt");
int b = ;
while ((b = fr.read()) != -) {
System.out.print((char) b);
} // 方式二:在给定从中读取数据的文件名的情况下创建一个新 FileReader。
// FileReader( String fileName)
FileReader fr2 = new FileReader(new File("D:\\aaa\\a.txt"));
char[] by = new char[];
int len = ;
while ((len = fr2.read(by, , )) != -) {
System.out.println(new String(by, , len));
}
}
}
/*
* aaabcdefaaa
bcd
ef
*/
1.0
3.1.3 BufferedReader
a:构造方法
package d8; import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException; public class BufferedReaderGouZao {
public static void main(String[] args) throws IOException { // 方式一:根据一个字节输入流 + 默认编码 得到一个字符输入对象
// BufferedReader(Reader in)
BufferedReader br = new BufferedReader(new FileReader("D:\\aaa\\a.txt")); // 方式二:BufferedReader(Reader in, int sz)
// 创建一个使用指定大小输入缓冲区的缓冲字符输入流。
BufferedReader br2 = new BufferedReader(new FileReader("D:\\aaa\\a.txt"),); }
}
1.0
b:read方法
package d8; import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException; public class BufferedReaderRead {
public static void main(String[] args) throws FileNotFoundException, IOException { // 方式一:BufferedReader(Reader in)
// 创建一个使用指定大小输入缓冲区的缓冲字符输入流。
BufferedReader br = new BufferedReader(new FileReader("D:\\aaa\\a.txt"));
int b = ;
while ((b = br.read()) != -) {
System.out.print((char) b);
} // 方式二:BufferedReader(Reader in, int sz)
// 创建一个使用指定大小输入缓冲区的缓冲字符输入流。
BufferedReader br2 = new BufferedReader(new FileReader("D:\\aaa\\a.txt"), );
char[] by = new char[];
int len = ;
while ((len = br2.read(by, , )) != -) {
System.out.println(new String(by, , len));
}
}
}
/*
* aaaa
*/
1.0
2.0 写入一个文本行
3.2 Writer
3.2.1 OutputStreamWriter
a:构造方法
package d8; import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException; public class OutputStreamWriterGouZao {
public static void main(String[] args) throws FileNotFoundException, IOException { // 字符输出流:字节输出流+编码 // 方式一:根据一个字节输出流 + 默认编码 得到一个字符输出对象
// OutputStreamWriter(OutputStream out)
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:\\aaa\\a.txt")); // 方式二:根据一个字节输出流 + 指定编码 得到一个字符输出对象
// OutputStreamWriter(OutputStream out, String charsetName)
OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream("D:\\aaa\\a.txt"), "utf-8"); }
}
1.0
b: Write方法
package d8; import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException; public class OutputStreamWriterWrite {
public static void main(String[] args) throws FileNotFoundException, IOException { // 方式一: 写入单个字符 write(int c)
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:\\aaa\\a.txt"));
osw.write();
osw.write('a');
osw.close(); // 方式二:写入字符数组。 write(char[] cbuf)
OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream("D:\\aaa\\b.txt"), "utf-8");
char[] che = { 'a', 'b', 'c', 'd', 'e', 'f' };
osw2.write(che);
osw2.flush();
osw2.close(); // 方式三:写入字符数组的某一部分。 write(char[] cbuf, int off, int len)
OutputStreamWriter osw3 = new OutputStreamWriter(new FileOutputStream("D:\\aaa\\c.txt"));
char[] che2 = { 'a', 'b', 'c', 'd', 'e', 'f' };
osw3.write(che2, , );
osw3.write("Hello world".toCharArray()); osw3.close(); // 方式四: 写入字符串 。 write(String str)
OutputStreamWriter osw4 = new OutputStreamWriter(new FileOutputStream("D:\\aaa\\d.txt"), "utf-8");
String str = "Hello World Java";
osw4.write(str);
osw4.flush();
osw4.close(); // 方式五: 写入字符串的某一部分。 write(String str, int off, int len)
OutputStreamWriter osw5 = new OutputStreamWriter(new FileOutputStream("D:\\aaa\\e.txt"), "utf-8");
String str2 = "Hello World Java";
osw5.write(str2,,);
osw5.flush();
osw5.close();
}
} /*
* aa
* abcdef
* cdeHello world
* Hello World Java
* lo W
*/
1.0
3.2.2 FileWriter
a:构造方法
package d8; import java.io.File;
import java.io.FileNotFoundException; import java.io.IOException;
import java.io.FileWriter;
import java.io.UnsupportedEncodingException; public class FileWriterGouZao {
public static void main(String[] args) throws FileNotFoundException, IOException { // 方式一: 根据给定的文件名值来构造 FileWriter 对象
// FileWriter(String fileName)
FileWriter fw = new FileWriter("D:\\aaa\\a.txt"); // 方式二: 根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象
// FileWriter(String fileName, boolean append)
FileWriter fw2 = new FileWriter(("D:\\aaa\\a.txt"),true); // 方式三: 根据给定的文件名值来构造 FileWriter 对象
// FileWriter(File file)
FileWriter fw3 = new FileWriter(new File("D:\\aaa\\a.txt") ); // 方式四: 根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象
//FileWriter(File file, boolean append)
FileWriter fw4 = new FileWriter(new File("D:\\aaa","a.txt"),true); }
}
1.0
b: Write方法
package d8; import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException; public class FileWriterWrite {
public static void main(String[] args) throws FileNotFoundException, IOException { // 方式一: 根据给定的文件名值来构造 FileWriter 对象
// FileWriter(String fileName)
FileWriter fw = new FileWriter("D:\\aaa\\a.txt");
// 方式一: 写入单个字符 write(int c)
fw.write();
fw.write('a');
fw.close(); // 方式二: 根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象
// FileWriter(String fileName, boolean append)
FileWriter fw2 = new FileWriter(("D:\\aaa\\a.txt"), true);
// 方式二:写入字符数组。 write(char[] cbuf)
char[] che = { 'a', 'b', 'c', 'd', 'e', 'f' };
fw2.write(che);
fw2.flush();
fw2.close(); // 方式三: 根据给定的文件名值来构造 FileWriter 对象
// FileWriter(File file)
FileWriter fw3 = new FileWriter(new File("D:\\aaa\\b.txt"));
// 方式三:写入字符数组的某一部分。 write(char[] cbuf, int off, int len)
char[] che2 = { 'a', 'b', 'c', 'd', 'e', 'f' };
fw3.write(che2, , );
fw3.close(); // 方式四: 根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象
// FileWriter(File file, boolean append)
FileWriter fw4 = new FileWriter(new File("D:\\aaa", "b.txt"), true);
// 方式四: 写入字符串 。 write(String str)
String str = "Hello World Java";
fw4.write(str);
fw4.flush();
fw4.close(); // 方式一: 根据给定的文件名值来构造 FileWriter 对象
// FileWriter(String fileName)
FileWriter fw5 = new FileWriter("D:\\aaa\\c.txt");
// 方式五: 写入字符串的某一部分。 write(String str, int off, int len)
String str2 = "Hello World Java";
fw5.write(str2, , );
fw5.flush();
fw5.close();
}
} /*
*aaabcdef
*cdeHello World Java
*lo W
*/
1.0
3.2.3 BufferedWwriter
a:构造方法
package d8; import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException; public class BufferedWriterGouZao {
public static void main(String[] args) throws IOException { // 方式一: 创建一个使用默认大小输出缓冲区的新缓冲字符输出流。
// BufferedWriter(Writer out)
BufferedWriter bw = new BufferedWriter( new FileWriter("D:\\aaa\\a.txt")); // 方式二: 创建一个使用给定大小输出缓冲区的新缓冲字符输出流。
// BufferedWriter(Writer out, int sz)
BufferedWriter bw2 = new BufferedWriter( new FileWriter("D:\\aaa\\a.txt"),); }
}
1.0
b: Write方法
package d8; import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException; public class BufferedWriterWrite {
public static void main(String[] args) throws FileNotFoundException, IOException { // 方式一: 创建一个使用默认大小输出缓冲区的新缓冲字符输出流。
// BufferedWriter(Writer out)
BufferedWriter bw = new BufferedWriter( new FileWriter("D:\\aaa\\a.txt"));
// 方式一: 写入单个字符 write(int c)
bw.write();
bw.write('a');
bw.close(); // 方式二: 创建一个使用给定大小输出缓冲区的新缓冲字符输出流。
// BufferedWriter(Writer out, int sz)
BufferedWriter bw2 = new BufferedWriter( new FileWriter("D:\\aaa\\b.txt"),);
// 方式二:写入字符数组。 write(char[] cbuf)
char[] che = { 'a', 'b', 'c', 'd', 'e', 'f' };
bw2.write(che);
bw2.flush();
bw2.close(); // 方式一: 创建一个使用默认大小输出缓冲区的新缓冲字符输出流。
// BufferedWriter(Writer out)
BufferedWriter bw3 = new BufferedWriter( new FileWriter("D:\\aaa\\c.txt"));
// 方式三:写入字符数组的某一部分。 write(char[] cbuf, int off, int len)
char[] che2 = { 'a', 'b', 'c', 'd', 'e', 'f' };
bw3.write(che2, , );
bw3.close(); // 方式一: 创建一个使用默认大小输出缓冲区的新缓冲字符输出流。
// BufferedWriter(Writer out)
BufferedWriter bw4 = new BufferedWriter( new FileWriter("D:\\aaa\\d.txt"));
// 方式四: 写入字符串 。 write(String str)
String str = "Hello World Java";
bw4.write(str);
bw4.flush();
bw4.close(); // 方式一: 创建一个使用默认大小输出缓冲区的新缓冲字符输出流。
// BufferedWriter(Writer out)
BufferedWriter bw5 = new BufferedWriter( new FileWriter("D:\\aaa\\e.txt"));
// 方式五: 写入字符串的某一部分。 write(String str, int off, int len)
String str2 = "Hello World Java";
bw5.write(str2, , );
bw5.flush();
bw5.close();
}
} /*
*aa
*abcdef
*cde
*Hello World Java
*lo W
*/
1.0
2.0 写入一个行分隔符
3.3 练习
练习1:5中方法复制文本文件
package d8; import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException; public class CopyTxt { public static void main(String[] args) throws IOException {
Long start = System.currentTimeMillis();
method1();
Long end = System.currentTimeMillis();
System.out.println("方法一:耗时"+(end-start));
Long start2 = System.currentTimeMillis();
method2();
Long end2 = System.currentTimeMillis();
System.out.println("方法二:耗时"+(end2-start2)); Long start3 = System.currentTimeMillis();
method3();
Long end3 = System.currentTimeMillis();
System.out.println("方法三:耗时"+(end3-start3)); Long start4 = System.currentTimeMillis();
method4();
Long end4 = System.currentTimeMillis();
System.out.println("方法四:耗时"+(end4-start4)); Long start5 = System.currentTimeMillis();
method5();
Long end5 = System.currentTimeMillis();
System.out.println("方法五:耗时"+(end5-start5)); } private static void method5() throws IOException {
// Buffered 一次读取一个字符数组
FileReader fr = new FileReader("D:\\aaa\\a.txt");
FileWriter fw = new FileWriter("D:\\aaa\\b.txt", true);
BufferedReader br = new BufferedReader(fr);
BufferedWriter bw = new BufferedWriter(fw); bw.write("--方法五,FileXXX 开始");
bw.newLine();
String line;
while ((line = br.readLine()) != null) {
bw.write(line);;
}
bw.newLine();
bw.write("--方法五,FileXXX 结束");
bw.newLine();
// 释放资源
br.close();
bw.close();
} private static void method4() throws IOException {
// Buffered 一次读取一个字符数组
FileReader fr = new FileReader("D:\\aaa\\a.txt");
FileWriter fw = new FileWriter("D:\\aaa\\b.txt", true);
BufferedReader br = new BufferedReader(fr);
BufferedWriter bw = new BufferedWriter(fw); bw.write("--方法四,FileXXX 开始");
bw.newLine();
int len = ;
char[] ch = new char[];
while ((len = br.read(ch)) != -) {
bw.write(ch, , len);
}
bw.newLine();
bw.write("--方法四,FileXXX 结束");
bw.newLine();
// 释放资源
br.close();
bw.close();
} private static void method3() throws IOException {
// Buffered 一次读取一个字符
FileReader fr = new FileReader("D:\\aaa\\a.txt");
FileWriter fw = new FileWriter("D:\\aaa\\b.txt", true);
BufferedReader br = new BufferedReader(fr);
BufferedWriter bw = new BufferedWriter(fw); bw.write("--方法三,FileXXX 开始");
bw.newLine();
int i = ;
while ((i = br.read()) != -) {
bw.write((i));
}
bw.newLine();
bw.write("--方法三,FileXXX 结束");
bw.newLine();
// 释放资源
br.close();
bw.close();
} private static void method2() throws IOException {
// File 一次读取一个字符数组
FileReader fr = new FileReader("D:\\aaa\\a.txt");
FileWriter fw = new FileWriter("D:\\aaa\\b.txt", true);
fw.write("--方法二,FileXXX 开始");
fw.write("\r\n");
int len = ;
char[] ch = new char[];
while ((len = fr.read(ch)) != -) {
fw.write(ch, , len);
}
fw.write("\r\n");
fw.write("--方法二,FileXXX 结束");
fw.write("\r\n");
// 释放资源
fr.close();
fw.close();
} private static void method1() throws IOException {
// File 一次读取一个字符
FileReader fr = new FileReader("D:\\aaa\\a.txt");
FileWriter fw = new FileWriter("D:\\aaa\\b.txt");
fw.write("--方法一,FileXXX 开始");
fw.write("\r\n");
int i = ;
while ((i = fr.read()) != -) {
fw.write((i));
}
fw.write("\r\n");
fw.write("--方法一,FileXXX 结束");
fw.write("\r\n");
// 释放资源
fr.close();
fw.close(); }
/*
* 方法一:耗时3
方法二:耗时2
方法三:耗时2
方法四:耗时1
方法五:耗时1 *
*
*
*--方法一,FileXXX 开始
aa
bb
cc
dd
ee
ff
gg
--方法一,FileXXX 结束
--方法二,FileXXX 开始
aa
bb
cc
dd
ee
ff
gg
--方法二,FileXXX 结束
--方法三,FileXXX 开始
aa
bb
cc
dd
ee
ff
gg
--方法三,FileXXX 结束
--方法四,FileXXX 开始
aa
bb
cc
dd
ee
ff
gg
--方法四,FileXXX 结束
--方法五,FileXXX 开始
aabbccddeeffgg
--方法五,FileXXX 结束
*/
}
1.0
4:综合练习
1:复制单级文件夹
package d8; import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException; public class CopySingeFolder {
public static void main(String[] args) throws IOException {
// 需求:将单层文件夹例如:aaa文件下内容(只有文件)复制到bbb文件 // 根据文件路径获取文件集合
File srcFolder = new File("D:\\aaa");// 源文件
File destFolder = new File("D:\\bbb");// 目标文件 // 如果目标路径不存在,就创建,如果存在,就清空
if (destFolder.exists()) {
//清空文件夹
clearFolder(destFolder);
}
destFolder.mkdir();
// 获取源文件夹中的文件
CopyFolder(srcFolder,destFolder); } //复制文件
private static void CopyFolder(File srcFolder, File destFolder) throws IOException {
File[] srcFiles = srcFolder.listFiles();
if (srcFiles.length > ) {
for (File file : srcFiles) {
CopyFile(file,destFolder);
}
}
} private static void CopyFile(File file, File destFolder) throws IOException {
BufferedInputStream bis= new BufferedInputStream(new FileInputStream(file));
String destName = file.getName();
BufferedOutputStream bos= new BufferedOutputStream(new FileOutputStream(new File(destFolder,destName)));
int len=;
byte [] by=new byte[];
while ((len=bis.read(by))!=-) {
bos.write(by,,len);
}
bos.close();
bis.close();
} //清空目标文件夹
private static void clearFolder(File destFolder) {
// TODO Auto-generated method stub
File [] destFiles =destFolder.listFiles();
if (destFiles!=null&&destFiles.length>) {
for (File file : destFiles) {
file.delete();
}
}
destFolder.delete();
} }
1.0
2:复制文件
package d8; import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException; public class CopyMultistageFolder {
public static void main(String[] args) throws IOException {
// 需求:文件夹复制 // 根据文件路径获取文件集合
File srcFolder = new File("D:\\aaa");// 源文件
File destFolder = new File("D:\\bbb");// 目标文件 // 如果目标路径不存在,就创建,如果存在,就清空
if (destFolder.exists()) {
//清空文件夹
clearFolder(destFolder);
}
destFolder.mkdir();
// 获取源文件夹中的文件
CopyFolder(srcFolder,destFolder); } //复制文件
private static void CopyFolder(File srcFolder, File destFolder) throws IOException {
File[] srcFiles = srcFolder.listFiles();
if (srcFiles.length > ) {
for (File file : srcFiles) {
if (file.isFile()) {
CopyFile(file,destFolder);
}
else if (file.isDirectory()) {
//创建一个文件夹
File newFolder = new File(destFolder.getAbsolutePath(),file.getName());// 目标文件
newFolder.mkdir();
CopyFolder(file,newFolder);
}
}
}
} private static void CopyFile(File file, File destFolder) throws IOException {
BufferedInputStream bis= new BufferedInputStream(new FileInputStream(file));
String destName = file.getName();
BufferedOutputStream bos= new BufferedOutputStream(new FileOutputStream(new File(destFolder,destName)));
int len=;
byte [] by=new byte[];
while ((len=bis.read(by))!=-) {
bos.write(by,,len);
}
bos.close();
bis.close();
} //清空目标文件夹
private static void clearFolder(File destFolder) {
//级联删除
if (destFolder.isFile()||destFolder == null ) {
destFolder.delete();
}else if(destFolder.isDirectory()&&destFolder.listFiles().length<) {
destFolder.delete();
}else {
File [] destFiles =destFolder.listFiles();
if (destFiles!=null&&destFiles.length>) {
for (File file : destFiles) {
clearFolder(file);
}
}
destFolder.delete();
} destFolder.delete();
} }
1.0
3:模拟BufferedReader的readLine()+ BufferedWriter的newLine()+LineNumberReader的getLineNumber()和setLineNumber()
package d8; import java.io.IOException;
import java.io.Reader; public class MyBufferedReader {
private Reader r; public MyBufferedReader(Reader r) {
this.r =r;
} public String readLine() throws IOException {
StringBuilder sb = new StringBuilder();
int i = ;
while ((i = r.read()) != -) {
if (i == '\r') {
continue;
}
if (i == '\n') {
return sb.toString();
}else {
sb.append((char)i);
}
}
if (sb.toString().length()>) {
return sb.toString();
}
return null;
} // close方法
public void close() throws IOException {
r.close();
}
}
MyBufferedReader
package d8; import java.io.IOException;
import java.io.Writer; public class MyBufferedWriter {
//首先需要一個屬性Writer
private Writer w;
//創建一個構造方法
public MyBufferedWriter( Writer w) {
this.w =w;
}
public void newLine () throws IOException {
w.write('\r');
w.write('\n');
}
public void write (String str) throws IOException {
w.write(str);
}
public void close() throws IOException {
w.close();
}
}
MyBufferedWriter
package d8; import java.io.IOException;
import java.io.Reader; public class MyLineNumberReader {
private Reader r;
private int lineNumber;
public MyLineNumberReader(Reader r) {
this.r =r;
} public String readLine() throws IOException {
lineNumber++;
StringBuilder sb = new StringBuilder();
int i = ;
while ((i = r.read()) != -) {
if (i == '\r') {
continue;
}
if (i == '\n') {
return sb.toString();
}else {
sb.append((char)i);
}
}
if (sb.toString().length()>) {
return sb.toString();
}
return null;
} public int getLineNumber() {
return lineNumber;
} public void setLineNumber(int lineNumber) {
this.lineNumber = lineNumber;
} // close方法
public void close() throws IOException {
r.close();
}
}
MyLineNumberReader 1.0
package d8; import java.io.IOException;
import java.io.Reader; public class MyLineNumberReader2 extends MyLineNumberReader { private Reader r;
private int lineNumber;
public MyLineNumberReader2(Reader r) {
super(r);
}
public String readLine() throws IOException {
lineNumber++;
return super.readLine();
} public int getLineNumber() {
return lineNumber;
} public void setLineNumber(int lineNumber) {
this.lineNumber = lineNumber;
}
}
MyLineNumberReader2
package d8; import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException; public class MyBufferedTest {
public static void main(String[] args) throws IOException {
MyBufferedReader mbr = new MyBufferedReader(new FileReader("D:\\aaa\\a.txt"));
MyBufferedWriter mbw = new MyBufferedWriter(new FileWriter("D:\\aaa\\b.txt"));
String line = "";
while ((line = mbr.readLine())!=null) {
System.out.println(line);
mbw.write(line);
mbw.newLine();
mbw.write("哈哈");
mbw.newLine();
}
mbr.close();
mbw.close(); MyLineNumberReader mlnr = new MyLineNumberReader(new FileReader("D:\\aaa\\a.txt"));
mlnr.setLineNumber();
while ((line = mlnr.readLine())!=null) {
System.out.println(mlnr.getLineNumber()+":"+line);
}
mlnr.close(); MyLineNumberReader2 mlnr2 = new MyLineNumberReader2(new FileReader("D:\\aaa\\a.txt"));
mlnr2.setLineNumber();
while ((line = mlnr2.readLine())!=null) {
System.out.println(mlnr2.getLineNumber()+":"+line);
}
mlnr2.close();
}
}
MyBufferedTest
滴水穿石-08IO的更多相关文章
- 熬之滴水穿石:Spring--精简的J2EE(5)
47--Spring的MVC 在Spring的框架中也存在MVC这样的模式,在Spring下有2个这样的控制器一个叫Controller, ...
- 熬之滴水穿石:JSP--HTML中的JAVA代码(6)
39--JSTL 在JSP编码中需考虑的一种方法,因为这种方法可以 ...
- 熬之滴水穿石:Spring--精简的J2EE(6)
48--曾用过的View 在Spring MVC架构中View实际上是有多种选择的.JSP是首选的view,实际上在J2E ...
- 滴水穿石-10GUI
GUI 图形用户界面 1 Frame 窗体 package d10; //第一导入包 import java.awt.Frame; import java.awt.event.WindowAdapte ...
- 滴水穿石-07Java开发中常见的错误
1:使用工具Eclipse 1.1 "语法错误" 仅当源级别为 1.5 时已参数化的类型才可用 设置eclipse,窗口—>java—>编译器—>JDK一致性调到 ...
- 滴水穿石-04Eclipse中常用的快捷键
一:常用快捷键 1:内容辅助键 :Alt+/ :main + 该快捷键 :自动生成main方法 :syso + 该快捷键 :自动生成System.out.println();语句 :提示作用 :内容 ...
- 滴水穿石-01JAVA和C#的区别
排名不分先后,想到哪写到哪 1:数组的定义格式不同 java定义: 方式1: ] ; 方式2: ] ; C#中只有方式1 java有两种,C#只有一种 2:继承的实现关键字不同,同时java中实现接口 ...
- 滴水穿石 C#中多线程 委托的使用
什么是多线程?我们在建立以个C#项目时,往往会在Form1上添加控件,然后写代码,初 学者都是在重复这个过程,其实这个过程是单线程的,可以理解为只有“main”主线程,有 的时候往往需要同时测量多个东 ...
- F5负载均衡的初识和基本配置
目前全球范围内应用比较广泛的负载均衡设备为美国的F5.F5于2000年底进驻中国,在国内业界,F5负载均衡产品已经成为了主流负载均衡技术的代名词.下面我们对F5负载均衡设备做一个基本介绍,方便大家去认 ...
随机推荐
- 20165234 《Java程序设计》第一周学习总结
第一周学习总结 教材学习内容总结 java的特点 语法简单,面向对象,稳定,与平台无关,多线程,动态. 平台是由操作系统和处理器(CPU)所构成,每个平台都会形成自己独特的机器指令,相同的CPU和不同 ...
- OGG-01168
https://blog.csdn.net/zhrzhl/article/details/21698659
- Configuring Automatic Restart of an Oracle Database
https://docs.oracle.com/cd/E11882_01/server.112/e25494/restart.htm#ADMIN12708
- 高效的多维空间点索引算法 — Geohash 和 Google S2
原文地址:https://www.jianshu.com/p/7332dcb978b2 引子 每天我们晚上加班回家,可能都会用到滴滴或者共享单车.打开 app 会看到如下的界面: app ...
- Codeforces 914D - Bash and a Tough Math Puzzle 线段树,区间GCD
题意: 两个操作, 单点修改 询问一段区间是否能在至多一次修改后,使得区间$GCD$等于$X$ 题解: 正确思路; 线段树维护区间$GCD$,查询$GCD$的时候记录一共访问了多少个$GCD$不被X整 ...
- python操作三大主流数据库(14)python操作redis之新闻项目实战②新闻数据的展示及修改、删除操作
python操作三大主流数据库(14)python操作redis之新闻项目实战②新闻数据的展示及修改.删除操作 项目目录: ├── flask_redis_news.py ├── forms.py ├ ...
- PHP程序守护进程化
一般Server程序都是运行在系统后台,这与普通的交互式命令行程序有很大的区别.glibc里有一个函数daemon.调用此函数,就可使当前进程脱离终端变成一个守护进程,具体内容参见man daemon ...
- 运输层TCP/UDP
UDP:用户数据报协议 客户不与服务器建立连接,它只管用函数sendto给服务器发送数据报,此函数要求目的地址(服务器)作为其参数.类似的,服务器不从客户接受连接,它只管调用函数recvfrom,等待 ...
- pyhon 前面补充和set
一, 主要内容. 补充一个字符串的基本操作 li = ["李嘉诚", "麻花藤", "黄海峰", "刘嘉玲"] s = ...
- [转]Java微服务框架选型(Dubbo 和 Spring Cloud?)
转载于 http://www.cnblogs.com/xishuai/p/dubbo-and-spring-cloud.html 微服务(Microservices)是一种架构风格,一个大型复杂软件应 ...