java学习【知识点及代码12.2】

一：File

1.1

File:文件和目录(文件夹)路径名的抽象表示形式。

1.2 File的构造方法：

File(String pathname):把一个路径名称封装成File对象
File(String parent, String child):把一个父路径和一个子路径封装成一个File对象
File(File parent, String child):把一个父路径File对象和一个子路径封装成一个File对象

package day12.edu_01;

import java.io.File;
import java.io.IOException;

public class FileDemo {
public static void main(String[] args) throws IOException {
//File(String pathname):把一个路径名称封装成File对象
//      File file = new File("D://a.txt");
//      System.out.println(file.createNewFile());//当文件不存在的时候，创建文件，如果文件存在，不创建

//File(String parent, String child):把一个父路径和一个子路径封装成一个File对象
//      File
4000
file = new File("D://test", "a.txt");
//java.io.IOException: 系统找不到指定的路径
//      System.out.println(file.createNewFile());

//File(File parent, String child):把一个父路径File对象和一个子路径封装成一个File对象
File file = new File("D://test");
File file2 = new File(file,"a.txt");
System.out.println(file2.createNewFile());
}
}

1.3 创建功能：

A:创建文件
public boolean createNewFile():如果文件不存在，就创建。否则，不创建。
需求：D盘下造一个文件a.txt

B:创建目录
public boolean mkdir():如果目录不存在，就创建。否则，不创建。
需求：D盘下造一个文件夹test

public boolean mkdirs():如果目录不存在，就创建。否则，不创建。
即使父目录不存在，也可以连父目录一起创建。
需求：D盘下造一个文件夹(D:/aaa/bbb/ccc)
需求：D盘下造一个文件夹("D:\\ddd\\eee\\f.txt");

package day12.edu_02;

import java.io.File;

public class FileDemo {
public static void main(String[] args) {
//public boolean mkdir():如果目录不存在，就创建。否则，不创建。
//需求：D盘下造一个文件夹test
File file = new File("D://test");
System.out.println(file.mkdir());

//public boolean mkdirs():如果目录不存在，就创建。否则，不创建。
//即使父目录不存在，也可以连父目录一起创建。
//      File file = new File("D:\\ddd\\eee\\f.txt");
//      System.out.println(file.mkdirs());
}
}

注意事项：

A:你要造什么东西，就应该用对应的方法。

1.4 删除功能：

public boolean delete():既可以删除文件，又可以删除目录。

路径问题：
A:绝对路径  就是以盘符开始的路径(d:\\test\\aaa\\b.txt)
B:相对路径  就是不以盘符开始的路径(a.txt)
一般都是相对应当前的项目而言的。

package day12.edu_02;

import java.io.File;

public class FileDemo2 {
public static void main(String[] args) {
//删除D://a.txt
//      File file = new File("D://a.txt");
//      System.out.println(file.delete());

//删除D://test//a.txt
//      File file = new File("D://test//a.txt");
//      System.out.println(file.delete());

//删除D://test,删除文件夹的时候只能删除空的文件夹
File file = new File("D://test");
System.out.println(file.delete());
}
}

注意事项：

A:Java程序的删除不走回收站。

B:如果目录内还有内容就不能删除。

1.5 判断功能

public boolean isDirectory():是否是目录
public boolean isFile():是否是文件
public boolean exists():是否存在
public boolean canRead():是否可读
public boolean canWrite():是否可写
public boolean isHidden():是否隐藏

package day12.edu_02;

import java.io.File;
import java.io.IOException;

public class FileDemo3 {
public static void main(String[] args) throws IOException {
File file = new File("D://a.txt");
System.out.println(file.createNewFile());

System.out.println("是否是目录:"+file.isDirectory());
System.out.println("是否是文件:"+file.isFile());
System.out.println("是否存在:"+file.exists());
System.out.println("是否可读:"+file.canRead());
System.out.println("是否可写:"+file.canWrite());
System.out.println("是否隐藏:"+file.isHidden());
}
}

1.6 获取功能

public String getAbsolutePath():获取绝对路径
public String getPath():获取相对路径
public String getName():获取名称

package day12.edu_02;

import java.io.File;
import java.io.IOException;

public class FileDemo4 {
public static void main(String[] args) throws IOException {
//创建一个文件
File file = new File("a.txt");
System.out.println(file.createNewFile());

//  public String getAbsolutePath():获取绝对路径
System.out.println(file.getAbsolutePath());

//public String getPath():获取相对路径
System.out.println(file.getPath());//a.txt

//public String getName():获取名称
System.out.println(file.getName());
}
}

二：字节流及字节高效流

2.1 I/O流的分类（画图）



