java 文件硬盘存取练习

读写文件操作

对字符流文件读写

1 写文件
　　FileOutputStream 节点类负责写字节
　　OutputStreamWriter 转化类负责字节到字符转换
　　BufferedWriter 装饰类负责写字符到缓存区
　示例：
　　BufferedWriter b=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("路径")))

2 读文件
　　FileInputStream 节点类负责写字节
　　InputStreamReader 转化类负责字节到字符转换
　　BufferedReader装饰类负责写字符到缓存区
示例：
　　BufferedReaderb=new BufferedReader(new InputStreamReader (new FileInputStream ("路径")))

进行对各种类型的二进制文件读写

1 字节型写文件
　　FileOutputStream 节点类负责写字节
　　BufferedOutputStream 装饰类负责写字符到缓存区
　　DataOutputStreamWriter 转化类负责数据类型到字节转换
　示例：
　　DataOutputStreamWriter d=new DataOutputStreamWriter (new BufferedOutputStream(new FileOutputStream("路径")))

2 字节型读文件
　　FileInputStream 节点类负责写字节
　　BufferedInputStream 装饰类负责写字符到缓存区
　　DataInputStreamWriter 转化类负责数据类型到字节转换
　示例：
　　DataInputStreamWriter d=new DataInputStreamWriter (new BufferedInputStream(new FileInputStream ("路径")))

场景一：单机游戏的存档

存档：将游戏中的玩家对象从内存写入到硬盘上
----持久化的过程（需要对象的序列化支持）
读档：将保存在硬盘上的对象数据读取到存档中转化成玩家对象，继续游戏

=========================================================

readme:

1.软件的基本功能：将用户输入以字节流序列化存到硬盘中，并读取

2.运行代码的方法：eclipse

3.简要的使用说明:输入用户等级与姓名

4.代码目录结构说明：

　　运用Serializable接口封装player类，主函数调用循环是否继续存取

package objstream;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.Serializable;
import java.util.Scanner;

/**
 * @author CF
 * @序列化与反序列化
 * 前提：对象必须实现Serializable接口（序列化接口）
 * 2019年3月6日
 * 下午8:37:47
 */
