有关IO流的一些练习

练习1:

文本之间的复制（五种方法）：

方法1、2：

package com.westos.BufferedDome;
 
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
 
public class CopyDome {
 
public static void main(String[] args) throws Exception {

InputStreamReader isr=new InputStreamReader(new FileInputStream( "file.txt"));
OutputStreamWriter isw=new OutputStreamWriter(new FileOutputStream( "c.txt"));

/*//方式1：基本的字符流一次读取一个字节
int len=0;
while((len=isr.read())!=-1) {
isw.write(len);
}*/

//方式2：一次读取一个数组
char[] ch=new char[1024];
int len =0;
while((len=isr.read(ch))!=-1) {
isw.write(ch,0, len);
}

//关闭资源
isr.close();
isw.close();
}
}

方式3、4：

package com.westos.BufferedDome;
 
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
 
public class CopyDome2 {
 
public static void main(String[] args) throws Exception {

//创建字符缓冲输入输出流对象
BufferedReader br=new BufferedReader(new FileReader("File.txt"));
BufferedWriter bw=new BufferedWriter(new FileWriter("d.txt"));

/*//方式3：一次读取一个数据
int len=0;
while((len=br.read())!=-1) {
bw.write(len);
bw.flush(); }*/

//方式4：一次读取一个数组
char[] ch=new char[1024];
int len=0;
while((len=br.read(ch))!=-1) {
bw.write(ch,0,len);
bw.flush();
}
//关闭资源
br.close();
bw.close();
}
}

方式5：

package com.westos.BufferedDome;
 
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
 
public class CopyDome3 {
 
public static void main(String[] args) throws Exception {

//创建字符缓冲输入输出流对象
BufferedReader br=new BufferedReader(new FileReader("File.txt"));
BufferedWriter bw=new BufferedWriter(new FileWriter("d.txt"));

//方式5：一次获取一行
String str = null;
while((str=br.readLine())!=null) {
bw.write(str);
bw.newLine();
bw.flush();
}

//关闭资源
br.close();
bw.close();
}
}

练习2：

将ArrayList集合中的元素写在文本中：

package com.westos.BufferedDome;
 
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
 
//需求：把ArrayList集合中的字符串数据存储到文本文件
public class ArrayListToFileDome {
 
public static void main(String[] args) throws IOException {

//创建一个ArrayList集合对象
ArrayList<String> list=new ArrayList<String>();

//创建字符缓冲输出流对象
BufferedWriter bw=new BufferedWriter(new FileWriter("e.txt"));

//向集合中添加元素
list.add("两只老虎，");
list.add("两只老虎，");
list.add("跑的块，");
list.add("跑的块");

//遍历集合
for(String s:list) {
bw.write(s);
bw.newLine();
bw.flush();
}

bw.close();
}
}

将文本中的数据添加到ArrayList集合中：

package com.westos.BufferedDome;
 
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
 
//需求:有一个文本文本,需要将文本文件中的内容放到ArrayList集合中,遍历集合获取元素 
public class FileToArrayListDome {
 
public static void main(String[] args) throws IOException {

//创建一个ArrayList集合对象
ArrayList <String> list=new ArrayList <String>();

//创建一个字符缓冲输出流
BufferedReader br=new BufferedReader(new FileReader("e.txt"));

//一次读取一行
String st=null;
while((st=br.readLine())!=null) {
list.add(st);
}

//关闭资源
br.close();

//循环遍历
for(String s:list) {
System.out.println(s);
}

}
}

练习3：

需要将一个文本中的元素随机的读取一个出来（就是随机点一个人的名字）

思路：

1)封装一个文本文件:使用字符缓冲输入流读文件

2)创建一个ArrayList<String>

3)使用字符缓冲输入流readLine(),一次读取一行,就将该行数据添加到集合中

4)创建Random类对象

5)Random类对象.nextInt(集合对象.size()) ;

6)通过角标get(int index ):获取内容

例如：

package com.westos.test;
 
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Random;
 