IO流分类：

流向：
输入流
输出流

数据类型：
字节流
字节输入流
字节输出流
字符流
字符输入流
字符输出流

注意：一般我们在讨论IO的分类时，默认是按照数据类型分的。

字节流：

字节输入流       InputStream(抽象类)
字节输出流       OutputStream（抽象类）

字符流：

字符输入流       Reader
字符输出流       Writer

学习习惯：

字节流

字符流

2.2

需求：请用字节流往一个文本文件中写一句话：”helloworld”。

分析：
首先要知道是字节流
写数据我们就应该知道是字节输出流
所以最终选择了OutputStream
而OutputStream是抽象类，所以我们应该找其子类
文件这个单词是File，所以我们就大胆的猜测下：FileOutputStream存在否。

我们如何往一个文件写数据呢?

或者说就是字节输出流的操作步骤是什么呢?

* A:创建字节输出流对象

* B:调用写数据的方法

* C:释放资源

做法：

A： 两个构造的区别？

FileOutputStream(File file)

FileOutputStream(String name)

FileOutputStream fos = new FileOutputStream(“fos.txt”);

请问上面这个操作做了哪几件事情？

* 1.创建了一个文件输出流fos,指向文件a.txt

* 2.创建了a.txt这个文件

B： fos.write(“helloworld”.getBytes());

C: fos.close();关流

D： fos.write(“java”.getBytes());

package cokm.edu_01;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class OutputStreamDemo {
public static void main(String[] args) throws IOException {
/**
* 怎么使用文件输出流往文件中途写数据？
* 1.创建文件输出流对象
* 2.调用输出流对象的方法给文件中写数据
* 3.释放资源
*/
//public FileOutputStream(String name)
//public FileOutputStream(File file)
//创建文件输出流对象
FileOutputStream fos = new FileOutputStream("a.txt");

//public FileOutputStream(File file)
//File file = new File("a.txt");
//FileOutputStream fos = new FileOutputStream(file);

/**
* FileOutputStream fos = new FileOutputStream("a.txt");
* 做了那些事情？
* 1.创建fos对象指向文件a.txt
* 2.创建一个文件a.txt
*/

//调用输出流的写数据的方法给文件中写数据
//public void write(byte[] b)
byte[] byf = "helloworld".getBytes();
fos.write(byf);

//释放资源,关流操作
fos.close();

//关流之后，我们还能继续往文件中写数据码
//这样是不行的。。
//fos.write("java".getBytes());//java.io.IOException: Stream Closed

}
}

2.3

FileOutputStream写数据的方法

write(byte[] b)

write(int b) ：一次写一个字节

write(byte[] b, int off, int len) ：一次写一个字节数组的一部分

package cokm.edu_01;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class OutPutStreamDemo2 {
public static void main(String[] args) throws IOException {
/**
* 1.创建文件输出流对象，并关联指定文件
* 2.调用写书数据的方法，写书文件
* 3.关流
*/
//1.创建文件输出流对象，并关联指定文件
FileOutputStream fos = new FileOutputStream("b.txt");

//2.调用写书数据的方法，书写文件
//write(int b) ：一次写一个字节
//fos.write(97);

//write(byte[] b, int off, int len) ：一次写一个字节数组的一部分
byte[] byf = {97,98,99,100};
fos.write(byf, 1, 2);

//3.关流
fos.close();

}
}

2.4

字节输入流：

具体操作步骤：

字节输入流操作步骤：
A:创建字节输入流对象
FileInputStream  fis = new FileInputStream("a.txt");

B:调用方法读取数据
一次读取一个字节：read() -- 测试读取不到内容的时候的返回值（并且用循环改进）

C:释放资源
fis.close

package cokm.edu_02;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class InputStreamDmeo {
public static void main(String[] args) throws IOException {
//读取文件a.txt
//1.创建文件输入流对象，并关联文件
FileInputStream fis = new FileInputStream("a.txt");

//2.调用输入流的读取文件的方法，读取文件
//public int rea
fb8f
d() 一次读取一个字节
/*      System.out.println((char)fis.read());
System.out.println((char)fis.read());
System.out.println((char)fis.read());
System.out.println((char)fis.read());
System.out.println((char)fis.read());
System.out.println((char)fis.read());
System.out.println((char)fis.read());
System.out.println((char)fis.read());
System.out.println((char)fis.read());
System.out.println((char)fis.read());

System.out.println(fis.read());
System.out.println(fis.read());*/

int by;
while ((by=fis.read())!=-1) {
System.out.println((char)by);
}
//3.释放资源
fis.close();
}
}

练习：

A:把a.txt的内容复制到b.txt中

