黑马程序员_Java基础_IO(1)

最新推荐文章于 2022-01-06 17:26:46 发布

sensitivefish

最新推荐文章于 2022-01-06 17:26:46 发布

阅读量413

点赞数

分类专栏：黑马程序员文章标签： java 黑马程序员

本文链接：https://blog.csdn.net/sensitivefish/article/details/38098213

版权

黑马程序员专栏收录该内容

20 篇文章 0 订阅

订阅专栏

---------------------- Android、Java开发期待与您交流！ ----------------------

IO流相关的辅助方法和类

在Java API中，可以从其中读入字节或字符序列的对象称为输入流，可以向其中写入字节或字符序列的对象称作输出流。这些字节序列的来源地和目的地可以是文件，而且通常都是文件，但也可以是网络连接，甚至是内存块。

1.java.lang.System

在 System 类提供的设施中，有标准输入、标准输出和错误输出流；对外部定义的属性和环境变量的访问；加载文件和库的方法；还有快速复制数组的一部分的实用方法。

并且所有的方法为静态方法。

static long currentTimeMillis()：返回以毫秒为单位的当前系统时间内的long值

static Proproperties getProperties()：确定当前的系统属性，返回值是一个Map集合，系统的各项属性以String类型的键值对存在

static String getProperty(String name)：返回确定属性名所对应的值

static void setProperty(String key,String value)：设置指定键的属性和值

2.java.lang.Runtime

每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。可以通过 getRuntime 方法获取当前运行时。应用程序不能创建自己的 Runtime 类实例。

static Runtime getRuntime()：返回与当前 Java 应用程序相关的运行时对象。

Process exec(String command)：在单独的进程中执行指定的字符串命令。

void exit(int status)：通过启动虚拟机的关闭序列，终止当前正在运行的 Java 虚拟机。System.exit()方法是调用此方法的一种传统而便捷的途径

void gc()：运行垃圾回收器。System.gc()方法是调用此方法的一种传统而便捷的途径

3.java.lang.Properties

Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。

Properties()：创建一个无默认值的空属性列表。

Properties(Properties defaults)：创建一个带有指定默认值的空属性列表。

String getProperty(String key)：用指定的键在此属性列表中搜索属性。

Object setProperty(String key，String value)：调用 Hashtable 的方法put。

void list(PrintStream out)：将属性列表输出到指定的字节输出流。

void list(PrintWriter out)：将属性列表输出到指定的字符输出流。

void load(InputStream ips)：从字节输入流中读取属性列表（键和元素对）。

void load(Reader reader)：按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。

void store(OutputStream ops,String comments)：以适合使用load(InputStream)方法加载到Properties 表中的格式，将此Properties 表中的属性列表（键和元素对）写入输出流

void store(Writer writer,String comments)：以适合使用 load(Reader)方法的格式，将此Properties 表中的属性列表（键和元素对）写入输出字符。

4.java.io.RandomAccessFile

此类的实例支持对随机访问文件的读取和写入，一个类搞定之前两个类需要解决的问题

5.java.io.Serializable接口

类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义。

注意：

                静态参数不能被序列化
                transient:被修饰的非静态成员不能被序列化
                被序列化后生成的文件通常定为object格式

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.io.RandomAccessFile;
import java.io.Serializable;
import java.text.SimpleDateFormat;

import java.util.Date;
import java.util.Properties;
import java.util.Set;
import java.util.TreeSet;

public class IORelative {
	public static void main(String[] args) throws Exception {
		systemDemo();
		// runtimeDemo();
		// propertiesDemo();

		/*
		 * String src = "c:\\windows\\system.ini"; String dest =
		 * "c:\\system.java"; RandomAccessFile rafr = new RandomAccessFile(src,
		 * "r"); RandomAccessFile rafw = new RandomAccessFile(dest, "rw");
		 * RAFTest(rafr, rafw);
		 */

		String serializablePath = "c:\\obj.obj";
		FileOutputStream fos = new FileOutputStream(serializablePath);
		Person person = new Person("wxd", 28, 'h', "en");
		writeObj(person, fos);
		FileInputStream fis = new FileInputStream(serializablePath);
		readObj(fis);
	}

	public static void systemDemo() throws Exception {
		// 标准输出流System.out
		System.out.println("标准输出流！");
		// 标准输入流System.in
		// 返回以毫秒为单位的当前时间
		long time = System.currentTimeMillis();
		System.out.println("myStyleTiem:" + myStyleTime(time));
		// 将系统属性设置为Properties的Map集合
		Properties prop = System.getProperties();
		// 设置"时间"属性的值为"20140620"
		prop.setProperty("shijian", "20140620");
		System.out.println("shijian=" + prop.getProperty("shijian"));
		// 将porp属性列表输出到指定的输出流
		prop.list(System.out);
	}