public class TestDome {
 
public static void main(String[] args) throws IOException {
//创建一个字符缓冲输入流对象
BufferedReader br=new BufferedReader(new FileReader("a.txt"));

//创建一个ArrayList集合对象
ArrayList<String> list=new ArrayList<String>();

//一次读取一行
String str=null;
while((str=br.readLine())!=null) {
list.add(str);
}
//关闭资源
br.close();

//创建Random类对象
Random r=new Random();
int index = r.nextInt(list.size());
String s = list.get(index);
System.out.println("被抽取到的人是："+s);
}
}

练习4：

运用流的方式 ：写一个程序实现在测试类中将一个猜数字小游戏的程序只能用5次，超过5次提示：游戏试玩已结束，请付费。

例如：

package com.westos.PropertiesTest;
 
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
 
/**
 * 需求:
 * 我有一个猜数字小游戏的程序，请写一个程序实现在测试类中只能用5次，
 * 超过5次提示：游戏试玩已结束，请付费。
 * 思路：
 * 1）创建一个file文本，里面有键值对cou=0(代表玩的次数为0)
 * 2）创建字符输入流对象，来读取文本的内容
 * 3）创建属性集合类对象（作用是通过load（）方法可以将文本的内容传入到集合类中）
 * 4）因为Properties是继承hashtable集合，所以可以调用Map集合中的方法，遍历集合中键值对，判断次数超过五次与五次内的输出
 * 5）创建字符输出流，将集合类中的元素传入到文本中
 */
猜字小游戏的程序：
 
package com.westos.PropertiesTest;
 
import java.util.Scanner;
 
public class GuessNumber {
 
//创建该类的私有无参构造
private GuessNumber() {

}

//创建猜字小游戏方法
public static void GuessNumberGame() {
//初始化要猜的次数为0
int count=0;
//获取一百以内的随机数,运用Math类中的Random（）方法,需要进行强制转换成int类型
int num=(int)(Math.random()*100+1);
while(true) {
//键盘录入要猜的数字
Scanner sc=new Scanner(System.in);
System.out.println("请输入您要猜测的数字...");
int number = sc.nextInt();
//每键盘输入一次，count+1
count++;
//进行判断
if(number>num) {
System.out.println("您猜的有点偏大哦...");
}else if(number<num) {
System.out.println("您猜的有点偏小哦...");
}else {
System.out.println("恭喜您在猜了"+count+"次后猜对了...");
break;
}
}
}
}

测试类：

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

//创建字符输入流对象
FileReader fr=new FileReader("a.txt");

//创建一个属性集合类对象
Properties pro=new Properties();
//将文本内容添加到集合类中
pro.load(fr);
//关闭资源
fr.close();
//获取集合类中的值,键就是文本中（count=0）初始化的count，值就是0但是不确定还在改变
String str = pro.getProperty("count");
//需要将number的String类型转变成int类型
int number = Integer.parseInt(str);
//判断次数是否超过了五次
if(number>5) {
System.out.println("游戏试玩结束，请充值...");
//直接退出
System.exit(0);
}else {
//每玩一次，次数+1
number++;
//这时number的值发生了改变，需要将改变的值添加到集合类中
//因为Properties类中的setProperty（）方法添加的元素被系统强制定为String类型，所以需要再将number的int类型转变成String类型
String s = String.valueOf(number);
pro.setProperty("count", s);
//创建字符输出流
FileWriter fw=new FileWriter("a.txt");
//用Properties类中store方法将集合类中元素添加到文本中
pro.store(fw, "game'content");
//关闭资源
fw.close();
//调用猜字小游戏
GuessNumber.GuessNumberGame();
}
}
}

练习5：用IO流的方式去模拟用户注册、登录

先创建一个用户实体类：

package com.westos.regist_login.entity;
 
/**
 * @author 杰哥
 *这里是用户类
 */
public class User {
 
/*//私有化该类的无参构造
private User() {

}*/

//定义属性
private String username;
private String password;


public User() {
super();
}
 
public String getUsername() {
return username;
}
 
public void setUsername(String username) {
this.username = username;
}
 
public String getPassword() {
return password;
}
 
public void setPassword(String password) {
this.password = password;
}
 
public User(String username, String password) {
super();
this.username = username;
this.password = password;
}

}

再创建一个接口去写入登录和注册方法

