文件
文件的输出用delete（）方法只能删除空目录，带有文件的目录需先删除目录下的文件在删除目录。
读取数据一般用字节流，而字符流只能读取记事本中我们依旧能读懂的内容。
字节流写数据换行，记事本中正常换行符号的规范使用：Windows:\r\n Linus:\n mac:\r
文件追加数据方法：FileOutputStream(String name, boolean append)
字节流读取数据的常用代码
byte[] bytes=new byte[1024];
int len;
while((len=InputSream.read(bytes))!=-1){
……
}
字节缓冲流
- BufferedOutPutSream:该类实现缓冲输出流。通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用
- BufferedInputSream:创建BufferedInputStream将创建一个内部缓冲区数组。当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节
构造方法： - 字节缓冲输出流：BufferedOutputStream(OupurSrteam out)
- 字节缓冲输入流：BufferedInputStream(InoutStream in)
通过字节缓冲流可以提高效率，大大减少了时间
String s="中国";
byte[] bytes=s.getBytes("GBK");
String ss=new String(bytes,"GBK");
字符流
字符流抽象基类
- Reader：字符输入流的抽象类
- Writer：字符输出流的抽象类
字符流中和编码解码问题相关的两个类（可以指定编码） - InputStreamReader
- OutputStreamWriter
char[] chars=new char[1024];
int len;
while((len=InputSreamReader.read(chars))!=-1){
……
}
字符缓冲流
- BufferedWriter：将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途
- BufferedReader：从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可以指定缓冲区大小，或者可以使用默认大小。默认值足够大，可用于大多数用途
构造方法： - BufferedWriter（Writer out）
特有方法 void newLine()：写一行分隔符，行分隔符字符串由系统属性定义 - BufferedReader（Reader in）
特有方法 public String readline()：读一行文字。结果包含行内的内容的字符串，不包括任何行终止字符，如果流的结尾已经倒带，则为null
BufferedReader br=new BufferedReader(new FileReader("FromFileLoction"));
BufferedWriter bw-bew BufferedWriter(new FileWriter("ToFileLocation"));
String line;
while((line=br.readline())!=null){
bw.write(line)l
bw.nextline();
bw.flush();
}
bw.close();
br.close();
复制单个文件夹
import java.io.*;
public class TestCopyFolderDemo {
public static void main(String[] args) throws IOException{
File beginFolder = new File("D:\\idea-2020\\测试\\测试1");
String beginFolderName=beginFolder.getName();
File endFolder=new File("D:\\idea-2020\\测试\\测试2",beginFolderName);
if(!endFolder.exists()){
endFolder.mkdir();
}
File[] files = beginFolder.listFiles();
for(File file:files){
String fileName=file.getName();
File enFile=new File(endFolder,fileName);
copyFile(file,enFile);
}
}
private static void copyFile(File file, File enFile) throws IOException{
BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(file));
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(enFile));
byte[] bytes = new byte[1024];
int len;
while((len=bufferedInputStream.read(bytes))!=-1){
bufferedOutputStream.write(bytes,0,len);
}
bufferedOutputStream.close();;
bufferedInputStream.close();
}
}
复制多级文件夹
import java.io.*;
public class TestCopyFoldersDemo {
public static void main(String[] args)throws IOException {
File beginFile = new File("D:\\idea-2020\\测试\\测试2");
File enFile = new File("D:\\idea-2020\\测试\\测试3");
copyFolder(beginFile,enFile);
}
private static void copyFolder(File beginFile, File enFile)throws IOException {
if(beginFile.isDirectory()){
String fileName = beginFile.getName();
File newFolder = new File(enFile,fileName);
if(!newFolder.exists()){
newFolder.mkdir();
}
File[] files = beginFile.listFiles();
for(File file:files){
copyFolder(file,newFolder);
}
}else {
File newFile = new File(enFile,beginFile.getName());
copyFile(beginFile,newFile);
}
}
private static void copyFile(File file, File enFile) throws IOException {
BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(file));
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(enFile));
byte[] bytes = new byte[1024];
int len;
while((len=bufferedInputStream.read(bytes))!=-1){
bufferedOutputStream.write(bytes,0,len);
}
bufferedOutputStream.close();;
bufferedInputStream.close();
}
}
将集合写入文件
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
public class TestArrayInFile {
public static void main(String[] args)throws IOException {
ArrayList<String> strings = new ArrayList<>();
strings.add("Hello");
strings.add("World");
strings.add("Java");
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("D:\\IDEA-2020\\学习\\src\\com\\max\\day01\\array.txt"));
for(String s:strings){
bufferedWriter.write(s);
bufferedWriter.newLine();
bufferedWriter.flush();
}
bufferedWriter.close();
}
}
将文件写进集合
public class TesFileInArray {
public static void main(String[] args) throws IOException {
BufferedReader bufferedReader = new BufferedReader(new FileReader("D:\\IDEA-2020\\学习\\src\\com\\max\\day01\\array.txt"));
ArrayList<String> strings = new ArrayList<>();
String line;
while((line=bufferedReader.readLine())!=null){
strings.add(line);
}
bufferedReader.close();
for(String s:strings){
System.out.println(s);
}
}
}
将排序集合写进文件
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;
public class TestTreeSetToFile {
public static void main(String[] args) throws IOException {
TreeSet<Student> students = new TreeSet<>(new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
int num1=s2.getSum()-s1.getSum();
int num2=num1==0?s2.getChinese()-s1.getChinese():num1;
int num3=num2==0?s2.getEnglish()-s2.getEnglish():num2;
int num4=num3==0?s2.getName().compareTo(s1.getName()):num3;
return num4;
}
});
for(int i=0;i<4;i++) {
Scanner scanner = new Scanner(System.in);
System.out.println("请录入第" + (i + 1) + "个学生信息");
System.out.println("姓名：");
String name = scanner.nextLine();
System.out.println("语文成绩：");
int chinese = scanner.nextInt();
System.out.println("英语成绩：");
int english = scanner.nextInt();
System.out.println("数学成绩：");
int math = scanner.nextInt();
Student student = new Student();
student.setName(name);
student.setChinese(chinese);
student.setEnglish(english);
student.setMath(math);
students.add(student);
}
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("D:\\IDEA-2020\\学习\\src\\com\\max\\day01\\students.txt"));
for(Student s:students) {
StringBuilder sb = new StringBuilder();
sb.append(s.getName()).append(",").append(s.getChinese()).append(",").append(s.getEnglish()).append(",").append(s.getMath()).append(",").append(s.getSum());
bufferedWriter.write(sb.toString());
bufferedWriter.newLine();
bufferedWriter.flush();
}
bufferedWriter.close();
}
}
标准输入输出流
System类中有两个静态的成员变量：
- public static final InputStream in：标准输入流。通常该流对应于键盘输入或由主机环境或用户指定的另一个输入源
- public static final OutputStream out：标准输出流。通常该流对应于显示输出或由主机环境或用户指定的另一个输出目标
自己实现键盘录入数据 - BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
调用Scanner类 - Scanner scan=new Scanner(System.in);
输出语句的本质
- PrintStream ps=System.out;
字符打印流
- PrintWriter(String fileName)：使用指定的文件名创建一个新的PrintWriter，但需要手动执行刷新
- PrintWriter(Writer out,boolean autoFlush)
out：字符输出流
autoFlush：一个布尔值，如果为真，则println，printf，或format方法将刷新输出缓冲区
字符打印流可以减少代码
对象序列化
对象序列化：就是将对象保存到磁盘中，或者在网络中传输对象
这种机制激素使用一个字节序列表示一个对象，该字节序列包含：对象的类型、对象的数据和对象中存储的属性等信息
反之，该字节序列海可以从文件中读取回来，重构对象，对它进行反序列化
要实现序列化和反序列化就要使用对象序列化流和对象反序列化流：
- 对象序列化流：ObjectOutputStream
- 对象反序列化流：ObjectInputStream
对象序列化流
对象序列化流：ObjectOutputStream
- 将java对象的原始数据类型和图形写入OutputStream。可以使用ObjectInputStream读取（重构）对象。可以通过使用流的文件来实现对象的持久储存。如果流是网络套接字流，则可以在另一个主机上或另一个进程中重构对象
构造方法
- ObjectOutputStream(OutputStream out)：创建一个写入指定的OutputStream的ObjectOutputStream
序列化对象的方法 - void writeObject((Object obj)：将指定的对象写入ObjectOutputStream
注意： - 一个对象想要被序列化，该对象所属的类必须实现Serializable接口
- Serializable是一个标记接口，实现该接口，不需要重写任何方法
对象反序列化流
对象反序列化流：ObjectInputStream
- ObjectInputStream反序列化先前使用ObjectOutputStream编写的原始数据和对象
构造方法： - ObjectInputStream(InputStream in)：创建从指定的InputStream读取的ObjectInputStream
反序列化对象的方法 - Object readObjec()：从ObjectInputStream读取一个对象
用对象序列流序列化一个对象后，假如我们修改了对象所属的类文件，读取数据会出问题：
- 抛出InvalidClassException异常
解决方案： - 给对象所属类加一个serialVersionUID
private static final long serialVersionUID=42L;(42L是可改的值）
如果对象中某个成员变量的值不想被序列化，实现方案：
- 给改成员变量加transient关键字修饰，该关键字标记的成员变量不参与序列化过程
Properties
- 是一个Map体系的集合类
- Properties可以保存到流或从流中加载。 属性列表中的每个键及其对应的值都是一个字符串。
Properties作为Map集合的使用(不能使用泛型)
import java.util.Properties;
import java.util.Set;
public class TestPropertiesDemo {
public static void main(String[] args) {
Properties properties = new Properties();
properties.put("001","小猪");
properties.put("002","小猪哥");
properties.put("003","小猪哥哥");
Set<Object> keySet = properties.keySet();
for(Object key:keySet){
Object value = properties.get(key);
System.out.println(key+","+value);
}
}
}
Properties作为集合特有的方法：
import java.util.Properties;
import java.util.Set;
public class TestPropertiesDemo02 {
public static void main(String[] args) {
Properties properties = new Properties();
properties.setProperty("001", "小猪");
properties.setProperty("002", "小猪哥");
properties.setProperty("003", "小猪哥哥");
Set<String> strings = properties.stringPropertyNames();
for (String key : strings) {
System.out.println(key+","+properties.getProperty(key));
}
}
}
Properties和IO流相结合的方法：
import java.io.*;
import java.util.Properties;
public class TestPropertiesDemo04 {
public static void main(String[] args)throws IOException {
myStore();
myLoad();
}
private static void myLoad() throws IOException{
Properties properties = new Properties();
properties.load(new FileInputStream("D:\\IDEA-2020\\学习\\src\\com\\max\\day01\\properties.txt"));
System.out.println(properties);
}
private static void myStore() throws IOException {
Properties properties = new Properties();
properties.setProperty("001", "小猪");
properties.setProperty("002", "小猪哥");
properties.setProperty("003", "小猪哥哥");
properties.store(new FileOutputStream("D:\\IDEA-2020\\学习\\src\\com\\max\\day01\\properties.txt"),null);
}
}
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
public class TestPropertiesDemo03 {
public static void main(String[] args)throws IOException {
myStore();
myLoad();
}
private static void myLoad() throws IOException{
Properties properties = new Properties();
properties.load(new FileReader("D:\\IDEA-2020\\学习\\src\\com\\max\\day01\\properties.txt"));
System.out.println(properties);
}
private static void myStore() throws IOException {
Properties properties = new Properties();
properties.setProperty("001", "小猪");
properties.setProperty("002", "小猪哥");
properties.setProperty("003", "小猪哥哥");
properties.store(new FileWriter("D:\\IDEA-2020\\学习\\src\\com\\max\\day01\\properties.txt"),null);
}
}
游戏次数设计
猜数字游戏类
import java.util.Random;
import java.util.Scanner;
public class GuessNumber {
public GuessNumber() {
}
public static void start() {
Random random = new Random();
int number = random.nextInt(100) + 1;
while (true) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入你所猜测的数字");
int guessNumber = scan.nextInt();
if (guessNumber > number) {
System.out.println("你猜的数字" + guessNumber + "大了");
} else if (guessNumber < number) {
System.out.println("你猜的数字" + guessNumber + "小了");
} else {
System.out.println("恭喜你猜中了");
break;
}
}
}
}
保存
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
public class TestProperties {
public static void main(String[] args) throws IOException {
Properties properties = new Properties();
properties.load(new FileReader("D:\\IDEA-2020\\学习\\src\\com\\max\\day01\\game.txt"));
String count=properties.getProperty("count");
int number=Integer.parseInt(count);
if(number>=3){
System.out.println("游戏试玩已结束，想玩请充值（www.itcast.cn)" );
}else {
GuessNumber.start();
number++;
properties.setProperty("count",String.valueOf(number));
properties.store(new FileWriter("D:\\IDEA-2020\\学习\\src\\com\\max\\day01\\game.txt"),null);
}
}
}
扫一扫
710
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
