1.30 Java周末总结①控制显示多少位小数位②读txt和写txt模拟ATM数据库

1.30 Java周末总结①控制显示多少位小数位②读txt和写txt模拟ATM数据库

一、控制显示多少位小数位

有些时候小数位数太多了，想保留多少位小数，这里介绍一种利用四舍五入保留想要的小数位数
Math.round四舍五入到整数位，所以把小数乘以整10或整百，在除以整10或整百，就得到想要的位数了

double a = 3.14159265359;
double weishu = 5;
double b = Math.pow(10,weishu);
a = Math.round(a*b)/b;

二、读txt和写txt模拟ATM数据库
在模拟ATM存取钱的时候，第二次运行就没有上一次的数据了，没有把信息储存到本地。在网上查了些txt
的读写。

经过理解之后，发现主要是以下步骤：
①载入txt的文件，主要代码是： File filename = new File（"d:/bankinfo.txt"）
②然后把文件放入文件输入流，再放入读取缓存，再用一行一行读取的方法，主要代码如下
BufferedReader reader = new BufferedReader(new FileReader(file));
String tempString = reader.readLine()；
得到每一行的数据可以打印输出，也可以把这一行的数据用正则表达式拆分出自己想要的信息。
比如我这里就是把账户名，密码和余额放一起的。

写入的时候，是先全部读在缓存中，一行一行的读取，并一行一行的写入，到最后一行为空的时候，写入
新的数据。
主要代码如下：
String temp = br.readLine()
StringBuffer buf = buf.append(temp)

以上的代码都不是很懂，不会灵活运用，但是不妨碍根据自己的需求修改。
需求分析：
1、需要n组银行的账号，密码，余额。
2、输入账号和密码的时候匹配每一行txt的账户，密码，并得到余额。
3、存取钱的时候余额需要修改

设计思路：
1、账号用随机数生成银行卡后八位，随机生成6位数密码，随机生成10万以内的余额，并且保存到txt的
一行。
2、输入账号和密码后，读取txt的每一行，每一行取出后，根据正则表达式拆分成数组，存着账户余额密
码。依次遍历看是否匹配账户，如果匹配在看是否匹配密码。登录成功返回true，并且取出余额，还有此
行的行数，用于写数据
3、余额修改时，在写txt的时候，写到账户那一行，就把账户，密码，余额重写一次，其他行也重写一次
，其他不变

缺点：
此小程序只作于模仿，和真正的数据库差很多，txt也只作于存写数据。只是算txt读写的练习
源代码如下：

package com.ATM;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;
import java.io.FileNotFoundException;
/**
 * 
 * @author YuanqiuChen
 * date 1.20-23
 *模拟一个简易ATM机
 *
 *
要求：
先做只有一个用户的：
1、ATM运行之前，准备好一个账户名、账户对应的密码和账户对应的余额，
   并且规定，ATM机初始化时默认的剩余金额是15万，最大金额容量为20万，最大取款限额为10万。
2、有一个欢迎界面
3、用户输入账号和密码，并进行验证
   如果三次输入错误，则给出提示并退出系统
   如果输入正确则显示以下菜单
   1.查询余额  2.取款  3.存款  4.退出
   提示用户选择菜单
   如果用户输入1，则显示余额;
   如果用户输入2，则提示输入要取出的金额，
       如果金额等于0，相应提示；
       如果金额不是100的倍数，则给出相应提示；
       如果金额为负数，也提示；
       如果金额输入不合法（比如输入了特殊符号或者字母），也提示；
       如果输入的金额大于该用户的余额，也要提示，
       如果输入的金额超过ATM机中的剩余金额，也要提示。
   如果选择3，则显示存款界面，提示用户放入现金:
       如果输入的金额加上ATM机中剩余的金额超过了ATM机最大金额容量，则提示用户。
   如果选择4.则直接退出系统。
 *
 */
public class ATM {

    public static void main(String[] args){
        
        ATMRunning people = new ATMRunning();
        people.welcome("中国银行");
        
        Card card1 = new Card();
        if(people.load(card1)){
            people.accountOperation(card1);
        }
        
                
    }
}

