D11（java基础）

D11（java基础）

流

• 概念：内存与存储设备之间传输数据的通道。

流的分类

按方向：

• 输入流：将存储设备中的内容读入到内存中。

• 输出流：将内存中的内容写入到存储设备中。

 

按单位：

• 字节流：以字节为单位，可以读写所有数据。

• 字符流：以字符为单位，只能读写文本数据。

 

按功能：

• 节点流：具有实际传输数据的读写功能。

• 过滤流：在节点流的基础之上增强功能。

 

文件字节输入流

public static void main(String[] args) throws Exception {
    //创建FileInputStream，并指定文件路径。
    FileInputStream fis=new FileInputStream("d:\\aaa.txt");
    int data=0;
    while((data=fis.read())!=-1){
        System.out.println((char)data);
    }
    fis.close();
    System.out.println("执行完毕");
}
//读取一个文件内的数据。

// 一次读多个字节。
byte[] buf=new byte[3];
int count= fis.read(buf);
System.out.println(new String(buf));

byte[] buf=new byte[1024];
int count=0;
while((count=fis.read(buf))!=-1){
    System.out.println(new String(buf,0,count));
}

 

文件字节输出流

public static void main(String[] args) throws Exception{
    //创建文件输出字节流对象。
    FileOutputStream fos=new FileOutputStream("d:\\bbb.txt");
    fos.write(97);
    fos.write('b');
    fos.write('c');
​
    fos.close();
    System.out.println("执行完毕");
}
//向一个文件内写入数据。

String string="helloworld";
fos.write(string.getBytes());

 

字节流复制文件

public static void main(String[] args) throws Exception{
    FileInputStream fis=new FileInputStream("d:\\111.webp");
​
    FileOutputStream fos=new FileOutputStream("d:\\222.webp");
​
    byte[] buf=new byte[1024];
    int count=0;
    while((count=fis.read(buf))!=-1){
        fos.write(buf,0,count);
    }
​
    fis.close();
    fos.close();
    System.out.println("复制完毕");
}

 

字节缓冲流

• 提高IO效率，减少访问磁盘的次数。

//使用字节缓冲流读取文件。
public static void main(String[] args) throws Exception{
    FileInputStream fis=new FileInputStream("d:\\aaa.txt");
    BufferedInputStream bis=new BufferedInputStream(fis);
​
    int data=0;
    while((data=bis.read())!=-1){
        System.out.print((char)data);
    }
​
    bis.close();
}

---

public static void main(String[] args) throws Exception{
    FileOutputStream fos=new FileOutputStream("d:\\buffer.txt");
    BufferedOutputStream bos=new BufferedOutputStream(fos);
​
    for(int i=0;i<10;i++){
        bos.write("helloworld\r\n".getBytes());//写入8K缓冲区。
        bos.flush();                           //刷新到硬盘。
    }
    
    bos.close();//内部调用flush方法。
}

 

对象流

• 使用流传输对象的过程称为序列化（把对象写入文件），反序列化。

序列化

ObjectOutputStream

• 序列化类必须要实现Serializable接口。

public static void main(String[] args) throws Exception {
    FileOutputStream fos=new FileOutputStream("d:\\stu.bin");
    ObjectOutputStream oos=new ObjectOutputStream(fos);
Student zhangsan =new Student("张三",20);
oos.writeObject(zhangsan);

oos.close();
System.out.println("序列化完毕");

}

 

反序列化

public static void main(String[] args) throws Exception{
    FileInputStream fis=new FileInputStream("d:\\stu.bin");
    ObjectInputStream ois=new ObjectInputStream(fis);
Student s=(Student) ois.readObject();

ois.close();
System.out.println("执行完毕");
System.out.println(s.toString());

}

 

注意事项

1. 序列化类必须要实现Serializable接口。

2. 序列化类中对象属性要求实现Serializable接口。

3. 序列化版本号ID，保证序列化的类和反序列化的类是同一个类。

4. 使用transient（瞬间的）修饰属性，这个属性就不能被序列化了。

5. 静态属性不能序列化。

6. 序列化多个对象，可以借助集合（ArrayList）实现。

 

字符流

• 字符流的父类（抽象类）

Reader：字符输入流

Writer：字符输出流

 

文件字符流

• 使用FileReader读取文件

public static void main(String[] args) throws Exception{
        FileReader fr=new FileReader("d:\\hello.txt");
//        int data=0;

//        while((data=fr.read())!=-1){

//            System.out.print((char)data);

//        }
    char[] buf=new char[1024];
    int count=0;
    while((count=fr.read(buf))!=-1){
        System.out.println(new String(buf,0,count));
    }
    fr.close();
}</pre>




使用FileWriter写入文件


public static void main(String[] args) throws Exception{
    FileWriter fw=new FileWriter("d:\\write.txt");
​
    for(int i=0;i<10;i++){
        fw.write("java能用\r\n");
        fw.flush();
    }
    fw.close();
    System.out.println("执行完毕");
}



使用FileReader和FileWriter复制文本文件，不能复制图片等二进制文件（因为它们没有字符编码）。


使用字节流可以复制任意文件。


public static void main(String[] args) throws  Exception{
    FileReader fr=new FileReader("d:\\write.txt");
    FileWriter fw=new FileWriter("d:\\write2.txt");
​
    int data=0;
    while((data=fr.read())!=-1){
        fw.write(data);
        fw.flush();
    }
    fr.close();
    fw.close();
    System.out.println("执行完毕");
​
}
 
字符缓冲流



使用字符缓冲流读取文件。


