* java.io包* 1、java.io.File类：* 例如：d:/1.txt  文件的路径名*       D:/新建文件夹    目录的路径名*    /2.txt    文件的路径名*    ../../3.txt  目录的路径名*    * 在Java中一个File对象可能表示一个文件，也可能表示一个目录（文件夹）* 所以在IO流操作时，要注意，我们的读写数据必须对应的是代表文件的File，* 如果是代表目录的File对象，是否无法直接读写数据的。* * 接触：* java.lang：String,Object,System,Math,Comparable,Iterable...* java.util：集合，Arrays,Comparator，Scanner，日期* java.text：SimpleDateFormat,Collator* java.math：BigInteger,BigDecimal* ....* * * 2、File类的常用的方法* （1）构造器：new File(路径)* file对象不一定代表的是已存在的文件或目录* （2）路径：* getPath()：构造器中指定的路径* getAbsolutePath()：绝对路径* getCanonicalPath()：规范路径，会对..等进行解析* （3）文件名* getName()* getLength()：字节  只能获取文件的大小，不能获取目录的大小       如果不存在返回0* lastModified()：毫秒                             如果不存在返回0* （4）其他的属性：如果不存在，返回false* exists()* isFile()* isDirectory()* isHidden()* canRead()* ...* * 这些属性，如果文件或目录存在，在创建File对象是，它会自动从操作系统层面获取数据为属性赋值，否则都是默认值* 但是path是根据你创建File对象时指定路径进行赋值的* * （5）文件和目录的创建、删除等操作* 创建目录：* mkdir()* mkdirs()* 删除目录：* delete()只能删除空目录      如果要删除非空目录，需要先删除里面的东西，在删除它* * 创建文件：* createNewFile()：如果对应的路径不存在，会报异常* 删除文件：* delete()* * 重命名：* renameTo(File 新)* * （6）获取父目录和获取目录的下一级* String getParent()* File getParentFile()* String[] list()* File[] listFiles()* * （7）如何统计目录的大小* * （8）如何删除一个非空目录

　　@Testpublic void test1() throws IOException{　　//路径名的表示方式；绝对路径、相对路径File fil = new File("F:\\code\\day01_全天资料\\day01_exam");File file = new File("/day01_exam/day01_words.txt");  //因为我的工作空间在D盘;相对路径,相对项目File file2 = new File("F:"+ File.separator+ "code" + File.separator + "day01_全天资料" + File.separator + "day01_exam");//直接使用File.separator常量值表示分隔符　　　 　System.out.println("user.dir =" + System.getProperty("user.dir"));System.out.println("文件名:" + file.getName()); //如果路径是目录or文件名，就打印目录文件夹or文件名字；System.out.println("文件路径:" + file.getPath()); //构造器中指定的路径System.out.println("文件绝对路径:" + file.getAbsolutePath());//绝对路径； window的路径分隔符使用“\”，而Java程序中的“\”表示转义字符，所以在Windows中表示路径，需要用“\\”。或者直接使用“/”也可以System.out.println("文件规范路径:" + file.getCanonicalFile());//规范路径，会对..等进行解析　　　　　System.out.println("File对象的父目录名:" + file.getParentFile()); //父目录，上一级的；　　　　  System.out.println("File对象的父目录名所对应的对象:" + file.getParentFile());

}@Testpublic void test2(){File file = new File("F:\\code\\day01_全天资料\\day01_video\\day01_01Java历史概述.avi");System.out.println("文件的大小:" + file.length()); //对应的文件的内容的长度（字节数）,如果File对象对应的是目录，则结果是不确定的。System.out.println("文件的最后修改时间（毫秒值）:" + file.lastModified());long time = file.lastModified();Date date = new Date(time);System.out.println(date);//Mon Nov 12 09:57:56 GMT+08:00 2018SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//System.out.println(dateFormat.format(date)); //2018-11-12 09:57:56
        }@Testpublic void test3(){File file = new File("");file.exists(); //文件或目录是否存在file.isFile();//是否是文件  file.isDirectory(); //是否是文件夹file.isHidden(); //是否隐藏file.canRead(); //是否只读;　　　　 file.isAbsolute()；//判断File对象对应的文件或目录是否是绝对路径
        File file1 = new File("D:/HAH");//file1.mkdirs();创建hehe，因为xixi和haha不存在，一并创建了file1.mkdir();//创建hehe，因为xixi和haha不存在，所以失败，没有报异常;只能创建单层文件夹file1.delete();//只是删除最里层的文件或者文件夹,一层层的删(也要确保file1的path地址是对应的);
        }
