Java基础语法_Day21

一、标准输入流 & 转换流 & 打印流

public static final InputStream in:标准输入流
public static final PrintStream out:标准输出流

package com.neuedu.demo;
/*
* 标准输入输出流：
*     public static final InputStream in：字节输入流,用来读取键盘录入的数据
*         public static final int x;
*         InputStream is = System.in;
*         Scanner sc = new Scanner(System.in);
*     public static final PrintStream out：字节输出流,将数据输出到命令行
*         System.out.println();
*/    
public class SystemInOutDemo {
  
}

转换流

OutputStreamWriter:将字节输出流转换为字符输出流

案例代码一:

   package com.neuedu.demo;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;

/*
* 需求：读取项目根目录下的SystemInOutDemo.java，并输出到命令行
* 
* 数据源：项目根目录下的SystemInOutDemo.java BufferedReader
* 目的地：命令行 System.out
* 
* 
* 由于标准输出流是一个字节输出流，所以只能输出字节或者字节数组，但是我们读取到的数据则是字符串，如果想进行输出还需要转换成字节数组
* 我们要想通过标准输出流输出字符串，把标准输出流转换成一种字符输出流即可，OutputStreamWriter
* 
* OutputStreamWriter(OutputStream out) :转换流，把字节输出流转换成字符输出流
* 
* 
*/
public class OutputStreamWriterDemo {
  public static void main(String[] args) throws IOException   {
      //method2();
      
      //创建输入流对象
      BufferedReader br = new BufferedReader(new FileReader("SystemInOutDemo.java"));
      //创建输出流对象
      //OutputStream os = System.out;
      //Writer w = new OutputStreamWriter(System.out);//多态，父类型引用指向子类对象
      //BufferedWriter bw = new BufferedWriter(w);
      
      BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
      
      
      //进行数据的读写
      String line;//用于存储读取到的数据
      while((line = br.readLine()) != null) {
          bw.write(line);
          bw.newLine();
      }
      
      
      //释放资源
      bw.close();
      br.close();
  
  }

  private static void method2() throws FileNotFoundException, IOException {
      //创建输入流对象
      BufferedReader br = new BufferedReader(new FileReader("SystemInOutDemo.java"));
      //创建输出流对象
      //OutputStream os = System.out;
      Writer w = new OutputStreamWriter(System.out);//多态，父类型引用指向子类对象
      
      //进行数据的读写
      String line;//用于存储读取到的数据
      while((line = br.readLine()) != null) {
          w.write(line);
          w.write("\r\n");
      }
      
  
      //释放资源
      w.close();
      br.close();
  }

  private static void method() throws FileNotFoundException, IOException {
      //创建输入流对象
      BufferedReader br = new BufferedReader(new FileReader("SystemInOutDemo.java"));
      //创建输出流对象
      OutputStream os = System.out;
      
      String line;//用于存储读取到的数据
      while((line = br.readLine()) != null) {
          os.write(line.getBytes());
          os.write("\r\n".getBytes());
      }
      
      //释放资源
      os.close();
      br.close();
  }
}

InputStreamReader:将字节输入流转换为字符输入流
案例代码二:

package com.neuedu.demo;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;

/*
* 需求：读取键盘录入的数据，并输出到项目根目录下的a.txt文件中
* 
* 数据源：读取键盘录入的数据   System.in
* 目的地：项目根目录下的a.txt    FileWriter
* 
* 
* 
* 转换流：需要把字节输入流转换成字符输入流，InputStreamReader
* InputStreamReader(InputStream in) 
*/
public class InputStreamReaderDemo {
  public static void main(String[] args) throws IOException  {
      //创建输入流对象
      InputStream is = System.in;
      Reader r = new InputStreamReader(is);
      //创建输出流对象
      FileWriter fw = new FileWriter("a.txt");
      
      //读写数据
      char[] chs = new char[1024];
      int len;
      while((len = r.read(chs)) != -1) {
          fw.write(chs,0,len);
          fw.flush();
      }
      
      
      //释放资源
      fw.close();
      is.close();
      
  }

