一、CopyFileDemo1
package com.shujia.lhw.day23;
import java.io.FileInputStream;
import java.io.FileOutputStream;
/*
把当前目录下的a.txt内容复制到当前项目目录下的b.txt中
输入流
InputStream--FileInputStream
一次读取一个字节
一次性读取一个字节数组
a.txt
输出流
OutputStream--FileOutputStream
以西写一个int类型数值
一次写一个字节数组
一次血一个字节数组的一部分
b.txt
*/
public class CopyFileDemo1 {
public static void main(String[] args) throws Exception{
//1、创建字节输入流对象和字节输出流对象
FileInputStream fis = new FileInputStream("a.txt");
FileOutputStream fos = new FileOutputStream("f.txt");
//2、读取数据
//a:一次读取一个字节
// int i = 0;
// while ((i = fis.read())!=-1){
// System.out.println();
// fos.write(i);
// }
//b:一次读取一个字节数组
byte[] bytes = new byte[1024];
int length = 0;
while((length = fis.read(bytes))!=-1){
fos.write(bytes,0,length);
}
//释放资源
fos.close();
fis.close();
}
}
---------------------------------------------------------------------------------------------------------------------------------
二、CopyFileDemo2
package com.shujia.lhw.day23;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
/*
把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
数据源：
a.txt -- 读取数据--字符输入流--Reader--InputStreamReader
目的地：
b.txt--写出数据--字符输出流--Writer--OutputStreamWriter
*/
public class CopyFileDemo2 {
public static void main(String[] args) throws Exception{
//1、创建字符输入流对象和字符输出流对象
InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("b.txt"));
//读写数据
//第一种方式
int ch = 0;
while((ch=isr.read())!=-1){
osw.write(ch);
osw.flush();
}
//第二种方式
char[] chars = new char[1024];
int length = 0;
while((length = isr.read(chars))!=-1){
osw.write(chars,0,length);
osw.flush();
}
//释放资源
osw.close();
isr.close();
}
}
--------------------------------------------------------------------------------------------------------------------------------
三、CopyFileDemo3
package com.shujia.lhw.day23;
import java.io.*;
/*
由于我们常见的操作都是用基本默认的编码，我们基本上使用的时候不去指定编码
但是呢，我觉得创建字符转换流对象的时候，名字有点长，所以Java提供了子类供我们使用
字符流 = 字节流 + 编码表
OutputStreamWriter = FileOutputStream + 编码表
InputStreamReader = FileInputStream + 编码表
把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt当中
数据源：
a.txt--读取数据--字符输入流--Reader--InputStreamReader--FileReader
目的地：
b.txt--写出数据--字符输出流--Writer--OutputStreamWriter--FileWriter
*/
public class CopyFileDemo3 {
public static void main(String[] args) throws Exception{
// InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));
// OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("b.txt"));
//FileReader(String fileName)
//创建一个新的FileReader，给定要读取的文件的名称
FileReader fr = new FileReader("a.txt");
//创建字符输出对象
//FileWriter(String fileName)
//构造一个给定文件名的FileWriter对象
FileWriter fw = new FileWriter("b.txt");
//一次读写一个字符
int ch = 0;
while((ch=fr.read())!=-1){
fw.write(ch);
fw.flush();
}
//一次读写一个字符数组
char[] chars = new char[1024];
int length = 0;
while((length = fr.read(chars))!=-1){
fw.write(chars,0,length);
fw.flush();
}
//释放资源
fw.close();
fr.close();
}
}
-------------------------------------------------------------------------------------------------------------------------
四、CopyFileDemo4
package com.shujia.lhw.day23;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
/*
把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中
数据源：
a.txt--读取数据--字符输入流--Reader--InputStreamReader--FileReader--BufferedReader
目的地：
b2.txt--写入数据--字符输出流--Writer--OutputStreamWriter--FileWriter--BufferWriter
*/
public class CopyFileDemo4 {
public static void main(String[] args) throws Exception{
//1、创建字符缓冲输入流对象和字符缓冲输出流对象
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("b2.txt"));
//一次读写一个字符数组
char[] chars = new char[1024];
int length = 0;
while((length=br.read(chars))!=-1){
bw.write(chars,0,length);
bw.flush();
}
//释放资源
bw.close();
br.close();
}
}
--------------------------------------------------------------------------------------------------------------------------
五、CopyJpgDemo1
package com.shujia.lhw.day23;
import java.io.FileInputStream;
import java.io.FileOutputStream;
/*
把当前项目下的冯提莫.jpg复制到当前项目下day23目录下
数据源：从哪来
冯提莫.jpg--读取数据--InputStream--FileInputStream
目的地：到哪里去
com\\shujia\\lhw\\day23\\ftm.jpg--写出数据--OutputStream--FileOutputStream
*/
public class CopyJpgDemo1 {
public static void main(String[] args) throws Exception{
//创建字节输入流对象和字节输出流对象
FileInputStream fis = new FileInputStream("冯提莫.jpg");
FileOutputStream fos = new FileOutputStream("src\\com\\shujia\\lhw\\day23\\ftm.jpg");
byte[] bytes = new byte[1024];
int length = 0;
while((length = fis.read(bytes))!=-1){
fos.write(bytes,0,length);
}
//释放资源
fos.close();
fis.close();
}
}
---------------------------------------------------------------------------------------------------------------------------------
六、CopyMp4Demo1
package com.shujia.lhw.day23;
import java.io.FileInputStream;
import java.io.FileOutputStream;
/*
将D盘下的大数据.mp4复制到D盘数加科技目录下
数据源：D:\\大数据.mp4
读取数据--InputStream--FileInputStream
目的地：D:\\数加科技\\大数据.mp4
写出数据--OutputStream--FileOutputStream
*/
public class CopyMp4Demo1 {
public static void main(String[] args) throws Exception{
//1、创建字节输入流对象和字节输出流对象
FileInputStream fis = new FileInputStream("D:\\大数据.mp4");
FileOutputStream fos = new FileOutputStream("D:\\数加科技\\大数据.mp4");
//2、读取数据
byte[] bytes = new byte[1024];
int length = 0;
while((length=fis.read(bytes))!=-1){
fos.write(bytes,0,length);
}
//3、释放资源
fos.close();
fis.close();
}
}
----------------------------------------------------------------------------------------------------------------------------
七、FileInputStreamDemo1
package com.shujia.lhw.day23;
import java.io.File;
import java.io.FileInputStream;
/*
字节输入流：InputStream（抽象类）
FileInputStream
FileInputStream的构造方法
FileInputStream(File file)
FileInputStream(String name)
字节输入流读取数据的两种方式：
FileInputStream的成员方法：
public int read
public int read(byte[] b)
*/
public class FileInputStreamDemo1 {
public static void main(String[] args) throws Exception {
//1、创建字节流输入对象
//FileInputStream(File file)
//读取数据的时候，如果文件不存在，报错
// File file = new File("f.txt");//f.txt(系统找不到指定的文件)
// File file = new File("e.txt");
// FileInputStream fis = new FileInputStream(file);
//FileInputStream(String name)
FileInputStream fis = new FileInputStream("e.txt");
//调用read方法读取数据，并输出在控制台上
//public int read(),一次只能读取一个字节，返回的值是ASCII码值，强制类型转换
// int read = fis.read();
// System.out.println((char)read);
// int read2 = fis.read();
// System.out.println((char)read2);
//如果文件中的数据很多的话，还是这样一个字节一个字节的读取，没有做任何改进，即将会很麻烦
//使用循环改进读取
//由于我们不知道什么时候将文件数据读取完毕，所以使用wile循环
//控制跳出wile循环的条件是什么，数据的下一个字节，如果达到文件的末尾，-1
// int read = fis.read();
// while (read != -1) {
// System.out.println((char) read);
// read = fis.read();
// }
//字节输入流读取数据的第一种方式最终版写法：
int i = 0;
while ((i = fis.read()) != -1) {
System.out.print((char) i);
}
//释放资源
fis.close();
}
}
---------------------------------------------------------------------------------------
八、FileInputStreamDemo2
package com.shujia.lhw.day23;
import java.io.FileInputStream;
/*
字节输入流读取数据的第二种方式：一次读取一个字节数组
public int read(byte[] b)
*/
public class FileInputStreamDemo2 {
public static void main(String[] args) throws Exception {
//创建字节输入流对象
FileInputStream fis = new FileInputStream("e.txt");
//2、读取数据
//public int read(byte[] b)
//定义一个字节数组
// byte[] bytes = new byte[8];
// //一旦调用这个方法，将实际获取到的字节存储到数组中，返回的是，数组实际读取到的字节数
// int i = fis.read(bytes);
// System.out.println(i);
// for (byte b : bytes) {
// System.out.print((char) b);
// }
// System.out.println("======================================");
// String s = new String(bytes);
// System.out.println(s);
// String s = new String(bytes,0,i);
// System.out.println(s);
//用循环改进
//字节流读取数据的第二种方式最终代码
//读入缓冲区的总字节数，如果没有更多的数据，文件的结尾已经达到，-1
byte[] bytes = new byte[1024];
int length = 0;
while((length=fis.read(bytes))!=-1){
System.out.println(new String(bytes,0,length));
}
//释放资源
fis.close();
}
}
-------------------------------------------------------------------------------------------------------------------------------
九、InputStreamReaderDemo1
package com.shujia.lhw.day23;
import java.io.FileInputStream;
import java.io.InputStreamReader;
/*
Reader
InputStreamReader:字符输入流
public InputStreamReader(InputStream in)
读取数据，根据默认的编码用字符作为桥梁将字节流的数据转换为字符流
public InputStreamReader(InputStream in,String charsName)
读取数据，根据指定的编码用字符作为桥梁将字节流的数据转换为字符流
*/
public class InputStreamReaderDemo1 {
public static void main(String[] args) throws Exception{
// InputStreamReader isr = new InputStreamReader(new FileInputStream("bbb.txt"));
InputStreamReader isr = new InputStreamReader(new FileInputStream("ccc.txt"), "GBK");
//一次读取一个字符
int c = 0;
while ((c=isr.read())!=-1){
System.out.print((char)c);
}
//释放资源
isr.close();
}
}
------------------------------------------------------------------------------------------------------------------------------
十、InputStreamReaderDemo2
package com.shujia.lhw.day23;
import java.io.FileInputStream;
import java.io.InputStreamReader;
/*
InputStreamReader:字符输入流
读取数据的方法：
public int read()
public int read(char[] cbuf)
*/
public class InputStreamReaderDemo2 {
public static void main(String[] args) throws Exception{
//1、创建字符输入流对象
InputStreamReader isr = new InputStreamReader(new FileInputStream("e.txt"));
//一次只读一个字符
//字符读取，如果已经达到流的结尾，则为-1
// int i = 0;
// while((i=isr.read())!=-1){
// System.out.print((char) i);
// }
//一次读取一个字符数组
//读取的字符数组，如果已经达到流的结尾，则为-1
char[] chars = new char[1024];
int length = 0;
while((length = isr.read(chars))!=-1){
System.out.println(new String(chars,0,length));
}
//释放资源
isr.close();
}
}
--------------------------------------------------------------------------------------------------------------------------------
十一、Output StreamWriter Demo1
package com.shujia.lhw.day23;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
/*
字符流：
字符输入流
Reader
字符输出流
Writer
Writer
OutputStreamWriter:字符输出流是以字节流加上编码表得到的一个转换流，后期写数据的时候可以
根据自己指定的编码进行写入
public OutputStreamWriter(OutputStream out)
创建一个使用默认字符编码的OutputStreamWriter。根据默认的编码用字符作为桥梁将字节流的数据
转换成字符流
public OutputStreamWriter(OutputStream out,String charsName)
根据指定的编码用字符作为桥梁将字节流的数据转换为字符流
把字节流转化字符流
字符流 = 字节流 + 编码表
*/
public class OutputStreamWriterDemo1 {
public static void main(String[] args) throws Exception {
//1、创建字符输出流对象
// OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("aaa.txt"));
// OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("bbb.txt"),"GBK");
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("ccc.txt"), "GBK");
osw.write("中国");
//释放资源
osw.close();
}
}
------------------------------------------------------------------------------------------------------------------------------
十二、OutputStreamWriterDemo2
package com.shujia.lhw.day23;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
/*
OutputStreamWriter写数据的方法：
public void write(int c)
public void write(char[] cbuf)
public void write(char[] cbuf,int odd,int len)
public void write(String str)
public void write(String str,int off,int len)
flush()和close()的区别：
1、调用完flush()后，流对象没有关闭，还能继续写数据
2、调用完close()后，流对象关闭了，后续无法再通过这个对象写数据
*/
public class OutputStreamWriterDemo2 {
public static void main(String[] args) throws Exception{
//1、创建字符输出流对象
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("ddd.txt"));
//写数据
//public void write(int c)写一个字符
// osw.write(99);
// osw.write('a');
//现象，我们在把close去掉之后，发现数据没有写入到数据中
//原因
//文件实际上在硬盘存储的是字节，需要手动转换一下进行存储
//void flush()
//刷新流
// osw.flush();
// osw.write();
//public void write(char[] cbuf)写一个字符数组
char[] chars = {'a','b','c','d','e'};
osw.write(chars);
//public void write(char[] cbuf,int off,int len)写字符数组的一部分
osw.write(chars,1,3);
//public void write(String str)
osw.write("明旺和王宇真帅");
//public void write(String str,int off,int len)写字符串的一部分
osw.write("明旺和王宇真帅",3,2);
//释放资源
osw.close();//包含了flush()操作
// osw.write();
}
}
---------------------------------------------------------------------------------------------------------------------------------
十三、BufferedDemo1
package com.shujia.lhw.day23;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
/*
字符缓冲流的特殊读写方法：
BufferedWriter:
void newLine()
写一行行分隔符。行分隔符字符串由系统属性line.separator定义，并不一定是单个换行符('\n')字符
BufferedReader：
public String readLine()
读一行文字。一行被视为由换行符('\n')，回车符('\r')中的任何一个或随后的换行符终止
*/
public class BufferedDemo1 {
public static void main(String[] args) {
try {
write();
} catch (Exception e) {
e.printStackTrace();
}
try {
read();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void read() throws Exception{
//创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
//public String readLine() 一次读取一行文字
//包含行的内容的字符串，不包括任何终止字符，如果已达到流的末尾，则为null
String s = br.readLine();
System.out.println(s);
String s2 = br.readLine();
System.out.println(s2);
//用循环读取
String line = null;
while((line = br.readLine())!=null){
System.out.println(line);
}
//释放资源
br.close();
}
public static void write() throws Exception{
//创建字符流缓冲输出对象
BufferedWriter bw = new BufferedWriter(new FileWriter("a3.txt"));
for(int i=1;i<=10;i++){
bw.write("大数据"+i);
bw.write("\r\n");
bw.newLine();//根据系统写入换行符
bw.flush();
}
//释放资源
bw.close();
}
}
-------------------------------------------------------------------------------------------------------------------------
十四、BufferedInputStreamDemo1
package com.shujia.lhw.day23;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
/*
字节缓冲输入流
BufferedInputStream
*/
public class BufferedInputStreamDemo1 {
public static void main(String[] args) throws Exception {
//BufferedInputStream
//BufferedInputStream(InputStream in)
//创建一个BufferedInputStream并保存其参数，输入流in，供以后使用
// FileInputStream fis = new FileInputStream("g.txt");
// BufferedInputStream bis = new BufferedInputStream(fis);
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("g.txt"));
//
//读取数据
//一次读取一个字节
// int b = 0;
// while((b=bis.read())!=-1){
// System.out.print((char)b);
// }
System.out.println("=====================================");
byte[] bytes = new byte[1024];
int length = 0;
while((length=bis.read(bytes))!=-1){
System.out.print(new String(bytes,0,length));
}
//释放资源
bis.close();
}
}
----------------------------------------------------------------------------------------------------------------------------
十五、BufferedInputStreamDemo2
package com.shujia.lhw.day23;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
/*
字节流一次只读一个字节的时候，如果数据是中文，出现了我们看不懂的符号
*/
public class BufferedInputStreamDemo2 {
public static void main(String[] args) throws Exception{
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("g.txt"));
//读取数据
//一次读取一个字节
int b = 0;
while((b=bis.read())!=-1){
System.out.println((char)b);
}
//释放资源
bis.close();
}
}
---------------------------------------------------------------------------------------------------------------------------------
十六、BufferedOutputStreamDemo1
package com.shujia.lhw.day23;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
/*
缓冲区类（高效类）
字节缓冲输出流
BufferedOutputStream
字节缓冲输入流
BufferedInputStream
*/
public class BufferedOutputStreamDemo1 {
public static void main(String[] args) throws Exception{
//BufferedOutputStream(OutputStream out)
//创建一个新的缓冲输出流，以将数据写入指定的底层输出流
// FileOutputStream fos = new FileOutputStream("g.txt");
// BufferedOutputStream bos = new BufferedOutputStream(fos);
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("g.txt"));
//一次性写一个字节数组
bos.write("大数据".getBytes());
bos.close();
}
}
-------------------------------------------------------------------------------------------------------------------------------
十七、BufferedReaderDemo1
package com.shujia.lhw.day23;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.InputStreamReader;
/*
BufferedReader:字符缓冲输入流
从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取
可以指定缓冲区大小，或者可以使用默认大。默认值足够大，可用于大多数用途
BufferedReader(Reader in)
创建使用默认大小的输入缓冲区的缓冲字符输入流
*/
public class BufferedReaderDemo1{
public static void main(String[] args) throws Exception{
// BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("a.txt")));
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
//1、一次读取一个字符
// int ch = 0;
// while((ch=br.read())!=-1){
// System.out.println((char)ch);
// }
//2、一次读取一个字符数组
char[] chars = new char[1024];
int length = 0;
while((length=br.read(chars))!=-1){
System.out.println(new String(chars,0,length));
}
//释放资源
br.close();
}
}
------------------------------------------------------------------------------------------------------------------------------
十八、BufferedWriterDemo1
package com.shujia.lhw.day23;
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.OutputStreamWriter;
/*
字符流为了高效读写，也提供了对应的字符缓冲流
字符缓冲输出流：BufferedWriter
字符缓冲输入流：BufferedReader
BufferedWriter:
将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入
可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途。
BufferedWriter(Writer out)
创建使用默认大小的输出缓冲区的缓冲字符数输出流
*/
public class BufferedWriterDemo1 {
public static void main(String[] args) throws Exception{
// BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("a2.txt")));
BufferedWriter bw = new BufferedWriter(new FileWriter("a2.txt"));
bw.write("hello");
bw.write("\r\n");
bw.write("world");
bw.write("\r\n");
bw.write("java");
bw.write("\r\n");
bw.write("hadoop");
bw.flush();
//释放资源
bw.close();
}
}
----------------------------------------------------------------------------------------------------------------------------
十九、DataOutputStreamDemo1
package com.shujia.lhw.day23;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
/*
*/
public class DataOutputStreamDemo1 {
public static void main(String[] args) throws Exception{
//创建字节输出流操作基本数据类型数据
DataOutputStream dos = new DataOutputStream(new FileOutputStream("b3.txt"));
//写基本类型的数据
dos.writeInt(10);
dos.writeShort(5);
dos.writeByte(1);
dos.writeLong(1000L);
dos.writeFloat(12.34F);
dos.writeDouble(23.45);
dos.writeChar('a');
dos.writeBoolean(true);
//释放资源
dos.close();
}
}
--------------------------------------------------------------------------------------------------------------------------------
二十、DataInputStreamDemo1
package com.shujia.lhw.day23;
import java.io.*;
/*
读的顺序与写的顺序一致
*/
public class DataInputStreamDemo1 {
public static void main(String[] args) throws Exception{
// write();
read();
}
private static void read() throws FileNotFoundException,IOException{
DataInputStream dis = new DataInputStream(new FileInputStream("b3.txt"));
// byte b = dis.readByte();
// System.out.println(b);
// short s =dis.readShort();
// System.out.println(s);
// int i = dis.readInt();
// System.out.println(i);
int i = dis.readInt();
System.out.println(i);
short s = dis.readShort();
System.out.println(s);
byte b = dis.readByte();
System.out.println(b);
long l = dis.readLong();
System.out.println(l);
float f = dis.readFloat();
System.out.println(f);
double d = dis.readDouble();
System.out.println(d);
char ch = dis.readChar();
System.out.println(ch);
boolean bb = dis.readBoolean();
System.out.println(bb);
dis.close();
}
private static void write() throws IOException{
DataOutputStream dos = new DataOutputStream(new FileOutputStream("dos.txt"));
dos.writeByte(1);
dos.writeShort(20);
dos.writeInt(300);
dos.writeLong(4000);
dos.writeFloat(12.34f);
dos.writeDouble(12.56);
dos.writeChar('a');
dos.writeBoolean(true);
dos.close();
}
}
----------------------------------------------------------------------------------------------------------------------------
二十一、StringDemo
package com.shujia.lhw.day23;
/*
String(byte[] bytes,Charset charset)
构造一个新的String由指定用指定的字节的数组解码charset。解码
byte[] getBytes(Chars charset)
使用给定的charset将该String编码为字节序列，将结果存储到新的字符数组中。便阿门
编码：把看得懂的变成看不懂的，类似于加密
String--byte[]
解码：把看不懂的变成看得懂的，类似于解密
byte[] -- String
*/
public class StringDemo {
public static void main(String[] args) throws Exception{
String s = "你好";
//String -- byte[]
// byte[] bytes1 = s.getBytes("GBK");
// System.out.println(bytes1);
// printArray(bytes1);
byte[] bytes2 = s.getBytes("Unicode");
printArray(bytes2);
System.out.println();
//byte[]--String
String s1 = new String(bytes2,"Unicode");
System.out.println(s1);
}
private static void printArray(byte[] bytes2) {
for(byte b:bytes2){
System.out.print(b+",");
}
}
}
------------------------------------------------------------------------------------------------------------------------------
二十二、IOTest1
package com.shujia.lhw.day23;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
/*
把ArrayList集合中的字符串数据存储到文本文件
*/
public class IOTest1 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
//向集合中添加元素
list.add("hello");
list.add("world");
list.add("java");
list.add("bigdata");
BufferedWriter bw = null;
//创建字符缓冲输出流对象
try {
bw = new BufferedWriter(new FileWriter("a4.txt"));
for (String s:list){
bw.write(s);
bw.newLine();
bw.flush();
}
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
-------------------------------------------------------------------------------------------------------------------------------
二十三、IOTest2
package com.shujia.lhw.day23;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.Arrays;
/*
已知s.txt文件中由这样的一个字符串："hcexfgijkamdnoqrzstuvwybpl"
请编写程序读取数据内容，把数据排序后写入ss.txt中。
*/
public class IOTest2 {
public static void main(String[] args) throws Exception{
//创建字节缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("s.txt"));
String s = br.readLine();
br.close();
//将字符串转成字符数组
char[] chars = s.toCharArray();
//Arrays工具类中的sort方法排序
Arrays.sort(chars);
//创建字符缓冲输出流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("ss.txt"));
bw.write(chars);
bw.flush();
bw.close();
}
}