package cokm.edu_03;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyFile {
public static void main(String[] args) throws IOException {
//A:把a.txt的内容复制到b.txt中
//封装数据源和目的地
FileInputStream fis = new FileInputStream("OutputStreamDemo.java");
FileOutputStream fos = new FileOutputStream("c.java");

//2.读取数据源中的数据，将读取到的数据写入目的地中
int by;
while ((by=fis.read())!=-1) {
//System.out.println(by);
//将读取到的字节写入fos中
fos.write(by);
}

//释放资源
fos.close();
fis.close();
}
}

B:把d:\复制视频文件

package cokm.edu_03;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyMp4 {
public static void main(String[] args) throws IOException {
//1.封装数据源和目的地
FileInputStream fis = new FileInputStream("D://b.mp4");
FileOutputStream fos = new FileOutputStream("d.mp4");

//2.读取数据源，写如目的地
int by;
while ((by=fis.read())!=-1) {
fos.write(by);
}

//3.释放资源
fos.close();
fis.close();
}
}

数据源：

IODemo.java – 读取数据 – InputStream – FileInputStream – 一次读取一个字节

目的地：

Copy.java – 写出数据 – OutputStream – FileOutputStream – 一次写一个字节

2.5

字节输入流：

具体操作步骤：

字节输入流操作步骤：
A:创建字节输入流对象
FileInputStream  fis = new FileInputStream("a.txt");

B:调用方法读取数据（一次读取一个字节数组，提升效率）
一次读取一个字节数组： public int read(byte[] b):返回实际读取长度,数据被读取到数组中。
-- 测试方法返回长度？根据String类的构造方法构造字符串
C:释放资源
fis.close

package cokm.edu_04;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileInputStreamDemo {
public static void main(String[] args) throws IOException {
//读取a.txt中的文件
//1.创建文件输入流
FileInputStream fis = new FileInputStream("a.txt");

//一次读取一个字节数组
/*      byte[] bys= new byte[4];
System.out.println(fis.read(bys));//读取到的是字节数组的实际长度
System.out.println(fis.read(bys));
System.out.println(fis.read(bys));

System.out.println(fis.read(bys));*/

//创建一个字节数组，一般来说字节数组的长度都是1024或者1024的倍数
byte[] bys= new byte[1024];
int len;//实际读取到的长度
while ((len=fis.read(bys))!=-1) {
//只需要将实际读取到的长度转换为字符串就可以
System.out.println(new String(bys, 0, len));
}

//3.关流
fis.close();
}
}

（利用一次读写一个字节数组完成）

练习：

A:把a.txt的内容复制到b.txt中

package cokm.edu_04;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyFile {
public static void main(String[] args) throws IOException {
//A:把a.txt的内容复制到b.txt中
//1.封装数据源和目的地
FileInputStream fis = new FileInputStream("OutputStreamDemo.java");
FileOutputStream fos= new FileOutputStream("f.java");

//一次读写一个字节数组
byte[] byf = new byte[1024];
int len;
while ((len=fis.read(byf))!=-1) {
fos.write(byf, 0, len);
}

//3.关流
fos.close();
fis.close();
}
}

B:把d:\复制视频文件

package cokm.edu_04;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyMp4 {
public static void main(String[] args) throws IOException {
//一次读写一个字节数组
//1.封装数据源和目的地
FileInputStream fis = new FileInputStream("D://b.mp4");
FileOutputStream fos = new FileOutputStream("e.mp4");

//一次读写一个字节数组
byte[] bys =  new byte[1024];
int len;
while ((len=fis.read(bys))!=-1) {
//读取多少就给fos中写多少数据
fos.write(bys, 0, len);
}

//释放资源
fos.close();
fis.close();
}
}

2.6

字节缓冲区流（也叫高效流）：

BufferedInputStream(read() 一次读取一个字节, public int read(byte[] b):返回实际读取长度,数据被读取到数组中。)
BufferedOutputStream（write(byte[] b)）

流

低级流: 基本的流，可以直接操作文件。
高级流：是操作基本流的流。

package cokm.edu_05;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferedInputStreamDemo {
public static void main(String[] args) throws IOException {
//一次读取一个字节数组的时候，复制一个mp4文件
//疯转数据源和目的地
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D://b.mp4"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("j.mp4"));

//1.一次读写一个字节
/*      int by;
while ((by=bis.read())!=-1) {
bos.write(by);
}*/

//2.一次读写一个字节数组
byte[] byf = new byte[1024];
int len;
while ((len = bis.read(byf))!=-1) {
bos.write(byf, 0, len);
}

//3.关流
bos.close();
bis.close();

}
}

2.6

