Java学习笔记（3.31）

老板来条小鱼干

已于 2024-03-31 18:50:45 修改

阅读量1k

点赞数 18

文章标签： java 学习笔记

于 2024-03-31 18:47:47 首次发布

本文链接：https://blog.csdn.net/2301_79690135/article/details/137020348

版权

一、IO流

概述：

IO指输入输出（Input/Output）

流是一种抽象概念，是对数据传输的总称。也就是说数据在设备之间的传输称为流，流的本质是传输数据。

IO流就是用来处理设备间数据传输问题的，常见应用有：文件复制、文件下载、文件上传。

1、IO流的分类

按数据的流向----输入流：读数据/输出流：写数据。

按数据类型----字节流：字节输入流、字节输出流 / 字符流：字符输入流、字节输出流。

两种流的使用选择：

如果通过Windows自带的记事本打开，能读懂里面的内容，就使用字符流。否则使用字节流。使用字节流居多。

2、字节流

1、字节流写数据

字节流抽象基类

InputStream：这个抽象类是表示字节输入流的所有类的超类。

OutputStream：这个抽象类表示字节输出流的所有类的超类。

子类名称特点：子类名称都是以其父类名作为子类名的后缀。

FileOutputStream（String name）：创建文件输出流以指定的名称写入文件。

• 创建字节输出流对象（调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件）

• 调用字节输出流对象的写数据方法

• 释放资源（关闭此文件输出流并释放与此流相关联的任何系统资源）

2、字节流写数据的方式

package myByteStream002;

import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamDemo {
	public static void main(String[] args) throws IOException {
		FileOutputStream fos=new FileOutputStream("fos.txt");
		fos.write(97);
		fos.write(98);
		//将指定的字节写入此文件输出流
		
		byte[]bys= {97,98};
		fos.write(bys);
		//将bys.length字节从指定的字节数组写入此文件输出流
		byte[] b="abcde".getBytes();
		//byte[] getBytes();返回字符串对应的字节数组
		fos.write(b);
		
		fos.write(b, 0,b.length);
		//将b.length字节从指定的字节数组开始，从偏移量off开始写入此文件输出流。一次写一个字节数组的部分数据
		fos.close();
	}
}

3、字节流写数据的两个小问题

1、如何换行：

Windows--->\r\n

linux--->\n

mac--->\r

2、如何实现追加写入：

使用如下方法构造新的FileOutputStream类型数据

public FileOutputStream（Stringname,boolean append);

创建文件输出流以指定的名称写入文件。如果第二个参数为true，则字节将写入文件的末尾而不是开头

package myByteStream003;

import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamDemo {
	public static void main(String[] args) throws IOException {
		FileOutputStream fos=new FileOutputStream("C:\\Users\\yushimin\\eclipse-workspace\\myByteStream\\fos.txt");
		for(int i=0;i<10;i++) {
			fos.write("hello".getBytes());
			fos.write("\r\n".getBytes());
			
		}
		
		fos.close();
		FileOutputStream fos2 =new FileOutputStream("fos.txt",true);
		for(int i=0;i<10;i++) {
			fos2.write("hello".getBytes());
			fos2.write("\r\n".getBytes());
			
		}
		fos2.close();
	}

}

4、字节流写数据的异常处理

finally：在异常处理时提供finally块来执行所有清除操作。

比如说IO流中的释放资源特点：被finally控制的语句一定会执行，除非NVM退出

package myByteStream004;

