学习大数据，所必需的java基础（7）

本文主要是介绍学习大数据，所必需的java基础（7），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

File类

计算机常识：
1.什么叫做文本文档
能够记事本打开，人能看懂的文件：txt，java，html
2.电脑硬盘上存储的东西由什么构成：文件和文件夹
3.以.jpg结尾一定是图片吗？ 不一定
4.E:\Idea\io\1.jpg其中1.jpg的父路径 E:\Idea\io
5.路径分割符(一个路径和其他路径之间的分隔符)：路径名称分割符（一个路径中文件夹和文件夹名称或者文件名称之间的分隔符）
6.IO流中的英语单词
文件 file
文件夹：directory
输出：output
输入：input
写: write
读：read
file类概述：文件和目录路径名的抽象表示形式
简单理解：创建file对象，知名要操作的文件或者文件夹的路径
就可以根据路径找到该文件夹或者文件，就可以调用file中的方法，去操作文件或者文件夹

File 的静态成员

static String pathSeparator：与系统有关的路径分隔符
static String separator：与系统有关的默认名称分隔符

public class test04_file {public static void main(String[] args) {//与系统有关的路径分隔符File.pathSeparatorSystem.out.println(File.pathSeparator);//与系统有古纳的默认路径分隔符System.out.println(File.separator);}
}

如何用字符串正确的描述一个文件的路径

import java.io.File;public class test05 {public static void main(String[] args) {String path1 = "E:\\abc\\hh\\hhe";System.out.println(path1);/** 将来写代码要做到：一次编写，到处运行* 开发用这种方式* 练习时可以写死* */String path2 = "E:" + File.separator + "abc" + File.separator + "hhe";System.out.println(path2);}
}

File的构造方法

File(String parent, String child) -> 根据所填写的路径创建File对象
parent:父路径
child:子路径
File(File parent, String child) -> 根据所填写的路径创建File对象
parent:父路径->File对象
child:子路径
File(String pathname) -> 根据所填写的路径创建File对象
字符串的路径

public class test06 {public static void main(String[] args) {
//        File(String parent, String child) -> 根据所填写的路径创建File对象
//        parent:父路径
//        child:子路径File file1 = new File("E:\\Idea\\io","1.jpg");System.out.println(file1);
//        File(File parent, String child) -> 根据所填写的路径创建File对象
//        parent:父路径->File对象
//        child:子路径final File parent = new File("E:\\Idea\\io");final File file2 = new File(parent + "1.jpg");System.out.println(file2);
//        File(String pathname) -> 根据所填写的路径创建File对象
//                字符串的路径final File file = new File("E:\\Idea\\io2");System.out.println(file);}
}

创建FIle对象时指定的路径可以不存在，但是写不存在的路径没什么意义

File的获取方法

• public String getAbsolutePath() ：返回此File的绝对路径名字符串。->带盘符的路径
• public String getPath() ：将此File转换为路径名字符串。-> 获取的是File的封装路径
  new File的时候,传递的是啥路径,getPath方法就获取的是啥路径
• public String getName() ：返回由此File表示的文件或目录的名称。
• public long length() ：返回由此File表示的文件的长度。->文件的字节数
• public File getParentFile()返回由此File表示的文件或目录的父目录，如果没有父目录，返回null。

public class test07 {public static void main(String[] args) {final File file = new File("E:\\idea\\io\\li.jpg");
//        - public String getAbsolutePath() ：返回此File的绝对路径名字符串。->带盘符的路径final File absoluteFile = file.getAbsoluteFile();System.out.println(absoluteFile);
//        - public String getPath() ：将此File转换为路径名字符串。-> 获取的是File的封装路径
//        new File的时候,传递的是啥路径,getPath方法就获取的是啥路径System.out.println(file.getPath());
//        - public String getName()  ：返回由此File表示的文件或目录的名称。System.out.println(file.getName());
//        - public long length()  ：返回由此File表示的文件的长度。->文件的字节数System.out.println(file.length());
//        - public File getParentFile()返回由此File表示的文件或目录的父目录，如果没有父目录，返回null。System.out.println(file.getParentFile());}
}

相对路径和绝对路径

1.绝对路径：从网符开始写的路径 ---- 如果跨盘符访问
2.相对路径：不从盘符开始写 — 同一个盘符中访问

3.在idea中相对路径怎么写
a.需要先找一个参照路径：当前project的绝对路径
b.谁是参照路径，就可以省略谁，剩下的就是相对类路径的写法
4.比如：day18 map这个模块下有一个io文件夹，io文件夹下有一个1.txrt，1.txt的相对路径咋写
a.找绝对路径:E:\Idea\idea2019\workspace\220905_bigdata\day18_map\io\1.txt
b.找参照路径:E:\Idea\idea2019\workspace\220905_bigdata
c.将参照路径干掉: day18_map\io\1.txt
说白了就是从模块名开始写
5.注意
如果相对路径不写module名称，那么默认位置在当前projrct下，不在moudle下了

File的创建方法

boolean createNewFile() -> 创建新文件
如果指定的文件之前有,创建失败,返回false
如果指定的文件之前没有,创建成功,返回true
boolean mkdirs() -> 既可以创建单级文件夹,还可以创建多级文件夹
如果指定的文件夹之前有,创建失败,返回false
如果指定的文件夹之前没有,创建成功,返回true

public class test08 {public static void main(String[] args) throws IOException {final File file = new File("D:\\1.txt");//创建新文件，如果之前有则返回false，没有返回trueSystem.out.println(file.createNewFile());//boolean mkdits  既可以创建单级文件夹，还可以创建多级文件夹//如果之前存在则返回false创建失败，否则返回true、final File file1 = new File("D:\\Ajava\\exc");System.out.println(file1.mkdirs());}
}

File类中的删除方法

boolean delete() 删除文件或者文件夹 ---- 不走回收站
注意 删除文件夹时，要求文件夹是空的

