import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
public class AAA {
public static void main(String[] args) throws IOException {
File src = new File("D:\\aaa");
File dest = new File("D:\\");
zip(src, dest);
}
public static void zip(File src, File dest) throws IOException {
ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(new File(dest, src.getName() + ".zip")));
zip0(src, zos, src.getName());
zos.close();
}
public static void zip0(File src, ZipOutputStream zos, String name) throws IOException {
File[] files = src.listFiles();
for (File file : files) {
if (file.isFile()) {
FileInputStream fis = new FileInputStream(file);
zos.putNextEntry(new ZipEntry(name + "\\" + file.getName()));
int len;
byte[] bytes = new byte[1024];
while ((len = fis.read(bytes)) != -1) {
zos.write(bytes,0,len);
}
zos.closeEntry();
fis.close();
} else {
zip0(file, zos, name + "\\" + file.getName());
}
}
}
}
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
public class BBB {
public static void main(String[] args) throws IOException {
File src = new File("D:\\aaa.zip");
File dest = new File("E:\\");
zip(src, dest);
}
public static void zip(File src, File dest) throws IOException {
ZipInputStream zip = new ZipInputStream(new FileInputStream(src));
zip0(zip, dest);
zip.close();
}
private static void zip0(ZipInputStream zip, File dest) throws IOException {
ZipEntry entry;
while ((entry = zip.getNextEntry()) != null) {
System.out.println(entry);
File file = new File(dest, entry.toString());
new File(file.getParent()).mkdirs();
FileOutputStream fos = new FileOutputStream(file);
byte[] bytes = new byte[1024];
int len;
while ((len = zip.read(bytes)) != -1) {
fos.write(bytes,0,len);
}
zip.closeEntry();
fos.close();
}
}
}
import java.io.*;
public class CCC {
public static void main(String[] args) throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("myio\\a.txt"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myio\\a.txt"));
int b;
while((b = bis.read()) != -1){
bos.write(b);
}
bis.close();
bos.close();
}
}
import java.io.*;
public class BufferedStreamDemo1 {
public static void main(String[] args) throws IOException {
/*
* 需求：
* 利用字节缓冲流拷贝文件
*
* 字节缓冲输入流的构造方法：
* public BufferedInputStream(InputStream is)
*
* 字节缓冲输出流的构造方法：
* public BufferedOutputStream(OutputStream os)
*
* */
//1.创建缓冲流的对象
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("myio\\a.txt"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myio\\a.txt"));
//2.循环读取并写到目的地
int b;
while ((b = bis.read()) != -1) {
bos.write(b);
}
//3.释放资源
bos.close();
bis.close();
}
}
import java.io.*;
public class BufferedStreamDemo2 {
public static void main(String[] args) throws IOException {
/*
* 需求：
* 利用字节缓冲流拷贝文件
*
* 字节缓冲输入流的构造方法：
* public BufferedInputStream(InputStream is)
*
* 字节缓冲输出流的构造方法：
* public BufferedOutputStream(OutputStream os)
*
* */
//1.创建缓冲流的对象
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("myio\\a.txt"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myio\\copy2.txt"));
//2.拷贝（一次读写多个字节）
byte[] bytes = new byte[1024];
int len;
while((len = bis.read(bytes)) != -1){
bos.write(bytes,0,len);
}
//3.释放资源
bos.close();
bis.close();
}
}
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class BufferedStreamDemo3 {
public static void main(String[] args) throws IOException {
/*
* 字符缓冲输入流：
* 构造方法：
* public BufferedReader(Reader r)
* 特有方法：
* public String readLine() 读一整行
*
* */
//1.创建字符缓冲输入流的对象
BufferedReader br = new BufferedReader(new FileReader("myio\\a.txt"));
//2.读取数据
//细节：
//readLine方法在读取的时候，一次读一整行，遇到回车换行结束
// 但是他不会把回车换行读到内存当中
/* String line1 = br.readLine();
System.out.println(line1);
String line2 = br.readLine();
System.out.println(line2);*/
String line;
while ((( line = br.readLine()) != null)){
System.out.println(line);
}
//3.释放资源
br.close();
}
}
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class BufferedStreamDemo4 {
public static void main(String[] args) throws IOException {
/*
*
* 字符缓冲输出流
* 构造方法：
* public BufferedWriter(Writer r)
* 特有方法：
* public void newLine() 跨平台的换行
*
* */
//1.创建字符缓冲输出流的对象
BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt",true));
//2.写出数据
bw.write("123");
bw.newLine();
bw.write("456");
bw.newLine();
//3.释放资源
bw.close();
}
}
import java.io.FileOutputStream;
import java.io.IOException;
public class ByteStreamDemo1 {
public static void main(String[] args) throws IOException {
/*
* 演示：字节输出流FileOutputStream
* 实现需求：写出一段文字到本地文件中。（暂时不写中文）
*
* 实现步骤：
* 创建对象
* 写出数据
* 释放资源
* */
//1.创建对象
//写出 输出流 OutputStream
//本地文件 File
FileOutputStream fos = new FileOutputStream("myio\\a.txt");
//2.写出数据
fos.write(97);
//3.释放资源
fos.close();
}
}
import java.io.FileOutputStream;
import java.io.IOException;
public class ByteStreamDemo2 {
public static void main(String[] args) throws IOException {
/*
字节输出流的细节：
1.创建字节输出流对象
细节1：参数是字符串表示的路径或者是File对象都是可以的
细节2：如果文件不存在会创建一个新的文件，但是要保证父级路径是存在的。
细节3：如果文件已经存在，则会清空文件
2.写数据
细节：write方法的参数是整数，但是实际上写到本地文件中的是整数在ASCII上对应的字符
‘9’
‘7’
3.释放资源
每次使用完流之后都要释放资源
*/
//1.创建对象
FileOutputStream fos = new FileOutputStream("myio\\a.txt");
//2.写出数据
fos.write(57);
fos.write(55);
//3.释放资源
fos.close();
while(true){}
}
}
import java.io.FileOutputStream;
import java.io.IOException;
public class ByteStreamDemo3 {
public static void main(String[] args) throws IOException {
/*
void write(int b) 一次写一个字节数据
void write(byte[] b) 一次写一个字节数组数据
void write(byte[] b, int off, int len) 一次写一个字节数组的部分数据
参数一：
数组
参数二：
起始索引 0
参数三：
个数 3
*/
//1.创建对象
FileOutputStream fos = new FileOutputStream("myio\\a.txt");
//2.写出数据
//fos.write(97); // a
//fos.write(98); // b
byte[] bytes = {97, 98, 99, 100, 101};
/* fos.write(bytes);*/
fos.write(bytes,1,2);// b c
//3.释放资源
fos.close();
}
}
import java.io.FileOutputStream;
import java.io.IOException;
public class ByteStreamDemo4 {
public static void main(String[] args) throws IOException {
/*
换行写：
再次写出一个换行符就可以了
windows： \r\n
Linux: \n
Mac: \r
细节：
在windows操作系统当中，java对回车换行进行了优化。
虽然完整的是\r\n，但是我们写其中一个\r或者\n，
java也可以实现换行，因为java在底层会补全。
建议：
不要省略，还是写全了。
续写：
如果想要续写，打开续写开关即可
开关位置：创建对象的第二个参数
默认false：表示关闭续写，此时创建对象会清空文件
手动传递true：表示打开续写，此时创建对象不会清空文件
*/
//1.创建对象
FileOutputStream fos = new FileOutputStream("myio\\a.txt",true);
//2.写出数据
String str = "kankelaoyezuishuai";
byte[] bytes1 = str.getBytes();
fos.write(bytes1);
//再次写出一个换行符就可以了
String wrap = "\r\n";
byte[] bytes2 = wrap.getBytes();
fos.write(bytes2);
String str2 = "666";
byte[] bytes3 = str2.getBytes();
fos.write(bytes3);
//3.释放资源
fos.close();
}
}
import java.io.FileInputStream;
import java.io.IOException;
public class ByteStreamDemo1 {
public static void main(String[] args) throws IOException {
/*
* 演示：字节输入流FileInputStream
* 实现需求：读取文件中的数据。（暂时不写中文）
*
* 实现步骤：
* 创建对象
* 读取数据
* 释放资源
* */
//1.创建对象
FileInputStream fis = new FileInputStream("myio\\a.txt");
//2.读取数据
int b1 = fis.read();
System.out.println((char)b1);
int b2 = fis.read();
System.out.println((char)b2);
int b3 = fis.read();
System.out.println((char)b3);
int b4 = fis.read();
System.out.println((char)b4);
int b5 = fis.read();
System.out.println((char)b5);
int b6 = fis.read();
System.out.println(b6);//-1
//3.释放资源
fis.close();
}
}
import java.io.FileInputStream;
import java.io.IOException;
public class ByteStreamDemo2 {
public static void main(String[] args) throws IOException {
/*
字节输入流的细节：
1.创建字节输入流对象
细节1：如果文件不存在，就直接报错。
Java为什么会这么设计呢？
输出流：不存在，创建
把数据写到文件当中
输入流：不存在，而是报错呢？
因为创建出来的文件是没有数据的，没有任何意义。
所以Java就没有设计这种无意义的逻辑，文件不存在直接报错。
程序中最重要的是：数据。
2.写数据
细节1：一次读一个字节，读出来的是数据在ASCII上对应的数字
细节2：读到文件末尾了，read方法返回-1。
3.释放资源
细节：每次使用完流之后都要释放资源
*/
//1.创建对象
FileInputStream fis = new FileInputStream("myio\\b.txt");
//2.读取数据
int b1 = fis.read();
System.out.println((char)b1);
//3.释放资源
fis.close();
}
}
import java.io.FileInputStream;
import java.io.IOException;
public class ByteStreamDemo3 {
public static void main(String[] args) throws IOException {
/*
字节输入流循环读取
*/
//1.创建对象
FileInputStream fis = new FileInputStream("myio\\a.txt");
//2.循环读取
int b;
while ((b = fis.read()) != -1) {
System.out.println((char) b);
}
//3.释放资源
fis.close();
/* *//*
*
* read :表示读取数据，而且是读取一个数据就移动一次指针
*
* *//*
FileInputStream fis = new FileInputStream("myio\\a.txt");
//2.循环读取
while ((fis.read()) != -1) {
System.out.println(fis.read());//98 100 -1
}
//3.释放资源
fis.close();*/
}
}
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class ByteStreamDemo4 {
public static void main(String[] args) throws IOException {
/*
* 练习：
* 文件拷贝
* 把D:\itheima\movie.mp4拷贝到当前模块下。
*
* 注意：
* 选择一个比较小的文件，不要太大。大文件拷贝我们下一个视频会说。
*
*
*
* 课堂练习：
* 要求统计一下拷贝时间，单位毫秒
* */
long start = System.currentTimeMillis();
//1.创建对象
FileInputStream fis = new FileInputStream("D:\\itheima\\movie.mp4");
FileOutputStream fos = new FileOutputStream("myio\\copy.mp4");
//2.拷贝
//核心思想：边读边写
int b;
while((b = fis.read()) != -1){
fos.write(b);
}
//3.释放资源
//规则：先开的最后关闭
fos.close();
fis.close();
long end = System.currentTimeMillis();
System.out.println(end - start);
}
}
import java.io.FileInputStream;
import java.io.IOException;
public class ByteStreamDemo5 {
public static void main(String[] args) throws IOException {
/*
public int read(byte[] buffer) 一次读一个字节数组数据
*/
//1.创建对象
FileInputStream fis = new FileInputStream("myio\\a.txt");
//2.读取数据
byte[] bytes = new byte[2];
//一次读取多个字节数据，具体读多少，跟数组的长度有关
//返回值：本次读取到了多少个字节数据
int len1 = fis.read(bytes);
System.out.println(len1);//2
String str1 = new String(bytes,0,len1);
System.out.println(str1);
int len2 = fis.read(bytes);
System.out.println(len2);//2
String str2 = new String(bytes,0,len2);
System.out.println(str2);
int len3 = fis.read(bytes);
System.out.println(len3);// 1
String str3 = new String(bytes,0,len3);
System.out.println(str3);// ed
//3.释放资源
fis.close();
}
}
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class ByteStreamDemo6 {
public static void main(String[] args) throws IOException {
/*
* 练习：
* 文件拷贝
* 把D:\itheima\movie.mp4 (16.8 MB) 拷贝到当前模块下。
*
* */
long start = System.currentTimeMillis();
//1.创建对象
FileInputStream fis = new FileInputStream("D:\\itheima\\movie.mp4");
FileOutputStream fos = new FileOutputStream("myio\\copy.mp4");
//2.拷贝
int len;
byte[] bytes = new byte[1024 * 1024 * 5];
while((len = fis.read(bytes)) != -1){
fos.write(bytes,0,len);
}
//3.释放资源
fos.close();
fis.close();
long end = System.currentTimeMillis();
System.out.println(end - start);
}
}
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class ByteStreamDemo7 {
public static void main(String[] args) {
/*
*
* 利用try...catch...finally捕获拷贝文件中代码出现的异常
*
*
* */
//1.创建对象
FileInputStream fis = null;
FileOutputStream fos = null;
try {
fis = new FileInputStream("D:\\itheima\\movie.mp4");
fos = new FileOutputStream("myio\\copy.mp4");
//2.拷贝
int len;
byte[] bytes = new byte[1024 * 1024 * 5];
while((len = fis.read(bytes)) != -1){
fos.write(bytes,0,len);
}
} catch (IOException e) {
//e.printStackTrace();
} finally {
//3.释放资源
if(fos != null){
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(fis != null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class ByteStreamDemo8 {
public static void main(String[] args) {
/*
*
* JDK7:IO流中捕获异常的写法
*
* try后面的小括号中写创建对象的代码，
* 注意：只有实现了AutoCloseable接口的类，才能在小括号中创建对象。
* try(){
*
* }catch(){
*
* }
*
* */
try (FileInputStream fis = new FileInputStream("D:\\itheima\\movie.mp4");
FileOutputStream fos = new FileOutputStream("myio\\copy.mp4")) {
//2.拷贝
int len;
byte[] bytes = new byte[1024 * 1024 * 5];
while ((len = fis.read(bytes)) != -1) {
fos.write(bytes, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class ByteStreamDemo9 {
public static void main(String[] args) throws FileNotFoundException {
/*
*
* JDK9:IO流中捕获异常的写法
*
*
* */
FileInputStream fis = new FileInputStream("D:\\itheima\\movie.mp4");
FileOutputStream fos = new FileOutputStream("myio\\copy.mp4");
try (fis;fos) {
//2.拷贝
int len;
byte[] bytes = new byte[1024 * 1024 * 5];
while ((len = fis.read(bytes)) != -1) {
fos.write(bytes, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
import java.io.FileInputStream;
import java.io.IOException;
public class CharSetDemo1 {
public static void main(String[] args) throws IOException {
/*
字节流读取中文会出现乱码
*/
FileInputStream fis = new FileInputStream("myio\\a.txt");
int b;
while ((b = fis.read()) != -1){
System.out.print((char)b);
}
fis.close();
}
}
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CharSetDemo2 {
public static void main(String[] args) throws IOException {
//1.创建对象
FileInputStream fis = new FileInputStream("myio\\a.txt");
FileOutputStream fos = new FileOutputStream("myio\\a.txt");
//2.拷贝
int b;
while((b = fis.read()) != -1){
fos.write(b);
}
//3.释放资源
fos.close();
fis.close();
}
}
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
public class CharSetDemo3 {
public static void main(String[] args) throws UnsupportedEncodingException {
/*
Java中编码的方法
public byte[] getBytes() 使用默认方式进行编码
public byte[] getBytes(String charsetName) 使用指定方式进行编码
Java中解码的方法
String(byte[] bytes) 使用默认方式进行解码
String(byte[] bytes, String charsetName) 使用指定方式进行解码
*/
//1.编码
String str = "ai你哟";
byte[] bytes1 = str.getBytes();
System.out.println(Arrays.toString(bytes1));
byte[] bytes2 = str.getBytes("GBK");
System.out.println(Arrays.toString(bytes2));
//2.解码
String str2 = new String(bytes1);
System.out.println(str2);
String str3 = new String(bytes1,"GBK");
System.out.println(str3);
}
}
import java.io.FileReader;
import java.io.IOException;
public class CharStreamDemo1 {
public static void main(String[] args) throws IOException {
/*
第一步：创建对象
public FileReader(File file) 创建字符输入流关联本地文件
public FileReader(String pathname) 创建字符输入流关联本地文件
第二步：读取数据
public int read() 读取数据，读到末尾返回-1
public int read(char[] buffer) 读取多个数据，读到末尾返回-1
第三步：释放资源
public void close() 释放资源/关流
*/
//1.创建对象并关联本地文件
FileReader fr = new FileReader("myio\\a.txt");
//2.读取数据 read()
//字符流的底层也是字节流，默认也是一个字节一个字节的读取的。
//如果遇到中文就会一次读取多个，GBK一次读两个字节，UTF-8一次读三个字节
//read（）细节：
//1.read():默认也是一个字节一个字节的读取的,如果遇到中文就会一次读取多个
//2.在读取之后，方法的底层还会进行解码并转成十进制。
// 最终把这个十进制作为返回值
// 这个十进制的数据也表示在字符集上的数字
// 英文：文件里面二进制数据 0110 0001
// read方法进行读取，解码并转成十进制97
// 中文：文件里面的二进制数据 11100110 10110001 10001001
// read方法进行读取，解码并转成十进制27721
// 我想看到中文汉字，就是把这些十进制数据，再进行强转就可以了
int ch;
while((ch = fr.read()) != -1){
System.out.print((char)ch);
}
//3.释放资源
fr.close();
}
}
import java.io.FileReader;
import java.io.IOException;
public class CharStreamDemo2 {
public static void main(String[] args) throws IOException {
/*
第一步：创建对象
public FileReader(File file) 创建字符输入流关联本地文件
public FileReader(String pathname) 创建字符输入流关联本地文件
第二步：读取数据
public int read() 读取数据，读到末尾返回-1
public int read(char[] buffer) 读取多个数据，读到末尾返回-1
第三步：释放资源
public void close() 释放资源/关流
*/
//1.创建对象
FileReader fr = new FileReader("myio\\a.txt");
//2.读取数据
char[] chars = new char[2];
int len;
//read(chars)：读取数据，解码，强转三步合并了，把强转之后的字符放到数组当中
//空参的read + 强转类型转换
while((len = fr.read(chars)) != -1){
//把数组中的数据变成字符串再进行打印
System.out.print(new String(chars,0,len));
}
//3.释放资源
fr.close();
}
}
import java.io.FileWriter;
import java.io.IOException;
public class CharStreamDemo3 {
public static void main(String[] args) throws IOException {
/*
第一步：创建对象
public FileWriter(File file) 创建字符输出流关联本地文件
public FileWriter(String pathname) 创建字符输出流关联本地文件
public FileWriter(File file, boolean append) 创建字符输出流关联本地文件，续写
public FileWriter(String pathname, boolean append) 创建字符输出流关联本地文件，续写
第二步：读取数据
void write(int c) 写出一个字符
void write(String str) 写出一个字符串
void write(String str, int off, int len) 写出一个字符串的一部分
void write(char[] cbuf) 写出一个字符数组
void write(char[] cbuf, int off, int len) 写出字符数组的一部分
第三步：释放资源
public void close() 释放资源/关流
'我' 25105
*/
FileWriter fw = new FileWriter("myio\\a.txt",true);
//fw.write(25105);
//fw.write("你好威啊???");
char[] chars = {'a','b','c','我'};
fw.write(chars);
fw.close();
}
}
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class CharStreamDemo4 {
public static void main(String[] args) throws IOException {
FileReader fr = new FileReader("myio\\b.txt");
fr.read();//会把文件中的数据放到缓冲区当中
//清空文件
FileWriter fw = new FileWriter("myio\\b.txt");
//请问，如果我再次使用fr进行读取
//会读取到数据吗？
//会把缓冲区中的数据全部读取完毕
//正确答案：
//但是只能读取缓冲区中的数据，文件中剩余的数据无法再次读取
int ch;
while((ch = fr.read()) != -1){
System.out.println((char)ch);
}
fw.close();
fr.close();
}
}
同学各个都很厉害");
fw.write("说话声音很好听");
fw.flush();
fw.write("都是人才");
fw.write("超爱这里哟");
fw.close();
fw.write("B站");
}
}
import java.io.*;
import java.nio.charset.Charset;
public class ConvertStreamDemo1 {
public static void main(String[] args) throws IOException {
/*
利用转换流按照指定字符编码读取(了解)
因为JDK11：这种方式被淘汰了。替代方案(掌握)
F:\JavaSE最新版\day29-IO（其他流）\资料\gbkfile.txt
*/
/* //1.创建对象并指定字符编码
InputStreamReader isr = new InputStreamReader(new FileInputStream("myio\\gbkfile.txt"),"GBK");
//2.读取数据
int ch;
while ((ch = isr.read()) != -1){
System.out.print((char)ch);
}
//3.释放资源
isr.close();*/
FileReader fr = new FileReader("myio\\gbkfile.txt", Charset.forName("GBK"));
//2.读取数据
int ch;
while ((ch = fr.read()) != -1){
System.out.print((char)ch);
}
//3.释放资源
fr.close();
}
}
import java.io.*;
import java.nio.charset.Charset;
public class ConvertStreamDemo2 {
public static void main(String[] args) throws IOException {
/*
利用转换流按照指定字符编码写出
*/
/*
//1.创建转换流的对象
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myio\\b.txt"),"GBK");
//2.写出数据
osw.write("你好你好");
//3.释放资源
osw.close();*/
FileWriter fw = new FileWriter("myio\\c.txt", Charset.forName("GBK"));
fw.write("你好你好");
fw.close();
}
}
import java.io.*;
import java.nio.charset.Charset;
public class ConvertStreamDemo3 {
public static void main(String[] args) throws IOException {
/*
将本地文件中的GBK文件，转成UTF-8
*/
//1.JDK11以前的方案
/* InputStreamReader isr = new InputStreamReader(new FileInputStream("myio\\b.txt"),"GBK");
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("myio\\d.txt"),"UTF-8");
int b;
while((b = isr.read()) != -1){
osw.write(b);
}
osw.close();
isr.close();*/
//2.替代方案
FileReader fr = new FileReader("myio\\b.txt", Charset.forName("GBK"));
FileWriter fw = new FileWriter("myio\\e.txt",Charset.forName("UTF-8"));
int b;
while ((b = fr.read()) != -1){
fw.write(b);
}
fw.close();
fr.close();
}
}
import java.io.*;
public class ConvertStreamDemo4 {
public static void main(String[] args) throws IOException {
/*
利用字节流读取文件中的数据，每次读一整行，而且不能出现乱码
//1.字节流在读取中文的时候，是会出现乱码的，但是字符流可以搞定
//2.字节流里面是没有读一整行的方法的，只有字符缓冲流才能搞定
*/
/* FileInputStream fis = new FileInputStream("myio\\a.txt");
InputStreamReader isr = new InputStreamReader(fis);
BufferedReader br = new BufferedReader(isr);
String str = br.readLine();
System.out.println(str);
br.close();*/
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("myio\\a.txt")));
String line;
while ((line = br.readLine()) != null){
System.out.println(line);
}
br.close();
}
}
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class ObjectStreamDemo1 {
public static void main(String[] args) throws IOException {
/*
需求：
利用序列化流/对象操作输出流，把一个对象写到本地文件中
构造方法：
public ObjectOutputStream(OutputStream out) 把基本流变成高级流
成员方法：
public final void writeObject(Object obj) 把对象序列化（写出）到文件中去
*/
//1.创建对象
Student stu = new Student("zhangsan",23);
//2.创建序列化流的对象/对象操作输出流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("myio\\a.txt"));
//3.写出数据
oos.writeObject(stu);
//4.释放资源
oos.close();
}
}
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.security.Security;
import java.util.Arrays;
public class ObjectStreamDemo2 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
/*
需求：
利用反序列化流/对象操作输入流，把文件中中的对象读到程序当中
构造方法：
public ObjectInputStream(InputStream out) 把基本流变成高级流
成员方法：
public Object readObject() 把序列化到本地文件中的对象，读取到程序中来
*/
//1.创建反序列化流的对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("myio\\a.txt"));
//2.读取数据
Student o = (Student) ois.readObject();
//3.打印对象
System.out.println(o);
//4.释放资源
ois.close();
}
}
import java.io.Serializable;
/*
*
* Serializable接口里面是没有抽象方法，标记型接口
* 一旦实现了这个接口，那么就表示当前的Student类可以被序列化
* 理解：
* 一个物品的合格证
* */
public class Student implements Serializable {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "Student{name = " + name + ", age = " + age + "}";
}
}
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
public class WeightRandom {
private final List items = new ArrayList<>();
private double[] weights;
public WeightRandom(List> itemsWithWeight) {
this.calWeights(itemsWithWeight);
}
/**
* 计算权重，初始化或者重新定义权重时使用
*
*/
public void calWeights(List> itemsWithWeight) {
items.clear();
// 计算权重总和
double originWeightSum = 0;
for (ItemWithWeight itemWithWeight : itemsWithWeight) {
double weight = itemWithWeight.getWeight();
if (weight <= 0) {
continue;
}
items.add(itemWithWeight.getItem());
if (Double.isInfinite(weight)) {
weight = 10000.0D;
}
if (Double.isNaN(weight)) {
weight = 1.0D;
}
originWeightSum += weight;
}
// 计算每个item的实际权重比例
// actualWeightRatios：真实的权重比例
double[] actualWeightRatios = new double[items.size()];
int index = 0;
for (ItemWithWeight itemWithWeight : itemsWithWeight) {
double weight = itemWithWeight.getWeight();
if (weight <= 0) {
continue;
}
actualWeightRatios[index++] = weight / originWeightSum;
}
// 计算每个item的权重范围
// 权重范围起始位置
weights = new double[items.size()];
double weightRangeStartPos = 0;
for (int i = 0; i < index; i++) {
weights[i] = weightRangeStartPos + actualWeightRatios[i];
weightRangeStartPos += actualWeightRatios[i];
}
}
/**
* 基于权重随机算法选择
*
*/
public T choose() {
double random = new Random().nextDouble();
int index = Arrays.binarySearch(weights, random);
if (index < 0) {
index = -index - 1; //index：实际的插入点
} else {
return items.get(index);
}
if (index < weights.length && random < weights[index]) {
return items.get(index);
}
// 通常不会走到这里，为了保证能得到正确的返回，这里随便返回一个
return items.get(0);
}
public static class ItemWithWeight {
T item;
double weight;
public ItemWithWeight() {
}
public ItemWithWeight(T item, double weight) {
this.item = item;
this.weight = weight;
}
public T getItem() {
return item;
}
public void setItem(T item) {
this.item = item;
}
public double getWeight() {
return weight;
}
public void setWeight(double weight) {
this.weight = weight;
}
}
public static void main(String[] args) {
// for test
int count = 10000000;
ItemWithWeight server1 = new ItemWithWeight<>("server1", 1.0);
ItemWithWeight server2 = new ItemWithWeight<>("server2", 3.0);
ItemWithWeight server3 = new ItemWithWeight<>("server3", 2.0);
WeightRandom weightRandom = new WeightRandom<>(Arrays.asList(server1, server2, server3));
int count1 = 0;
int count2 = 0;
int count3 = 0;
for (int i = 0; i < count; i++) {
String choose = weightRandom.choose();
if("server1".equals(choose)){
count1++;
}else if("server2".equals(choose)){
count2++;
}else{
count3++;
}
}
System.out.println(count1);
System.out.println(count2);
System.out.println(count3);
}
}
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Test01 {
public static void main(String[] args) throws IOException {
//拷贝一个文件夹，考虑子文件夹
//1.创建对象表示数据源
File src = new File("D:\\aaa\\src");
//2.创建对象表示目的地
File dest = new File("D:\\aaa\\dest");
//3.调用方法开始拷贝
copydir(src,dest);
}
/*
* 作用：拷贝文件夹
* 参数一：数据源
* 参数二：目的地
*
* */
private static void copydir(File src, File dest) throws IOException {
dest.mkdirs();
//递归
//1.进入数据源
File[] files = src.listFiles();
//2.遍历数组
for (File file : files) {
if(file.isFile()){
//3.判断文件，拷贝
FileInputStream fis = new FileInputStream(file);
FileOutputStream fos = new FileOutputStream(new File(dest,file.getName()));
byte[] bytes = new byte[1024];
int len;
while((len = fis.read(bytes)) != -1){
fos.write(bytes,0,len);
}
fos.close();
fis.close();
}else {
//4.判断文件夹，递归
copydir(file, new File(dest,file.getName()));
}
}
}
}
import java.io.*;
public class Test02 {
public static void main(String[] args) throws IOException {
/*
为了保证文件的安全性，就需要对原始文件进行加密存储，再使用的时候再对其进行解密处理。
加密原理：
对原始文件中的每一个字节数据进行更改，然后将更改以后的数据存储到新的文件中。
解密原理：
读取加密之后的文件，按照加密的规则反向操作，变成原始文件。
^ : 异或
两边相同：false
两边不同：true
0：false
1：true
100:1100100
10: 1010
1100100
^ 0001010
__________
1101110
^ 0001010
__________
1100100
*/
}
public static void encryptionAndReduction(File src, File dest) throws IOException {
FileInputStream fis = new FileInputStream(src);
FileOutputStream fos = new FileOutputStream(dest);
int b;
while ((b = fis.read()) != -1) {
fos.write(b ^ 2);
}
//4.释放资源
fos.close();
fis.close();
}
}
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
public class Test03 {
public static void main(String[] args) throws IOException {
/*
文本文件中有以下的数据：
2-1-9-4-7-8
将文件中的数据进行排序，变成以下的数据：
1-2-4-7-8-9
*/
//1.读取数据
FileReader fr = new FileReader("myio\\a.txt");
StringBuilder sb = new StringBuilder();
int ch;
while((ch = fr.read()) != -1){
sb.append((char)ch);
}
fr.close();
System.out.println(sb);
//2.排序
String str = sb.toString();
String[] arrStr = str.split("-");//2-1-9-4-7-8
ArrayList list = new ArrayList<>();
for (String s : arrStr) {
int i = Integer.parseInt(s);
list.add(i);
}
Collections.sort(list);
System.out.println(list);
//3.写出
FileWriter fw = new FileWriter("myio\\a.txt");
for (int i = 0; i < list.size(); i++) {
if(i == list.size() - 1){
fw.write(list.get(i) + "");
}else{
fw.write(list.get(i) + "-");
}
}
fw.close();
}
}
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Arrays;
public class Test04 {
public static void main(String[] args) throws IOException {
/*
文本文件中有以下的数据：
2-1-9-4-7-8
将文件中的数据进行排序，变成以下的数据：
1-2-4-7-8-9
细节1：
文件中的数据不要换行
细节2:
bom头
*/
//1.读取数据
FileReader fr = new FileReader("myio\\a.txt");
StringBuilder sb = new StringBuilder();
int ch;
while((ch = fr.read()) != -1){
sb.append((char)ch);
}
fr.close();
System.out.println(sb);
//2.排序
Integer[] arr = Arrays.stream(sb.toString()
.split("-"))
.map(Integer::parseInt)
.sorted()
.toArray(Integer[]::new);
//3.写出
FileWriter fw = new FileWriter("myio\\a.txt");
String s = Arrays.toString(arr).replace(", ","-");
String result = s.substring(1, s.length() - 1);
fw.write(result);
fw.close();
}
}
import java.io.*;
public class Test05 {
public static void main(String[] args) throws IOException {
/*
四种方式拷贝文件，并统计各自用时
*/
long start = System.currentTimeMillis();
//method1();
//method2(); //16.253秒
//method3(); //95.466秒
//method4(); //17.686秒
long end = System.currentTimeMillis();
System.out.println((end - start) / 1000.0 + "秒");
}
//字节流的基本流：一次读写一个字节4,588,568,576 字节
public static void method1() throws IOException {
FileInputStream fis = new FileInputStream("E:\\aaa\\CentOS-7-x86_64-DVD-1810.iso");
FileOutputStream fos = new FileOutputStream("myio\\copy.iso");
int b;
while ((b = fis.read()) != -1) {
fos.write(b);
}
fos.close();
fis.close();
}
//字节流的基本流：一次读写一个字节数组
public static void method2() throws IOException {
FileInputStream fis = new FileInputStream("E:\\aaa\\CentOS-7-x86_64-DVD-1810.iso");
FileOutputStream fos = new FileOutputStream("myio\\copy.iso");
byte[] bytes = new byte[8192];
int len;
while ((len = fis.read(bytes)) != -1) {
fos.write(bytes, 0, len);
}
fos.close();
fis.close();
}
//字节流的基本流：一次读写一个字节数组
public static void method3() throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\aaa\\CentOS-7-x86_64-DVD-1810.iso"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myio\\copy.iso"));
int b;
while ((b = bis.read()) != -1) {
bos.write(b);
}
bos.close();
bis.close();
}
//字节流的基本流：一次读写一个字节数组
public static void method4() throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\aaa\\CentOS-7-x86_64-DVD-1810.iso"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myio\\copy.iso"));
byte[] bytes = new byte[8192];
int len;
while ((len = bis.read(bytes)) != -1) {
bos.write(bytes, 0, len);
}
bos.close();
bis.close();
}
}
import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class Test06Case01 {
public static void main(String[] args) throws IOException {
/*
需求：把《出师表》的文章顺序进行恢复到一个新文件中。
*/
//1.读取数据
BufferedReader br = new BufferedReader(new FileReader("myio\\csb.txt"));
String line;
ArrayList list = new ArrayList<>();
while((line = br.readLine()) != null){
list.add(line);
}
br.close();
//2.排序
//排序规则：按照每一行前面的序号进行排列
Collections.sort(list, new Comparator() {
@Override
public int compare(String o1, String o2) {
//获取o1和o2的序号
int i1 = Integer.parseInt(o1.split("\\.")[0]);
int i2 = Integer.parseInt(o2.split("\\.")[0]);
return i1 - i2;
}
});
//3.写出
BufferedWriter bw = new BufferedWriter(new FileWriter("myio\\result.txt"));
for (String str : list) {
bw.write(str);
bw.newLine();
}
bw.close();
}
}
import java.io.*;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class Test06Case02 {
public static void main(String[] args) throws IOException {
/*
需求：把《出师表》的文章顺序进行恢复到一个新文件中。
*/
//1.读取数据
BufferedReader br = new BufferedReader(new FileReader("myio\\csb.txt"));
String line;
TreeMap tm = new TreeMap<>();
while((line = br.readLine()) != null){
String[] arr = line.split("\\.");
//0：序号 1 ：内容
tm.put(Integer.parseInt(arr[0]),line);
}
br.close();
//2.写出数据
BufferedWriter bw = new BufferedWriter(new FileWriter("myio\\result2.txt"));
Set> entries = tm.entrySet();
for (Map.Entry entry : entries) {
String value = entry.getValue();
bw.write(value);
bw.newLine();
}
bw.close();
}
}
import java.io.*;
public class Test07 {
public static void main(String[] args) throws IOException {
/*
实现一个验证程序运行次数的小程序，要求如下：
1.当程序运行超过3次时给出提示:本软件只能免费使用3次,欢迎您注册会员后继续使用~
2.程序运行演示如下:
第一次运行控制台输出: 欢迎使用本软件,第1次使用免费~
第二次运行控制台输出: 欢迎使用本软件,第2次使用免费~
第三次运行控制台输出: 欢迎使用本软件,第3次使用免费~
第四次及之后运行控制台输出:本软件只能免费使用3次,欢迎您注册会员后继续使用~
*/
//1.把文件中的数字读取到内存中
//原则：
//IO：随用随创建
// 什么时候不用什么时候关闭
BufferedReader br = new BufferedReader(new FileReader("myio\\count.txt"));
String line = br.readLine();
br.close();
System.out.println(line);//null
int count = Integer.parseInt(line);
//表示当前软件又运行了一次
count++;//1
//2.判断
if(count <= 3){
System.out.println("欢迎使用本软件,第"+count+"次使用免费~");
}else{
System.out.println("本软件只能免费使用3次,欢迎您注册会员后继续使用~");
}
BufferedWriter bw = new BufferedWriter(new FileWriter("myio\\count.txt"));
//3.把当前自增之后的count写出到文件当中
bw.write(count + ""); //97 + ""
bw.close();
}
}
单词