import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamDemo {
	public static void main(String[] args)  {
		FileOutputStream fos=null;
		try {
			fos=new FileOutputStream("fos.txt");
			fos.write("hello".getBytes());
		
		}catch(IOException e) {
			e.printStackTrace();
		}finally {
			if(fos!=null) {
				try {
				fos.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			}
			
		}
		
		
		
	}
}

5、字节流读数据

把文件中的内容读取出来，在控制台输出。

使用字节输入流读数据的步骤：

1- 创建字节输入流对象

2- 调用字节输入流对象的读数据方法

3- 释放资源

1、一次读一个字节数据

FilelnputStream：从文件系统中的文件获取输入字节。

•FilelnputStream（String name）：通过打开与实际文件的连接来创建一个 FilelnputStream，该文件由文件系統中的路径名 name命名

package myByteStream005;

import java.io.FileInputStream;
import java.io.IOException;

public class ByteStreamDemo {
	public static void main(String[] args) throws IOException {
		FileInputStream fis=new FileInputStream("fos.txt");
		int by;
		while((by=fis.read())!=-1) {
			//System.out.println(by);
			System.out.print((char)by);
		}
	
		//文件达到末尾输出  -1
		
		fis.close();
	}

}

2、一次读一个字节数组数据

package myByteStream006;

import java.io.FileInputStream;
import java.io.IOException;

public class ByteStreamDemo {
	public static void main(String[] args) throws IOException {
		FileInputStream fis=new FileInputStream("fos.txt");
		byte[] b=new byte[1024];//一般为1024的整数倍
		int len;
		while((len=fis.read(b))!=-1) {
			System.out.print(new String(b,0,len));
		}
		
		fis.close();
	}

}

6、字节缓冲流

package myByteStream007;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamDemo {
	public static void main(String[] args) throws IOException {
		//字节缓冲输出流
		/*
		 * FileOutputStream fos=new FileOutputStream("bos.txt"); 
		 * BufferedOutputStream bos=new BufferedOutputStream(fos);
		 */
		BufferedOutputStream bos =new BufferedOutputStream(new FileOutputStream ("bos.txt"));
		bos.write("hello".getBytes());
		bos.close();
		//字节缓冲输入流
		BufferedInputStream bis=new BufferedInputStream(new FileInputStream ("bos.txt"));
//		int by;
//		while((by=bis.read())!=-1) {
//			System.out.print((char)by);
//		}
		byte [] byt=new byte[1024];
		int len;
		while((len=bis.read(byt))!=-1) {
			System.out.print(new String(byt,0,len));
		}
	
		bis.close();
	}
}

二、字符流

由于字节流操作中文不是特别的万便，所以Java就提供字符流

• 字符流=字节流＋编码表

用字节流复制文本文件时，文本文件也会有中文，最终底层操作会自动进行字节拼接成中文，汉字在存储的时候，无论选择哪种编码存储，第一个字节都是负数。

package myCharStream001;

import java.io.FileInputStream;
import java.io.IOException;

public class CharStreamDemo {
	public static void main(String[] args) throws IOException {
		FileInputStream fis=new FileInputStream("fos.txt");
		int by;
		while((by=fis.read())!=-1) {
			System.out.print((char)by);
		}
		fis.close();
	}

}

1、编码表

基础知识：

计算机中储存的信息都是用二进制数表示的；我们在屏幕上看到的英文、汉字等字符是二进制数转换之后的结果

按照某种规则，将字符存储到计算机中，称为编码。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码。

这里强调一下：按照A编码存储，必须按照A编码解析，这样才能显示正确的文本符号。否则就会导致乱码现象。

字符集：

是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等

计算机要准确的存储和识别各种字符集符号，就需要进行字符编码，一套字符集必然至少有一套字符编码。

常见字符集有ASCII字符集、GBXXX字符集、Unicode字符集等

2、字符串中的编码解码问题

编码：

●byte[]getBytes():使用平台的默认字符集将该String编码为一系列字节，将结果存储到新的字节数组中

●byte[] getBytes(String charsetName):使用指定的字符集将该String编码为一系列字节，将结果存储到新的字节数组中

解码:

●String(byte[] bytes):通过使用平台的默认字符集解码指定的字节数组来构造新的String

●String(byte[] bytes,String charsetName):通过指定的字符集解码指定的字节数组来构造新的String

package myCharStream001;

import java.io.UnsupportedEncodingException;
import java.lang.reflect.Array;
import java.util.Arrays;

public class CharStreamDemo001 {
	public static void main(String[] args) throws UnsupportedEncodingException {
		String s="中国";
		byte [] bys1=s.getBytes("UTF-8");
		System.out.println(Arrays.toString(bys1));
		
		byte [] bys2=s.getBytes("GBK");
		System.out.println(Arrays.toString(bys2));
		
		byte[] bys3=s.getBytes();
		String ss=new String(bys3);
		System.out.println(ss);
		//使用何种编码方式编码，就要用何种方式解码
	}
}

3、字符流中的编码解码问题

字符流抽象基类

• Reader：字符输入流的抽象类

• Writer：字符输出流的抽象类

字符流中和编码解码问题相关的两个类：

•InputStreamReader

•OutputStreamWriter

package myCharStream002;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class CharStreamDemo {
	public static void main(String[] args) throws IOException {
		FileOutputStream fos=new FileOutputStream("C:\\Users\\yushimin\\eclipse-workspace\\myCharStream\\bin\\myCharStream002\\ows.txt");
		OutputStreamWriter osw=new OutputStreamWriter(fos,"GBK");
		osw.write("中国");
		osw.close();
		FileInputStream fis=new FileInputStream("C:\\Users\\yushimin\\eclipse-workspace\\myCharStream\\bin\\myCharStream002\\ows.txt");
		InputStreamReader isr=new InputStreamReader(fis,"GBK");
		int by;
		while((by=isr.read())!=-1) {
			System.out.print((char)by);
		}
		fis.close();
	}

}

4、字符流写数据

package myCharStream003;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class CharStreamDemo {
	public static void main(String[] args) throws IOException {
		OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("ows.txt"));
		osw.write(97);
		osw.flush();
		//刷新流
		osw.write(100);
		char[] ch= {'a','b','c','d'};
		osw.write(ch);
		osw.write(ch, 1, 3);
		//写入字符数组的一部分
		osw.write("hello");
		osw.write("java", 1, 2);
		osw.close();
	}
}

5、字符流读数据

package myCharStream003;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class CharStreamDemo {
	public static void main(String[] args) throws IOException {

		InputStreamReader isr=new InputStreamReader(new FileInputStream("ows.txt"));
		int ch;
		while((ch=isr.read())!=-1) {
			System.out.print((char)ch);
		}
		System.out.println("\n");
		System.out.println("---------------------");
		
		char []chr=new char [1024];
		int len;
		while((len=isr.read(chr))!=-1) {
			System.out.println(new String(chr,0,len));
		}
		isr.close();
	}
}

6、字符缓冲流

字符缓冲流：

• BufferedWiter：将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符申的高效写

入，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途

• BufferedReader：从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可以

指定缓冲区大小，或者可以使用默认大小。默认值足够大，可用于大多数用途

构造方法：

BufferedWriter (Writert Out);

BufferedReader (Reader Out);

package myCharStream004;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CharStreamDemo {
	public static void main(String[] args) throws IOException {
		FileWriter fw=new FileWriter("bw.txt");
		BufferedWriter bw=new BufferedWriter(fw);
		bw.write("hello");
		bw.write("\n");
		bw.write("java");
		bw.close();
		fw.close();
		
		BufferedReader br=new BufferedReader(new FileReader("bw.txt"));
		char[] ch=new char[1024];
		int len;
		while(( len=br.read(ch))!=-1) {
			System.out.print(new String (ch,0,len));
		}
		br.close();
	}

}