public class objectstream {
    public static final String path = "E:\\学习\\java\\程序\\test\\src\\objstream\\cc.txt";
    public static void main(String[] args) {
        player player1 = new player();
        Scanner input=new Scanner(System.in);
        System.out.println("请输入");
        char a='y';
        while(a=='y')
        {
            System.out.println("请输入姓名");
            player1.setName(input.next());
            System.out.println("请输入等级");
            player1.setLevel(input.nextInt());
            write(path,player1);
            reader(path);
            System.out.println("是否继续输入y/n");
            a=input.next().charAt(0);
        }

    }
    public static void write(String path,player player1) {

        
        try(
                FileOutputStream fout=new FileOutputStream(path);
                ObjectOutputStream ostream=new ObjectOutputStream(fout)
        ){
            ostream.writeObject(player1);
            System.out.println("!");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void reader(String path) {
        try(
                FileInputStream finout=new FileInputStream(path);
                ObjectInputStream ostrea=new ObjectInputStream(finout);
        ){
            player plater2=(player)ostrea.readObject();
            System.out.println("读出成功:"+plater2.getName()+" "+plater2.getLevel());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        
    }

}


class player implements Serializable{

    private static final long serialVersionUID = -1529270225938850227L;
    private String name;
    private int level;
    
    public player() {}
    public player(String n,int i)
    {
        setName(n);
        setLevel(i);
    }
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getLevel() {
        return level;
    }
    public void setLevel(int level) {
        this.level = level;
    }
    
}

====================================================================================================

readme：

1.对歌词进行适当改变，读取文件每行进行判断，再写入另一文件中

2.一函数字节流一函数字符流都可运行

package 歌词改编;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.Writer;
/**
 * @author CF
 * @字符流转
 * 2019年3月6日
 * 下午7:01:24
 */
public class 字符流 {
    public static final String path1 = "E:\\学习\\java\\程序\\test\\src\\歌词改编\\music.txt";
    public static final String path2 = "E:\\学习\\java\\程序\\test\\src\\歌词改编\\change.txt";
    public static final String path3 = "E:\\学习\\java\\程序\\test\\src\\歌词改编\\change1.txt";

    public static String bytstring(String path) {
        StringBuffer content=new StringBuffer();
        Reader reader=null;
        BufferedReader breader=null;    
        try {
            reader=new FileReader(path);
            breader=new BufferedReader(reader);
            String line=null;
            while((line=breader.readLine())!=null) {
                content.append(line);
                content.append(System.getProperty("line.separator"));//拼接一个系统默认分隔符
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                breader.close();
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            
        }
        return content.toString();
        
    }
    public static boolean bytwrite(String str) {
        FileWriter write=null;
        BufferedWriter writ=null;
        try {
            write = new FileWriter(path2);
            writ=new BufferedWriter(write);
            writ.write(str);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                writ.close();
                write.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return true;
    }

    public static void printwr(String str,String pathing,boolean iswrite){
    
        try (
                FileOutputStream output = new FileOutputStream(pathing);
                PrintWriter writer=new PrintWriter(output);
            ){
            writer.append(str);
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e1) {
            e1.printStackTrace();
        }    
    }
    public static void main(String[] args) {
        String str=bytstring(path1);//读文件
        printwr(str, path3,true);
//        if(bytwrite(str))
//            System.out.println("转录成功");
        
    }
    
}

===========================================================================================

readme：

对输入输出流进行演示

package 输入输出流;

import java.io.File;
import java.io.FileInputStream;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * @author CF
 * @演示输入输出流用法
 * 2019年2月25日
 * 下午9:13:49
 */
public class FileStreamDemo {

    private static final String path="C:/Users/59474/Desktop/java笔记/文件.txt";
    private static final String path1="C:/Users/59474/Desktop/java笔记/lala.txt";

    public static void main(String[] args) throws IOException {
        File file=new File(path);
        InputStream inputstream=new FileInputStream(file);
        byte[] bytes=new byte[20000];
    
        inputstream.read(bytes);
//        for (int i = 0; i<bytes.length; i++) {
//            
//            bytes[i]=(byte)inputstream.read();
//        }
        
        String content=new String(bytes);
        System.out.println(content);
        inputstream.close();
        File file1=new File(path1);
        
        OutputStream out=new FileOutputStream(file1);
        String str="what`s your name?";
        out.write(str.getBytes());
        out.close();
    }
}

@@@@@@@@@@@@@@@@@@对文件函数的总结@@@@@@@@@@@@@@@@@@

File（path） //用file类型直接打开文件
content.append(System.getProperty("line.separator"));//拼接一个系统默认分隔符

字节流
InputStream
OutputStream  　　　　　　　　　　　//读/写byte型文件
子类
FileinputStream（file1）
FileOutputStream （file1）　　　　　 //打开文件
ObjectInputStream　　　　　　　　  //对其目标文件进行强转成要得到的类型
ObjectOutputStream 　　　　　　　　　　//序列化和反序列化（实现Serializable接口）

字符流
Reader
Writer　　　　　　　　　　　　 //打开文件
子类
BufferedWriter 　　　　　　　　//缓冲字符输出流用其write（）方法写入字符串
BufferedReader
InputStreamReader
OutputStreamWriter
PrintWriter　　　　　　　　　 //用append拼接字符串

子类
FileReader(path/file)　　　　　　 //字符流读取文件

FileWriter(path/file) 　　　　　　//写入文件

***************************以读取文件为例****************

两者都实例化后方可：

1.先用Reader/FileinputStream打开文件后

2.再用其他子类去对文件修改

=================================================================================

Readme：

1.给定地址进行网络文件的读取操作

package 网路文件读取;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.net.URL;

/**
 * @author CF
 * @从给定的URL上读取内容
 * 2019年3月6日
 * 下午7:50:04
 */
public class readerURL {

    public static final String path2 = "E:\\学习\\java\\程序\\test\\src\\网路文件读取\\read.html";
    public static void main(String[] args) throws MalformedURLException {
        URL url=new URL("http://www.163.com/index.html");
        //将inputreader转换为reader的套路：使用装饰器inputstreamreader
        
        StringBuffer str=new StringBuffer();
        try(BufferedReader breader=new BufferedReader(new InputStreamReader(url.openStream())))
        {
            String line=null;
            while((line=breader.readLine())!=null)
            {
                 str.append(line);
                 str.append(System.getProperty("line.separator"));
            }
            歌词改编.字符流.printwr(str.toString(), path2, true);
        } catch (IOException e) {
            e.printStackTrace();
        }
    
    }
}

posted @ 2019-03-06 23:27 cc123nice 阅读(542) 评论(0) 编辑收藏举报

刷新页面返回顶部

cc123nice

java 文件硬盘存取 练习

读写文件操作

对字符流文件读写

进行对各种类型的二进制文件读写

公告

java 文件硬盘存取练习