Day22_IO第四天

1、合并流(序列流)-SequenceInputStream(了解)

概念

合并流也叫序列流，可以把多个字节输入流整合成一个, 从序列流中读取数据时, 将从被整合的第一个流开始读, 读完一个之后继续读第二个, 以此类推.

1、将两个输入流合并

public static void demo1() throws FileNotFoundException, IOException {
		FileInputStream fis1 = new FileInputStream("a.txt");		//创建字节输入流关联a.txt
		FileOutputStream fos = new FileOutputStream("c.txt");		//创建字节输出流关联c.txt
		
		int b1;
		while((b1 = fis1.read()) != -1) {							//不断的在a.txt上读取字节
			fos.write(b1);											//将读到的字节写到c.txt上
		}
		fis1.close();												//关闭字节输入流
		
		FileInputStream fis2 = new FileInputStream("b.txt");
		int b2;
		while((b2 = fis2.read()) != -1) {
			fos.write(b2);
		}
		
		fis2.close();
		fos.close();
	}

2、将多个输入流合并


	public static void main(String[] args) throws IOException {
		//demo1();
		//demo2();
		FileInputStream fis1 = new FileInputStream("a.txt");
		FileInputStream fis2 = new FileInputStream("b.txt");
		FileInputStream fis3 = new FileInputStream("c.txt");
		
		Vector<FileInputStream> v = new Vector<>();					//创建集合对象
		v.add(fis1);												//将流对象存储进来
		v.add(fis2);
		v.add(fis3);
		
		Enumeration<FileInputStream> en = v.elements();
		SequenceInputStream sis = new SequenceInputStream(en);		//将枚举中的输入流整合成一个
		FileOutputStream fos = new FileOutputStream("d.txt");
		
		int b;
		while((b = sis.read()) != -1) {
			fos.write(b);
		}
		
		sis.close();
		fos.close();
	}

2、字节数组流(内存输出流)-ByteArrayOutputStream(掌握)

概念

该输出流可以向内存中写数据, 把内存当作一个缓冲区, 写出之后可以一次性获取出所有数据

.使用方式

创建对象: new ByteArrayOutputStream()

写出数据: write(int), write(byte[])

获取数据: toByteArray()

案例：定义一个文件输入流,调用read(byte[] b)方法,将a.txt文件中的内容打印出来(byte数组大小限制为5)

3、随机流-RandomAccessFile(了解)

概述

RandomAccessFile概述

RandomAccessFile类不属于流，是Object类的子类。但它融合了InputStream和OutputStream的功能。

支持对文件指定位置的读取和写入。换句话说写入和读取之前必须先指定位置

方法

read(),write()配合seek(位置)

1、先调用seek(10)在调用write,在10这个位置写入

2、先调用seek(10)再调用read,读取10这个位置的数据

4、序列化流(对象操作流)-ObjectInputStream\ObjectOutputStream(掌握)

序列化概念

把内存中的数据写入到硬盘

反序列化概念

把硬盘中的数据读取到内存中

注意事项

被序列化的类要实现Serializable接口

解决黄色警告线问题

给类增加serialVersionUID属性

方法

ObjectOutputStream的writeObject() 方法：将对象写入到文件

ObjectInputStream的readObject()方法：将文件中的对象读取出来

演示：

*　将对象存储在集合中写出

	Person p1 = new Person("张三", 23);
	Person p2 = new Person("李四", 24);
	Person p3 = new Person("马哥", 18);
	Person p4 = new Person("辉哥", 20);
	
	ArrayList<Person> list = new ArrayList<>();
	list.add(p1);
	list.add(p2);
	list.add(p3);
	list.add(p4);
	
	ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("f.txt"));
	oos.writeObject(list);									//写出集合对象
	
	oos.close();
















* 读取到的是一个集合对象

	ObjectInputStream ois = new ObjectInputStream(new FileInputStream("f.txt"));
	ArrayList<Person> list = (ArrayList<Person>)ois.readObject();	//泛型在运行期会被擦除,索引运行期相当于没有泛型
	//想去掉黄色可以加注解			
	@SuppressWarnings("unchecked")
	for (Person person : list) {
		System.out.println(person);
	}
	
	ois.close();

5、数据输入输出流DataInputStream\ DataOutputStream(了解)

1.什么是数据输入输出流

* DataInputStream, DataOutputStream可以按照基本数据类型大小读写数据