//创建目录| 创建文件| 删除文件| 重命名文件@Testpublic void test11() throws IOException{File dir = new File("D:/Jiing/heihei/day03.txt");

　　　　　dir.mkdir();//创建目录(只能创建一个),不存在不会报错，只是没创建成功,;dir.mkdirs();//只能创建目录文件；如果带.txt会给你创建一个文件夹；如果前面目录都没有就都给你一块创建了；dir.createNewFile(); //在目录存在的情况下才能创建文件.txt等，不能创建目录； 如果指定的文件不存在并成功地创建，则返回 true；如果指定的文件已经存在，则返回 false。//dir.renameTo(new File ("D:/Jiing/heihei/day03.txt")); //重命名//dir.delete(); //如果文件夹里边有文件，则delete这个文件夹是删除不了的，要先删除里边的文件才能删除这个文件夹；只能一个个的删System.out.println(dir.listFiles());//[Ljava.io.File;@5cb0d902
    }

public static void test1(File file){//String[] list = file.list(); //列出当前目录的文件的名称File[] listFiles = file.listFiles();//列出当前目录对应的File对象,文件路径for (File string : listFiles) {System.out.println(string);}}@Test public void test5(){  //筛选出所有的.java文件File file = new File("D:\\code\\day01");File[] listFiles = file.listFiles(new FileFilter() { //File[] listFiles(FileFilter filter) @Override　　　　　　　　　　　　//它有一个抽象方法boolean accept(File pathname)，它属于SAM接口public boolean accept(File pathname) {return pathname.getName().endsWith(".java");}});for (File file2 : listFiles) {System.out.println(file2);}}//遍历递归出目录下的所有文件路径public static void listAllFile(File file){if(file.isDirectory()){File[] listFiles = file.listFiles();for (File file2 : listFiles) {listAllFile(file2);}System.out.println(file);}}
--->>>
D:\Jing\1
D:\Jing\2\22
D:\Jing\2
D:\Jing\新建文件夹
D:\Jingpublic void listAllFiles(File dir){if(dir.isDirectory()){  //如果是文件夹System.out.println(dir); //输出目录(文件夹)File[] list = dir.listFiles();//System.out.println(list);for (File file : list) {   //每一个file都有可能有下一级listAllFiles(file);  //自己调用自己叫递归
            }}else{System.out.println(dir);//如果是文件直接打印//把 file 的所有的下一级（包括下一级的下一级）的文件的大小全部加起来public long getSize(File file){if(file.isFile()){  //如果是文件，直接返回它的大小return file.length();}else if(file.isDirectory()){File[] list = file.listFiles();  //(1)列出dir的下一级long sum = 0;            //2)累加每一个下一级的大小for (File file2 : list) {sum += getSize(file2);   //file2可能是文件也可能是目录
            }retur 0L;//递归删除目录文件public static void deleteDir(File file){if(file.isDirectory()){File[] listFiles = file.listFiles();for (File sub : listFiles) {deleteDir(sub);}file.delete(); //递归删除空文件夹
        }//file.delete(); //删除所有的文件夹
    }//跟上边是一样的public static void deleteAllSubFile(File file){if(file.isDirectory()){File[] listFiles = file.listFiles();for (File file2 : listFiles) {if(file2.length() == 0){file2.delete();}deleteAllSubFile(file2);}}}

/*     递归：方法自己调用自己注意：一定要有“出口”，否则就死循环，就栈溢出递归的效率比较低，能用循环解决的就不要用递归*/@Testpublic void test1(){System.out.println(diGui(10));System.out.println(printSum(10));}public long diGui(int n){if(n == 0){return 1;}return n * diGui(n - 1);}public long printSum(int n){long sum = 1;for (int i = 1; i <= n; i++) {sum *= i;}return sum;}

