概述
package org.lemon.DataStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* @author zhaojiangbo
*针对Java基本数据类型的数据进行读写操作
*/
public class DataStreamDemo {
public static void main(String[] args) throws IOException {
write();
read();
}
private static void read() throws FileNotFoundException,IOException {
DataInputStream dis = new DataInputStream(new FileInputStream("a.txt"));
dis.readInt();
long l = dis.readLong();
byte b = dis.readByte();
boolean boolean1 = dis.readBoolean();
double d = dis.readDouble();
float f = dis.readFloat();
dis.close();
System.out.println(l);
System.out.println(b);
System.out.println(boolean1);
System.out.println(d);
System.out.println(f);
}
private static void write() throws FileNotFoundException, IOException {
DataOutputStream dos = new DataOutputStream(new FileOutputStream("a.txt"));
dos.writeInt(85);
dos.writeByte(10);
dos.writeDouble(2.4);
dos.writeLong(99999999L);
dos.writeFloat(15.66F);
dos.close();
}
}
package org.lemon.ByteArrayStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
/**
* @author zhaojiangbo
*ByteArrayInputStream和ByteArrayOutStream
* 内存操作流:针对内存的数据进行操作的,程序一结束,这些内存中的数据就消失掉了!
* 特点:针对小文件进行操作!
*
* public ByteArrayOutputStream():创建默认的缓冲区大小的内存操作输出流(单位是字节)
*
* public byte[] toByteArray()创建一个新分配的 byte 数组(将内存操作输出流对象转换成字节数组)
* void reset():重置内存操作输出流
*
* public ByteArrayInputStream(byte[] buffer):参数是一个字节数组(缓冲数组)
*/
public class ByteArrayStreamDemo {
public static void main(String[] args) throws IOException {
//创建内存操作输出流对象
ByteArrayOutputStream bos = new ByteArrayOutputStream();
for(int i =0;i<5;i++) {
bos.write(("wo"+i).getBytes());
}
bos.close();
//将内存操作输出流对象转换成字节数组
byte[] buffer = bos.toByteArray();
//创建内存操作输入流对象
ByteArrayInputStream bis = new ByteArrayInputStream(buffer);
int by = 0;
while((by=bis.read())!=-1) {
System.out.print((char)by);
}
bis.close();
}
}package org.lemon.CopyFile;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/**
* @author zhaojiangbo
*需求:将当前项目下的DataStreamDemo.java中的内容复制到当前项目下Copy.java文件中------改进版
*/
public class CopyFileDemo {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new FileReader("DataStreamDemo.java"));
PrintWriter pw = new PrintWriter(new FileWriter("Copy.java"),true);
String line = null;
while((line=br.readLine())!=null) {
pw.println(line);
}
br.close();
pw.close();
}
}
package org.lemon.Print;
import java.io.IOException;
import java.io.PrintWriter;
/**
* @author zhaojiangbo
*字节打印流:PrintStream
*字符打印流:PrintWriter
* 打印流特点:
* 1)在复制文件的,打印流不能操作数据源,只能操作目的地的数据(只能输出数据)
* 2)打印流可以有自动刷新的功能
* 3)打印流可以直接针对文本文件进行操作:(构造方法的参数有File类或者是String类型)
* 构造方法:
* public PrintWriter(String fileName)
*/
public class PrintWriterDemo {
public static void main(String[] args) throws IOException {
//创建字符打印流对象
PrintWriter pw = new PrintWriter("a.txt");
pw.write("wo");
pw.write("ai");
pw.write("ni");
pw.flush();
pw.close();
}
}
package org.lemon.Print;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/**
* @author zhaojiangbo
*PrintWriter:有自动刷新功能:
* public PrintWriter(Writer out,boolean autoFlush)
* 第二个参数指定为true,则启动自动刷新
* PrintWriter pw = new PrintWriter(new FileWriter("pw.txt"),true) ;
* 加入自动刷新功能并且在写数据的时候,使用println():换行 println("hello")
* 作用相当于:
* pw.write("") ; pw.newLine() ; pw.flush() ;
*/
public class PrintWriterDemo2 {
public static void main(String[] args) throws IOException {
PrintWriter pw = new PrintWriter(new FileWriter("abc.txt"), true);
pw.println("wo");
pw.println("yi");
pw.println("ran");
pw.println("ai");
pw.println("ni");
pw.close();
}
}
package org.lemon.System;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/**
* @author zhaojiangbo
*键盘录入
* 1.Scanner类
* Scanner sc = new Scanner(System.in) ;
* 2.使用IO流的形式进行录入数据
* BufferedReader br = new BufferedReader(new InputStreamReader(System.in)) ;
*/
public class SystemInDemo {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.println("请输入一个字符串");
String line = br.readLine();
System.out.println("数据是:"+line);
System.out.println("请输入一个整数");
String line2 = br.readLine();
int i = Integer.parseInt(line2);
System.out.println("数据是："+i);
}
}package org.lemon.System;
import java.io.PrintStream;
/**
* @author zhaojiangbo
*标准输入和输出流
* System类:
* in:----->InputStream is = System.in ;
* out----->PrintStream ps = System.out ;
* System.out.println();
*/
public class SystemOutDemo {
public static void main(String[] args) {
System.out.println("wo ai ni");
System.out.println("ni ai wo");
//字节打印流
PrintStream out = System.out;
out.println("wo yi ran ai ni");//打印一个字符串数据并且终止当前行
}
}
package org.lemon.RandomAccessFile;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
/**
* @author zhaojiangbo
*RandomAccessFile:随机访问流:此类的实例支持对随机访问文件的读取和写入
* 不是实际意义上的流,因为它继承自Object类
* 构造方法:
* public RandomAccessFile(String name, String mode)
参数一:指定该文件的路径
参数二:指定的一种模式:常用的模式:"rw",这种模式是可以读也可以写
*/
public class RandomAccessFileDemo {
public static void main(String[] args) throws IOException {
read();
write();
}
private static void read() throws FileNotFoundException, IOException {
RandomAccessFile raf = new RandomAccessFile("abc.txt", "rw");
byte b = raf.readByte();
System.out.println(b);
System.out.println("getFilePointer:"+raf.getFilePointer());
char ch = raf.readChar();
System.out.println(ch);
String str = raf.readUTF();
System.out.println(str);
raf.close();
}
private static void write() throws FileNotFoundException, IOException {
RandomAccessFile raf2 = new RandomAccessFile("abc.txt", "rw");
raf2.writeByte(100);
raf2.writeChar('A');
raf2.writeInt(21);
raf2.writeUTF("我爱高圆圆");
raf2.close();
}
}package org.lemon.Sequence;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
/**
* @author zhaojiangbo
*SequenceInputStream:合并流(读数据):表示其他输入流的逻辑串联
* 合并流在复制文件的时候,只能操作数据源,不能操作目的地
* 构造方法:public SequenceInputStream(InputStream s1,InputStream s2)
*
* 需求:将DataStreamDemo.java和ByteArrayStreamDemo.java两个java文件中的内容复制到Copy.java文件中
*/
public class SequenceInputStreamDemo {
public static void main(String[] args) throws IOException {
// 分别封装这个两个java文件
InputStream s1 = new FileInputStream("DataStreamDemo.java");
InputStream s2 = new FileInputStream("ByteArrayStreamDemo.java");
// 创建合并流对象
SequenceInputStream sis = new SequenceInputStream(s1, s2);
// 封装目的地
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("Copy.java"));
// 读数据
byte[] bys = new byte[1024];
int len = 0;
while ((len = sis.read(bys)) != -1) {
// 写数据
bos.write(bys, 0, len);
bos.flush();
}
// 释放资源
sis.close();
bos.close();
}
}package org.lemon.Sequence;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;
/**
* @author zhaojiangbo
*复制多个文件
* public SequenceInputStream(Enumeration<? extends InputStream> e)
* Vector集合中的特有功能:public Enumeration<E> elements()
* 需求:将DataStreamDemo.java,ByteArrayStreamDemo.java,以及CopyFileDemo.java将这三个文件中的内容
* 复制到当前项目下:Copy.java文件中
*/
public class SequenceInputStreamDemo2 {
public static void main(String[] args) throws IOException {
//封装文件
InputStream s1 = new FileInputStream("DataStreamDemo.java");
InputStream s2 = new FileInputStream("ByteArrayStreamDemo.java");
InputStream s3 = new FileInputStream("CopyFileDemo.java");
//创建Vector集合且使用泛型
Vector<InputStream> vector = new Vector<InputStream>();
//添加
vector.add(s1);
vector.add(s2);
vector.add(s3);
//调用特有功能:public Enumeration<E> elements()
Enumeration<InputStream> en = vector.elements() ;
SequenceInputStream sis = new SequenceInputStream(en);
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("Copy.java"));
//读写
byte[] bys = new byte[1024];
int len = 0;
while((len=sis.read())!=-1) {
bos.write(bys,0,len);
}
//释放资源
sis.close();
bos.close();
}
}
package org.lemon.ObjectStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
* @author zhaojiangbo
* 序列化流:将对象像流的方式或者网络传输中的数据写数据.对象---->流数据:ObjectOutputStream
* 反序列化:将流数据或者网络传输中的流数据读取出来.流数据---->还原成对象:ObjectInputStream
*
* public final void writeObject(Object obj):将obj对象写入到当前的序列化流中
* public final Object readObject():从当前反序列化流中读取一个对象
*/
public class ObjectStreamDemo {
public static void main(String[] args) throws IOException, ClassNotFoundException {
read();
}
private static void read() throws IOException, FileNotFoundException, ClassNotFoundException {
//创建一个反序列化流对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("qwer.txt"));
//使用反序列化 读数据
Object obj = ois.readObject();
System.out.println(obj);
ois.close();
write();
}
private static void write() throws IOException, FileNotFoundException {
//创建一个序列化流对象
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("qwer.txt"));
Student s = new Student("杨桃",28);
//写数据
oos.writeObject(s);
oos.close();
}
}
package org.lemon.ObjectStream;
import java.io.Serializable;
/**
* @author zhaojiangbo
*如果启用序列化功能,那么必须实现一个接口:Serializable
*transient:不用被序列化的时候用它修饰
*序列化或者是反序列化!如果一个接口中没有字段,没有构造方法,没有成员方法,叫做标记接口
*/
public class Student implements Serializable {
/**
*
*/
private static final long serialVersionUID = 1L;
private String name;
public transient int age;
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = 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;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}package org.lemon.Properties;
import java.util.Properties;
import java.util.Set;
/**
* @author zhaojiangbo
*Properties:属性集合类,该类继承自Hashtable<K,V>,该类属于Map集合
* 属性列表中每个键及其对应值都是一个字符串
*/
public class PropertiesDemo {
public static void main(String[] args) {
// 创建Properties
Properties p = new Properties();
// 添加
p.put("高圆圆", 38);
p.put("杨桃", 27);
p.put("黄海波", 40);
p.put("果然", 28);
// 遍历
Set<Object> keySet = p.keySet();
for (Object key : keySet) {
Object value = p.get(key);
System.out.println(key + "---" + value);
}
}
}package org.lemon.Properties;
import java.util.Properties;
import java.util.Set;
/**
* @author zhaojiangbo
* public Object setProperty(String key,String value) 给属性列表中添加元素
* public Set<String> stringPropertyNames():获取当前属性列表中所有的键的集合,键值都是String类型
* public String getProperty(String key)用指定的键在此属性列表中搜索属性值
*/
public class PropertiesDemo2 {
public static void main(String[] args) {
Properties p = new Properties();
p.setProperty("我", "20"); // 都是String类型
p.setProperty("依", "18");
p.setProperty("然", "21");
p.setProperty("爱", "22");
p.setProperty("你", "19");
Set<String> keySet = p.stringPropertyNames();
for (String key : keySet) {
String value = p.getProperty(key);
System.out.println(key + "---" + value);
}
}
}package org.lemon.Properties;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
/**
* @author zhaojiangbo
* 将文件中的数据加载到属性集合中:public void load(Reader reader)
* 将属性集合中的数据保存到文件中:public void store(Writer writer,String comments)
* 第二个参数:comments:对当前属性列表 的描述
*/
public class PropertiesDemo3 {
public static void main(String[] args) throws IOException {
myload();
mystore();
}
private static void myload() throws FileNotFoundException, IOException {
Properties p = new Properties();
FileReader fr = new FileReader("name.txt");
p.load(fr);
fr.close();
System.out.println(p);
}
private static void mystore() throws IOException {
Properties prop = new Properties();
prop.setProperty("我", "34") ;
prop.setProperty("爱", "29") ;
prop.setProperty("高圆圆", "28") ;
//将属性列表中的数据保存到文件中 public void store(Writer writer,String comments)
FileWriter fw = new FileWriter("name.txt") ;
prop.store(fw, "names content") ;
fw.close() ;
}
}package org.lemon.Properties;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
import java.util.Properties;
import java.util.Set;
/**
* @author zhaojiangbo
*需求：文本文件(user.txt)，知道数据是键值对形式的，不知道内容是
请写一个程序判断是否有"abc"这样的键存在，如果有就改变其值为”100”
*/
public class PropertiesDemo4 {
public static void main(String[] args) throws IOException {
//创建属性集合类对象
Properties prop = new Properties();
//创建字符输入流对象
Reader r = new FileReader("user.txt");
//加载到属性集合中
prop.load(r);
// 关闭流资源
r.close();
// 遍历属性列表
Set<String> keySet = prop.stringPropertyNames();
for (String key : keySet) {
if ("abc".equals(key)){
prop.setProperty(key, "100");// 修改
}
}
// 创建字符输出流对象
Writer w = new FileWriter("user.txt");
// 调用功能
prop.store(w, "content");
// 释放资源
w.close();
}
}
最后
以上就是魁梧大船为你收集整理的Java-11.26的全部内容，希望文章能够帮你解决Java-11.26所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
发表评论 取消回复