* 例如按Long大小写出一个数字, 写出时该数据占8字节. 读取的时候也可以按照Long类型读取, 一次读取8个字节.

2.使用方式

* DataOutputStream(OutputStream), writeInt(), writeLong()

DataOutputStream dos = new DataOutputStream(new FileOutputStream("b.txt"));

dos.writeInt(997);

dos.writeInt(998);

dos.writeInt(999);

dos.close();

* DataInputStream(InputStream), readInt(), readLong()

DataInputStream dis = new DataInputStream(new FileInputStream("b.txt"));

int x = dis.readInt();

int y = dis.readInt();

int z = dis.readInt();

System.out.println(x);

System.out.println(y);

System.out.println(z);

dis.close();

6、打印流(掌握PrintWriter)

概念

该流可以很方便的将对象的toString()结果输出, 并且自动加上换行, 而且可以使用自动刷出的模式

特点(掌握)

A、可以写入任意类型数据

B、可以自动刷新。必须先启动，并且是使用println.方法才有效,而我们的print方法仅仅是可以写入任意类型的数据

C、可以直接对文件进行写入

D、底层调用的是转换流

注意事项(掌握)

打印流只能输出数据，不能读取数据换句话说就是只能操作数据目的能操作数据源

PrintWriter 和 PrintStream的区别

1、PrintWriter构造方法可以传入字符流或者字节流，而PrintStream只能传入字节流

2、PrintWriter想要实现自动刷新构造方法必须手动指定，而PrintStream则不需要手动指定

使用

我们使用打印流就是为了使用自动刷新功能，所以以下只针对如何实现自动刷新进行案例演示

A、PrintWriter的使用方式(掌握)

1、通过构造方法创建对象并且启用自动刷新功能

PrintWriter(OutputStrem out, boolean autoFlush);

PrintWriter(Writer out, boolean autoFlush);

2、调用println\printf\format方法，只有调用这三个个方法才会自动调用flush方法
PrintWriter printWriter = newPrintWriter(new FileWriter("d.txt"),true);
printWriter.printf("1");//仅仅写入数据并且刷新
printWriter.println("2");//写入数据并且增加换行符，刷新
printWriter.format("你好 %s", "张三");
B、PrintStream的使用方式

1、通过构造方法创建对象并且启用自动刷新功能

PrintStream(OutputStrem out, boolean autoFlush);

2、调用println\printf\format方法

PrintStream ps = newPrintStream(new FileOutputStream("a.txt"),true);//,true可有可无
ps.printf("你好");

7、Properties(掌握)

1、概述

Properties是一个键值对的集合类,不是IO类，键和值都是字符串。可以从流中加载数据或者把数据保存到流中，是唯一一个可以和IO流集合使用的集合类

添加修改

public Object put(Object key, Object value)

添加修改

public Object setProperty(String key,String value)

调用的就是 put方法

获取功能

public String get(String key)

获取

Public String getProperty(String key)

底层调用的是 get

Public String getProperty(String, String defaultValue)

底层调用 get,如果找不到，返回 defaultValue

public Set<String> stringPropertyNames()

获取键集合

转换功能

public void list(PrintWriter out)
将当前的集合里面的键值保存到指定的文本中

public void list(PrintStream out)

public void load(InputStream inputStream)

从输入流中读取属性和列表

public void load(Reader reader)

public void store(OutputStream out, String comment)

把集合中的数据保存到文本中

public void store(Writer writer, String comments)

public Set keySet()

获取所有键的集合

注意：Properties类在以后Android中会有新的Properties替代，在EE中我们会重新封装一个Properties工具类,因为Properties的缺点很明显，不能直接操作File对象

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.util.Map.Entry;

import java.util.Properties;

import java.util.Set;

public class PropertiesDemo {

    /**

     * 通过Properties修改config.inf中的PhoneIndex,值修改成123

     * @param args

     */

    public static void main(String[] args) throws Exception {

        /*

         * 1、加载config.inf

         * 2、在内存修改config.inf中的phoneIndex

         * 3、将修改后的集合重新写入到配置文件

         */

        Properties p  = new Properties();

        p.load(new FileInputStream("config.inf"));





        p.put("PhoneIndex","123");

        p.store(new FileOutputStream("config.inf"), "PhoneIndex被修改过！！！");



    }

}

8、System类(掌握)

1、系统类，提供了静态的变量和方法供我们使用