字节流复制文件（视频文件，并测试所用时间）：

A:基本字节流一次读写一个字节
B:基本字节流一次读写一个字节数组
C:高效字节流一次读写一个字节
D:高效字节流一次读写一个字节数组

获取时间的方法：

System.currentTimeMillis()

package cokm.edu_06;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test {
public static void main(String[] args) throws IOException {
//复制文件开始之前的时间
long startTime = System.currentTimeMillis();
//      method1();//A:基本字节流一次读写一个字节 15099
//      method2();// B:基本字节流一次读写一个字节数组  31(这种处理方案使用的是最多的)
//      method3();//C:高效字节流一次读写一个字节 234
method4();//D:高效字节流一次读写一个字节数组16
long endTime = System.currentTimeMillis();
System.out.println(endTime-startTime);
}

private static void method4() throws IOException {
// TODO Auto-generated method stub
//C:高效字节流一次读写一个字节
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D://b.mp4"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("a.mp4"));

//高效字节流一次读写一个字节
byte[] byf = new byte[1024];
int len;
while ((len = bis.read(byf))!=-1) {
bos.write(byf, 0, len);
}

//3.关流
bos.close();
bis.close();
}

private static void method3() throws IOException {
//C:高效字节流一次读写一个字节
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D://b.mp4"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("a.mp4"));

//高效字节流一次读写一个字节
int by;
while ((by = bis.read())!=-1) {
bos.write(by);
}

//3.关流
bos.close();
bis.close();

}

private static void method2() throws IOException {
// B:基本字节流一次读写一个字节数组
//封装数据源和目的地
FileInputStream fis = new FileInputStream("D://b.mp4");
FileOutputStream fos = new FileOutputStream("a.mp4");

//一次读写一个字节
byte[] byf =new byte[1024];
int len;
while ((len=fis.read(byf))!=-1) {
fos.write(byf, 0, len);
}

//3.释放资源
fos.close();
fis.close();
}

private static void method1() throws IOException {
//A:基本字节流一次读写一个字节
//疯转数据剧院和目的地
FileInputStream fis = new FileInputStream("D://b.mp4");
FileOutputStream fos = new FileOutputStream("a.mp4");

//一次读写一个字节
int by;
while ((by=fis.read())!=-1) {
fos.write(by);
}

//3.释放资源
fos.close();
fis.close();
}
}

三：编码问题？？（案例代码演示）

String中的编码和解码问题。

编码：

把我们能够看懂的字符转换为看不懂的数据

解码：

把我们看不懂的数据转换为看得懂的字符

举例：

电报/潜伏(余则成 深海)

编码表：
小本子，这个本子上记录了很多的汉字和对应的数据值。

延安：
今晚兴庆公园见

发报员：
今晚兴庆公园见
转换成数据
发送数据

余则成：
接收数据
记录完毕后，就找出小本子，通过对应的数据值找到对应的字符
今晚兴庆公园见

public byte[] getBytes(String charsetName) 按照给定的编码方式，编码字节数组（gbk,utf-8）

String(byte[] bytes, String charsetName) 按照给定的编码方式解码字符数组

String s = "中国好";
byte[] bytes = s.getBytes("utf-8");
System.out.println(Arrays.toString(bytes));

//String(byte[] bytes, String charsetName)
System.out.println(new String(bytes,"gbk"));

结论：用什么编码，就必须用什么解码。

package cokm.edu_07;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class EncodingDemo {
public static void main(String[] args) throws UnsupportedEncodingException {
//创建一个字符串
String s = "中国好";
//byte[] byf = s.getBytes();
//使用gbk去进行编码的时候，我们是将一个汉字编码成两个负数的字节。
//当我们解码的时候，如果字节数组中遇见负数的话，会将前面和后面的负数进行拼接，去gbk码表中找到相应的明文
//System.out.println(Arrays.toString(byf));

System.out.println("=---------------");
//byte[] bytes = s.getBytes("gbk");
//System.out.println(Arrays.toString(bytes));

System.out.println("------------");
byte[] bytes = s.getBytes("utf-8");
//当使用uft-8进行编码的时候，一个汉字会被编码成3个负数的字节
//解码的时候，一旦遇见负数，三个拼接，去码表中进行解码
System.out.println(Arrays.toString(bytes));

System.out.println("--------------");
System.out.println(new String(bytes));//涓浗濂?
System.out.println(new String(bytes, "utf-8"));//中国好

//结论：咱们以后使用哪种编码就使用哪种解码(编解码方式必须一致，不然会出现乱码)
//我们以后编解码方式一般来说不需要指定特定的码表，一般来说使用默认的就可以

}
}