	/**
	 * 每个java应用程序都有一个Runtime类实例，使应用程序能够与其运行的环境相连接
	 */
	public static void runtimeDemo() throws Exception {
		Runtime runtime = Runtime.getRuntime();
		//
		String command = "C:\\WINDOWS\\system32\\calc.exe";
		// String command ="cmd.exe";
		// String command = "D:\\Program Files\\Tencent\\QQ\\Bin\\qq.exe";
		// 在单独的进程中执行指定的字符串命令
		try {
			runtime.exec(command);
		} catch (Exception e) {
			throw new IllegalArgumentException("命令参数为空！");

		}

		// 返回java虚拟机中的内存总量
		long totalMemory = runtime.totalMemory();
		// 返回java虚拟机试图使用的最大内存量
		long maxMemory = runtime.maxMemory();
		// 返回java虚拟机的空闲内存量
		long freeMemory = runtime.freeMemory();
		System.out.println("totalMemory:" + totalMemory);
		System.out.println("maxMemory:" + maxMemory);
		System.out.println("freeMemory:" + freeMemory);
		// 运行垃圾回收器System.gc()是调用此方法的一种传统而便捷的方式
		runtime.gc();
		// System.exit()是调用runtime.exit()的一种传统而便捷的方
		// 通过启动虚拟机的关闭序列，终止当前正在运行的 Java 虚拟机
		// runtime.exit();
	}

	public static void propertiesDemo() throws IOException {
		Properties prop = System.getProperties();
		PrintStream ps = null;
		ps = new PrintStream("c:\\sys.properties");
		prop.list(ps);
		Set<String> set = new TreeSet<String>();
		set = prop.stringPropertyNames();
		System.out.println(set.toString());
		System.out.println("java.runtime.name = "
				+ prop.getProperty("java.runtime.name"));
		prop.setProperty("java.runtime.name", "JRE");
		System.out.println("java.runtime.name = "
				+ prop.getProperty("java.runtime.name"));
		System.out.println("prop.size():" + prop.size());
	}

	public static String myStyleTime(long time) {
		Date date = new Date(time);
		String dateTime = null;
		// dateTime = DateFormat.getDateInstance().format(date);
		String timeStyle = "yyyy-MM-dd HH:mm:ss";
		// 用给定的时间模式构造SimpleDateFormat
		SimpleDateFormat sdf = new SimpleDateFormat(timeStyle);
		dateTime = sdf.format(date);

		return dateTime;
	}

	public static void RAFTest(RandomAccessFile rafr, RandomAccessFile rafw)
			throws IOException {
		byte[] buf = new byte[1024];
		int len = 0;
		try {
			while ((len = rafr.read(buf)) != -1) {
				rafr.read(buf, 0, len);
				rafw.write(buf, 0, len);
			}
		} catch (Exception e) {
			throw e;
		}
	}

	public static void RAFRead(RandomAccessFile rafr) throws IOException {
		byte[] buf = new byte[1024];
		int len = 0;
		try {
			while ((len = rafr.read(buf)) != -1) {
				rafr.read(buf, 0, len);
			}
		} catch (Exception e) {
			throw e;
		}
	}

	/**
	 * RandomAccessFile 随机读写文件
	 * 
	 * @param obj
	 * @param os
	 * @throws Exception
	 */
	public static void writeObj(Object obj, OutputStream os) throws Exception {
		ObjectOutputStream oos = new ObjectOutputStream(os);
		oos.writeObject(obj);
		oos.close();
	}

	public static void readObj(InputStream is) throws Exception {
		ObjectInputStream ois = new ObjectInputStream(is);
		// Person person =(Person)ois.readObject();
		Object object = ois.readObject();
		System.out.println(object);
		ois.close();

	}
}

/**
 * 对象序列化
 * 
 * @author wxd
 * 
 */
class Person implements Serializable {
	public static final long serialVersionUID = 416L;
	String name;
	transient int age;
	char sex;
	static String country = "CN";

	public void setName(String name) {
		this.name = name;
	}

	public String getName() {
		return this.name;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public int getAge() {
		return this.age;
	}

	public void setSex(char sex) {
		this.sex = sex;
	}

	public char getSex() {
		return this.sex;
	}

	public String toString() {
		return name + ":" + age + ":" + String.valueOf(sex) + ":" + country;
	}

	public Person() {
	}

	public Person(String name, int age, char sex, String country) {
		this.name = name;
		this.age = age;
		this.sex = sex;
		Person.country = country;
	}
}

---------------------- Android、Java开发期待与您交流！ ----------------------

sensitivefish

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员_Java基础_IO(1)

---------------------- Android、Java开发期待与您交流！ ----------------------IO流相关的辅助方法和类在Java API中，可以从其中读入字节或字符序列的对象称为输入流，可以向其中写入字节或字符序列的对象称作输出流。这些字节序列的来源地和目的地可以是文件，而且通常都是文件，但也可以是网络连接，甚至是内存块。
复制链接

扫一扫