2018高考第一天，第一批00后已经高考了！
哇，时间过的是真快，一晃高考已是七年之前了！
祝莘莘学子，高考加油！考得都会，蒙的都对！
一、PrintStream
PrintStream：打印字节流，只有输出流，没有输入流。
作用：提供了对8种基本数据类型，以及String，以及对象的转换为字符串（PrintStream内部实现），然后写出去的方法。
写入字符串并写入换行符的方法。
特点：
1：只有输出流，没有输入流
2：PrintStream 永远不会抛出 IOException。
3：PrintStream 提供了自动刷新的功能。
System.out 就是PrintStream 的一个静态的实例。 在系统启动的时候就初始化好了。对应着标准的输出设备，控制台。
System.in 是一个InputStream 的静态的实例。在系统启动的时候初始化好。对应着标准输入设备 键盘。
System.err 就是PrintStream 的一个静态的实例，系统启动初始化。错误打印流，输出的内容为红色。
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
public class PrintStreamTest {
public static void main(String[] args) throws Exception {
test1();
test2();
test3();
test4();
test5();
}
//八种基本数据类型和 String 和 对象的字符串 输出到指定的文件中
static void test1() throws Exception{
//自动刷新功能
PrintStream ps = new PrintStream(new BufferedOutputStream(new FileOutputStream("./res/ps.txt")), true);
ps.println(127);
ps.println(3232);
ps.println(100000000);
ps.println(10000000000000L);
ps.println(1.0);
ps.println(1.0f);
ps.println('A');
ps.println(false);
ps.println("fjdsljfowe;iuro");
ps.println(new PrintStreamTest());
ps.close();
}
//改变标准输出设备
static void test2() throws Exception{
PrintStream ps = new PrintStream(new BufferedOutputStream(new FileOutputStream("./res/ps.txt",true)), true);
PrintStream out = System.out;
//改变标准输出流，
System.setOut(ps);
System.out.println("11111111111");
System.out.println("11111111111");
System.out.println("11111111111");
System.out.println("11111111111");
System.out.println("11111111111");
System.setOut(out);
System.out.println(343);
ps.close();
}
//改变标准输入设备
static void test3() throws Exception{
FileInputStream fis = new FileInputStream("./res/my_letter.txt");
System.setIn(fis);
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.println(br.readLine());
br.close();
}
//面试题
static void test4(){
int x = 10;
//重写一个PrintStream 的println(int) 方法
PrintStream ps = new PrintStream(System.out){
@Override
public void println(int x) {
System.out.println("x = "+x);
}
};
//重新设置out
System.setOut(ps);
//x = 10; 重写println 方法
System.out.println(x);
}
//PrintStream 的应用
static void test5() throws FileNotFoundException{
try {
int a = 10;
int b = 0;
a/=b;
} catch (Exception e) {
//e.printStackTrace();
//将异常信息输出到打印流中
PrintStream ps = new PrintStream(new BufferedOutputStream(new FileOutputStream("./res/exception.log",true)),true);
Date date = new Date();
DateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
ps.println("************************************************************");
ps.println(sdf.format(date));
e.printStackTrace(ps);
ps.println("************************************************************");
ps.close();
}
}
}
二、PrintWriter
PrintWriter：是字符打印流。
和PrintStream 的区别：
1：构造方法，PrintWriter 多了2个可以用使用向字符流作为输出 的构造方法。
2：PrintWriter 没有提供原始的 write(字节) 写出字节数据的方法。
三、DataInputStream-DataOutputStream
数据输入输出字节流。
这两个流在一种特定的时候使用。
作用：这两个流提供了对8种基本数据类型和 String（UTF-8）类型的原始字节数据的读写的方法。
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class DataInputOutputStreamTest {
public static void main(String[] args) throws Exception {
writeData();
readData();
}
//使用DataOutputStream 写出8种基本数据类型和 字符串
static void writeData() throws Exception{
DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("./res/7.txt")));
dos.writeByte(1);//1
dos.writeShort(1);//2
dos.writeInt(1);//4
dos.writeLong(1L);//8
dos.writeFloat(1.0f);//4
dos.writeDouble(1.1);//8
dos.writeBoolean(true);//1
dos.writeChar('你');//2
//使用utf-8 将字符序列编码为字节
//先写入一个writeShort(short value) value 值的大小是 当前要写入的字符串 使用utf-8 编码为的字节数组的长度
dos.writeUTF("起风了");//9
dos.close();
}
//什么样的顺序写入，那么就需要什么样的顺序读出去
static void readData() throws Exception{
DataInputStream dis = new DataInputStream(new BufferedInputStream(new FileInputStream("./res/7.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.readFloat());
System.out.println(dis.readDouble());
System.out.println(dis.readBoolean());
System.out.println(dis.readChar());
//先readShort 得到接下来的使用多长的字节数组还原 字符序列。
System.out.println(dis.readUTF());//??读多少字节
dis.close();
}
}
四、Properties
java.util.Properties：这是一个容器。是Hashtable 的子类。 是一个用于保存键值对的容器。
特点：
1：没有泛型，key 和 value 必须都是 String。
2：支持中文不好。
3：可以用于操作配置的文件。
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.util.Iterator;
import java.util.Properties;
import java.util.Set;
/**
* 配置文件
*
*/
public class PropertiesTest {
public static void main(String[] args) throws Exception {
test1();
test2();
test3();
test4();
}
//使用Properties 创建一个配置文件
//配置信息 fontSize=20 bkColor=red
static void test1() throws Exception{
//创建Properties 对象
Properties prop = new Properties();
//将配置的信息 添加到 容器中
prop.setProperty("fontSize", "20");
prop.setProperty("bkColor", "red");
//生成配置文件
prop.store(new FileOutputStream("./res/prop.ini"), "我是注释");
}
//修改配置文件的信息
static void test2() throws Exception{
//将配置文件的信息加载进来
Properties prop = new Properties();
prop.load(new FileReader("./res/prop.ini"));
System.out.println(prop);
//修改
prop.setProperty("bkColor", "black");
prop.setProperty("fontSize", "12");
//保存
prop.store(new FileOutputStream("./res/prop.ini"), "I am the comments");
}
static void test3(){
//装的是所有的jvm 启动的时候，加载的本地系统的配置信息
Properties properties = System.getProperties();
Set set = properties.keySet();
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
String key = (String) iterator.next();
String value = properties.getProperty(key);
System.out.println(key+"-->"+value);
}
}
//控制软件试用的次数，在配置信息中，添加一条用于记录用户使用软件的次数 count=4，最多试用的次数是5次。
static void test4() throws Exception{
//软件运行的时候，将所有的配置信息加载，看配置信息中是否包含了试用次数的key 和 value。
Properties prop = new Properties();
FileInputStream fis = new FileInputStream("./res/prop.ini");
prop.load(fis);
fis.close();
String value = prop.getProperty("count");
if(value == null){//没有，添加一条 count=1
prop.setProperty("count", "1");
System.out.println("剩余试用次数 = " + 4);
}else{//如果已经存在，把value 取出来，+1 再写回去。
//是否达到了试用的次数
int count = Integer.parseInt(value);
if(count < 5){
int newCount = Integer.parseInt(value)+1;
System.out.println("剩余试用次数 = " + (5-newCount));
prop.setProperty("count", Integer.toString(newCount));
}else{//试用结束
System.out.println("软件试用结束，请付费使用，程序员也需要生活！");
System.exit(0);
}
}
FileOutputStream fos = new FileOutputStream("./res/prop.ini");
prop.store(fos, "");
fos.close();
}
}
五、SequenceInputStream-合并，切割
SequenceInputStream：序列流，一个功能流。用于合并数据。
例：
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;
public class SequenceInputStreamTest {
public static void main(String[] args) throws Exception {
mergeFile1();
//cutFile();
}
//将多个文本文件合并为一个文本文件
static void test1() throws Exception{
//三个文件字节输入流，合并为一个
SequenceInputStream temp = new SequenceInputStream(new FileInputStream("./res/2.txt"), new FileInputStream("./res/3.txt"));
SequenceInputStream sis = new SequenceInputStream(temp, new FileInputStream("./res/6.txt"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("./res/236.txt"));
int value = sis.read();
while(value != -1){
bos.write(value);
value = sis.read();
}
bos.close();
sis.close();
}
//切割文件
static void cutFile() throws Exception{
FileInputStream fis = new FileInputStream("c:/77.jpg");
byte[] buf = new byte[10240];
int count = fis.read(buf);
int counter = 0;
while(count != -1){
//将1M的数据生成一个单独的文件
FileOutputStream fos = new FileOutputStream("c:/77_"+counter ++ +".jpg");
fos.write(buf, 0, count);
fos.close();
count = fis.read(buf);
}
fis.close();
}
//合并
static void mergeFile() throws Exception{
//将所有的合并的文件，放到一个容器中，
Vector vector = new Vector<>();
for(int i=0;i<6;i++){
vector.add(new FileInputStream("c:/77_"+i+".jpg"));
}
//然后得到容器的枚举器。
Enumeration enumeration = vector.elements();
//然后创建 序列流对象
SequenceInputStream sis = new SequenceInputStream(enumeration);
byte[] buf = new byte[100000];
//创建用于生成合并文件的输出流
FileOutputStream fos = new FileOutputStream("c:/77_copy.jpg");
int count = sis.read(buf);
while(count != -1){
fos.write(buf, 0, count);
count = sis.read(buf);
Thread.sleep(100);
}
sis.close();
fos.close();
}
//合并
static void mergeFile1() throws Exception{
//将所有的合并的文件，放到一个容器中，
ArrayList list = new ArrayList<>();
for(int i=0;i<6;i++){
list.add(new FileInputStream("c:/77_"+i+".jpg"));
}
//然后得到容器的枚举器。
// Enumeration enumeration = vector.elements();
//得到ArrayList 的枚举器
// Enumeration enumeration = Collections.enumeration(list);
//创建枚举器对象，用于遍历 list
Enumeration enumeration = new Enumeration() {
int index = 0;
//list 的当前元素是否还有下一个元素
public boolean hasMoreElements() {
return list.size()>index;
}
// 返回list 的下一个元素
public InputStream nextElement() {
InputStream is = list.get(index);
index ++;
return is;
}
};
//然后创建 序列流对象
SequenceInputStream sis = new SequenceInputStream(enumeration);
byte[] buf = new byte[100000];
//创建用于生成合并文件的输出流
FileOutputStream fos = new FileOutputStream("c:/77_copy111.jpg");
int count = sis.read(buf);
while(count != -1){
fos.write(buf, 0, count);
count = sis.read(buf);
Thread.sleep(100);
}
sis.close();
fos.close();
}
//合并
static void mergeFile2() throws Exception{
//将所有的合并的文件，放到一个容器中，
ArrayList list = new ArrayList<>();
for(int i=0;i<6;i++){
list.add(new FileInputStream("c:/77_"+i+".jpg"));
}
//然后得到容器的枚举器。
// Enumeration enumeration = vector.elements();
//得到ArrayList 的枚举器
// Enumeration enumeration = Collections.enumeration(list);
//使用list 的迭代器，得到 list 的枚举器
Iterator iterator = list.iterator();
//创建枚举器对象，用于遍历 list
Enumeration enumeration = new Enumeration() {
//list 的当前元素是否还有下一个元素
public boolean hasMoreElements() {
return iterator.hasNext();
}
// 返回list 的下一个元素
public InputStream nextElement() {
return iterator.next();
}
};
//然后创建 序列流对象
SequenceInputStream sis = new SequenceInputStream(enumeration);
byte[] buf = new byte[100000];
//创建用于生成合并文件的输出流
FileOutputStream fos = new FileOutputStream("c:/77_copy111.jpg");
int count = sis.read(buf);
while(count != -1){
fos.write(buf, 0, count);
count = sis.read(buf);
Thread.sleep(100);
}
sis.close();
fos.close();
}
}
