文件：
- 文件构造器：
public static void main(String[] args) throws UnknownHostException { //文件的构造器是用来创建对象的，我们创建文件对象的时候要保证文件路径正确 File file = new File("E:\\test.txt"); System.out.println(file.getName()); // java 中的 File 类的对象可以代表目录,也可以代表文件 File file2 = new File("E:\\aa"); System.out.println(file2.getName()); File file1 = new File("E:\\aa","青城.txt"); System.out.println(file1.getName()); //根据目录的文件对象创建一个文件 File file3 = new File(file2,"青城.txt"); System.out.println(file3.getName()); } - 创建文件：
public static void main(String[] args) throws IOException { //初始化创建文件的路径和名称 ---> 注意：文件的路径要正确 File file = new File("E:\\aa\\博雅.txt"); //创建一个文件 boolean newFile = file.createNewFile(); System.out.println(newFile); //创建目录,目录对象上一层的路径必须正确 File file1 = new File("E:\\aa\\bb"); boolean mkdir = file1.mkdir(); System.out.println(mkdir); //创建多级目录,上一层路径必须正确 File file2 = new File("E:\\aa\\bb\\cc\\dd"); boolean mkdirs = file2.mkdirs(); System.out.println(mkdirs); } - 文件的删除：
public static void main(String[] args) throws IOException { //删除路径的最后一层,只有空目录才能被删除 File file = new File("E:\\aa\\bb\\cc\\dd"); //程序删除不走回收站 boolean del = file.delete(); System.out.println(del); } - 文件的判断：
public static void main(String[] args) throws IOException { File file = new File("E:\\aa"); //判断文件是否存在 boolean exists = file.exists(); System.out.println(exists); //判断这个文件对象是否是文件 boolean isFile = file.isFile(); System.out.println("该文件是否是文件:" + isFile); //判断这个文件对象是否是目录 boolean isDir = file.isDirectory(); System.out.println("文件对象是否是目录:" + isDir); //判断一个文件是否是绝对路径 boolean absolute = file.isAbsolute(); System.out.println("该文件是否是绝对路径:" + absolute); File file1 = new File("E:\\aa\\博雅.txt"); //判断文件是否是可读 boolean read = file1.canRead(); System.out.println("文件是否可读:" + read); //判断文件是否可写 boolean write = file1.canWrite(); System.out.println("该文件是否可写:" + write); //判断文件是否是隐藏状态 boolean isHidden = file1.isHidden(); System.out.println("该文件是否隐藏:" + isHidden); } - 文件的获取功能：
public static void main(String[] args) throws IOException { //获取磁盘的根目录 File[] files = File.listRoots(); System.out.println(Arrays.toString(files)); //获取一个目录下的子文件对象 File file = new File("E:\\aa"); //获得 E:\aa 下的子文件对象 File[] files1 = file.listFiles(); for (File f : files1){ System.out.println(f); } //获得的子文件的名字 String[] list = file.list(); System.out.println(Arrays.toString(list)); } - 练习：递归查询文件的内部所有文件
//定义一个文件的目录层级 static int level; public static void main(String[] args) throws IOException { //创建一个目录 File file = new File("E:\\aa"); //调用方法查询内部所有文件 parseFile(file); } private static void parseFile(File file) { //编写递归结束条件 if(file == null || !file.exists()){ return; } //如果有文件,把层级 加一 level++; //获得文件对象的子对象 File[] files = file.listFiles(); //遍历子文件 for(File f : files){ //打印层级的缩进 for (int i = 0; i < level; i++) { System.out.print("\t"); } //打印文件 System.out.println(f.getName()); //判断子文件是否是目录,如果为目录继续向下递归 if(f.isDirectory()){ //递归方式查找子文件 parseFile(f); } } //本层递归完毕层级需 -- ,把层级减回来 level--; } - 练习：如何删除一个文件夹下所有的文件，不包括目录
public static void main(String[] args) throws IOException { //创建一个目录 File file = new File("E:\\aa"); //调用方法查询内部所有文件 parseFile(file); } public static void parseFile(File file){ //递归结束条件 if(file == null || !file.exists()){ return; } //获取文件对象的所有子文件对象 File[] files = file.listFiles(); //遍历所有子对象 for(File f : files){ //子文件为文件夹时继续向下递归 否则删除 if(f.isDirectory()){ parseFile(f); } //该子文件不为 文件夹,删除该文件 f.delete(); } //删除空文件夹 file.delete(); }
递归：
- 递归本质就是自己调用自己
- 注意：递归的结束条件
-
public static void main(String[] args) throws IOException { /** * 5! = 5*4! * 4! = 4*3! * 3! = 3*2! * 2! = 2*1! * 1! = 1 * * fn(num) = num * fn(num - 1); * */ int result = fn(5); System.out.println("5的阶乘为:" + result); } public static int fn(int num){ int result = 0; //当数值大于 1 的时候进行递归相乘法 if(num > 1){ result = num * fn(num-1); } //当 num 为 1 的时候不需要再进行递归 return result; }
IO流：
-
概述：
- IO(input / output)：输入和输出，指的是某个设备或环境进行数据的输入或者输出。例如：键盘的输入和显示器的输出图像
- 对于 Java 来说输出问题， Java 将它抽象成流对象来解决
-
流的分类：
- IO 流在 java 中从输入输出角度分类：
- 输入流
- 输出流
- IO 流在 java 中从数据的角度来分类：
- 字符流：文本，我们能读的都可以认为是字符流。比如：文章，java 文件等
- 字符输入流的超类：
- Reader --- 子类：FileReader，BufferReader
- 字符输出流的超类：
- Writer：子类 FileWriter，BufferWriter
- 字符输入流的超类：
- 字节流：二进制的数据，这种数据一般用文本打开我们读不懂。比如：图片文件，MP3等
- 字节流输入的超类：
- InputStream --- 子类为：FileInputStream
- 字节流输出的超类：
- OutputStream --- 子类为：FileOutputStream
- 字节流输入的超类：
- 字符流：文本，我们能读的都可以认为是字符流。比如：文章，java 文件等
- IO 流在 java 中从输入输出角度分类：
-
案例：
- 使用字符流向一个文件输入 "helloworld"
- 步骤：
- 创建文件
- 创建输出流对象
- 把流指向指定的文件
- 释放资源
public static void main(String[] args) { //创建一个文件 File file = new File("E:\\aaa\\text.txt"); Writer writer = null; try { //IO 流是需要关闭的,如果不这样设计就不能关闭资源 writer = new FileWriter(file); writer.write("HelloWorld!!!"); } catch (IOException e) { e.printStackTrace(); }finally { //判断 writer 不是空,防止空指针异常 if(writer != null){ try{ writer.close(); }catch (Exception e){ e.printStackTrace(); } } } }
- 步骤：
- 文件的追加：
public static void main(String[] args) { //创建一个文件 File file = new File("E:\\aaa\\text.txt"); Writer writer = null; try { //IO 流是需要关闭的,如果不这样设计就不能关闭资源 //后面加入 true 表示,向文本后追加字符串 writer = new FileWriter(file,true); writer.write("HelloWorld!!!"); } catch (IOException e) { e.printStackTrace(); }finally { //判断 writer 不是空,防止空指针异常 if(writer != null){ try{ writer.close(); }catch (Exception e){ e.printStackTrace(); } } } - 换行输入：
- 换行符：把文本写入文件中 \n 代表换行
- Windows：\r\n
- Linux：\n
- Mac：\r
public static void main(String[] args) { //创建一个文件 File file = new File("E:\\aaa\\text.txt"); Writer writer = null; try { //IO 流是需要关闭的,如果不这样设计就不能关闭资源 //后面加入 true 表示,向文本后追加字符串 writer = new FileWriter(file,true); for (int i = 0; i < 10; i++) { writer.write("Hello Word!!!!!!!\r\n"); //当写入五次后,做一次 flush,将文本写入文件中 if(i % 5 == 0 ){ writer.flush(); } } } catch (IOException e) { e.printStackTrace(); }finally { //判断 writer 不是空,防止空指针异常 if(writer != null){ try{ writer.close(); }catch (Exception e){ e.printStackTrace(); } } } }
- Wirter的五种写法：
public static void main(String[] args) { //创建一个文件 File file = new File("E:\\aaa\\text.txt"); Writer writer = null; try { //IO 流是需要关闭的,如果不这样设计就不能关闭资源 //后面加入 true 表示,向文本后追加字符串 writer = new FileWriter(file,true); //定义一个数组 char[] chars = {'H','e','l','l','o'}; //将数组中的元素全部写入 writer.write(chars); //把数组中的一部分写入 //从下标 2 开始,向后写入 2 个字符 writer.write(chars,2,2); //输入第九十三个字符 writer.write(97); //从字符串中选取字符写入 //从下标 2 开始,向后写入 3 个字符 writer.write("helloword",2,3); } catch (IOException e) { e.printStackTrace(); }finally { //判断 writer 不是空,防止空指针异常 if(writer != null){ try{ writer.close(); }catch (Exception e){ e.printStackTrace(); } } } }
- 使用字符流向一个文件输入 "helloworld"
-
字符流转向字节路的桥梁：
- GBK编码
public static void main(String[] args) throws IOException { //创建字符流转换字节流桥梁的对象 OutputStreamWriter outputStreamWriter = null; try { //字节流通向字节流的桥梁可以指定存储编码 outputStreamWriter = new OutputStreamWriter(new FileOutputStream("1.txt"),"GBK"); outputStreamWriter.write("中"); outputStreamWriter.flush(); }catch (Exception e){ e.printStackTrace(); }finally { try { if(outputStreamWriter != null){ outputStreamWriter.close(); } }catch (Exception e){ e.printStackTrace(); } } } - UTF-8编码：略
- GBK编码
-
Properties：
- 定义：
- Properties 类表示了一个持久的属性集
- Properties 可以保存在流中或从流中加载
- 属性列表中每个键及其对应的值都是一个字符串
- 特点：
- 继承于 HashTable，线程安全的键值对存储结构
- Properties 可保存在流中或从流中加载
- 只能保存 字符串 的键值对
- 实战应用：
public static void main(String[] args) throws IOException { //创建一个 Properties 对象 Properties properties = new Properties(); InputStream in = null; try { in = Test.class.getClassLoader().getResourceAsStream("names.properties"); //从字节流中来加载数据到属性对象中 properties.load(in); System.out.println(properties); }catch (Exception e){ e.printStackTrace(); }finally { if(in != null){ try { in.close(); }catch (Exception e){ e.printStackTrace(); } } } }
- 定义：
-
序列化流：
- 对象流出流：
- ObjectOutputStream：将 Java 对象写入 OutputStream
- 对象输入流：
- ObjectInputStream：对以前使用 ObjectOutputStream 写入得对象进行反序列化
- ObjectOutputStream：
- 我们需要序列化的对象需要实现序列化接口
- 实体类实现序列化接口
- 我们需要序列化的对象需要实现序列化接口
- 我们一般会提供一个 serialVersionUID
- 某个类序列化之后，如果发生了，那么依然可以反序列化
- 如果要是多个对象来做序列化，一定要放到集合中
-
字符编码：
- 存储：
- 在计算机中存储字符都是存储的字符所对应的数值以二进制的形式表示
- 展示：
- 获取相关的编码表中去查找改值(存储的值)所对应的字符
- Ascii
a : 97 b : 98 c : 99 ······ - GBK：用于存储中文的码表
中 [-42,-48] s.getBytes(); - UTF-8：最大的一张码表包含了所有的字符标准
中 [-28,-72,-83] - 用什么编码，就要用什么解码
- 存储：
- 对象流出流：
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