  private static void method() throws IOException {
      //创建输入流对象
      InputStream is = System.in;
      //创建输出流对象
      FileWriter fw = new FileWriter("a.txt");
      
      //读写数据
      byte[] bys = new byte[1024];
      int len;//用于存储读取到的字节个数
      while((len = is.read(bys)) != -1) {
          fw.write(new String(bys,0,len));
          fw.flush();
      }
      
      
      //释放资源
      fw.close();
      is.close();
  }
}

打印流

打印流添加输出数据的功能，使它们能够方便地打印各种数据值表示形式.
字符打印流 PrintWriter
void print(String str): 输出任意类型的数据，
void println(String str): 输出任意类型的数据，自动写入换行操作

案例代码三:

package com.neuedu.demo;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter;

/*
* 打印流：
*         PrintStream
*         PrintWriter
*             可以自动换行，println()
*             不能输出字节，但是可以输出其他任意类型
*             通过某些配置，可以实现自动刷新（只有在调用 println、printf 或 format才有用）
*             也是包装流，不具备写出功能
*             可以把字节输出流转换成字符输出流
* 
* 注意：只能输出不能输入
* 
*  
*/
public class PrintWriterDemo {
  public static void main(String[] args) throws IOException  {
      //创建打印流对象
      PrintWriter pw = new PrintWriter("b.txt");
      
      //写出数据
      pw.write("hello");
      pw.write("world");
      pw.write("java");
      
      //释放资源
      pw.close();
  }
}

案例代码四:
利用打印流实现自动换行与自动更新

package com.neuedu.demo;

import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

/*
* 打印流的特有功能：
*         自动换行 使用方法println()实现自动换行
*         自动刷新  创建PrintWriter对象时启动自动刷新开关，并且使用println等3个方法可以实现自动刷新
* 
* 注意：创建FileWriter对象时boolean参数是是否追加，
*         而创建打印流对象的boolean类型参数是是否自动刷新
*/
public class PrintWriterDemo2 {
  public static void main(String[] args) throws IOException  {
      //method();
      //创建打印流对象
      //PrintWriter pw = new PrintWriter("d.txt");
      
      PrintWriter pw = new PrintWriter(new FileWriter("d.txt"),true);
      
      pw.println("hello");
      pw.println("world");
      pw.println("java");
      
      //释放资源
      //pw.close();
              
  }

  private static void method() throws FileNotFoundException {
      //创建打印流对象
      PrintWriter pw = new PrintWriter("c.txt");
      
      /*pw.write("hello");
      pw.write("world");
      pw.write("java");*/
      
      pw.print("hello");
      pw.println("world");
      pw.println("java");
      
      //释放资源
      pw.close();
  }
}

案例代码五:
利用打印流将根目录下的SystemInOutDemo.java复制到d:\SystemInOutDemo.java下

package com.neuedu.demo;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

/*
* 使用打印流复制文本文件
* 
* 数据源 SystemInOutDemo.java    BufferedReader
* 目的地 d:\\SystemInOutDemo.java    PrintWriter
* 
*/
public class PrintWriterDemo3 {
  public static void main(String[] args) throws IOException  {
      //创建输入流对象
      BufferedReader br = new BufferedReader(new FileReader("SystemInOutDemo.java"));
      //创建打印流对象
      PrintWriter pw = new PrintWriter(new FileWriter("d:\\SystemInOutDemo.java"),true);
      
      String line;//用于存储读取到的每行数据
      while((line = br.readLine()) != null) {
          pw.println(line);
      }
      
      //释放资源
      pw.close();
      br.close();
  }
}

二、对象操作流

概述

用于从流中读取对象的
ObjectInputStream 称为反序列化流,利用输入流从文件中读取对象
ObjectOutputStream 称为序列化流,利用输出流向文件中写入对象
特点：用于操作对象。可以将对象写入到文件中，也可以从文件中读取对象。

package com.neuedu.demo;
/* 
* 对象操作流：可以用于读写任意类型的对象
*         ObjectOutputStream
*                 writeObject 
*                 ObjectOutputStream(OutputStream out) 
*         ObjectInputStream
*                 readObject
*                 ObjectInputStream(InputStream in)
* 
* 注意：
*         使用对象输出流写出对象，只能使用对象输入流来读取对象
*         只能将支持 java.io.Serializable 接口的对象写入流中
* 
*/
public class ObjectOutputStreamDemo2 {
  public static void main(String[] args)  {
      
  }
}

利用序列化流读写对象