        final File file = new File("D:\\1.txt");System.out.println(file.delete());

File的遍历方法

1.String[] list() ---- 遍历指定的文件夹，返回的是String数组
2.File[] listFiles() ----- 遍历指定的文件夹，返回的是file数组
listFiles（） 方法底层是list() 将list方法获取到的文件或者文件夹封装到FIle对象中，再将对象放到file数组中，最终返回file数组

public class test09 {public static void main(String[] args) {final File file = new File("D:\\A3驱动");//遍历指定的文件夹，返回的是String的数组
/*        String[] list = file.list();for (String s : list) {System.out.println(s);}*///遍历指定的文件夹，返回的是file数组File[] files = file.listFiles();for (File file1 : files) {System.out.println(files);}}
}

字节流

IO流介绍以及输入输出以及流向的介绍

1. I：Input 输入
   O：Output 输出
2. IO流：将一个数据从一个设备上传输的到另一个设备上的技术
3. 为啥要学IO流？
   之前我们学过数组和集合，用于存储数据，但是数组和集合都是临时存储的，后面我们要用数据的话，就没了
   所以我们就想，将数据永久保存起来，可以保存到硬盘的文件中
   而我们学的IO流可以将数据保存到硬盘上的文件中，后续使用的话可以从文件中读出来使用

IO流的流向

1.输出：将数据从内存中写到硬盘上 ----- write
2.输入：将数据从硬盘上读到内存中 ----- read

IO流分类

1.字节流：一切皆字节，万能流
字节输出流：OutputStream 父类
字节输入流：InputStream 父类
2.字符流： 专门操作文本文档的
a.文本文档：用记事本打开，人能够看懂的文档
字符输出流：Writer 父类
字节输入流：Reader 父类
3.我们将要学以下几个流：
FileOutputStream//字节输出流
FileInputStream//字节输入流
FileWriter//字符输出流
FileReader//字符输入流
BufferedOutputStream//字节缓冲输出
BufferedInputStream//字节缓冲输入
BufferedWriter//字符缓冲输出
BufferedReader//字符缓冲输入
OutputStreamWriter
InputStreamReader
PrintStream
ObjectOutputStream
ObjectInputStream
扩展:Commons-IO

IO流分类 OutputStream中的子类FileOutoutStream的介绍以及方法的简单介绍

1.概述：OutputStream(抽象类)
2.子类：FileOutputStream输出流对象
3.作用：将数据从内存中写到硬盘上
4.构造：
FileOutputStream(File path)
FileOutput(String path)
5.方法
void write(int b) 一次写一个字节
void write(byte[] b) 一次写一个字节数组
void write(byte[] b, int off, int len)一次写一个字节数组一部分
b:要操作的数组
off:从数组的哪个索引位置开始写
len:写多少个
void close()->关流
6.注意：如果指定的文件不存在，输出流会自动创建

public class test10 {public static void main(String[] args) throws IOException {final File file = new File("D:\\Ajava\\output.txt");final FileOutputStream fileOutputStream = new FileOutputStream(file);//一次写一个字节fileOutputStream.write(98);//fileOutputStream.close();//一次写一个字节数组byte[] bytes = {97,98,99,100};fileOutputStream.write(bytes);//fileOutputStream.close();//一次写一个数组的一部分,从哪一个开始写，写多长fileOutputStream.write(bytes,2,2);//fileOutputStream.close();//写中文fileOutputStream.write("李云龙".getBytes(StandardCharsets.UTF_8));fileOutputStream.close();}
}

1.注意：FileOutputStream默认情况下，每次运行都会创建一个新的文件
覆盖老文件，然后将在写入的内容放到新文件中
2.续写追加
FileOutputStream(String name, boolean append) append:true 则不会副高老文件，会继续直接续写追加的内容
3.换行
\r \n window系统换行符

public class test01 {public static void main(String[] args) throws IOException {final File file = new File("D:\\Ajava\\output1.txt");final FileOutputStream fileOutputStream = new FileOutputStream(file);fileOutputStream.write("古藤老树昏鸦，\r\n".getBytes(StandardCharsets.UTF_8));fileOutputStream.write("小桥流水人家，\r\n".getBytes(StandardCharsets.UTF_8));fileOutputStream.write("古道西风瘦马，\r\n".getBytes(StandardCharsets.UTF_8));fileOutputStream.write("夕阳西下，断肠人在天涯！\r\n".getBytes(StandardCharsets.UTF_8));fileOutputStream.close();}
}

InputStream子类[fileInputStream]的介绍以及方法的使用

1.概述 InputStream 抽象类
2.子类 FileInputStream
3.作用 将数据从硬盘上读到内存中
4.构造：
FileInputStream(File file)
FileInputStream(String path)
5.方法：
int read() ----- 一次读取一个字节，返回的是读取的那个字节
int read(byte[] b) 一次读取一个字节数组，返回的是读取的个数
int read(byte[] b, int off, int len) 一次读取一个字节数组一部分，返回的是读取的个数
b:要读取的数组
off 从数组数组的哪个字节开始读
len：读多少个
void close() 关流

一次读取一个字节

public class test02 {public static void main(String[] args) throws IOException {final File file = new File("D:\\Ajava\\output.txt");final FileInputStream fileInputStream = new FileInputStream(file);int read01 = fileInputStream.read();System.out.println("read01 = " + read01);int read02 = fileInputStream.read();System.out.println("read01 = " + read02);int read03 = fileInputStream.read();System.out.println("read01 = " + read03);int read04 = fileInputStream.read();System.out.println("read01 = " + read04);int a ;while ((a = fileInputStream.read())!=-1){System.out.println(a);}fileInputStream.close();}
}

注意：
1.不要判断的时候read一次，输出的时候再read一次，否则输出结果会跳着输出
2.不要读完之后，再重新读了，因为读不出来了
3.如果流被关闭了，流就不能再使用了

一次读取一个字节数组

int read(byte[] b)一次读取一个字节数组，返回的是读取的个数
首先定义一个数组，此数组是一个临时存储空间，读取的内容先保存到数组中，从数组中获取
将来我们不知道文件中存储了多少内容，所以byte数组长度无法定义
所以我们一般长度都指定1024或者其倍数

public class test03 {public static void main(String[] args) throws IOException {final File file = new File("D:\\Ajava\\output.txt");final FileInputStream fileInputStream = new FileInputStream(file);//注意数组长度为几，就读取几个byte[] bytes =new byte[4];//System.out.println("fileInputStream.read() = " + fileInputStream.read());//int read() 返回的是读取的个数int num = fileInputStream.read(bytes);System.out.println(num);//读取数组中的内容System.out.println(new String(bytes,0,num));int len;while ((len = fileInputStream.read(bytes))!=-1){System.out.println(new String(bytes,0,len));}fileInputStream.close();}
}

字节流实现图片复制代码实现

public class test04 {public static void main(String[] args) throws IOException {final File file = new File("C:\\Users\\94863\\Pictures\\Saved Pictures\\huahua.jpg");final File file1 = new File("C:\\Users\\94863\\Pictures\\Saved Pictures\\xiaohua.jpg");final FileInputStream fileInputStream = new FileInputStream(file);final FileOutputStream fileOutputStream = new FileOutputStream(file1);final byte[] bytes = new byte[1024];//final int read = fileInputStream.read(bytes);int read;//边读边写while ((read = fileInputStream.read(bytes))!=-1){fileOutputStream.write(bytes,0,read);}//关流fileInputStream.close();fileOutputStream.close();}
}

字符流

字节读取中文的问题

1.中文在不同的编码表中，所在字节不一样
GBK：一个中文占两个字节
UTF-8：一个中文占3个字节
2.注意：
字节流确实是万能的（万能流侧重值得是文件复制），但是不要边读边看（边读边输出）

FileReader的介绍以及使用

字符流：主要操作文本文档 ---- Reader抽象类
子类：FileReader
作用：读文本文档中的内容
构造：
FileReader(File file)
FileReader(String path)
方法
int read() --------- 一次读取一个字符，返回的是字符编码
int read(char[] cbuf) ---------- 一次读取一个字符数组，返回读取的个数
int read(char[] cbuf, int off, int len) ------ 一次读取一个字符数组一部分，返回读取的个数
void close — 关流

public class test05 {public static void main(String[] args) throws IOException {final File file = new File("D:\\Ajava\\output1.txt");final FileReader fileReader = new FileReader(file);System.out.println((char) fileReader.read());System.out.println((char) fileReader.read());System.out.println((char) fileReader.read());System.out.println((char) fileReader.read());int char1;while((char1 = fileReader.read())!=-1){System.out.print((char) char1);}fileReader.close();}
}

public class test06 {public static void main(String[] args) throws IOException {final File file = new File("D:\\Ajava\\output1.txt");final FileReader fileReader = new FileReader(file);char[] chars = new char[2];int len;while ((len = fileReader.read(chars))!=-1){System.out.println(new String(chars,0,len));}}
}

FileWriter的介绍以及使用

1.字符输出流：Write(抽象类)
2.子类 FileWriter ---- 指定的文件如果不存在，自动创建
3.作用 将数据从内存中写到硬盘上
4.构造
FileWriter(File file)
FileWriter(String path)
FileWriter(String path, boolean append) ----- 追加续写
5.方法
void write(int c)
void write(char[] cbuf)
void write(char[] cbuf, int off, int len)
void write(String str)
void close()
void flush() -> 将数据从缓冲区中刷新到文件中
6.注意：
字符输出流底层自带缓冲区，我们要写的数据需要先存到缓冲区，然后再从缓冲区中将数据刷到文件中

public class test08 {public static void main(String[] args) throws IOException {final File file = new File("D:\\Ajava\\writer.txt");final FileWriter fileWriter = new FileWriter(file);fileWriter.write("两只黄鹂鸣翠");fileWriter.flush();fileWriter.close();method();}public static void method() throws IOException {final File file = new File("D:\\Ajava\\writer1.txt");//在源文件后面追加final FileWriter fileWriter = new FileWriter(file,true);fileWriter.write("两只黄鹂鸣翠柳");fileWriter.write("\r\n");fileWriter.write("一行白鹭上青天");fileWriter.close();}
}

FileWriter的刷新功能和关闭功能

flush() 只有刷新效果，但是关闭不了流对象，如果使用FileWriter写数据，但是不想关闭流，只需要调用flush
close() 先刷新，后关闭，如果想直接关闭，直接close即可

IO异常处理的方式

相应的代码块

public class text09 {public static void main(String[] args) {FileWriter fw = null;try {fw =new FileWriter("D:\\Ajava\\wri.txt");fw.write("123");} catch (IOException e) {e.printStackTrace();}finally {/** 如果fw不等于null，证明new出来了* 所以我们需要close* 否则就不用关了* */}if (fw!=null){try {fw.close();} catch (IOException e) {e.printStackTrace();}}}
}

字节缓冲流

缓冲流和突通流有啥区别
1.缓冲流自带缓冲区（长度为8192的数组），读写的数据都会进入到缓冲区中，读写操作时缓冲区之间读写
2.缓冲流都是缓冲区之间的读和写，也就是说读写操作是在内存中完成的，而普通流读写都是直接和系统打交道的
所以缓冲流读写操作要比普通流要快
3.普通流读写操作read和write方法本地方法

为啥要学缓冲流：读写速度快 （读和写是在内存中完成的，还不是本地方法）

1.BufferedOutputStream — 字节缓冲输出流
BufferedOutputStream(OutputStream out) OutputStream — 抽象类，传递子类对象FileOutStream
2.BufferedInputStream(InputStream in) InputStream ---- 抽象类，传递子类对象FileInputStream

3.用法和FileOutStream以及FileInputStream一模一样

我们通过将图片移动到另一个为位置来比较普通流和缓冲流之间的运行速递
相关代码

public class test10 {public static void main(String[] args) throws IOException {//method();method01();}public static void method() throws IOException {final long start = System.currentTimeMillis();final File file = new File("C:\\Users\\94863\\Pictures\\Saved Pictures\\huahua.jpg");final File file1 = new File("C:\\Users\\94863\\Pictures\\Camera Roll\\huahua.jpg");final FileInputStream fileInputStream = new FileInputStream(file);final FileOutputStream fileOutputStream = new FileOutputStream(file1);byte[] bytes = new byte[1024];int num;while ((num = fileInputStream.read(bytes))!= -1){fileOutputStream.write(bytes,0,num);}final long end = System.currentTimeMillis();System.out.println(end-start);fileInputStream.close();fileOutputStream.close();}public static void method01() throws IOException {long start = System.currentTimeMillis();final File file = new File("C:\\Users\\94863\\Pictures\\Saved Pictures\\huahua.jpg");final File file1 = new File("C:\\Users\\94863\\Pictures\\Camera Roll\\huahua.jpg");//1。创建一个FileInputStream用于读取本地上的照片final FileInputStream fileInputStream = new FileInputStream(file);final BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);//创建一个FileOutputStream用于将本地上的图片写到指定的位置final FileOutputStream fileOutputStream = new FileOutputStream(file1);final BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);//边读边写byte[] bytes = new byte[1024];int num;while((num = bufferedInputStream.read(bytes))!=-1){bufferedOutputStream.write(bytes,0,num);}final long end = System.currentTimeMillis();System.out.println(end-start);}//关流bufferedInputStream.close();bufferedOutputStream.close();
}

这篇关于学习大数据，所必需的java基础（7）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---