java IO 在实际开发项目中的应用 java io例子

转载

mob64ca1403528a 2024-05-31 00:45:34

文章标签 java IO 在实际开发项目中的应用 java 数据 System 字符串 文章分类 Java 后端开发

JavaIO编程案例

数字大小比较

题目：输入三个整数，求最大值和最小值
若想进行数字输入处理，应可以保证输入错误时可以重新输入，为了可以达到重用的设计，应该准备一个单独的输入数据类。

定义一个输入工具类

import java.util.Scanner;

public class InputUtil {
	private InputUtil() {}
	/**
	 * 实现键盘接收数字
	 * @param promot 提示信息
	 * @return 可以使用的数字
	 */
	public static int getInt(String promot) {
		int num = 0;
		boolean flag = true;
		while(flag){
			Scanner Input = new Scanner(System.in);
			System.out.println(promot);
			if(Input.hasNext("\\d+")) {
				flag = false;
				num = Integer.parseInt(Input.next());
			} else {
				System.out.println("输入错误！");
			}
		}
		return num;
	}
}

定义接口

interface INumberService{
	/**
	 * 输入数据并且返回数据最大/最小值
	 * @param count 输入数据个数
	 * @return 最大/最小值
	 */
	public int[] stat(int count);
}

接口实现子类

class NumberServiceImpl implements INumberService{
	@Override
	public int[] stat(int count) {
		int result[] = new int[2];		//返回结果数组
		int data[] = new int[count];	//存放输入数据
		for(int x=0;x<data.length;x++) {
			data[x] = InputUtil.getInt("请输入第"+ (x+1)+"个数字！");
		}
		result[0] = data[0];		//最大值
		result[1] = data[0];		//最小值
		for(int x=0; x<data.length;x++) {
			if(data[x]>result[0]) {
				result[0] = data[x];
			}
			if(data[x]< result[1]) {
				result[1] = data[x];
			}
		}
		return result;
	}
}

定义工厂类获取接口对象

class Factory{
	private Factory() {}
	public static INumberService getInstance() {
		return new NumberServiceImpl();
	}
}

编写测试程序

public static void main(String[] args) {
		INumberService numberService = Factory.getInstance();
		int result[] = numberService.stat(3);
		System.out.println("max:"+ result[0] + " min:"+ result[1]);
	}

文件保存

题目：从键盘输入文件的内容和要保存的文件名称，根据名称创建文件并保存内容
本程序中只要求开发者保存文件名称并没有设置文件路径，则应准备好文件路径。

定义文件服务接口

interface IFileService{
	/**
	 * 定义文件保存处理方法
	 * @return 保存成功返回true
	 */
	public boolean save();
}

输入字符串处理方法类

public static String getString(String prompt) {
		String str = null;
		boolean flag = true;
		while(flag) {
			System.out.println(prompt);
			try {
				str = INPUT.readLine();
				if(!"".equals(str)) {
					flag = false;
				} else {
					System.out.println("输入不得为空！");
				}
			} catch (IOException e) {
				// TODO: handle exception
				e.printStackTrace();
				System.out.println("输入不得为空！");
			}
		}
		return str;
	}

整体代码

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintWriter;

import IO_Example.InputUtil;		//见NumberComparable

@SuppressWarnings("unused")
interface IFileService{
	public static final String SAVE_DIR = "C:"+File.separator+ "Project"+File.separator+"Java_study"+File.separator+"src"+File.separator+"文件";
	/**
	 * 定义文件保存处理方法
	 * @return 保存成功返回true
	 */
	public boolean save();
}

class FileServiceImpl implements IFileService{
	private String title;
	private String content;
	public FileServiceImpl() {
		this.title = InputUtil.getString("请输入文件名称！");
		this.content = InputUtil.getString("请输入文件内容！");
	}
	@Override
	public boolean save(){
		File file = new File(IFileService.SAVE_DIR + this.title);
		PrintWriter out = null;
		try {
			out = new PrintWriter(new FileOutputStream(file));
			out.print(this.content);
			out.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
			return false;
		} finally {
			out.close();
		}
		return true;
	}
}

class Factory_File{
	public static IFileService getInstance() {
		return new FileServiceImpl();
	}
}

public class File_Save {
	
	static {		//项目启动时该路径应首先创建
		File file = new File(IFileService.SAVE_DIR);
		if(!file.exists()) {
			file.mkdirs();
		}
	}
	public static void main(String[] args) {
		IFileService fileService = Factory_File.getInstance();
		System.out.println(fileService.save());
	}
}

字符串逆序显示

题目：从键盘传入多个字符串到程序中，并将他们按逆序输出到屏幕上。
本程序之中考虑到如下几种设计：

既然字符串的内容可以随时修改，最好建立一个StringBuffer做保存；
在进行数据处理的时候应该由用户自己决定是否继续输入；

定义字符串操作接口

interface IStringService{
	public void append(String str);		//追加数据
	public String[] reverse();		//翻转
}