装饰模式（Decorator Pattern）也称为包装模式（Wrapper Pattern），其使用一种对客户端透明的方式来动态地扩展对象的功能，它是通过继承扩展功能的替代方案之一。在现实生活中你也有很多装饰者的例子，例如：人需要各种各样的衣着，不管你穿着怎样，但是，对于你个人本质来说是不变的，充其量只是在外面加上了一些装饰，有，“遮羞的”、“保暖的”、“好看的”、“防雨的”....

FileInputStream 字节流 　　　　public static void main(String[] args) throws IOException {FileInputStream fil = new FileInputStream("sourse/1.txt");byte[] data = new byte[10];int len;StringBuilder s = new StringBuilder(); //可变字符串while((len = fil.read(data)) != -1){s.append(new String(data, 0, len)); //先读入字符串中 ； s.append( data,0 ,len byte())，没有针对字节的字符串append方法}System.out.println(s);fil.close();}

public static void main(String[] args) throws IOException {FileReader fil = new FileReader("sourse/1.txt");char[] data = new char[10];int len;StringBuilder s = new StringBuilder();  //创建一个可变字符串存数据while((len = fil.read(data)) != -1){  //fil.read( )--->>>返回的是int长度s.append(new String(data, 0, len)); //append( ) //形参是char类型，所以byte字节不能用这个方法　　　　　  　s.append(data, 0, len);}System.out.println(s);fil.close();}

public static void main(String[] args) throws IOException {Scanner input = new Scanner(System.in);System.out.print("请输入:");String s = input.next();FileOutputStream file = new FileOutputStream("sourse/2.txt");//如果需要覆盖模式，不用写true，如果追加模式，写,true
        file.write(s.getBytes());file.close();input.close();}

public static void main(String[] args) throws IOException {Scanner input = new Scanner(System.in);System.out.print("请输入:");String s = input.next();FileWriter fw = new FileWriter("sourse/2.txt");  fw.write(s);  //输入字符
        fw.close();  //必须把流关了，不然写不进去喔！！input.close();}

public static void copy(String srcFilePath, String destFilePath) throws IOException{FileInputStream file = new FileInputStream(srcFilePath); //创建输入流FileOutputStream f = new FileOutputStream(destFilePath); //输出流byte[] data = new byte[10]; //读取字节数据int len;while((len = file.read(data)) != -1){f.write(data, 0, len);}}

使用缓冲流的目的是为了提高读写效率

*  BufferedInputStream：包装InputStream字节输入流*  BufferedReader：包装Reader字符输入流，按行读取 *  BufferedOutputStream：包装OutputStream字节输出流*  BufferedWriter：包装Writer字符输出流

public static void copyBuffer(String srcFilePath, String destFilePath) throws IOException{FileInputStream fis = new FileInputStream(srcFilePath); //(1)创建IO流BufferedInputStream bis = new BufferedInputStream(fis);FileOutputStream fos = new FileOutputStream(destFilePath);BufferedOutputStream bos = new BufferedOutputStream(fos);//数据读从srcFilePath-->fis --> bis --> data数组;//数据写从data数组 --> bos --> fos --> destFilePath;//(2)一边读一边写byte[] data = new byte[10];int len;while((len = bis.read(data)) != -1){   //循环一次，从fis中把数据到data数组，从[0]装，一次len个bos.write(data, 0, len);//再从data数组[0]取len写到fos中
        }bis.close();fis.close();bos.close();fos.close();}

View Code

* BufferedReader：（1）String readLine()JDK1.7之后，有一个try...with...resouces
语法格式：
* try(声明需要关闭的资源
* ){
* 可能发生异常的代码
* }catch(异常类型 e){
* }
*
* 无论是否发生异常，都会自动关闭

　　　　public static void test1(String srcPath) throws IOException{try(FileReader fr = new FileReader(srcPath);BufferedReader br = new BufferedReader(fr); //字节-->字符；){while(true){String line = br.readLine();  if(line == null){break;}System.out.println(line);//边读边打印
            }}catch (FileNotFoundException e) {e.printStackTrace();}catch (IOException e){e.printStackTrace();}/*br.close();fr.close();*/}

 InputStreamReader：把字节流转为字符流，并且可以指定“编码方式”FileReader是按照平台默认的字符编码解码OutputStreamWriter：把字符流按照指定的编码转为字节流

//字符编码方式GBK的文件,在UTF-8的的控制台上,读取内容显示
    @Testpublic void test1() throws IOException{FileInputStream fs = new FileInputStream("sourse/22.txt");//字节输入流InputStreamReader isr = new InputStreamReader(fs, "UTF-8");//字节--字符；按字节流读取，然后再指定字符编码方式，转为字符流
        BufferedReader br = new BufferedReader(isr);//数据：resources/gbk.txt-->字节的方式-->fs-->按照指定的编码-->isr-->字符流-->缓冲流br
        String line;while((line = br.readLine()) != null){ //readLine()是按行读取；System.out.println(line);}br.close();isr.close();fs.close();}
//尝试用字符输入流读取
    @Testpublic void test2() throws IOException{FileInputStream fis = new FileInputStream("sourse/22.txt");byte[] data = new byte[10];int len;while((len = fis.read(data)) != -1){//String的构造器，也可以指定字符编码方式进行解码//String(byte[] bytes, int offset, int length, String charsetName)System.out.println(new String(data, 0, len, "GBK"));}  //也可以转成字节 new String(data, 0, len).getBytes();//转成字节fis.close();}

　　@Testpublic void test1() throws IOException{String str = "字符串";OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("sourse/1.txt"), "UTF-8");osw.write(str);osw.close();}@Testpublic void test2() throws UnsupportedEncodingException, IOException{String str = "字符串";FileOutputStream fos = new FileOutputStream("sourse/1.txt");fos.write(str.getBytes("UTF-8"));fos.close();}

    @Testpublic void testIn() throws IOException{//因为DataInputStream无法与文件直接相连;//需要文件字节输入流DataInputStream dis = new DataInputStream(new FileInputStream("sourse/7.txt"));String readUTF = dis.readUTF();int readInt = dis.readInt();double readDouble = dis.readDouble();char readChar = dis.readChar();System.out.println(readUTF);System.out.println(readInt);System.out.println(readDouble);System.out.println(readChar);dis.close();}@Testpublic void test1() throws IOException{String name = "白骨精";int age = 500;double engry = 789.5;char gender = '女';//DataOutputStream无法直接与文件相连，需要一个OutputStreamDataOutputStream dos = new DataOutputStream(new FileOutputStream("sourse/7.txt"));dos.writeUTF(name); //开始写数据
         dos.writeInt(age);dos.writeDouble(engry);dos.writeChar(gender);dos.close();}

View Code

/*要存储如下一组数据，到game.dat文件中，并在后面可以重写读取。
完成这个需求，可以使用DataOutputStream进行写，随后用DataInputStream进行读取，而且顺序要一致。*/
public static void saveData() throws IOException{String name = "巫师";int age = 300;char gender = '男';int energy = 5000;double price = 75.5;boolean relive = true;DataOutputStream dos = new DataOutputStream(new FileOutputStream("resource/game.dat"));dos.writeUTF(name);dos.writeInt(age);dos.writeChar(gender);dos.writeDouble(price);dos.writeBoolean(relive);}public static void reload() throws IOException{DataInputStream dis = new DataInputStream(new FileInputStream("resource/game.dat"));String name = dis.readUTF();int age = dis.readInt();char gender = dis.readChar();double price = dis.readDouble();boolean relive = dis.readBoolean();System.out.println("姓名:" + name + ",年龄:" + age + "性别:" + gender + "价格:" + price + ",重新生活" + relive);}

View Code

　　　　　　DataOutputStream dos = new DataOutputStream(socket.getOutputStream());dos.writeUTF(pathName);//三.按照字节读取文件内容FileInputStream fis = new FileInputStream(file);byte[] data = new byte[1024];int len;while((len = fis.read(data)) != -1){ //读取文件内容并写入 dos.write(data, 0, len); //可直接读取 }

* 将 Java 对象的基本数据类型和图形写入 OutputStream。可以使用 ObjectInputStream 读取（重构）对象。*     通过在流中使用文件可以实现对象的持久存储。如果流是网络套接字流，则可以在另一台主机上或另一个进程中重构对象。* * 凡是用ObjectOutputStream输出的对象，它的类必须实现java.io.Serializable接口（序列化接口）：* 只能将支持 java.io.Serializable 接口的对象写入流中。每个 serializable 对象的类都被编码，编码内容包括类名和类签名、对象的字段值和数组值，    以及从初始对象中引用的其他所有对象的闭包。* * * ObjectInputStream:反序列化（把字节序列重构成一个对象）* ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。* * 写对象：* void writeObject(obj)* 读对象：* Object obj = readObject()* 

　Account.setInterestRate(0.02); //静态属性Account account = new Account("101", "kris", "1234", 100000, 3.2);//把对象写入数据ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("resource/account.dat"));oos.writeObject(account);//把对象从文件中读出来ObjectInputStream ois = new ObjectInputStream(new FileInputStream("resource/account.dat"));Object obj = ois.readObject();System.out.println(obj); }Account类--->>>
class Account implements Serializable{private static double interestRate;private String number;private String name;private String password;private double balance;transient private double interest;  //加上这个当初始化的时候就不会给它初始化赋值了，而是还是默认值； 不是3.2了，而是默认值0.0public Account(String number, String name, String password, double balance, double interest) {super();this.number = number;this.name = name;this.password = password;this.balance = balance;this.interest = interest;}public static double getInterestRate() {return interestRate;}public static void setInterestRate(double interestRate) {Account.interestRate = interestRate;}....

View Code

    public class Account implements Serializable{private static double interestRate;private String number;private String name;private String password;private double balance;transient private double interest;

* Role类实现了Serializable接口后，每次编译，会自动生成一个serialVersionUID* 如果当数据序列化之后，重新修改了类，就会导致  “stream中的serialVersionUID"与"local的serialVersionUID"不一致。* * 如何解决？* 在序列化之前，不让这个类每次自动生成一个serialVersionUID，而是固定一个serialVersionUID值（序列化版本ID）。
private static final long serialVersionUID = 1L; 这是默认的

* 假设engry属性的值，不需要序列化。我们可以在这个属性之前加一个关键字transient* 一般像计算的结果值等，不需要序列化，在反序列后重新计算，这样的字段，加transient修改** 如果属性的类型是引用数据类型，那么这个引用数据类型也要支持序列化，即实现java.io.Serializable接口，* 例如:String,Owner* * 静态的变量是不会被序列化的。* 因为序列化的是对象的状态值，而静态变量是类的值。* 序列化的是对象独有的内容，而静态是所有对象共享的内容。

　　@Testpublic void testIn() throws FileNotFoundException, IOException, ClassNotFoundException{ObjectInputStream ois = new ObjectInputStream(new FileInputStream("sourse/66.txt"));Object obj = ois.readObject();System.out.println(obj);ois.close();}@Testpublic void testOut() throws IOException{FileOutputStream fos = new FileOutputStream("sourse/66.txt");ObjectOutputStream oos = new ObjectOutputStream(fos);User user = new User(10, 20, 30);oos.writeObject(user);oos.close();fos.close();}}class User implements Externalizable{private static int a = 1;private transient int b = 2;private int c = 3;public User() {super();}public User(int b, int c) {super();this.b = b;this.c = c;}public User(int a, int b, int c) {super();User.a = a;this.b = b;this.c = c;}@Overridepublic String toString() {return "a=" + a + ",b=" + b + ", c=" + c;}@Overridepublic void writeExternal(ObjectOutput out) throws IOException {out.writeInt(a);out.writeInt(b);out.writeInt(c);}@Overridepublic void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {a = in.readInt();b = in.readInt();c = in.readInt();}

　　@Testpublic void test1() throws FileNotFoundException{PrintStream ps = new PrintStream("sourse/2.txt");Scanner input = new Scanner(System.in);while(true){System.out.print("输入内容:");String next = input.next();  // input.nextLine();
            if("bye".equalsIgnoreCase(next)){break;}ps.print(next);}ps.close();input.close();}@Testpublic void test2() throws FileNotFoundException{//Scanner扫描仪，从输入流中扫描数据Scanner input = new Scanner(new FileInputStream("sourse/2.txt"));while(input.hasNext()){String nextLine = input.nextLine();System.out.println(nextLine);}input.close();}