class ATMRunning{
    
    private int localMoney = 150000;    //提款机本地现有钱数量
    private int get_Money_Already = 0;    //用户今天已经取钱数
    private final int MAX_LOCAL_MONEY = 200000;    //提款机本地最多存200000
    private final int MAX_GET_MONEY = 20000;    //这次取钱最多一共取10000元
    private final int MAX_GET_SIGLE_MONEY = 5000;//单次最多取5000
    
    ATMRunning(){
        
    }
    public double getLocalMoney() {
        return localMoney;
    }

    public void setLocalMoney(int localMoney) {
        this.localMoney = localMoney;
        
    }
    
    int lineNum = 0;                    //定义查到的账户的在文本数据

库里边的行数
    
    public void welcome(String bankName){
        System.out.println("*************************************\n\n");
        System.out.println("********欢  迎  使  用   " + bankName + " ATM 机

********\n\n");
        System.out.println("*************************************\n");
        System.out.println("ATM机正在运行");
    }
    
    
    public boolean accountCheck(Card card1){
        Card[] data = new Card[10];
        for(int i = 0; i < 4; i++){
            data[i] = new Card();
        }        
        
        data[0].setAccount(1234);
        data[0].setPassword(123456);
        data[0].setMoney(31689.4);
        
        data[1].setAccount(1111);
        data[1].setPassword(111111);
        data[1].setMoney(310000);

        
        File file = new File("d:/bankinfo.txt");
        BufferedReader reader = null;
        String str1 = null;
        String[] str2 = new String[3];

        try {//以行为单位读取文件内容，一次读一整行
            reader = new BufferedReader(new FileReader(file));
            int i = 0;
            while ((str1 = reader.readLine()) != null) {
                lineNum = i++;
                str2 = splitt(str1);
                if(card1.getAccount() == Double.parseDouble(str2[0])){
                    if(card1.getPassword() == Double.parseDouble(str2

[1])){
                        card1.setMoney(Double.parseDouble(str2[2]));    

    //问题，card1变了，data还没有变
                        return true;
                    }
                }
            }
            reader.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        return false;
    }

    
    public String[] splitt(String str) {
        String strr = str.trim();
        String[] strnew = strr.split("[\\p{Space}]+");
        return strnew;
    }
    
    
    public boolean load(Card card1) { //传进来一个新的空的card类型，用户输入对其赋值，然

后和数据库进行比较，检测是否登录成功
        
        
        long account_input , password_input;  
        for(int i = 0; i < 3 ; i++){
            Scanner scan = new Scanner(System.in);    //问题 这个放前边会（输入错

误时）出错
            System.out.println("请输入卡号：");
            if(scan.hasNextLong()){                 //检测账号是

否为int型，否则跳出当次
                account_input = scan.nextLong();
                card1.setAccount(account_input);
            }else{
                if(i == 2 ){
                    System.out.println("输入错误三次，已吞卡，请联系我行

客服！");
                    return false;
                }
                System.out.println("无效账号，请重输：");
                continue;
            }
            
            System.out.println("请输入密码：");    //检测密码是否为int型，否则

跳出当次
            if(scan.hasNextInt()){
                password_input = scan.nextInt();
                card1.setPassword(password_input);
            }else{
                if(i == 2 ){
                    System.out.println("输入错误三次，已吞卡，请联系我行

客服！");
                    return false;
                }
                System.out.println("无效密码，请重输：");
                continue;
            }
            if(accountCheck(card1)){            //把用户输入的这个账

号放入数据库进行比较，返回true或者false
                System.out.println("登录成功！\n");
                return true;
            }else if(i == 2 ){
                System.out.println("输入错误三次，已吞卡，请联系我行客

服！");
                return false;
            }else{                
                System.out.println("账号或密码错误，请重输：");
            }
    
        }
        
        return false;
    }    
    
    public void accountOperation(Card card1){
        Scanner scan = new Scanner(System.in);
        while(true){
            System.out.println("1、查询余额\n2、取款\n3、存款\n4、退出\n");
            String input = scan.next();
            if(input.equals("1")){
                balanceCheck(card1);
                continue;
            }else if(input.equals("2")){
                getMoney(card1);
                balanceCheck(card1);
            }else if(input.equals("3")){
                saveMoney(card1);
            }else if(input.equals("4")){
                System.out.println("卡已退出");
                System.exit(0);
            }else{
                continue;
            }
            
        }        
    }

    public void balanceCheck(Card card1){
        System.out.println("余额为："+ card1.getMoney() + "\n");
    }
    
    public void getMoney(Card card1){
        int get_Money = 0;        //用户取钱数
        
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入取款金额\n1、100元\n2、300元\n3、500元\n4、1000元

\n5、2000元\n6、输入金额\n");
        String input = scan.next();
        
        if(input.equals("1") || input.equals("2") || input.equals("3") || 

input.equals("4") || input.equals("5") ){
            double num = Double.parseDouble(input);
            int num1 = (int)num;
            switch(num1){
            case 1 : get_Money = 100;break;
            case 2 : get_Money = 300;break;
            case 3 : get_Money = 500;break;
            case 4 : get_Money = 1000;break;
            case 5 : get_Money = 2000;break;
            }

            if(card1.getMoney() < get_Money){
                System.out.println("余额不足");
            }else if(get_Money_Already + get_Money > MAX_GET_MONEY){
                System.out.println("本机每天最多取" + MAX_GET_MONEY);
            }else if(localMoney < get_Money){
                System.out.println("本机已无那么多钱");
            }else{
                card1.setMoney((card1.getMoney()-get_Money));    //改变余额
                
                
                //在文本信息里写入余额变化
                WriteInfo write = new WriteInfo();
                try {
                    write.creatTxtFile();
                    write.writeTxtFile(lineNum,card1);   
                } catch (IOException e) {
                    e.printStackTrace();
                }
                
                localMoney = (int)(localMoney - get_Money);        //改

变本机金额
                get_Money_Already += get_Money;
                System.out.println(get_Money + "元已出，请在规定时间取钱");
                System.out.println(get_Money_Already);
            }

            
            
        }else if(input.equals("6") ){
            System.out.println("请取钱输入金额：");
            if(scan.hasNextDouble()){
                input = scan.next();
                get_Money = (int)(Double.parseDouble(input));

                if(get_Money < 0){
                    System.out.println("输入错误，请输入整百数");    //输

入的是负数等    
                }else if(get_Money_Already + get_Money > MAX_GET_MONEY){
                    System.out.println("本机每天最多取" + 

MAX_GET_MONEY);
                }else if(get_Money % 100 != 0){
                    System.out.println("输入的不是整百数");    
                }else if(card1.getMoney() < get_Money){
                    System.out.println("余额不足");
                }else if(get_Money > MAX_GET_SIGLE_MONEY){
                    System.out.println("每次最多取" + 

MAX_GET_SIGLE_MONEY);
                }else if(get_Money > localMoney){
                    System.out.println("本机金额余量不足，请重新输入");
                }else{
                    card1.setMoney((card1.getMoney()-get_Money));
                    
                    //把余额信息写入文本信息
                    WriteInfo write = new WriteInfo();
                    try {
                        write.creatTxtFile();
                        write.writeTxtFile(lineNum,card1);   
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    
                    localMoney = (int)(localMoney - get_Money);
                    get_Money_Already += get_Money;
                    System.out.println(get_Money_Already);
                    System.out.println(get_Money + "元已出，请在规定时间

取钱");
                }
                
            }else{
                System.out.println("输入错误，请输入整百数");//输入的是字母

或者其他字符
            }    
        }
    }
    
    public void saveMoney(Card card1){
        Scanner scan = new Scanner(System.in);
        String input;
        double save_Money = 0;
        
        System.out.println("请输入存钱金额：");
        if(scan.hasNextDouble()){
            input = scan.next();
            save_Money = Double.parseDouble(input);
            if(save_Money > 0){
                if(save_Money % 100 == 0){
                    if(save_Money + localMoney <= MAX_LOCAL_MONEY){
                        System.out.println("请将纸币整齐的放入存钱口

");
                        //等待存钱，并且检测真假币
                        card1.setMoney(card1.getMoney() + 

save_Money);
                        
                        
                        //把余额信息写入文本信息
                        WriteInfo write = new WriteInfo();
                        try {
                            write.creatTxtFile();
                            write.writeTxtFile(lineNum,card1);   
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                        
                        
                        localMoney = (int)(localMoney + save_Money);
                        System.out.println("...   ...   ...");
                        System.out.println("钱已存入!\n");
                    }else{
                        System.out.println("大于本机最大可收取存钱数

，请减小存钱数");
                    }
                }else{
                    System.out.println("本机只能存整百数");
                }
            }else{
                System.out.println("存钱金额错误，请输入整百数");    //输

入的是负数等
            }
        }else{
            System.out.println("输入错误，请输入整百数");//输入的是字母或者其他

字符
        }    
    }
}

package com.ATM;

public class Card{
    private long account ;
    private long password ;
    private double money ;
    
    public Card(){
        
    }
    
    
    public long getAccount() {
        return account;
    }
    public void setAccount(long account) {
        this.account = account;
    }
    public long getPassword() {
        return password;
    }
    public void setPassword(long password) {
        this.password = password;
    }
    public double getMoney() {
        return money;
    }
    public void setMoney(double money) {
        this.money = money;
    }
    
}

package com.ATM;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

public class WriteInfo {
    private static String filenameTemp = "d:/bankinfo.txt";
    
    public WriteInfo(){
        
    }
    
//    public static void main(String[] args) {
//        Card card1 = new Card();
//        card1.setAccount(1234);
//        card1.setPassword(123456);
//        card1.setMoney(31689.4);
//        
//        WriteInfo write = new WriteInfo();
//        try {
//            write.creatTxtFile();
//            write.writeTxtFile(3,card1);
//            
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
//    }

    
    //创建文件
    
    public static boolean creatTxtFile() throws IOException {
        boolean flag = false;
        File filename = new File(filenameTemp);
        if (!filename.exists()) {
            filename.createNewFile();
            flag = true;
        }
        return flag;
    }

    public static boolean writeTxtFile(int num,Card card1) throws IOException {
        // 先读取原有文件内容，然后进行写入操作
        boolean flag = false;
        String filein = card1.getAccount() + "\t" + card1.getPassword() + "\t" + 

card1.getMoney();
//        filein = "111111    111111    1000000";
        String temp = "";

        FileInputStream fis = null;
        InputStreamReader isr = null;
        BufferedReader br = null;

        FileOutputStream fos = null;
        PrintWriter pw = null;
        try {
            // 文件路径
            File file = new File(filenameTemp);
            // 将文件读入输入流
            fis = new FileInputStream(file);
            isr = new InputStreamReader(fis);
            br = new BufferedReader(isr);
            StringBuffer buf = new StringBuffer();

            // 保存该文件原有的内容
            for (int j = 0; (temp = br.readLine()) != null; j++) {
                
                
                if(j != num){
                    buf = buf.append(temp);
                    buf = buf.append(System.getProperty("line.separator"));
                }else{
                    temp = filein;
                    buf = buf.append(temp);
                    buf = buf.append(System.getProperty("line.separator"));
                }
                
                // System.getProperty("line.separator")
                // 行与行之间的分隔符 相当于“\n”
            }
//            buf.append(filein);//写入

            fos = new FileOutputStream(file);
            pw = new PrintWriter(fos);
            pw.write(buf.toString().toCharArray());
            pw.flush();
            flag = true;
        } catch (IOException e1) {
            // TODO 自动生成 catch 块
            throw e1;
        } finally {
            if (pw != null) {
                pw.close();
            }
            if (fos != null) {
                fos.close();
            }
            if (br != null) {
                br.close();
            }
            if (isr != null) {
                isr.close();
            }
            if (fis != null) {
                fis.close();
            }
        }
        return flag;
    }

}