2 Day12--IO1

最新推荐文章于 2023-11-22 20:22:51 发布

abu1216

最新推荐文章于 2023-11-22 20:22:51 发布

阅读量119

点赞数

本文链接：https://blog.csdn.net/abu1216/article/details/110353077

版权

2.1 BigDecimal/BigInteger

2.1.1 概述

BigDecimal：常用来解决精确的浮点数运算。

BigInteger：常用来解决超大的整数运算。

2.1.3 常用方法

add(BigDecimal bd)：做加法运算

substract(BigDecimal bd) ：做减法运算

multiply(BigDecimal bd) ：做乘法运算

divide(BigDecimal bd) ：做除法运算

divide(BigDecimal bd,保留位数,舍入方式)：除不尽时使用

setScale(保留位数，舍入方式)：同上

pow(int n)：求数据的几次幂

2.1.4 练习1：测试常用方法

接收用户输入的两个数字，做运算。

package seday11;

import java.math.BigDecimal;

import java.util.Scanner;

public class Test2_BigD {

public static void main(String[] args) {

double a = new Scanner(System.in).nextDouble();

double b = new Scanner(System.in).nextDouble();

System.out.println(a+b);

System.out.println(a-b);

System.out.println(a*b);

System.out.println(a/b);//不精确

System.out.println(“===上面的除法不精确===”);

BigDecimal bd1 = BigDecimal.valueOf(a);

BigDecimal bd2 = BigDecimal.valueOf(b);

BigDecimal bd3;

bd3=bd1.add(bd2);

System.out.println(bd3.doubleValue());

bd3=bd1.subtract(bd2);

System.out.println(bd3.doubleValue());

bd3=bd1.multiply(bd2);

System.out.println(bd3.doubleValue());

// bd3=bd1.divide(bd2);//报错除不尽

//保留位数和舍入方式

bd3=bd1.divide(bd2,5,BigDecimal.ROUND_HALF_UP);

bd3=bd3.setScale(2, BigDecimal.ROUND_HALF_UP);//保留两位

System.out.println(bd3.doubleValue());

}

2.2 IO简介

2.2.1 继承结构

in/out相对于程序而言的输入(读取)和输出(写出)的过程。

在Java中，根据处理的数据单位不同，分为字节流和字符流

java.io包：

File

字节流：针对二进制文件

InputStream

--FileInputStream

--BufferedInputStream

--ObjectInputStream

OutputStream

--FileOutputStream

--BufferedOutputStream

--ObjectOutputStream

字符流：针对文本文件。读写容易发生乱码现象，在读写时最好指定编码集为utf-8

Writer

--BufferedWriter

--OutputStreamWriter

Reader

--BufferedReader

--InputStreamReader

--PrintWriter/PrintStream

2.2.2 流的概念

数据的读写抽象成数据，在管道中流动。

Ø 流只能单方向流动

Ø 输入流用来读取in

Ø 输出流用来写出Out

Ø 数据只能从头到尾顺序的读写一次

2.3 File文件流

2.3.1 概述

封装一个磁盘路径字符串，对这个路径可以执行一次操作。

可以用来封装文件路径、文件夹路径、不存在的路径。

2.3.2 创建对象

File(String pathname)

通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。

2.3.3 常用方法

文件、文件夹属性

length()：文件的字节量

exists()：是否存在，存在返回true

isFile()：是否为文件，是文件返回true

isDirectory()：是否为文件夹，是文件夹返回true

getName()：获取文件/文件夹名

getParent()：获取父文件夹的路径

getAbsolutePath()：获取文件的完整路径

创建、删除

createNewFile()：新建文件，文件夹不存在会异常，文件已经存在返回false

mkdirs()：新建多层不存在的文件夹\a\b\c

mkdir()：新建单层不存在的文件夹\a

delete()：删除文件，删除空文件夹

文件夹列表

list()：返回String[]，包含文件名

listFiles()：返回File[]，包含文件对象

2.3.4 练习1：测试常用方法

创建day10工程

创建cn.tedu.io包

创建Test1.java

package cn.tedu.io;

import java.io.File;

import java.io.IOException;

import java.util.Arrays;

import org.junit.Test;

//测试文件类

public class Test1_File {

//Junit单元测试方法：

//@Test + public + void + 没有参数

@Test

public void show() throws IOException {

//1，创建File对象，读取了指定位置的文件

File f = new File("D:\\teach\\a");

//文件夹列表list() listFiles()

String[] names = f.list();

System.out.println(Arrays.toString(names));

File[] files = f.listFiles();//推荐，更常见

System.out.println(Arrays.toString(files));

//TODO常用方法

System.out.println(f.createNewFile());//新建文件，文件夹不存在会异常，文件已经存在返回false

System.out.println(f.mkdir());//新建单层不存在的文件夹

System.out.println(f.mkdirs());//新建多层不存在的文件夹

System.out.println(f.delete());//删除文件，删除空文件夹

System.out.println();

System.out.println(f.length());//文件的字节量

System.out.println(f.exists());//是否存在，存在返回true

System.out.println(f.isFile());//是否为文件，是文件返回true

System.out.println(f.isDirectory());//是否为文件夹，是文件夹返回true

System.out.println(f.getName());//获取文件/文件夹名

System.out.println(f.getParent());//获取父文件夹的路径

System.out.println(f.getAbsolutePath());//获取文件的完整路径

}

2.3.5 练习2：递归求目录总大小

递归：不断的调用方法本身。

递归：统计文件大小，删除文件

求目录的总大小：

1、把指定目录封装成File对象

2、把文件夹列表列出来

3、判断，如果是文件，直接把f.length()相加

4、判断，如果是文件夹，继续列表，继续判断，如果是文件相加，如果又是文件夹，继续列表，继续判断，如果是文件相加......

5、如果是文件夹，递归调用方法本身的业务逻辑

package cn.tedu.io;

import java.io.File;

import org.junit.Test;

//递归求目录总大小

public class Test2_File2 {

public static void main(String[] args) {

// 1、把指定目录封装成File对象

File file = new File("D:\\teach\\a");

int size =count(file);

System.out.println(size);

}

private static int count(File file) {

// 2、把文件夹列表列出来

File[] files = file.listFiles();

//2.1 遍历数组里的每个资源

int sum = 0;//记录文件的大小

for (int i = 0; i < files.length; i++) {

// 3、判断，如果是文件，直接把f.length()相加

// files[i]表示每次遍历到的资源

if(files[i].isFile()) {

sum += files[i].length();//求文件的和

}else if(files[i].isDirectory()){

// 4、判断，如果是文件夹，继续列表，继续判断，如果是文件相加，如果又是文件夹，继续列表，继续判断，如果是文件相加......

// 5、如果是文件夹，递归调用方法本身的业务逻辑

sum += count(file[i]);//把当前遍历到的文件夹继续循环判断求和

}

return sum ;

}

2.4 字节流读取

字节流是由字节组成的,字符流是由字符组成的. Java里字符由两个字节组成.字节流是最基本的，所有的InputStream和OutputStream的子类都是，主要用在处理二进制数据。

流式传输主要指将整个音频和视频及三维媒体等多媒体文件经过特定的压缩方式解析成一个个压缩包，由视频服务器向用户计算机顺序或实时传送。在采用流式传输方式的系统中，用户不必像采用下载方式那样等到整个文件全部下载完毕，而是只需经过几秒或几十秒的启动延时即可在用户的计算机上利用解压设备对压缩的A/V、3D等多媒体文件解压后进行播放和观看。此时多媒体文件的剩余部分将在后台的服务器内继续下载。

2.4.1 InputStream抽象类

此抽象类是表示字节输入流的所有类的超类/抽象类。

常用方法：

abstract int read()

从输入流中读取数据的下一个字节。

int read(byte[] b)

从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。

int read(byte[] b, int off, int len)

将输入流中最多 len 个数据字节读入 byte 数组。

void close()

关闭此输入流并释放与该流关联的所有系统资源。

2.4.2 FileInputStream子类

直接插在文件上，直接读取文件数据。

创建对象

FileInputStream(File file)

通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。

FileInputStream(String pathname)

通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。

2.4.3 BufferedInputStream子类

BufferedInputStream 为另一个输入流添加一些功能，即缓冲输入以及支持 mark 和 reset 方法的能力。在创建 BufferedInputStream 时，会创建一个内部缓冲区数组(默认8M大小)。在读取或跳过流中的字节时，可根据需要从包含的输入流再次填充该内部缓冲区，一次填充多个字节。

创建对象

BufferedInputStream(InputStream in)
创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。

2.5 字符流读取

常用于处理纯文本数据。

2.5.1 Reader抽象类

用于读取字符流的抽象类。

常用方法：

int read()

读取单个字符。

int read(char[] cbuf)

将字符读入数组。

abstract int read(char[] cbuf, int off, int len)

将字符读入数组的某一部分。

int read(CharBuffer target)

试图将字符读入指定的字符缓冲区。

abstract void close()

关闭该流并释放与之关联的所有资源。

2.5.2 InputStreamReader子类

InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。

创建对象

InputStreamReader(InputStream in, String charsetName)

创建使用指定字符集的 InputStreamReader。

InputStreamReader(InputStream in)

创建一个使用默认字符集的 InputStreamReader。

2.5.3 FileReader子类

用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。

创建对象

FileReader(String fileName)
在给定从中读取数据的文件名的情况下创建一个新 FileReader。

FileReader(File file)
在给定从中读取数据的 File 的情况下创建一个新 FileReader。

2.5.4 BufferedReader子类

从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。

可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。

创建对象

BufferedReader(Reader in)

创建一个使用默认大小输入缓冲区的缓冲字符输入流。

2.6 练习：文件的读取

读取指定文件

package cn.tedu.hello;

import java.io.BufferedInputStream;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileInputStream;

import java.io.InputStream;

import java.io.InputStreamReader;

public class tt {

public static void main(String[] args) throws Exception {

method1();// 字节读取

method2();//字符读取

}

private static void method2() throws Exception {

//字符流读图片乱码

// BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(new File("D:\\teach\\1.jpg"))));

BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(new File("D:\\teach\\a\\1.txt"))));

// System.out.println(in.readLine());

// System.out.println(in.readLine());//null读到/n/r

String line = "";

while((line = in.readLine())!=null) {//一行一行读

System.out.println(line);

}

in.close();

}

private static void method1() throws Exception {

long s = System.currentTimeMillis();

InputStream in = new FileInputStream("D:\\teach\\1.jpg");

int b = 0;

while ((b = in.read()) != -1) {

// System.out.println(b);

}

s = System.currentTimeMillis() - s;

System.out.println(s + "--");// 7515

long ss = System.currentTimeMillis();

InputStream in2 = new BufferedInputStream(new FileInputStream("D:\\teach\\1.jpg"));

int b2 = 0;

while ((b2 = in2.read()) != -1) {

// System.out.println(b2);

}

ss = System.currentTimeMillis() - ss;

System.out.println(ss + "==");// 32

in.close();

in2.close();

}

2.7 扩展1

2.7.2 字符流读写乱码

new BufferedReader(new InputStreamReader(?,”utf-8”));

new BufferedWriter(new OutputStreamWriter(?,”utf-8”));

//默认是系统的编码，GBK写出。

//如果打开和写出的编码用的表不一致，会造成乱码。

OutputStreamWriter os = new OutputStreamWriter(new FileOutputStream("encode.txt"),"utf-8");

os.write("中国");

os.flush();

2.7.3 常见字符编码表

编码	说明	编码范围	字节量
ASC-II	英文,标点,基本指令	0到127	单字节
ISO-8859-1	ASC-II扩展,西欧字符	128到255	单字节
ANSI,CJK	ANSI是一种字符编码规范,设计为了使计算机支持更多语言,英文用单字节编码,其他字符用双字节编码 CJK表示亚洲字符编码的统称(中日韩)
GBK	中国国标码	最大65535	英文使用单字节, 中文使用双字节
UNICODE	统一码 Java的char类型字符就采用Unicode编码	100万+编码位,分为常用字符表,生僻字符表等,我们只是用常用表	常用字符表所有字符都采用双字节
UTF-8	Unicode传输格式 Unicode Transformations Format 为了解决Unicode英文字符字节量翻倍的问题,提出的一种变长的编码格式		英文单字节某些字符双字节中文三字节一些特殊符号四字节

测试

@Test

public void code() throws IOException {

String s = "我爱你中国";

System.out.println(s.getBytes("utf-8").length);//15--unicode/u8一个汉字3字节存储

System.out.println(s.getBytes("gbk").length);//10--中文双字节

System.out.println(s.getBytes("unicode").length);//12--双字节+2

System.out.println(s.getBytes("iso-8859-1").length);//5--单字节

}

2.7.4 JDK1.7新特性之IO关流

try( ){ }catch(){ }

private static void customBufferStreamCopy(File source, File target) {

InputStream fis = null;

OutputStream fos = null;

try {

fis = new FileInputStream(source);

fos = new FileOutputStream(target);

byte[] buf = new byte[8192];

int i;

while ((i = fis.read(buf)) != -1) {

fos.write(buf, 0, i);

}

catch (Exception e) {

e.printStackTrace();

} finally {

close(fis);

close(fos);

}

private static void close(Closeable closable) {

if (closable != null) {

try {

closable.close();

} catch (IOException e) {

e.printStackTrace();

}

上述代码对于异常处理十分复杂，

对于资源的关闭也很麻烦，那么可以和下面的进行对比：

private static void customBufferStreamCopy(File source, File target) {

try (InputStream fis = new FileInputStream(source);

OutputStream fos = new FileOutputStream(target)){

byte[] buf = new byte[8192];

int i;

while ((i = fis.read(buf)) != -1) {

fos.write(buf, 0, i);

}

catch (Exception e) {

e.printStackTrace();

}

package cn.tedu.api;

import java.util.Date;

//测试Date类
public class Test1_Date {

   public static void main(String[] args) {
       // 1.创建对象
       Date date=new Date();
       //2.常用方法
       System.out.println(date.getYear());//获取1900年到现在有多少年
       System.out.println(date.getDate());//一个月的哪一天
       System.out.println(date.getDay());//周几
       System.out.println(date.getHours());//几点
       System.out.println(date.getMinutes());//现在是哪一分钟
       System.out.println(date.getMonth());//底层0-11表示12个月
       System.out.println(date.getSeconds());//现在是哪一秒
       System.out.println(date.getTime());//自1970年1月1日0点到现在的毫秒值
       System.out.println(date.toLocaleString());//当前时区2021-1-25 21:54:10

}

package cn.tedu.api;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

//测试SimpleDateFormat工具类
public class Test2_SimpleDF {

   public static void main(String[] args) throws ParseException {
       // 1.创建对象--需要指定日期格式
       SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");

       //2.常用方法

       //接收用户输入的出生日期-年月日
       String input=new Scanner(System.in).nextLine();
       Date birth=sdf.parse(input);//把字符串转成Date
       System.out.println(birth.getMonth());
       System.out.println(sdf.format(birth));//把date转成字符串

       //记录存活天数
       long birthday=birth.getTime();//获取出生时的毫秒值
       long now =System.currentTimeMillis();//获取现在的毫秒值
       System.out.println((now-birthday)/1000/60/60/24);//ms->天
   }

}

package cn.tedu.api;

import java.math.BigDecimal;
import java.util.Scanner;

//测试小数运算精确的解决方案
public class Test3_BigDescimal {

public static void main(String[] args) {
//method();//暴露问题

       method2();//解决浮点数运算不精确
   }

   public static void method2() {
       //接收用户输入的两个小数，并做+—*/运算
       double a=new Scanner(System.in).nextDouble();
       double b=new Scanner(System.in).nextDouble();

       //1.创建一个BigDecimal对象
       BigDecimal bd1=new BigDecimal(a+"");
       BigDecimal bd2=new BigDecimal(b+"");

       BigDecimal bd3=bd1.add(bd2);//加法运算
       System.out.println(bd3);

       bd3=bd1.subtract(bd2);//减法运算
       System.out.println(bd3);

       bd3=bd1.multiply(bd2);//乘法运算
       System.out.println(bd3);

       /*除法运算时，如果发生除不尽的现象，直接抛出异常
       * divide(a,b,c);a是要做除法运算的对象，-b保留小数位数，c舍入方式
       * */
       bd3=bd1.divide(bd2,5,BigDecimal.ROUND_HALF_UP);//除法运算
       System.out.println(bd3);


   }
   //暴露问题
   public static void method() {
       //接收用户输入的两个小数，并做+—*/运算
       double a=new Scanner(System.in).nextDouble();
       double b=new Scanner(System.in).nextDouble();
       System.out.println(a+b);
       System.out.println(a-b);
       System.out.println(a*b);
       System.out.println(a/b);


   }

}

package cn.tedu.io;

import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.Scanner;

//测试File类
public class Test4_File {

   public static void main(String[] args) throws IOException {
       // 创建对象--封装文件和文件夹的路径
       File file=new File("D:\\iotest\\1.txt");

       //常用方法
       System.out.println(file.length());//字节量
       System.out.println(file.exists());//判断文件是否存在
       System.out.println(file.isFile());//判断是否是一个文件
       System.out.println(file.isDirectory());//判断是否是一个文件夹
       System.out.println(file.getName());//获取文件名
       System.out.println(file.getParent());//获取父路径
       System.out.println(file.getAbsolutePath());//获取完整路径

//       System.out.println(file.createNewFile());//创建一个不存在的文件
//
//       file=new File("D:\\iotest\\abc");
//       System.out.println(file.mkdir());//新建一个不存在的文件夹
//
//       file=new File("D:\\iotest\\abc\\x\\y\\z");
//       System.out.println(file.mkdirs());//新建多个不存在的文件夹
//       System.out.println(file.delete());//删除文件或者空的文件夹

       //列出文件夹里的资源
       file=new File("D:\\iotest");
       String[] strs=file.list();//获取文件名并存入String[]
       System.out.println(Arrays.toString(strs));

       File[] files=file.listFiles();//获取文件并存到File[]
       System.out.println(Arrays.toString(files));

       //接收用户输入的一串路径
       String path=new Scanner(System.in).nextLine();
       File f=new File(path);
       //判断如果是文件，求文件的字节量
       if(f.isFile()) {//如果是文件，返回ture
           System.out.println(f.length());
       }else if(f.isDirectory()) {//如果是文件夹，返回true
           //判断如果是文件夹，新建文件
           File[] fs=f.listFiles();//判断如果是文件夹，列出所有资源
           System.out.println("文件夹创建完成");
       }

}

package cn.tedu.io;

import java.io.File;
import java.util.Scanner;

//测试递归求目录总大小递归求目录总大小
public class Test5_Digui {

   public static void main(String[] args) {
       // 接收用户输入的文件夹路径
       String path=new Scanner(System.in).nextLine();
       File dir=new File(path);//封装成File对象
       long total=size(dir);//调用size求总大小
       System.out.println(total);

   }

   //创建size求总大小
   public static long size(File dir) {
       //1.列出文件夹下的所有资源
       File[] fs=dir.listFiles();

       long sum=0;//定义变量，记录总和

       //遍历数组，
       //如果你输入的是文件路径，直接空指针异常：
       //原因是，你调用了为null的对象，身上的功能
       for (int i = 0; i < fs.length; i++) {
           //获取每个资源fs[i]
           //2.判断当前资源是文件吗？是就直接.length()求和
           if(fs[i].isFile()) {
               sum=sum+fs[i].length();
           }else if(fs[i].isDirectory()) {
               //3.判断当前文件是文件夹吗？开始重复1 2 3....过程和size()一样
               sum=sum+size(fs[i]);//递归调用，在方法内部再调用方法本身
           }

       }

       return sum;//把总大小用return返回给调用位置
   }

}

package cn.tedu.io;

import java.io.File;
import java.util.Scanner;

//测试递归求目录总大小递归求目录总大小
public class Test6_Digui2 {

   public static void main(String[] args) {
       // 接收用户输入的文件夹路径
       String path=new Scanner(System.in).nextLine();
       File dir=new File(path);//封装成File对象
       del(dir);//调用方法删除指定文件夹

   }

   //删除指定文件夹
   public static void del(File dir) {
       //1.列出文件夹下的所有资源
       File[] fs=dir.listFiles();



       //遍历数组，
       //如果你输入的是文件路径，直接空指针异常：
       //原因是，你调用了为null的对象，身上的功能
       for (int i = 0; i < fs.length; i++) {
           //获取每个资源fs[i]
           //2.判断当前资源是文件吗？是就直接删除
           if(fs[i].isFile()) {
               fs[i].delete();
           }else if(fs[i].isDirectory()) {
               //3.判断当前文件是文件夹吗？开始重复1 2 3....过程和del()一样
               del(fs[i]);//递归调用，在方法内部再调用方法本身
           }

       }
       dir.delete();//删除空文件夹
       System.out.println("文件夹删除成功");
   }