2、成员方法

public static void exit(int value)

退出jvm，非0表示异常退出

public static long currentTimeMillis()

返回当前系统时间的毫秒值

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

从指定源数的指定位置开始复制，赋值到目标数组的指定位置

public static Properties getProperties();

获取当前系统的属性

public static String getProperty(String key)

获取指定键描述的系统属性

public static String getProperty(String key, String defaultValue)

获取指定键描述的系统属性，没有找到该键的话返回defaultValue

遍历Properties

/**

        * 遍历系统描述Properties

        */

        public static voidmain(String[] args) throws Exception{

              Properties properties = System.getProperties();

              Set<Object> keySet = properties.keySet();

              for(Object key:keySet){

                     System.out.println(key +"*****"+properties.get(key));

              }

       }

获取当前系统中的换行符

/**

        * 获取当前系统中的换行符

        */

        public static voidmain(String[] args) throws Exception{

               String line = System.getProperty("line.separator");

               System.out.println(line+"你好");

       }

9、IO体系(掌握)

10、案例(掌握)

1、定义一个文件输入流,调用read(byte[] b)方法,将a.txt文件中的内容打印出来(byte数组大小限制为5)

2、两种方式实现键盘录入

3、改变标准输入输出流拷贝图片

4、我有一个学生类，这个类包含以下成员变量：姓名，语文成绩，数学成绩，英语成绩。

请从键盘录入5个学生信息，然后按照自己定义的格式存储到文本文件中。

要求被存储的学生按照分数从高到低排序

5、定义一个文件输入流,调用read(byte[] b)方法,将a.txt文件中的内容打印出来(两种方式，不用字节数组流做)

11、案例代码(掌握)

1、定义一个文件输入流,调用read(byte[] b)方法,将a.txt文件中的内容打印出来(byte数组大小限制为5)

package com.heima.test;

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Test1 {

	/**
	 * @param args
	 * 定义一个文件输入流,调用read(byte[] b)方法,将a.txt文件中的内容打印出来(byte数组大小限制为5)
	 * 
	 * 分析:
	 * 1,reda(byte[] b)是字节输入流的方法,创建FileInputStream,关联a.txt
	 * 2,创建内存输出流,将读到的数据写到内存输出流中
	 * 3,创建字节数组,长度为5
	 * 4,将内存输出流的数据全部转换为字符串打印
	 * 5,关闭输入流
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		//1,reda(byte[] b)是字节输入流的方法,创建FileInputStream,关联a.txt
		FileInputStream fis = new FileInputStream("a.txt");
		//2,创建内存输出流,将读到的数据写到内存输出流中
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		//3,创建字节数组,长度为5
		byte[] arr = new byte[5];
		int len;
		
		while((len = fis.read(arr)) != -1) {
			baos.write(arr, 0, len);
			//System.out.println(new String(arr,0,len));
		}
		//4,将内存输出流的数据全部转换为字符串打印
		System.out.println(baos); 					//即使没有调用,底层也会默认帮我们调用toString()方法
		//5,关闭输入流
		fis.close();
	}
}

2、两种方式实现键盘录入

package com.heima.otherio;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;

public class Demo07_SystemIn {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		//方式1
		/*BufferedReader br = new BufferedReader(new InputStreamReader(System.in));		//InputStreamReader转换流
		String line = br.readLine();
		System.out.println(line);
		br.close();*/
		

		//方式2
		Scanner sc = new Scanner(System.in);
		String line = sc.nextLine();
		System.out.println(line);
		sc.close();
	}

}

3、改变标准输入输出流拷贝图片

package com.heima.test;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;

public class Test2 {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		System.setIn(new FileInputStream("双元.jpg"));			//改变标准输入流
		System.setOut(new PrintStream("copy.jpg")); 			//改变标准输出流
		
		InputStream is = System.in;
		PrintStream ps = System.out;
		
		byte[] arr = new byte[1024];
		int len;
		
		while((len = is.read(arr)) != -1) {
			ps.write(arr, 0, len);
		}
		
		is.close();
		ps.close();
	}

}

4、我有一个学生类，这个类包含以下成员变量：姓名，语文成绩，数学成绩，英语成绩。

请从键盘录入5个学生信息，然后按照自己定义的格式存储到文本文件中。

要求被存储的学生按照分数从高到低排序

package cn.itcast;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;

