本帖最后由 小石姐姐 于 2019-5-17 11:11 编辑
一、字节流缓冲流字节缓冲流：BufferOutputStream：该类实现缓冲输出流。通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用 BufferedInputStream：创建BufferedInputStream将创建一个内部缓冲区数组。当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节构造方法：字 节缓冲输出流：BufferedOutputStream(OutputStream out)字节缓冲输入流：BufferedInputStream(InputStream in)二、字节流复制视频思路： 根据数据源创建字节输入流对象 根据目的地创建字节输出流对象 读写数据，复制视频 释放资源 [Java] 纯文本查看 复制代码 package outputinputstream;
//使用字节流，字节缓冲流，复制视频，并且查看复制视频的时间都是多少，
// 一次读写一个字节，一次读写一个字节数组，分别使用字节流，和字节缓冲流
import java.io.*;
public class CopyAVI {
public static void main(String[] args) throws IOException {
long strat = System.currentTimeMillis();
//复制视频
//基础字节流一次读写一个字节
// method1();//共耗时：99940毫秒
//基础字节流一次读写一个字节数据
// method2();//共耗时：130毫秒
//字节缓冲流一次读写一个字节
// method3();//共耗时：300毫秒
//字节缓冲流一次读写一个字节数组
method4();//共耗时：50毫秒
long end = System.currentTimeMillis();
System.out.println("共耗时：" + (end - strat) + "毫秒");
}
public static void method1() throws IOException {
FileInputStream fis = new FileInputStream("F:\\黑马Java\\就业班课程\\就业班se\\day08\\素材\\itcast\\字节流复制图片.avi");
FileOutputStream fos = new FileOutputStream("day09\\字节流复制图片.avi");
int by;
while((by = fis.read()) != -1){
fos.write(by);
}
fis.close();
fos.close();
}
public static void method2() throws IOException{
FileInputStream fis = new FileInputStream("F:\\黑马Java\\就业班课程\\就业班se\\day08\\素材\\itcast\\字节流复制图片.avi");
FileOutputStream fos = new FileOutputStream("day09\\字节流复制图片.avi");
byte[] bys = new byte[1024];
int len;
while((len=fis.read(bys))!=-1){
fos.write(bys,0,len);
}
fis.close();
fos.close();
}
public static void method3() throws IOException{
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("F:\\黑马Java\\就业班课程\\就业班se\\day08\\素材\\itcast\\字节流复制图片.avi"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day09\\字节流复制图片.avi"));
int by;
while((by = bis.read())!=-1){
bos.write(by);
}
bis.close();
bos.close();
}
public static void method4() throws IOException{
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("F:\\黑马Java\\就业班课程\\就业班se\\day08\\素材\\itcast\\字节流复制图片.avi"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day09\\字节流复制图片.avi"));
byte[] bys = new byte[1024];
int len;
while((len = bis.read(bys))!=-1){
bos.write(bys,0,len);
}
bis.close();
bos.close();
}
}
三、为什么出现字符流由于字节流操作中文不是特别的方便，所以Java就提供字符流 字符流 = 字节流 + 编码表 用字节流复制文本文件时，文本文件也会有中文，但是没有问题，原因是最终底层操作会自动进行字节拼接成中文，如何识别是中文的呢？ 汉字在存储的时候，无论选择哪种编码存储，第一个字节都是负数 四、编码表（常用：GBK，UTF-8）按照某种规则，将字符存储到计算机中，称为编码。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码 ASCII(American Standard Code for Information Interchange，美国信息交换标准代码)：是基于拉丁字母的一套电脑编码系统，用于显示现代英语 GBK：最常用的中文码表。是在GB2312标准基础上的扩展规范，使用了双字节编码方案 UTF-8编码：可以用来表示Unicode标准中任意字符，大部分常用字（含中文），使用三个字节编码 五、字符串中的编码解码问题编码：byte[] getBytes()：使用平台的默认字符集将该 String编码为一系列字节，将结果存储到新的字节数组中 byte[] getBytes(String charsetName)：使用指定的字符集将该 String编码为一系列字节，将结果存储到新的字节数组中 解码：String(byte[] bytes)：通过使用平台的默认字符集解码指定的字节数组来构造新的 StringString(byte[] bytes, String charsetName)：通过指定的字符集解码指定的字节数组来构造新的 String [Java] 纯文本查看 复制代码 package stringencode;[/size][/b]//String数据编码解码问题
import java.io.UnsupportedEncodingException;
/*
byte[] getBytes()：使用平台的默认字符集将该 String编码为一系列字节，将结果存储到新的字节数组中
byte[] getBytes(String charsetName)：使用指定的字符集将该 String编码为一系列字节，将结果存储到新的字节数组中
解码：
String(byte[] bytes)：通过使用平台的默认字符集解码指定的字节数组来构造新的 String
String(byte[] bytes, String charsetName)：通过指定的字符集解码指定的字节数组来构造新的 String
*/
public class StringEncodeTest {
public static void main(String[] args) throws UnsupportedEncodingException {
//再进行编码时，你的编码格式是什么字符集(GBK,UTF-8)，解码时必须使用你编码时的字符集。
String s = "中国";
byte[] bys = s.getBytes();
for (byte by : bys){
System.out.print(by+" ");//-28 -72 -83 -27 -101 -67
}
System.out.println();
System.out.println(new String(bys));//中国
bys = s.getBytes("UTF-8");
for (byte by : bys){
System.out.print(by+" ");//-28 -72 -83 -27 -101 -67
}
System.out.println();
System.out.println(new String(bys));//中国
bys = s.getBytes("GBK");
for (byte by : bys){
System.out.print(by+" ");//-42 -48 -71 -6
}
System.out.println();
System.out.println(new String(bys));//�й�，默认使用UTF-8进行解码
System.out.println(new String(bys,"GBK"));//中国
}
}
六、字符流中的编码解码问题字符流中和编码解码问题相关的两个类：InputStreamReader OutputStreamWriter 和编码相关的构造方法：InputStreamReader(InputStream in, String charSetName) OutputStreamWriter(OutputStream out, String charSetName) [Java] 纯文本查看 复制代码 package readerwriter;
//使用字符输出流，把内容写入到文件当中
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class OutputStreamWriterTest {
public static void main(String[] args) throws IOException {
/*FileOutputStream fos = new FileOutputStream("day09\\osw.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos);*/
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("day09\\osw.txt"));
OutputStreamWriter osw1 = new OutputStreamWriter(new FileOutputStream("day09\\osw1.txt"),"UTF-8");
OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream("day09\\osw2.txt"),"GBK");
//字符输出流一次写入一个字符
osw.write(97);
osw.write("\r\n");
//字符输出流一次写入一个字符数组
char[] chs = {'a','b','c','d','e'};
osw.write(chs);
osw.write("\r\n");
//字符输出流一次写入一个字符数组，从哪个索引开始，写入多少长度
osw.write(chs,0,chs.length);
osw.write("\r\n");
//字符输出流一次写入一个字符串
osw.write("hello");
osw.write("\r\n");
//字符输出流一次写入一个字符串，从哪个索引开始，写入多少长度
osw.write("world",0,"world".length());
osw.write("\r\n");
//以UTF-8的编码格式写入数据
osw1.write(97);
osw1.write("\r\n");
char[] chs1 = {'a','b','c','d','e'};
osw1.write(chs1);
osw1.write("\r\n");
osw1.write(chs1,0,chs1.length);
osw1.write("\r\n");
osw1.write("hello");
osw1.write("\r\n");
osw1.write("world",0,"world".length());
osw1.write("\r\n");
//以GBK的编码格式写入数据
osw2.write(97);
osw2.write("\r\n");
char[] chs2 = {'a','b','c','d','e'};
osw2.write(chs2);
osw2.write("\r\n");
osw2.write(chs2,0,chs2.length);
osw2.write("\r\n");
osw2.write("hello");
osw2.write("\r\n");
osw2.write("world",0,"world".length());
osw2.write("\r\n");
osw.close();
osw1.close();
osw2.close();
}
}
package readerwriter;
//使用字符输入流，把文件中的内容读取出来
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class InputStreamReaderTest {
public static void main(String[] args) throws IOException {
/*FileInputStream fis = new FileInputStream("day09\\osw.txt");
InputStreamReader isr = new InputStreamReader(fis);*/
InputStreamReader isr = new InputStreamReader(new FileInputStream("day09\\osw.txt"));
InputStreamReader isr1 = new InputStreamReader(new FileInputStream("day09\\osw1.txt"),"UTF-8");
InputStreamReader isr2 = new InputStreamReader(new FileInputStream("day09\\osw2.txt"),"GBK");
//以默认编码格式读取文件
//字符输入流一次读取一个字符
/*int by = isr.read();
System.out.println((char)by);*/
//字符输入流一次读取一个字符数组
/*char[] chs = new char[1024];
int len = isr.read(chs);
System.out.println(len);
for (char ch : chs){
System.out.print(ch);
}*/
//字符输入流一次读取一个字符数组，从哪个索引开始，读取多少长度
/*char[] chs = new char[1024];
int len1 = isr.read(chs, 0, chs.length);
System.out.println(len1);
for (char ch : chs){
System.out.print(ch);
}*/
//以UTF-8字符集格式读取文件
//字符输入流一次读取一个字符
/*int by = isr1.read();
System.out.println((char)by);*/
//字符输入流一次读取一个字符数组
/*char[] chs = new char[1024];
int len = isr1.read(chs);
System.out.println(len);
for (char ch : chs){
System.out.print(ch);
}*/
//字符输入流一次读取一个字符数组，从哪个索引开始，读取多少长度
/*char[] chs = new char[1024];
int len1 = isr1.read(chs, 0, chs.length);
System.out.println(len1);
for (char ch : chs){
System.out.print(ch);
}*/
//以GBK字符集格式读取文件
//字符输入流一次读取一个字符
/*int by = isr2.read();
System.out.println((char)by);*/
//字符输入流一次读取一个字符数组
/*char[] chs = new char[1024];
int len = isr2.read(chs);//
System.out.println(len);
for (char ch : chs){
System.out.print(ch);
}*/
//字符输入流一次读取一个字符数组，从哪个索引开始，读取多少长度
char[] chs = new char[1024];
int len1 = isr2.read(chs, 0, chs.length);
System.out.println(len1);
for (char ch : chs){
System.out.print(ch);
}
isr.close();
isr1.close();
}
}七、字符流写数据的5种方式[Java] 纯文本查看 复制代码 package readerwriter;
//使用字符输出流，把内容写入到文件当中
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class OutputStreamWriterTest {
public static void main(String[] args) throws IOException {
/*FileOutputStream fos = new FileOutputStream("day09\\osw.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos);*/
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("day09\\osw.txt"));
OutputStreamWriter osw1 = new OutputStreamWriter(new FileOutputStream("day09\\osw1.txt"),"UTF-8");
OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream("day09\\osw2.txt"),"GBK");
//字符输出流一次写入一个字符
osw.write(97);
osw.write("\r\n");
//字符输出流一次写入一个字符数组
char[] chs = {'a','b','c','d','e'};
osw.write(chs);
osw.write("\r\n");
//字符输出流一次写入一个字符数组，从哪个索引开始，写入多少长度
osw.write(chs,0,chs.length);
osw.write("\r\n");
//字符输出流一次写入一个字符串
osw.write("hello");
osw.write("\r\n");
//字符输出流一次写入一个字符串，从哪个索引开始，写入多少长度
osw.write("world",0,"world".length());
osw.write("\r\n");
//以UTF-8的编码格式写入数据
osw1.write(97);
osw1.write("\r\n");
char[] chs1 = {'a','b','c','d','e'};
osw1.write(chs1);
osw1.write("\r\n");
osw1.write(chs1,0,chs1.length);
osw1.write("\r\n");
osw1.write("hello");
osw1.write("\r\n");
osw1.write("world",0,"world".length());
osw1.write("\r\n");
//以GBK的编码格式写入数据
osw2.write(97);
osw2.write("\r\n");
char[] chs2 = {'a','b','c','d','e'};
osw2.write(chs2);
osw2.write("\r\n");
osw2.write(chs2,0,chs2.length);
osw2.write("\r\n");
osw2.write("hello");
osw2.write("\r\n");
osw2.write("world",0,"world".length());
osw2.write("\r\n");
osw.close();
osw1.close();
osw2.close();
}
}
八、字符流读数据的2种方式[Java] 纯文本查看 复制代码 package readerwriter;
//使用字符输入流，把文件中的内容读取出来
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class InputStreamReaderTest {
public static void main(String[] args) throws IOException {
/*FileInputStream fis = new FileInputStream("day09\\osw.txt");
InputStreamReader isr = new InputStreamReader(fis);*/
InputStreamReader isr = new InputStreamReader(new FileInputStream("day09\\osw.txt"));
InputStreamReader isr1 = new InputStreamReader(new FileInputStream("day09\\osw1.txt"),"UTF-8");
InputStreamReader isr2 = new InputStreamReader(new FileInputStream("day09\\osw2.txt"),"GBK");
//以默认编码格式读取文件
//字符输入流一次读取一个字符
/*int by = isr.read();
System.out.println((char)by);*/
//字符输入流一次读取一个字符数组
/*char[] chs = new char[1024];
int len = isr.read(chs);
System.out.println(len);
for (char ch : chs){
System.out.print(ch);
}*/
//字符输入流一次读取一个字符数组，从哪个索引开始，读取多少长度
/*char[] chs = new char[1024];
int len1 = isr.read(chs, 0, chs.length);
System.out.println(len1);
for (char ch : chs){
System.out.print(ch);
}*/
//以UTF-8字符集格式读取文件
//字符输入流一次读取一个字符
/*int by = isr1.read();
System.out.println((char)by);*/
//字符输入流一次读取一个字符数组
/*char[] chs = new char[1024];
int len = isr1.read(chs);
System.out.println(len);
for (char ch : chs){
System.out.print(ch);
}*/
//字符输入流一次读取一个字符数组，从哪个索引开始，读取多少长度
/*char[] chs = new char[1024];
int len1 = isr1.read(chs, 0, chs.length);
System.out.println(len1);
for (char ch : chs){
System.out.print(ch);
}*/
//以GBK字符集格式读取文件
//字符输入流一次读取一个字符
/*int by = isr2.read();
System.out.println((char)by);*/
//字符输入流一次读取一个字符数组
/*char[] chs = new char[1024];
int len = isr2.read(chs);//
System.out.println(len);
for (char ch : chs){
System.out.print(ch);
}*/
//字符输入流一次读取一个字符数组，从哪个索引开始，读取多少长度
char[] chs = new char[1024];
int len1 = isr2.read(chs, 0, chs.length);
System.out.println(len1);
for (char ch : chs){
System.out.print(ch);
}
isr.close();
isr1.close();
}
}
九、字符流复制Java文件[Java] 纯文本查看 复制代码 package readerwriter;
//使用字符流，复制视频，一次读写一个字符，一次读写一个字符数组
import java.io.*;
public class Copy {
public static void main(String[] args) throws IOException {
InputStreamReader isr = new InputStreamReader(new FileInputStream("day09\\src\\arraybuffered\\ArrayToTXT.java"));
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("day09\\ReaderCopy.java"));
//字符流一次读写一个字符
/*int by;
while((by=isr.read()) != -1){
osw.write(by);
}*/
//字符流一次读写一个字符数组
char[] chs = new char[1024];
int len;
while((len=isr.read(chs)) != -1){
osw.write(chs,0,len);
}
//释放资源
isr.close();
osw.close();
}
}
十、字符流辅助Java文件改进版[Java] 纯文本查看 复制代码 package readerwriter;
//使用字符流简便类，复制文件，一次读写一个字符，一次读写一个字符数组
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Copy1 {
public static void main(String[] args) throws IOException {
FileReader fr = new FileReader("day09\\src\\readerwriter\\Copy.java");
FileWriter fw = new FileWriter("day09\\Reader1Copy.java");
//字符流简便类，一次读写一个字符
/*int by;
while((by=fr.read()) != -1){
fw.write(by);
}*/
//字符流简便，一次读写一个字符数组
char[] chs = new char[1024];
int len;
while((len = fr.read(chs)) != -1){
fw.write(chs,0,len);
}
//释放资源
fr.close();
fw.close();
}
}
十一、字符缓冲流字符缓冲流：BufferedWriter：将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途 BufferedReader：从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可以指定缓冲区大小，或者可以使用默认大小。 默认值足够大，可用于大多数用途 构造方法：BufferedWriter(Writer out) BufferedReader(Reader in)[Java] 纯文本查看 复制代码 package bufferedreaderwriter;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
/*
创建字符缓冲输入流对象
把某个文件中的数据读入程序
创建字符缓冲输出流对象
把数据输出到指定文件中
*/
public class BufferedReaderTest1 {
public static void main(String[] args) throws IOException {
//创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("day09\\copy.txt"));
//一次读取一个字符
/*int by;
while ((by=br.read())!=-1){
System.out.println((char) by);
}*/
//一次读取一个字符数组
char[] chs = new char[1024];
int len;
/*while ((len = br.read(chs))!=-1){
System.out.println(new String(chs,0,len));
}*/
//一次读取一个字节数组，从哪个索引开始，读取多少长度
len = br.read(chs,0,chs.length);
System.out.println(new String(chs,0,len));
br.close();
}
}[Java] 纯文本查看 复制代码 package bufferedreaderwriter;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class BufferedWriterTest1 {
public static void main(String[] args) throws IOException {
BufferedWriter bw = new BufferedWriter(new FileWriter("day9\\bwwww.txt"));
//一次写一个字符
bw.write(97);
char[] chs = {'a','b','c'};
//一次写一个字符数组
bw.write(chs);
//一次写一个字符数组，从哪个索引开始，写入多少长度
bw.write(chs,0,chs.length);
//一次写一个字符串
bw.write("abc");
//一次写一个字符串，从哪个索引开始，写入多少长度
bw.write("abc",0,"abc".length());
bw.close();
}
} 十二、字符缓冲流复制Java文件[Java] 纯文本查看 复制代码 package bufferedreaderwriter;
import java.io.*;
public class Copy1 {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new FileReader("day09\\copy.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("day09\\copy11.txt"));
//一次读写一个字符
int by;
while ((by=br.read()) != -1){
bw.write(by);
}
//一次读写一个字符数组
char[] chs = new char[1024];
int len;
while ((len = br.read(chs))!= -1){
bw.write(chs,0,len);
}
br.close();
bw.close();
}
}
十三、字符缓冲流特有功能缓冲流特有方法： BufferedWriter： void newLine()：写一行行分隔符，行分隔符字符串由系统属性定义 BufferedReader： public String readLine() ：读一行文字。 结果包含行的内容的字符串，不包括任何行终止字符，如果流的结尾已经到达，则为null [Java] 纯文本查看 复制代码 package bufferedreaderwriter;
//使用字符缓冲输入流，调用其功能，读取文件当中的内容
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class BufferedReaderTest {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new FileReader("day09\\bw.txt"));
//字符缓冲输入流一次读取一个字符
/*int by = br.read();
System.out.println((char)by);*/
//字符缓冲输入流一次读取一个字符数组
/*char[] chs = new char[1024];
int len = br.read(chs);
System.out.println(len);
for (char ch : chs){
System.out.print(ch);
}*/
//字符缓冲输入流一次读取一个字符数组，从哪个索引开始，读取多少长度
/*char[] chs = new char[1024];
int len = br.read(chs, 0, chs.length);
System.out.println(len);
for (char ch : chs){
System.out.print(ch);
}*/
//字符缓冲输入流一次读取一行，返回字符串，如果返回值是null，就表示已经到文本结尾
String line;
while((line=br.readLine()) != null){
System.out.println(line);
}
br.close();
}
}[Java] 纯文本查看 复制代码 package bufferedreaderwriter;
//使用字符缓冲输出流，调用其方法，把内容写入到文件当中
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class BufferedWriterTest {
public static void main(String[] args) throws IOException {
BufferedWriter bw = new BufferedWriter(new FileWriter("day09\\bw.txt"));
//字符缓冲输出流一次写入一个字符
bw.write(97);
bw.newLine();
//字符缓冲输出流一次写入一个字符数组
char[] chs = {'a','b','c','d','e'};
bw.write(chs);
bw.newLine();
//字符缓冲输出流一次写入一个字符数组，从哪个索引开始，写入多少长度
bw.write(chs,0,chs.length);
bw.newLine();
//字符缓冲输出流一次写入一个字符串
bw.write("hello");
bw.newLine();
//字符缓冲输出流一次写入一个字符串，从哪个索引开始，写入多少长度
bw.write("world",0,"world".length());
//释放资源
bw.close();
}
}
十四、字符缓冲流特有功能复制Java文件[Java] 纯文本查看 复制代码 package bufferedreaderwriter;
//使用字符缓冲流，复制Java文件
import java.io.*;
public class Copy {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new FileReader("day09\\src\\bufferedreaderwriter\\BufferedReaderTest.java"));
BufferedWriter bw = new BufferedWriter(new FileWriter("day09\\BrCopy.java"));
//字符缓冲流读写一次读写一个字符
/*int by;
while((by=br.read()) != -1){
bw.write(by);
}*/
//字符缓冲流读写一次读写一个字符数组
/*char[] chs = new char[1024];
int len;
while((len = br.read(chs)) != -1){
bw.write(chs,0,len);
}*/
//字符缓冲流读写一次读写一行，返回String
String line;
while((line = br.readLine()) != null){
bw.write(line);
bw.newLine();
bw.flush();
}
//释放资源
br.close();
bw.close();
}
}
十五、IO流小结字节流 ----------InputStream ---------- FileInputStream ---------- BufferedInputStream ----------OutputStream ---------- FileOutputStream ---------- BufferedOutputStream 字符流---------- Reader ---------- InputStreamReader ---------- FileReader（是 InputStreamReader的简易类） ---------- BufferedReader ---------- Writer ---------- OutputStreamWriter ---------- FileWriter（是 OutputStreamWriter的简易类） ---------- BufferedWriter 十六、集合到文件思路： 创建ArrayList集合 往集合中存储字符串元素 创建字符缓冲输出流对象 遍历集合，得到每一个字符串数据 调用字符缓冲输出流对象的方法写数据 释放资源[Java] 纯文本查看 复制代码 package arraybuffered;
//使用字符缓冲输出流，把集合中的内容写入到文本当中
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
public class ArrayToTXT {
public static void main(String[] args) throws IOException {
ArrayList<String> array = new ArrayList<>();
array.add("hello");
array.add("world");
array.add("java");
BufferedWriter bw = new BufferedWriter(new FileWriter("day09\\array1.txt"));
for (String s : array){
bw.write(s);
bw.newLine();
bw.flush();
}
bw.close();
}
} 十七、文件到集合步骤 创建字符缓冲输入流对象 创建ArrayList集合对象 调用字符缓冲输入流对象的方法读数据 把读取到的字符串数据存储到集合中 释放资源 遍历集合[Java] 纯文本查看 复制代码 package arraybuffered;
//使用字符缓冲输入流，把文本当中的内容读取，存储到集合当中
import java.io.*;
import java.util.ArrayList;
public class TXTToArray {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new FileReader("day09\\array1.txt"));
ArrayList<String> array = new ArrayList<>();
String line;
while((line=br.readLine()) != null){
array.add(line);
}
br.close();
for (String s : array){
System.out.println(s);
}
}
}
十八、点名器点名器案例步骤 创建字符缓冲输入流对象 创建ArrayList集合对象 调用字符缓冲输入流对象的方法读数据 把读取到的字符串数据存储到集合中 释放资源 使用Random产生一个随机数，随机数的范围在：[0,集合的长度) 把第6步产生的随机数作为索引到ArrayList集合中 获取值把第7步得到的数据 输出在控制台[Java] 纯文本查看 复制代码 package bufferedreaderarray;
//点名器，使用缓冲输入流，从文本当中读取姓名，存储到集合中，并随机点名（生成随机索引，根据索引获取集合对应的姓名）
import java.io.*;
import java.util.ArrayList;
import java.util.Random;
public class GetName {
public static void main(String[] args) throws IOException {
//集合数据写入到文件
BufferedWriter bw = new BufferedWriter(new FileWriter("day09\\names.txt"));
ArrayList<String> array = new ArrayList<>();
array.add("张三");
array.add("李四");
array.add("王五");
array.add("赵六");
array.add("田七");
for (String name : array){
bw.write(name);
bw.newLine();
bw.flush();
}
bw.close();
//文件数据读取到集合
BufferedReader br = new BufferedReader(new FileReader("day09\\names.txt"));
ArrayList<String> array1 = new ArrayList<>();
String name;
while((name=br.readLine())!=null){
array1.add(name);
}
Random r = new Random();
int index = r.nextInt(array1.size());
String names = array1.get(index);
System.out.println(names);
}
}
十九、集合到文件改进版步骤 定义学生类 创建ArrayList集合 创建学生对象 把学生对象添加到集合中 创建字符缓冲输出流对象 遍历集合，得到每一个学生对象 把学生对象的数据拼接成指定格式的字符串 调用字符缓冲输出流对象的方法写数据 释放资源[Java] 纯文本查看 复制代码 package bufferedreaderarray;
public class Student {
private String sid;
private String name;
private int age;
private String address;
public Student() {
}
public Student(String sid, String name, int age, String address) {
this.sid = sid;
this.name = name;
this.age = age;
this.address = address;
}
public String getSid() {
return sid;
}
public void setSid(String sid) {
this.sid = sid;
}
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;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "Student{" +
"sid='" + sid + '\'' +
", name='" + name + '\'' +
", age=" + age +
", address='" + address + '\'' +
'}';
}
}
[Java] 纯文本查看 复制代码 package bufferedreaderarray;
//使用字符缓冲输出流，把集合中的学生信息，写入到文本当中，按照指定的格式
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
public class ArrayToTXT {
public static void main(String[] args) throws IOException {
ArrayList<Student> array = new ArrayList<>();
Student s1 = new Student("001","张三",21,"西安");
Student s2 = new Student("002","李四",21,"北京");
Student s3 = new Student("003","王五",21,"成都");
array.add(s1);
array.add(s2);
array.add(s3);
BufferedWriter bw = new BufferedWriter(new FileWriter("day09\\student.txt"));
for (Student s : array){
StringBuilder sb = new StringBuilder();
sb.append(s.getSid()).append(",").append(s.getName()).append(",").append(s.getAge()).append(",").append(s.getAddress());
String stu = sb.toString();
bw.write(stu);
bw.newLine();
bw.flush();
}
bw.close();
}
}
二十、文件到集合改进版步骤 定义学生类 创建TreeSet集合，通过比较器排序进行排序 键盘录入学生数据 创建学生对象，把键盘录入的数据对应赋值给学生对象的成员变量 把学生对象添加到TreeSet集合 创建字符缓冲输出流对象 遍历集合，得到每一个学生对象 把学生对象的数据拼接成指定格式的字符串 调用字符缓冲输出流对象的方法写数据 释放资源[Java] 纯文本查看 复制代码 package bufferedreaderarray;
public class Student {
private String sid;
private String name;
private int age;
private String address;
public Student() {
}
public Student(String sid, String name, int age, String address) {
this.sid = sid;
this.name = name;
this.age = age;
this.address = address;
}
public String getSid() {
return sid;
}
public void setSid(String sid) {
this.sid = sid;
}
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;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "Student{" +
"sid='" + sid + '\'' +
", name='" + name + '\'' +
", age=" + age +
", address='" + address + '\'' +
'}';
}
}
[Java] 纯文本查看 复制代码 package bufferedreaderarray;
//使用缓冲输入流，把文本当中的学生信息读取出来，存储到集合中
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
public class TXTToArray {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new FileReader("day09\\student.txt"));
ArrayList<Student> array = new ArrayList<>();
String line;
while((line = br.readLine()) != null){
String[] strArr = line.split(",");
Student s = new Student();
s.setSid(strArr[0]);
s.setName(strArr[1]);
s.setAge(Integer.parseInt(strArr[2]));
s.setAddress(strArr[3]);
array.add(s);
}
for (Student s : array){
System.out.println(s);
}
}
}
|
收藏
淘帖
踩