package com.neuedu.demo;
import java.io.Serializable;
public class Student implements Serializable {
  
  String name;
  int age;
  
  public Student(String name,int age) {
      this.name = name;
      this.age = age;
  }


  @Override
  public String toString() {
      return "Student [name=" + name + ", age=" + age +"]";
  }
}

package com.neuedu.demo;
import java.io.EOFException;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/* 
* 使用对象输出流和读对象输入流写对象
* Exception in thread "main" java.io.NotSerializableException: com.itheima_07.Student
* Serializable:序列号，是一个标识接口，只起标识作用，没有方法
*                 当一个类的对象需要IO流进行读写的时候，这个类必须实现该接口
* 
* Exception in thread "main" java.io.EOFException:当输入过程中意外到达文件或流的末尾时，抛出此异常。
* 
*/
public class ObjectOutputStreamDemo {
  public static void main(String[] args) throws IOException, ClassNotFoundException  {
      //method();
      //创建对象输入流的对象
      ObjectInputStream ois = new ObjectInputStream(new FileInputStream("a.txt"));
      //读取对象
      /*Object obj = ois.readObject();
      System.out.println(obj);
      
      Object obj2 = ois.readObject();
      System.out.println(obj2);
      
      Object obj3 = ois.readObject();
      System.out.println(obj3);*/
      
      try {
          while(true) {
              Object obj = ois.readObject();
              System.out.println(obj);
          }
      } catch(EOFException e) {
          System.out.println("读到了文件的末尾");
      }
      
      //释放资源
      ois.close();
  }

  private static void method() throws IOException, FileNotFoundException {
      //创建对象输出流的对象
      //FileOutputStream fos = new FileOutputStream("a.txt");
      //ObjectOutputStream oos = new ObjectOutputStream(fos);
      ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("a.txt"));
      
      //创建学生对象
      Student s = new Student("zhangsan",18);
      Student s2 = new Student("lisi",19);
      //写出学生对象
      oos.writeObject(s);
      oos.writeObject(s2);
      
      //释放资源
      oos.close();
  }
}

案例代码六:

package com.neuedu.demo;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*
* 使用字符流复制文本文件
* 
* 数据源     IODemo.java
* 目的地     d:\\IODemo.java
*     
*/
public class FileCopyDemo {
  public static void main(String[] args) throws IOException  {
      //创建字符输入流对象
      FileReader fr = new FileReader("IODemo.java");
      //创建字符输出流对象
      FileWriter fw = new FileWriter("d:\\IODemo.java");
      
      //一次读写一个字符
      
      /*int ch;
      while((ch = fr.read()) != -1) {
          fw.write(ch);
          fw.flush();
      }*/
      
      //一次读写一个字符数组
      int len;//用于存储读到的字符个数
      char[] chs = new char[1024];
      while((len = fr.read(chs)) != -1) {
          fw.write(chs,0,len);
          fw.flush();
      }
      
      //释放资源
      fw.close();
      fr.close();
  }
}

解决对象输入流读取对象出现异常的问题

案例代码七:

package com.neuedu.demo;
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.util.ArrayList;

/*
* 解决对象输入流读取对象出现异常的问题
* 
*/
public class ObjectOutputStreamDemo3 {
  public static void main(String[] args) throws IOException, ClassNotFoundException   {
      //method();
      
      //创建对象输入流的对象
      ObjectInputStream ois = new ObjectInputStream(new FileInputStream("b.txt"));
      //读取数据
      Object obj = ois.readObject(); 
      //System.out.println(obj);
      
      //向下转型，获取具体的子类对象
      ArrayList<Student> list = (ArrayList<Student>) obj;
      for (Student student : list) {
          System.out.println(student);
      }
      
      //释放资源
      ois.close();
  }

  private static void method() throws IOException, FileNotFoundException {
      //创建对象输出流的对象
      ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("b.txt"));
      //创建集合对象
      ArrayList<Student> list = new ArrayList<Student>();
      //添加学生对象
      list.add(new Student("wangwu",30));
      list.add(new Student("zhaoliu",28));
      //写出集合对象
      oos.writeObject(list);
      
      //释放资源
      oos.close();
  }
}

解决读写对象版本不一致问题

案例代码八:

package com.neuedu.demo;
import java.io.Serializable;

public class Student implements Serializable {
  