/*
 * 我有一个学生类，这个类包含一下成员变量：姓名，语文成绩，数学成绩，英语成绩。
 * 请从键盘录入5个学生信息，然后按照自己定义的格式存储到文本文件中。
 * 要求被存储的学生按照分数从高到低排序。
 * 
 * 分析：
 * 		A:写一个学生类，有4个成员变量。
 * 		B:用Scanner实现键盘录入。
 * 		C:把这多个学生进行存储。用集合。
 * 			那么，用哪个集合呢?
 * 			由于最终需要排序，所以，我们选择TreeSet集合。
 * 		D:遍历集合，获取到集合中的每一个数据，用输出流写到文本文件。
 * 			name	chinese		math	english
 */
public class StudentTest {
	public static void main(String[] args) throws IOException {
		// 写一个学生类，有4个成员变量。
		System.out.println("学生信息录入开始");
		// 定义TreeSet集合
		TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
			@Override
			public int compare(Student s1, Student s2) {
				// 主要条件
				int num = s2.getSum() - s1.getSum();
				// 分析次要条件
				// 当总分相同，还得继续比较每一门的分数是否相同
				int num2 = (num == 0) ? s1.getChinese() - s2.getChinese() : num;
				int num3 = (num2 == 0) ? s1.getMath() - s2.getMath() : num2;
				// 当语文，数学，英语成绩都相同的，我们还得继续判断姓名是否相同。
				int num4 = (num3 == 0) ? s1.getName().compareTo(s2.getName())
						: num3;
				return num4;
			}
		});

		for (int x = 0; x < 5; x++) {
			// 用Scanner实现键盘录入。
			Scanner sc = new Scanner(System.in);
			// 键盘录入数据
			System.out.println("请输入第" + (x + 1) + "个学生的姓名:");
			String name = sc.nextLine();
			System.out.println("请输入第" + (x + 1) + "个学生的语文成绩:");
			int chinese = sc.nextInt();
			System.out.println("请输入第" + (x + 1) + "个学生的数学成绩:");
			int math = sc.nextInt();
			System.out.println("请输入第" + (x + 1) + "个学生的英语成绩:");
			int english = sc.nextInt();

			// 把数据封装到学生对象中
			Student s = new Student();
			s.setName(name);
			s.setChinese(chinese);
			s.setMath(math);
			s.setEnglish(english);

			ts.add(s);
		}

		// 遍历集合，获取到集合中的每一个数据，用输出流写到文本文件。
		BufferedWriter bw = new BufferedWriter(new FileWriter("students.txt"));
		bw.write("姓名\t语文\t数学\t英语");
		bw.newLine();
		bw.flush();

		for (Student s : ts) {
			StringBuilder sb = new StringBuilder();
			sb.append(s.getName()).append("\t").append(s.getChinese())
					.append("\t").append(s.getMath()).append("\t")
					.append(s.getEnglish());
			bw.write(sb.toString());
			bw.newLine();
			bw.flush();
		}

		bw.close();
		System.out.println("学生信息录入成功");
	}
}

package cn.itcast;

public class Student {
	private String name;
	private int chinese;
	private int math;
	private int english;

	public Student() {
	}

	public Student(String name, int chinese, int math, int english) {
		super();
		this.name = name;
		this.chinese = chinese;
		this.math = math;
		this.english = english;
	}

	public String getName() {
		return name;
	}

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

	public int getChinese() {
		return chinese;
	}

	public void setChinese(int chinese) {
		this.chinese = chinese;
	}

	public int getMath() {
		return math;
	}

	public void setMath(int math) {
		this.math = math;
	}

	public int getEnglish() {
		return english;
	}

	public void setEnglish(int english) {
		this.english = english;
	}

	public int getSum() {
		return this.chinese + this.math + this.english;
	}
}

5、定义一个文件输入流,调用read(byte[] b)方法,将a.txt文件中的内容打印出来(两种方式，不用字节数组流做)

		FileInputStream fileInputStream = new FileInputStream("LineNumberReader.java");
		
		byte[] data = new byte[fileInputStream.available()];
		
		int len = fileInputStream.read(data);
		System.out.println(new String(data,0,len));

12、关于Serializable的Serial Version ID的讨论(了解)

我们编写一个实现了Serializable接口（序列化标志接口）的类，Eclipse马上就会给一个黄色警告：需要增加一个Serial Version ID。为什么要增加？它是怎么计算出来的？有什么用？