public static void main(String[] args) throws Exception{
        FileReader fr=new FileReader("d:\\write.txt");
        BufferedReader br=new BufferedReader(fr);
​
//        char[] buf=new char[1024];//缓冲区
//        int count=0;
//        while((count=br.read(buf))!=-1){
//            System.out.print(new String(buf,0,count));
//        }
        //第二种方法：一行一行地读取。
        String line=null;
        while((line=br.readLine())!=null){
            System.out.println(line);
        }
        br.close();
        System.out.println("完毕");
    }



使用字符缓冲流写入文件。


public static void main(String[] args) throws Exception{
    FileWriter fw=new FileWriter("d:\\buffer.txt");
    BufferedWriter bw=new BufferedWriter(fw);
​
    for(int i=0;i<10;i++){
        bw.write("可以");
        bw.newLine();// 写入一个换行符，兼容性更好。
        bw.flush();
    }
​
    bw.close();
    System.out.println("完毕");
}
 
打印流


支持数据原样打印。（如97不会变成'A'）


public static void main(String[] args) throws Exception{
    PrintWriter pw=new PrintWriter("d:\\print.txt");
​
    pw.println(97);
    pw.println(true);
    pw.println(3.14);
    pw.println('a');
​
    pw.close();
    System.out.println("完毕");
​
}
 
转换流


InputStreamReader/OutputStreamWriter


可将字节流转换为字符流。


可设置字符的编码方式。


 
File类


File类的使用




分隔符


文件操作


文件夹操作



/*
File类的使用
1. 分隔符
2. 文件操作
3. 文件夹操作
*/
public class Demo{
  psvm(String[] args){
    separator();
  }
  // 1. 分隔符
  public static void separator(){
    sout("路径分隔符" + File.pathSeparator);
    sout("名称分隔符" + File.separator);
  }
  // 2. 文件操作
  public static void fileOpen(){
    // 1. 创建文件
    if(!file.exists()){ // 是否存在
        File file = new File("...");
        boolean b = file.creatNewFile();
    }
    
    // 2. 删除文件
    // 2.1 直接删除
    file.delete(); // 成功true
    // 2.2 使用jvm退出时删除
    file.deleteOnExit();
    
    // 3. 获取文件信息
    sout("获取绝对路径" + file.getAbsolutePaht());
    sout("获取路径" + file.getPath());
    sout("获取文件名称" + file.getName());
    sout("获取夫目录" + file.getParent());
    sout("获取文件长度" + file.length());
    sout("文件创建时间" + new Date(file.lashModified()).toLocalString());
    
    // 4. 判断
    sout("是否可写" + file.canWrite());
    sout("是否是文件" + file.isFile());
    sout("是否隐藏" + file.isHidden());
  }
  
  
  // 文件夹操作
  public static void directoryOpe() throws Exception{
    // 1. 创建文件夹
    File dir = new File("...");
    sout(dir.toString());
    if(!dir.exists()){
      //dir.mkdir(); // 只能创建单级目录
      dir.mkdirs(); // 创建多级目录
    }
    
    // 2. 删除文件夹
    // 2.1 直接删除
    dir.delete(); // 只能删除最底层空目录
    // 2.2 使用jvm删除
    dir.deleteOnExit();
    
    // 3. 获取文件夹信息
        sout("获取绝对路径" + dir.getAbsolutePaht());
    sout("获取路径" + dir.getPath());
    sout("获取文件名称" + dir.getName());
    sout("获取夫目录" + dir.getParent());
    sout("获取文件长度" + dir.length());
    sout("文件夹创建时间" + new Date(dir.lashModified()).toLocalString());
    
    // 4. 判断
    sout("是否是文件夹" + dir.isDirectory());
    sout("是否隐藏" + dir.isHidden());
    
    // 5. 遍历文件夹
    File dir2 = new File("...");
    String[] files = dir2.list();
    for(String string : files){
      sout(string);
    }
    
    // FileFilter接口的使用
    //过滤文件，只有满足特定条件的文件才会被记录。
    
    File[] files2 = dir2.listFiles(new FileFilter(){
      
      @Override
      public boolean accept(File pathname){
        if(pathname.getName().endsWith(".jpg")){
          return true;
        }
        return false;
      }
    });
    for(File file : files2){
      sout(file.getName());
    }
    
  }
}
 
递归遍历文件夹
psvm(String[] args){
  listDir(new File("d:\\myfiles"));
}
public static void listDir(File dir){
  File[] files = dir.listFiles();
  sout(dir.getAbsolutePath());
  if(files != null && files.length > 0){
    for(File file : files){
      if(file.isDirectory()){
        listDir(file); // 递归
      }else {
        sout(file.getAbsolutePath());
      }
    }
  }
}
递归删除文件夹
public static void deleteDir(File dir){
  File[] files = dir.listFiles();
  if(files != null && files.length > 0){
    for(File file : files){
      if(file.idDirectory()){
        deleteDir(file); // 递归
      }else{
        // 删除文件
        sout(file.getAbsolutePath() + "删除" + file.delete());
      }
    }
      System.out.println(dir.getAbsolutePath()+"删除"+dir.delete());//删除已被清空的文件夹
​
  }
}
 
Properties
 
public class PropertiesStudy {
    public static void main(String[] args) throws IOException {
        Properties properties = new Properties();
        properties.setProperty("String_Title", "PropertiesStudy");
        properties.setProperty("String_Name", "Properties");
        Set<String> strings = properties.stringPropertyNames();
        for (String string : strings) {
            System.out.println("Key:"+string+";"+properties.getProperty(string));
        }
        
        // 输出
        PrintWriter printWriter = new PrintWriter("PropertiesStudy.txt");
        properties.list(printWriter);
        printWriter.close();
        // 保存
        FileOutputStream fileOutputStream = new FileOutputStream("PropertiesStudyStore.properties");
        properties.store(fileOutputStream, "注释");
        fileOutputStream.close();
    }
}