  private static final long serialVersionUID = 6361890890437825953L;
  String name;
  int age;
  String gender;

  
  public Student(String name,int age) {
      this.name = name;
      this.age = age;
  }


  @Override
  public String toString() {
      return "Student [name=" + name + ", age=" + age + ", gender=" + gender + "]";
  }
}

package com.neuedu.demo;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/*
* 解决对实现序列化接口出现的黄色警告问题
* Exception in thread "main" java.io.InvalidClassException
* 当 Serialization 运行时检测到某个类具有以下问题之一时，抛出此异常。 
*     该类的序列版本号与从流中读取的类描述符的版本号不匹配 
*     该类包含未知数据类型 
*     该类没有可访问的无参数构造方法 
* 
*/
public class ObjectOutputStreamDemo4 {
  public static void main(String[] args) throws IOException, ClassNotFoundException  {
      //method();
      
      method2();
  }
  
  //读取学生对象
  private static void method2() throws IOException, FileNotFoundException, ClassNotFoundException {
      //创建对象输入流的对象
      ObjectInputStream ois = new ObjectInputStream(new FileInputStream("c.txt"));
      //读取对象
      Object obj = ois.readObject();
      System.out.println(obj);
      //释放资源
      ois.close();
  }
  
  //写出学生对象
  private static void method() throws IOException, FileNotFoundException {
      //创建对象输出流的对象
      ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("c.txt"));
      //创建的学生对象
      Student s = new Student("qianqi",28);
      //写出学生对象
      oos.writeObject(s);
      //释放资源
      oos.close();
  }
}

三、Properties集合

Properties介绍

Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。
特点：
1、Hashtable的子类，map集合中的方法都可以用。
2、该集合没有泛型。键值都是字符串。
3、它是一个可以持久化的属性集。键值可以存储到集合中，也可以存储到持久化的设备(硬盘、U盘、光盘)上。键值的来源也可以是持久化的设备。
4、有和流技术相结合的方法。

方法.png

利用Properties存储键值对

案例代码九:

  package com.neuedu.demo;

import java.util.Map;
import java.util.Properties;
import java.util.Set;

/*
* Properties：表示了一个持久的属性集，属性列表中每个键及其对应值都是一个字符串
* 
* 构造方法：
*         Properties() 
*/
public class PropertiesDemo2 {
  public static void main(String[] args) {
      //创建属性列表对象
      Properties prop = new Properties();
      //添加映射关系
      prop.put("CZBK001", "zhangsan");
      prop.put("CZBK002", "lisi");
      prop.put("CZBK003", "wangwu");
      
      //遍历属性列表
      //获取所有的key，通过key获取value
      Set<Object> keys = prop.keySet();
      for (Object key : keys) {
          Object value = prop.get(key);
          System.out.println(key + "=" + value);
      }
      System.out.println("------------------");
      //获取所有的结婚证对象
      Set<Map.Entry<Object,Object>> entrys = prop.entrySet();
      for (Map.Entry<Object, Object> entry : entrys) {
          Object key = entry.getKey();
          Object value = entry.getValue();
          System.out.println(key + "=" + value);
      }
  
  }
}

Properties与流结合使用

案例代码十:

package com.neuedu.demo;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Properties;

/*
* Properties和IO流结合的功能： 
*             void load(Reader reader) 
*             
*             void list(PrintWriter out)
*             void store(Writer writer, String comments) 
*         
*
*/
public class PropertiesDemo2 {
  public static void main(String[] args) throws IOException{
      //method();
      
      //method2();
      
      //创建属性列表对象
      Properties prop = new Properties();
      //添加映射关系
      prop.setProperty("CZBK001", "zhangsan");
      prop.setProperty("CZBK002", "lisi");
      prop.setProperty("CZBK003", "wangwu");
      //创建输出流对象
      FileWriter fw = new FileWriter("e.txt");
      
      //void store(Writer writer, String comments) 
      prop.store(fw, "hello world");
      
      //释放资源
      fw.close(); 
  }

  private static void method2() throws FileNotFoundException, IOException {
      //创建属性列表对象
      Properties prop = new Properties();
      //创建一个输入流对象
      FileReader fr = new FileReader("d.txt");
      
      //void load(Reader reader) 
      prop.load(fr);
      
      //释放资源
      fr.close();
      
      System.out.println(prop);
  }