1、为什么要增加?

类实现Serializable接口的目的是为了将内存中的对象保存到本地磁盘或者通过网络传输（也就是可持久化）

package io;

/**
 * 腾讯新闻手机客户端
 * @author haoyongliang
 *
 */
public class Consumer {
	public static void main(String[] args) {
		Person person = (Person)SerializationUtils.readObject();
		System.out.println(person.getName());
	}
}

package io;

/**
 * 腾讯新闻服务器
 * @author haoyongliang
 *
 */
public class Producer {
	public static void main(String[] args) {
		Person person = new Person();
		person.setName("混世魔王");
		SerializationUtils.writeObject(person);
	}
}

package io;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * 序列化工具类
 * @author haoyongliang
 *
 */
public class SerializationUtils {
	/** 序列化后的对象存储路径 */
	private static final String FILE_NAME = "C://obj.bin";

	public static void writeObject(Serializable s) {
		try (
				ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(FILE_NAME));
		){
			oos.writeObject(s);//将对象写入到C://obj.bin
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	public static Object readObject(){
		Object obj = null;
		try(
				ObjectInputStream ois = new ObjectInputStream(new FileInputStream(FILE_NAME))
		){
			obj = ois.readObject();
		}catch(Exception e){
			e.printStackTrace();
		}
		
		return obj;
	}
}

13、今天必须掌握的内容，面试题，笔试题。(掌握这个就可以放心学习后面的知识了)

1、说说合并流是干什么的

2、说说字节数组流是干什么的，底层是什么

3、说说随即流可以干什么

4、说说序列化流，并且通过序列化流将学生对象写入文件，并且将文件中的数据读取成学生对象

5、打印流有哪些，打印流可以读取数据吗？打印流的特点是什么，要想启用刷新功能，必须调用哪个方法

6、代码题：定义一个文件输入流,调用read(byte[] b)方法,将a.txt文件中的内容打印出来(byte数组大小限制为5)

7、代码题：两种方式实现键盘录入

8、代码题：我有一个学生类，这个类包含以下成员变量：姓名，语文成绩，数学成绩，英语成绩。

请从键盘录入5个学生信息，然后按照自己定义的格式存储到文本文件中。

要求被存储的学生按照分数从高到低排序

9、Properties的load store方法掌握

来自为知笔记(Wiz)

Day22_IO第四天的更多相关文章

构建一个基本的前端自动化开发环境 —— 基于 Gulp 的前端集成解决方案（四）
通过前面几节的准备工作,对于 npm / node / gulp 应该已经有了基本的认识,本节主要介绍如何构建一个基本的前端自动化开发环境. 下面将逐步构建一个可以自动编译 sass 文件.压缩 ja ...
《Django By Example》第四章中文翻译（个人学习，渣翻）
书籍出处:https://www.packtpub.com/web-development/django-example 原作者:Antonio Melé (译者注:祝大家新年快乐,这次带来<D ...
如何一步一步用DDD设计一个电商网站（四）—— 把商品卖给用户
阅读目录前言怎么卖领域服务的使用回到现实结语一.前言上篇中我们讲述了“把商品卖给用户”中的商品和用户的初步设计.现在把剩余的“卖”这个动作给做了.这里提醒一下,正常情况下,我们的每一步业 ...
从0开始搭建SQL Server AlwaysOn 第四篇（配置异地机房节点）
从0开始搭建SQL Server AlwaysOn 第四篇(配置异地机房节点) 第一篇http://www.cnblogs.com/lyhabc/p/4678330.html第二篇http://www ...
MVVM设计模式和WPF中的实现（四）事件绑定
MVVM设计模式和在WPF中的实现(四) 事件绑定系列目录: MVVM模式解析和在WPF中的实现(一)MVVM模式简介 MVVM模式解析和在WPF中的实现(二)数据绑定 MVVM模式解析和在WPF中 ...
“四核”驱动的“三维”导航 -- 淘宝新UI（需求分析篇）
前言孔子说:"软件是对客观世界的抽象". 首先声明,这里的"三维导航"和地图没一毛钱关系,"四核驱动"和硬件也没关系,而是为了复杂的应用而 ...
【翻译】MongoDB指南/CRUD操作（四）
[原文地址]https://docs.mongodb.com/manual/ CRUD操作(四) 1 查询方案(Query Plans) MongoDB 查询优化程序处理查询并且针对给定可利用的索引选 ...
HTML 事件(四) 模拟事件操作
本篇主要介绍HTML DOM中事件的模拟操作. 其他事件文章 1. HTML 事件(一) 事件的介绍 2. HTML 事件(二) 事件的注册与注销 3. HTML 事件(三) 事件流与事件委托 4. ...
【原】AFNetworking源码阅读（四）
[原]AFNetworking源码阅读(四) 本文转载请注明出处 —— polobymulberry-博客园 1. 前言上一篇还遗留了很多问题,包括AFURLSessionManagerTaskDe ...

随机推荐

Labview调用Python脚本
Labview程序框图如下: Python脚本如下: #!/usr/bin/env pythonimport sys #Command Line Arguements are stored in li ...
160个crackme-之Acid burn.exe
工具: Ollydbg(OD) 中文版运行: 我们拿到一个小程序时,总要看看它到底有什么功能,或者说它阻碍了我们什么,也就是寻找突破口! 这就是程序运行后的主界面我们进入Serial/Name后, ...
《JavaScript高级程序设计》读书笔记--（3）引用类型
ECMAScript从技术来说是一门面向对象的语言,但不具备传统的面向对象语言所支持的类和接口等基本结构.虽然引用类型与类看起来类似,但是他们并不是相同的概念.引用类型有时也被成为对象定义,因为它描述 ...
oc--UINavigationController控制器
UINavigationController导航控制器 UINavigationController导航控制器,是多个界面间跳转的重要元素,可以理解为它存储着多个viewController,它的存储 ...
快速加载DXF、DWG格式文件控件ABViewer
ABViewer是一种高品质,低成本,高效率的多功能设计及工程文档管理应用程序. ABViewer为您提供专业的cad文件浏览和编辑工具. 支持多种格式,如:DWG格式, DXF, DWF, Hewl ...
支付宝集成后报错ALI38173
原因: 支付时传的参数不正确. 出现这个错误, 说明支付功能已经集成成功, 前后台核对下参数就能找到原因了.
linux安装jdk(以centos安装jdk1.7为例)
1准备工作: 1 虚拟机一台vmware12,安装64位centos 2 oracle官网下载jdk1.7-linux-x64.rpm 3 winscp将jdk传送到linux上面 2开始安装: 1 ...
java多线程总结
java中的多线程一般来说,当运行一个应用程序的时候,就启动了一个进程,当然有些会启动多个进程.启动进程的时候,操作系统会为进程分配资源,其中最主要的资源是内存空间,因为程序是在内存中运行的.在进程 ...
mysql入门1
进入mysql数据库:进入mysql安装时的目录bin文件夹内
php 实现冒泡算法排序、快速排序、选择排序，插入排序
许多人都说算法是程序的核心,一个程序的好于差,关键是这个程序算法的优劣.作为一个初级phper,虽然很少接触到算法方面的东西 .但是对于冒泡排序,插入排序,选择排序,快速排序四种基本算法,我想还是要 ...

添加修改
public Object put(Object key, Object value)	添加修改
public Object setProperty(String key,String value)	调用的就是 put方法
获取功能
public String get(String key)	获取
Public String getProperty(String key)	底层调用的是 get
Public String getProperty(String, String defaultValue)	底层调用 get,如果找不到，返回 defaultValue
public Set<String> stringPropertyNames()	获取键集合
转换功能
public void list(PrintWriter out)	将当前的集合里面的键值保存到指定的文本中
public void list(PrintStream out)	将当前的集合里面的键值保存到指定的文本中
public void load(InputStream inputStream)	从输入流中读取属性和列表
public void load(Reader reader)	从输入流中读取属性和列表
public void store(OutputStream out, String comment)	把集合中的数据保存到文本中
public void store(Writer writer, String comments)	把集合中的数据保存到文本中
public Set keySet()	获取所有键的集合

public static void exit(int value)	退出jvm，非0表示异常退出
public static long currentTimeMillis()	返回当前系统时间的毫秒值
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)	从指定源数的指定位置开始复制，赋值到目标数组的指定位置
public static Properties getProperties();	获取当前系统的属性
public static String getProperty(String key)	获取指定键描述的系统属性
public static String getProperty(String key, String defaultValue)	获取指定键描述的系统属性，没有找到该键的话返回defaultValue

Day22_IO第四天

Day22_IO第四天的更多相关文章

随机推荐

热门专题