java学习【知识点及代码14】
2017-05-16 23:17
274 查看
1.
LineNumberReader:
2.操作基本数据类型的流
3.内存操作流:解决临时数据存储的问题。
操作字节数组(演示着一个案例)
ByteArrayInputStream
ByteArrayOutputStream
byte[] toByteArray() 将之前写入内存的流转换成字节数组
操作字符数组
CharArrayReader
CharArrayWrite
操作字符串
StringReader
StringWriter
案例:演示
操作字节数组
ByteArrayInputStream
ByteArrayOutputStream
将数据写到流中保存在内存,并且读取
4.
打印流:
字节打印流 PrintStream
字符打印流 PrintWriter
特点:
A:只能操作目的地,不能操作数据源
B:可以操作任意类型的数据
C:如果启动了自动刷新,能够自动刷新
D:可以操作文件的流
注意:什么流可以直接操作文件?
看流对象的API,如果其构造方法同时有File和String类型的参数,就可以直接操作文件。
案例1:利用字符打印流给文件中书写数据(String类型),需要手动刷新
操作任意类型的数据呢?
print()
println():如果启动了自动刷新,能够实现刷新,而且还实现了自动换行。
如何启动自动刷新:利用构造
PrintWriter(OutputStream out, boolean autoFlush)
PrintWriter(Writer out, boolean autoFlush)
如果启用了自动刷新,则只有在调用 println、printf 或 format 的其中一个方法时才可能完成此操作
案例2:利用字符流给文件中写数据(int类型,boolean类型),启动自动刷新
案例3:利用字符打印流复制java文件(BufferedReader+PrintWriter)
5.标准输入输出流
System类下有这样的两个成员变量:
标准输入流:
public static final InputStream in
案例1:利用标准输入流进行键盘录入,录入后读取流并打印在控制台
案例2:用IO流实现键盘录入,一次读取一行数据
标准输出流:
public static final PrintStream out
案例:解析输出语句System.out.println(“helloworld”);
6.
合并流:SequenceInputStream类可以将多个输入流串流在一起,合并为一个输入流,因此,该流也被称为合并流。
构造:
SequenceInputStream(InputStream s1, InputStream s2) :将s1和s2合并成一个输入流,先读取s1后读取s2
案例1:
我要把DataStreamDemo.java和ByteArrayStreamDemo.java写到一个文件Copy.java
数据源:
DataStreamDemo.java
ByteArrayStreamDemo.java
目的地:
Copy.java
8 对象的序列化和反序列化
序列化流:把对象按照流一样的方式写到文件或者在网络中传输。
反序列化流:把文件或者网络中的流对象数据还原对象。
ObjectOutputStream:序列化流
writeObject(Object obj) 将指定的对象写入 ObjectOutputStream。
ObjectInputStream:反序列化流
Object readObject() 从 ObjectInputStream 读取对象。
注意:如果一个类不是实现Serializable接口无法把实例化,会报异常java.io.NotSerializableException
类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。
如何实现序列化?
让对象所属类的实现序列化接口。
9 Properties(查看api实现map接口本质是一个map集合)
9.1
Properties:Properties 类表示了一个持久的属性集。属性列表中每个键及其对应值都是一个字符串。
特点:Properties 可保存在流中或从流中加载。
案例:使用map集合的put方法给集合中存储数据并且遍历
9.2
Properties的特有功能:
A:添加元素
public Object setProperty(String key,String value)
B:获取元素
public String getProperty(String key)
public Set stringPropertyNames()
案例:使用它的特有功能添加元素并遍历
9.3
可以和IO流进行结合使用:
把文件中的数据加载到集合中。注意:文件中的数据必须是键值对象形式的(例如:张杰=谢娜)。
public void load(InputStream inStream)
public void load(Reader reader)
案例:创建一个键值对文件,将文件中的键值对加载到集合中,输出集合
把集合中的数据存储到文本文件中,并且是按照键值对形式存储的。
public void store(OutputStream out,String comments)
public void store(Writer writer,String comments)
案例:将创建的键值对集合加载到文件中
案例:我有一个文本文件,我知道数据是键值对形式的,但是不知道内容是什么。
请写一个程序判断是否有“lisi”这样的键存在,如果有就改变其值为”100”
案例:我有一个猜数字小游戏的程序,请写一个程序实现在测试类中只能用5次,
超过5次提示:游戏试玩已结束,请付费。
LineNumberReader:
public int getLineNumber():获取行号 public void setLineNumber(int lineNumber):设置起始行号 String readLine():读取一行 案例:读取文件,每次读取一行打印并且加上行号
package com.edu_01; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; import java.io.LineNumberReader; public class LineNumberReaderDemo { public static void main(String[] args) throws IOException { //创建LineNumberReader对象 //public LineNumberReader(Reader in) LineNumberReader lnr = new LineNumberReader(new FileReader("a.txt")); //默认起始行号从0开始 //设置其实行号为从10开始 lnr.setLineNumber(10); //一次读取一行 String line; while ((line = lnr.readLine())!=null) { //打印每一行的行号和内容 System.out.println(lnr.getLineNumber()+":"+line); } //关流 lnr.close(); } }
2.操作基本数据类型的流
可以操作基本类型的流对象。 DataInputStream:读数据 DataOutputStream:写数据 案例:给流中写基本类型的数据,并且读取 注意: 读写顺序必须一致,否则数据有问题。
package day14.edu_02; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; public class DataOutputStreamDemo { public static void main(String[] args) throws IOException { write(); read(); } private static void read() throws IOException { DataInputStream dis = new DataInputStream(new FileInputStream("ds.txt")); //读数据了,按什么顺序写入就必须按照什么顺序读出来 System.out.println(dis.readByte()); System.out.println(dis.readShort()); System.out.println(dis.readInt()); System.out.println(dis.readLong()); System.out.println(dis.readChar()); System.out.println(dis.readFloat()); System.out.println(dis.readDouble()); System.out.println(dis.readBoolean()); //关流 dis.close(); } private static void write() throws IOException { DataOutputStream ds = new DataOutputStream(new FileOutputStream("ds.txt")); ds.writeByte(0); ds.writeShort(5); ds.writeInt(2); ds.writeLong(555L); ds.writeChar('a'); ds.writeFloat(15.34F); ds.writeDouble(458.23); ds.writeBoolean(true); //关流 ds.close(); } }
3.内存操作流:解决临时数据存储的问题。
操作字节数组(演示着一个案例)
ByteArrayInputStream
ByteArrayOutputStream
byte[] toByteArray() 将之前写入内存的流转换成字节数组
package com.edu_03; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; public class ByteArrayOutputStreamDemo { public static void main(String[] args) throws IOException { //给内存中写数据public ByteArrayOutputStream() ByteArrayOutputStream baos = new ByteArrayOutputStream(); //给内存中调用方法写数据 baos.write("hello".getBytes()); //将写入内存中的数据读取出来 byte[] buf = baos.toByteArray();//调用这个方法,将之前写入内存中的数据存储到字节数组中 ByteArrayInputStream bais = new ByteArrayInputStream(buf);//将刚才存储到字节数组中的内容关联上bais //只有这样之后,我们才可以直接从bais中读取我们想要的内容 //一次读取一个字节 int by; 4000 while ((by=bais.read())!=-1) { System.out.print((char)by); } //关流 bais.close(); baos.close(); } }
操作字符数组
CharArrayReader
CharArrayWrite
操作字符串
StringReader
StringWriter
案例:演示
操作字节数组
ByteArrayInputStream
ByteArrayOutputStream
将数据写到流中保存在内存,并且读取
4.
打印流:
字节打印流 PrintStream
字符打印流 PrintWriter
特点:
A:只能操作目的地,不能操作数据源
B:可以操作任意类型的数据
C:如果启动了自动刷新,能够自动刷新
D:可以操作文件的流
注意:什么流可以直接操作文件?
看流对象的API,如果其构造方法同时有File和String类型的参数,就可以直接操作文件。
package com.edu_04; import java.io.IOException; import java.io.PrintWriter; public class PrintWriterDemo { public static void main(String[] args) throws IOException { //使用打印流给文件中写入hello,java,world //public PrintWriter(String fileName) PrintWriter pw = new PrintWriter("pw.txt"); //给流关联的文件中写数据 pw.write("hello"); pw.write("java"); pw.write("world"); //刷新 pw.flush(); //3.关流 pw.close(); } }
案例1:利用字符打印流给文件中书写数据(String类型),需要手动刷新
操作任意类型的数据呢?
print()
println():如果启动了自动刷新,能够实现刷新,而且还实现了自动换行。
如何启动自动刷新:利用构造
PrintWriter(OutputStream out, boolean autoFlush)
PrintWriter(Writer out, boolean autoFlush)
如果启用了自动刷新,则只有在调用 println、printf 或 format 的其中一个方法时才可能完成此操作
package com.edu_04; import java.io.FileWriter; import java.io.IOException; import java.io.PrintWriter; public class PrintWriterDemo2 { public static void main(String[] args) throws IOException { //创建字符打印流对象,并开启自动刷新 //public PrintWriter(Writer out,boolean autoFlush) PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true); //给流中写数据 //pw.write("hello"); //pw.write("java"); //注意:如果已经开启了自动刷新功能,必须调用则 println、printf 或 format的时候,才可以实现自动刷新 pw.println("hello"); pw.println("java"); pw.println("world");//调用println这个方法给文件中写数据,1.写数据 2.换行 3.刷新 //可以操作任意类型的数据 pw.println(true); pw.println(12.34); //关流 pw.close(); } }
案例2:利用字符流给文件中写数据(int类型,boolean类型),启动自动刷新
案例3:利用字符打印流复制java文件(BufferedReader+PrintWriter)
package com.edu_04; import java.io.BufferedReader; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.io.PrintWriter; public class PrintWriterDemo3 { public static void main(String[] args) throws IOException { //数据源 BufferedReader br = new BufferedReader(new FileReader("PrintWriterDemo.java")); //目的地 //PrintWriter(Writer out, boolean autoFlush) PrintWriter pw = new PrintWriter(new FileWriter("copy.java"),true); //读一行写一行 String line; while ((line=br.readLine())!=null) { pw.println(line);//1.写数据 2.换行 3.刷新 } //关流 pw.close(); br.close(); } }
5.标准输入输出流
System类下有这样的两个成员变量:
标准输入流:
public static final InputStream in
案例1:利用标准输入流进行键盘录入,录入后读取流并打印在控制台
package com.edu_05; import java.io.IOException; import java.io.InputStream; public class SystemIn { public static void main(String[] args) throws IOException { /** * public static final InputStream in */ //将键盘录入的数据封装在了输入流中 //Scanner sc = new Scanner(System.in); InputStream is = System.in; //将键盘录入的数据从输入流中读取出来 int by; while ((by=is.read())!=-1) { System.out.print((char)by); } //关流 is.close(); } }
案例2:用IO流实现键盘录入,一次读取一行数据
分析: InputStream is = System.in; BufferedReader是字符缓冲流,是对字符流进行高效操作的 所以,参数必须是字符类型 而我们现在有的是字节类型的流 请问:怎么办呢?转换流
package com.edu_05; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class SystemIn2 { public static void main(String[] args) throws IOException { //将上面的分析写为一部 BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); //一次读取一行数据 System.out.println("请输入你的姓名"); String name = br.readLine(); System.out.println("请输入你的年龄"); String age = br.readLine(); System.out.println(name+":"+age); } }
标准输出流:
public static final PrintStream out
案例:解析输出语句System.out.println(“helloworld”);
package com.edu_05; import java.io.PrintStream; public class SystemOut { public static void main(String[] args) { // PrintStream ps = System.out; // ps.println(true); //上面两行合并为一行,底层调用的字节打印流中的方法 System.out.println(true); } }
6.
合并流:SequenceInputStream类可以将多个输入流串流在一起,合并为一个输入流,因此,该流也被称为合并流。
构造:
SequenceInputStream(InputStream s1, InputStream s2) :将s1和s2合并成一个输入流,先读取s1后读取s2
案例1:
我要把DataStreamDemo.java和ByteArrayStreamDemo.java写到一个文件Copy.java
数据源:
DataStreamDemo.java
ByteArrayStreamDemo.java
目的地:
Copy.java
package com.edu_06; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.SequenceInputStream; public class SequenceInputStreamDemo { public static void main(String[] args) throws IOException { //创建合并流对象 //SequenceInputStream(InputStream s1, InputStream s2) :将s1和s2合并成一个输入流,先读取s1后读取s2 //将两个数据源合而为一 SequenceInputStream sis = new SequenceInputStream(new FileInputStream("PrintWriterDemo.java"), new FileInputStream("SystemIn2.java")); //封装目的地 FileOutputStream fos = new FileOutputStream("copy2.java"); //一下读写一个字节数组 byte[] buf = new byte[1024]; int len; while ((len=sis.read(buf))!=-1) { //读多少写多少 fos.write(buf, 0, len); } //关流 fos.close(); sis.close(); } }
8 对象的序列化和反序列化
序列化流:把对象按照流一样的方式写到文件或者在网络中传输。
反序列化流:把文件或者网络中的流对象数据还原对象。
ObjectOutputStream:序列化流
writeObject(Object obj) 将指定的对象写入 ObjectOutputStream。
package com.edu_07; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectOutputStream; public class ObjectOutputStreamDemo { public static void main(String[] args) throws IOException { //创建序列化流对象 //public ObjectOutputStream(OutputStream out) ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos.txt")); //创建一个学生对象,将学生对象写入文件中 Studnet s = new Studnet("刘德华", 50); oos.writeObject(s); // java.io.NotSerializableException //类通过实现 java.io.Serializable 接口以启用其序列化功能 //关流 oos.close(); } }
package com.edu_07; import java.io.Serializable; public class Studnet implements Serializable{ //实现这个接口不需要实现任何方法,这个接口说白了就是仅仅给Student类,打上了一个可以被序列化的标示 private String name; private int age; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public Studnet(String name, int age) { super(); this.name = name; this.age = age; } public Studnet() { super(); // TODO Auto-generated constructor stub } @Override public String toString() { return "Studnet [name=" + name + ", age=" + age + "]"; } }
ObjectInputStream:反序列化流
Object readObject() 从 ObjectInputStream 读取对象。
注意:如果一个类不是实现Serializable接口无法把实例化,会报异常java.io.NotSerializableException
类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。
如何实现序列化?
让对象所属类的实现序列化接口。
package com.edu_07; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.io.ObjectInputStream; public class ObjectInputStreamDemo { public static void main(String[] args) throws Exception { //创建反序列化流对象 ObjectInputStream ois = new ObjectInputStream(new FileInputStream("oos.txt")); //读取文件中存储的对象,以实现反序列化 //readObject() Object object = ois.readObject(); System.out.println(object); //关流 ois.close(); } }
9 Properties(查看api实现map接口本质是一个map集合)
9.1
Properties:Properties 类表示了一个持久的属性集。属性列表中每个键及其对应值都是一个字符串。
特点:Properties 可保存在流中或从流中加载。
案例:使用map集合的put方法给集合中存储数据并且遍历
package com.edu_08; import java.util.Properties; import java.util.Set; public class ProppertiesDemo { public static void main(String[] args) { //创建Properties对象,本质上是一个map集合,但是键值都是String类型 Properties prop = new Properties(); //给对象中存储元素 prop.put("zhangjie", "xiena"); prop.put("huangxiaoming", "baby"); prop.put("wanglaoshi", "zhangziyi"); //map集合遍历 //获取键的集合 Set<Object> keys = prop.keySet(); for (Object key : keys) { System.out.println(key+":"+prop.get(key)); } } }
9.2
Properties的特有功能:
A:添加元素
public Object setProperty(String key,String value)
B:获取元素
public String getProperty(String key)
public Set stringPropertyNames()
案例:使用它的特有功能添加元素并遍历
package com.edu_08; import java.util.Properties; import java.util.Set; public class PropertiesDemo2 { public static void main(String[] args) { //创建Properties这个集合 Properties prop = new Properties(); //调用public Object setProperty(String key,String value) prop.setProperty("huangxiaoming", "baby"); prop.setProperty("dengchao", "sunli"); prop.setProperty("xidada", "pengliyuan"); //1.获取所有键的集合 //public Set<String> stringPropertyNames() Set<String> keys = prop.stringPropertyNames(); //遍历键,根据键找值 for (String key : keys) { System.out.println(key+":"+prop.getProperty(key)); } } }
9.3
可以和IO流进行结合使用:
把文件中的数据加载到集合中。注意:文件中的数据必须是键值对象形式的(例如:张杰=谢娜)。
public void load(InputStream inStream)
public void load(Reader reader)
案例:创建一个键值对文件,将文件中的键值对加载到集合中,输出集合
package com.edu_08; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; import java.util.Properties; import java.util.Set; public class PropertiesDemo3 { public static void main(String[] args) throws IOException { //创建集合 Properties prop = new Properties(); //将文件中的键值对,加载到集合中 prop.load(new FileReader("prop.txt")); //遍历集合 Set<String> keys = prop.stringPropertyNames(); for (String key : keys) { System.out.println(key+":"+prop.getProperty(key)); } } }
把集合中的数据存储到文本文件中,并且是按照键值对形式存储的。
public void store(OutputStream out,String comments)
public void store(Writer writer,String comments)
案例:将创建的键值对集合加载到文件中
package com.edu_08; import java.io.FileWriter; import java.io.IOException; import java.util.Properties; public class PropertiesDemo4 { public static void main(String[] args) throws IOException { //创建集合 Properties prop = new Properties(); //给集合中存储数据 prop.setProperty("liudehua", "50"); prop.setProperty("liming", "60"); prop.setProperty("zhangxueyou", "40"); //将集合中的元素,存储到文本文件中 prop.store(new FileWriter("prop2.txt"), "name=age"); } }
案例:我有一个文本文件,我知道数据是键值对形式的,但是不知道内容是什么。
请写一个程序判断是否有“lisi”这样的键存在,如果有就改变其值为”100”
package com.edu_09; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Properties; import java.util.Set; public class PropTest { public static void main(String[] args) throws IOException { /** * zhangsan=3 lisi=4 wangwu=5 1.创建集合对象 2.将文件中的键值对加载到集合中 3.获取多有的键的集合,遍历,判断 4.如果存在lisi,的话,给集合中重新存储键值对lisi=100 5.将集合中的数据存储到文件中 */ //1.创建集合对象 Properties prop = new Properties(); // 2.将文件中的键值对加载到集合中 prop.load(new FileReader("prop3.txt")); //3.获取多有的键的集合,遍历,判断 Set<String> keys = prop.stringPropertyNames(); // 4.如果存在lisi,的话,给集合中重新存储键值对lisi=100 for (String key : keys) { if ("lisi".equals(key)) { prop.setProperty(key, "100"); } } //5.将集合中的数据存储到文件中 prop.store(new FileWriter("prop3.txt"), null); } }
案例:我有一个猜数字小游戏的程序,请写一个程序实现在测试类中只能用5次,
超过5次提示:游戏试玩已结束,请付费。
package com.edu_01; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.Properties; /** *1.将文件中的键值对加载到集合中 * 2.拿出已经玩耍的次数做判断 * 3.如果已经超过5次,提示付费 * 4.如果少于5次开启游戏,将文件中的次数+1 */ public class PropTest { public static void main(String[] args) throws IOException { //1.将文件中的键值对加载到集合中 Properties prop = new Properties(); prop.load(new FileReader("count.txt")); //2.拿出已经玩耍的次数做判断 String count = prop.getProperty("count"); //将String类型转换为int类型 int number = Integer.parseInt(count); if (number>4) { System.out.println("次数已到,请付费"); }else { //开启游戏 GuessNumber.startGame(); number++; //将自增的次数重新存储到文件中 prop.setProperty("count", number+""); //将新的prop集合存储到文件中 prop.store(new FileWriter("count.txt"), null); } } }
package com.edu_01; import java.util.Scanner; public class GuessNumber { public static void startGame(){ int ran = (int) (Math.random()*100+1); Scanner sc = new Scanner(System.in); while (true) { System.out.println("请输入你猜测得数字"); int number = sc.nextInt(); if (number>ran) { System.out.println("大了"); }else if (number<ran) { System.out.println("小了"); }else if (number==ran) { System.out.println("猜对了"); break; } } } }
相关文章推荐
- Java学习【知识点及代码6】
- java学习【知识点及代码12.2】
- Java学习【知识点及代码7】
- java学习【知识点及代码11】
- java学习【知识点及代码15】
- Java学习【知识点及代码4.1】
- java学习【知识点及代码12.1异常】
- java学习【知识点及代码17】
- java学习【知识点及代码18】
- JAVA学习代码——知识点
- java学习【知识点及代码16】
- java学习【知识点及代码13】
- java学习【知识点及代码10】
- Java学习【知识点及代码5】
- Windows API 函数学习(14)---SN填写代码
- [学习笔记]Java代码构建一个线程池的自己学习写的实例,用这个你会更好的理解文章内容
- Java学习笔记14
- JAVA学习提高之---- JSP验证码的实现代码
- 学习java i/o库要掌握的三个关键知识点
- 学习java i/o库要掌握的三个关键知识点