实现子类里面使用StringBuffer

class StringServiceImple implements IStringService{
	public StringBuffer data = new StringBuffer();
	@Override
	public void append(String str) {
		this.data.append(str).append("|");
	}
	@Override
	public String[] reverse() {
		String result[] = this.data.toString().split("\\|");
		int center = result.length/2;
		int head = 0;
		int tail = result.length - 1;
		for(int x=0; x<center; x++) {
			String temp = result[head];
			result[head] = result[tail];
			result[tail] = temp;
		}
		return result;
	}
}

定义工厂类

class Factory_String{
	private Factory_String() {};
	public static IStringService getInstance() {
		return new StringServiceImple();
	}
}

定义一个Menu处理类，采用交互式界面形式完成处理。

class Menu{
	private IStringService stringService;
	public Menu() {
		this.stringService = Factory_String.getInstance();
		this.choose();
	}
	public void choose() {
		this.show();
		String choose = InputUtil.getString("请进行选择");
		switch (choose) {
		case "1":{		//接收输入数据
			String str = InputUtil.getString("请输入字符串数据");
			this.stringService.append(str);
			choose();		//重复出现
		}
		case "2":{
			//String str = InputUtil.getString("请输入字符串数据");
			String result[] = this.stringService.reverse();
			System.out.println(Arrays.toString(result));
			choose();
		}
		case "0":{
			System.out.println("bye");
			System.exit(1);
		}
		default :{
			System.out.println("非法选项！");
			choose();
		}
	}
	}
	public void show() {
		System.out.println("[1]追加字符串数据");
		System.out.println("[2]逆序显示所有字符串数据");
		System.out.println("[0]结束程序执行");
		System.out.println("\n\n");		
	}
}

编写测试

public static void main(String[] args) {
		new Menu();
	}

数据排序处理

题目：从键盘输入以下数据：TOM:89|JERRY:90|TONY:95，数据格式为：姓名：成绩，对输入内容按成绩排序（高-低）
对于排序处理肯定使用Comparable接口完成，同时利用Arrays类来完成处理，此时数据显示需要键盘输入。

建立Student程序类并且进行排序规则配置

class Student implements Comparable<Student>{
	private String name;
	private double score;
	public Student(String name, double score) {
		super();
		this.name = name;
		this.score = score;
	}
	@Override
	public int compareTo(Student o) {
		if(this.score > o.score) {
			return -1;
		} else if(this.score < o.score) {
			return 1;
		} else {
			return 0;
		}
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", score=" + score + "]";
	}
}

建立数据输入处理（牵扯到拆分操作）

interface IStudentService{
	public Student[] getData();
}

class StudentServiceImpl implements IStudentService{
	private String content;
	private Student[] students;
	public StudentServiceImpl(String content) {
		this.content = content;
		this.handle();		//进行数据处理
	}
	private void handle() {		//进行字符串数据处理
		String result[] = this.content.split("\\|");
		this.students = new Student[result.length];
		for(int x=0; x< result.length; x++) {
			String temp[] = result[x].split(":");
			this.students[x] = new Student(temp[0] , Double.parseDouble(temp[1]));
		}
	}
	@Override
	public Student[] getData() {
		Arrays.sort(this.students);
		return this.students;
	}
}

class Factory_Student{
	private Factory_Student() {};
	public static IStudentService getInstance() {
		return new StudentServiceImpl(InputUtil.getString("请输入数据信息。"));
	}
}

编写测试类

public class Data_Comparable {
	public static void main(String[] args) {
		System.out.println(Arrays.toString(Factory_Student.getInstance().getData()));
	}
}

数据排序处理深入（有问题）

题目：将上一题中内容进行扩展，将全部输入信息保存在文件中且还可以添加信息，并可以显示全部的数据

如果此时要进行内容的保存，首先一定要确认好所有输入数据的保存位置；
所有数据之间要想沿用之前的设计结构，则数据文件里面的保存应做到格式统一，即：姓名|成绩的形式进行存储，而在数据添加时可添加两个数据：“单独的内容”，“一组数据”；
暂时不考虑数据过大的问题。

设置文件处理类，该类提供数据追加以及读取

class FileUtil{
	public static String load(File file) {
		Scanner scan = null;
		try {
			scan = new Scanner(file);		//文件加载
			if(scan.hasNext()) {
				String str = scan.next();		//获取数据
				return str;
			}
			return null;
		} catch(Exception e) {
			e.printStackTrace();
			return null;
		} finally {
			if(scan != null) {
				scan.close();
			}
		}
		
	}
	public static boolean append(File file,String content) {
		PrintStream out = null;
		try {
			out = new PrintStream(new FileOutputStream(file, true));
			out.print(content);		//内容追加
			return true;
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return false;
		} finally {
			if(out != null) {
				out.close();
			}
		}
	}
}

扩充IStudentService操作方法；