package com.westos.regist_login.Dao;
 
import com.westos.regist_login.entity.User;
 
/**
 * @author 杰哥
 *这里是用户接口的注册和登录方法
 */
public interface UserDao {
 
//注册方法
public abstract void regist(User user);

//登录方法
public abstract boolean login(String username,String password);
}

再创建一个子实现类去实现接口中的注册、登录方法

package com.westos.regist_login.Dao_impl;
 
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
 
import com.westos.regist_login.Dao.UserDao;
import com.westos.regist_login.entity.User;
 
/**
 * @author 杰哥
 *该类是为了实现UserDao接口中的方法
 */
 
public class UserDaoImpl implements UserDao {

//创建一个文本
private static File file=new File("user.txt");
//静态代码块
 static{
if(file!=null) {
try {
file.createNewFile();
} catch (IOException e) {
// e.printStackTrace();
System.out.println("文本创建失败了...");
}
}
}
/**
 *实现注册方法
 */
@Override
public void regist(User user) {
BufferedWriter bw=null;
//创建一个字符输出流对象,向文本中写入注册时的用户名和密码
 try {
bw=new BufferedWriter(new FileWriter(file,true));
bw.write(user.getUsername()+"="+user.getPassword());
bw.newLine();
bw.flush();
} catch (IOException e) {
// e.printStackTrace();
System.out.println("注册失败...");
}finally {
if(bw!=null) {
try {
bw.close();
} catch (IOException e) {
// e.printStackTrace();
System.out.println("注册时释放资源失败...");
}
}
}
}
 
/**
 * 实现登录方法
 */
@Override
public boolean login(String username, String password) {
//初始化登录失败
boolean flag=false;
BufferedReader br=null;
//创建字符缓冲输出流对象
 try {
br=new BufferedReader(new FileReader(file));
//一次读取一行
String str=null;
while((str=br.readLine())!=null) {
//split方法返回的是字符串数组
String[] split = str.split("=");
//判断 
if(split[0].equals(username)&&split[1].equals(password)) {
flag=true;
break;
}
}
} catch (FileNotFoundException e) {
// e.printStackTrace();
System.out.println("读取文本失败...");
} catch (IOException e) {
// e.printStackTrace();
System.out.println("登录失败...");
}finally {
if(br!=null) {
try {
br.close();
} catch (IOException e) {
// e.printStackTrace();
System.out.println("登录时释放资源失败...");
}
}
}
 return flag;
}
}

最后写一个测试类去运行

package com.westos.Test;
 
import java.util.Scanner;
 
import com.westos.regist_login.Dao.UserDao;
import com.westos.regist_login.Dao_impl.UserDaoImpl;
import com.westos.regist_login.entity.User;
 
public class UserTest {
 
public static void main(String[] args) {
//通过多态创建接口子实现类的对象
UserDao ud=new UserDaoImpl();
//创建键盘录入
Scanner sc=new Scanner(System.in);
while(true) {
System.out.println("欢迎光临，请选择以下选项");
System.out.println("1:注册");
System.out.println("2:登录");
System.out.println("3:退出");

String number = sc.nextLine();
switch(number) {
case "1":
System.out.println("------------------欢迎进入注册页面--------------------");
System.out.println("请输入您的用户名：");
String name=sc.nextLine();
System.out.println("请输入您的密码：");
String word = sc.nextLine();
//创建User类对象，并将键盘录入的元素添加到User类中
User user=new User(name,word);
//调用接口中的注册方法
ud.regist(user);
System.out.println("恭喜您，注册成功...");
break;
case "2":
System.out.println("--------------------欢迎进入登录页面--------------------");
System.out.println("请输入您的用户名：");
String name2=sc.nextLine();
System.out.println("请输入您的密码：");
String word2 = sc.nextLine();
//调用接口中的登录方法
boolean login = ud.login(name2, word2);
if(login) {
System.out.println("恭喜您，登录成功...");
System.exit(0);
}else {
System.out.println("您输入的信息有误，请重新输入...");
}
break;
case "3":
default:
System.out.println("欢迎您下次再来..."); 
System.exit(0);
}
}
}
}

有关IO流的一些练习

猜你喜欢