  private static void method() throws FileNotFoundException {
      //创建属性列表对象
      Properties prop = new Properties();
      //添加映射关系
      prop.setProperty("CZBK001", "zhangsan");
      prop.setProperty("CZBK002", "lisi");
      prop.setProperty("CZBK003", "wangwu");
      
      //创建打印流对象
      PrintWriter out = new PrintWriter("d.txt");
      //void list(PrintWriter out)  
      prop.list(out);
      
      //释放资源
      out.close();
  }
}

四、编码表

编码表的概述

编码表：把计算机底层的二进制数据转换成我们能看到的字符

ASCII

GB2312 --- GBK
Unicode 所有的字符都占2个字节
UTF-8 长度可变的码表

ANSI：本地编码表 gbk
Java中的字符串默认使用的ANSI（gbk）

乱码：编码保持前后一致即可解决

Java中字符串的编码

常用方法

构造方法（字节数组转字符串）：
String():初始化一个新创建的 String 对象，使其表示一个空字符序列
String(byte[] bytes) 使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String
String(byte[] bytes, Charset charset) 通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String

成员方法（字符串转字节数组）
getBytes() 使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中
getBytes(Charset charset) 使用给定的 charset 将此 String 编码到 byte 序列，并将结果存储到新的 byte 数组

案例代码十一

package com.neuedu.demo;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;

/*
* 编码表：把计算机底层的二进制数据转换成我们能看到的字符
*         ASCII
* 
*         GB2312  --- GBK
*         Unicode 所有的字符都占2个字节
*         UTF-8   长度可变的码表
* 
* ANSI：本地编码表  gbk
* Java中的字符串默认使用的ANSI（gbk）
* 
* 乱码：编码保持前后一致即可解决
* 
*/
public class EncoderDemo {
  public static void main(String[] args) throws IOException   {
      //method();
      
      FileInputStream fis = new FileInputStream("a.txt");
      byte[] bys = new byte[1024];
      int len = fis.read(bys);
      //System.out.println(new String(bys,0,len));
      System.out.println(new String(bys,0,len,"UTF-8"));
  }

  private static void method() throws UnsupportedEncodingException, FileNotFoundException, IOException {
      String s = "高薪就业";
      //byte[] bys = s.getBytes();//通过默认编码转换成数组
      byte[] bys = s.getBytes("UTF-8");
      
      FileOutputStream fos = new FileOutputStream("a.txt");
      fos.write(bys);
      fos.close();
  }
}

字符流中的编码

常见对象

InputStreamReader(InputStream in, CharsetDecoder dec) 创建使用给定字符集解码器的 InputStreamReader

OutputStreamWriter(OutputStream out, CharsetEncoder enc) 创建使用给定字符集编码器的 OutputStreamWriter

案例代码十二

package com.neuedu.demo;

import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

/*
* 字符流中的编码
* 
* 字符流 = 字节流 + 编码
* 
*/
public class EncoderDemo2 {
  public static void main(String[] args) throws IOException {
      //method();
      OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("b.txt"),"UTF-8");
      //OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("b.txt"));
      String s = "迎娶白富美";
      osw.write(s);
      
      osw.close();
      
  }

  private static void method() throws IOException, UnsupportedEncodingException {
      FileWriter fw = new FileWriter("b.txt");
      
      String s = "月薪过万";
      byte[] bys = s.getBytes("UTF-8");
      
      //fw.write(s);
      fw.write(new String(bys));
      fw.close();
  }
}

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 212,332评论 6赞 493
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 90,508评论 3赞 385
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 157,812评论 0赞 348
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 56,607评论 1赞 284
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 65,728评论 6赞 386
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 49,919评论 1赞 290
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 39,071评论 3赞 410
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 37,802评论 0赞 268
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 44,256评论 1赞 303
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 36,576评论 2赞 327
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 38,712评论 1赞 341
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 34,389评论 4赞 332
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 40,032评论 3赞 316
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 30,798评论 0赞 21
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,026评论 1赞 266
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 46,473评论 2赞 360
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 43,606评论 2赞 350

Java基础语法_Day21

一、标准输入流 & 转换流 & 打印流

二、对象操作流

三、Properties集合

四、编码表

推荐阅读更多精彩内容