class StudentServiceImpl implements IStudentService{
	private static final File SAVE_FILE = new File("C:\\Project\\Java_study\\src\\文件\\test_inner.txt");
	private String content;
	private Student[] students;
	public StudentServiceImpl() {
		this.content = FileUtil.load(SAVE_FILE);		//读取已有数据内容
		this.handle();		//进行数据处理
	}
	private void handle() {		//进行字符串数据处理
		String result[] = this.content.split("\\|");
		this.students = new Student[result.length];
		for(int x=0; x<result.length; x++) {
			String temp[] = result[x].split(":");
			this.students[x] = new Student(temp[0] , Double.parseDouble(temp[1]));
		}
	}
	@Override
	public void append(String str) {
		// TODO Auto-generated method stub
		if(str.startsWith("|")) {
			str.substring(1);		//截取后面的部分
		}
		if(!str.endsWith("|")) {
			str = str + "|";		//与后面数据进行分割
			FileUtil.append(SAVE_FILE, str);		//数据追加
		}
	}
	@Override
	public Student[] getData() {
		Arrays.sort(this.students);
		return this.students;
	}
}

工厂类不再需要输入数据

public class Factory_Inner {
	private Factory_Inner() {}
	public static IStudentService getInstance(){
		return new StudentServiceImpl();
	}
}

奇偶数统计

题目：编程程序运行后，根据提示输入一个数字字符串，统计奇偶数数量
本质流程就是每一个字符串的拆分，而后进行数字的转换处理。

定义INumberService_1接口，进行数字处理服务。

public interface INumberService_1 {	
	public int[] stat();
}

定义接口子类

public class INumberServiceImp implements INumberService_1 {

	@Override
	public int[] stat() {
		int stat[] = new int[] {0,0};		//第一个为偶数，第二个为基数
		String str = InputUtil.getString("请输入数字信息！");
		String result[] = str.split("");		//按照每个字符拆分
		for(int x=0;x<result.length;x++) {
			if(Integer.parseInt(result[x]) % 2 ==0 ) {
				stat[0]++;
			} else {
				stat[1]++;
			}
		}
		return stat;
	}
}

建立工厂类

public class Factory_Inner {
	private Factory_Inner() {}
	public static INumberService_1 getInstance(){
		return new INumberServiceImp();
	}
}

定义主类调用程序

import java.util.Arrays;

public class jiou {

	public static void main(String[] args) {
		System.out.println(Arrays.toString(Factory_Inner.getInstance().stat()));
	}
}

用户登录

题目：完成登录程序，从命令行输入用户名和密码，如果没有输入用户名和密码，则提示输入用户名和密码；若仅输入了用户名提示用户输入密码。判断用户名为lyz，密码为hello，若正确提示成功，错误则显示登录失败，连续3次输入错误系统退出。
对于此事程序可以将用户名和密码同时输入，也可以先输入用户名后输入密码，超过此事则结束。用户名/密码的形式完成输入，若没有/表示没有输入密码。

定义用户操作接口

package IO_Example.User_log;

public interface IUserService {
	public boolean isExit();
	public boolean login(String name,String password);
}

定义操作接口子类

package IO_Example.User_log;


public class UserServiceImpl implements IUserService {
	private int count = 0;		//登录统计
	@Override
	public boolean isExit() {
		return this.count >= 3;		//执行登录退出的条件
	}

	@Override
	public boolean login(String name, String password) {
		return "lyz".equals(name) && "hello".equals(password);
	}
}

对于登录失败检测处理应该单独定义一个用户代理操作类。

package IO_Example.User_log;

import IO_Example.*;

public class UserServiceProxy implements IUserService {
	private IUserService userService;
	public UserServiceProxy(IUserService userService) {
		this.userService = userService;
	}
	@Override
	public boolean isExit() {
		return this.userService.isExit();
	}
	@Override
	public boolean login(String name, String password) {
		while(!this.isExit()) {		//不进行退出
			String inputData = InputUtil.getString("请输入登录信息");
			if(inputData.contains("/")) {
				String temp[] = inputData.split("/");
				if(this.userService.login(temp[0], temp[1])) {
					return true;		//循环结束
				} else {
					System.out.println("登录失败，错误的用户名或密码！");
				}
			} else {
				String pwd = InputUtil.getString("请输入密码");
				if(this.userService.login(inputData, pwd)) {
					return true;
				} else {
					System.out.println("登录失败，错误的用户名或密码！");
				}
			}
		}
		return false;
	}
}

设计工厂类定义

package IO_Example.User_log;

public class Factory {
	private Factory() {};
	public static IUserService getInstance() {
		return new UserServiceProxy(new UserServiceImpl());
	}
}

编写测试类

package IO_Example.User_log;

public class main {

	public static void main(String[] args) {
		System.out.println(Factory.getInstance().login(null, null));
	}

}

*注：*真实业务只实现核心功能，辅助逻辑处理交给代理控制。