Java基础-22总结登录注册IO版,数据操作流,内存操作流,打印流,标准输入输出流,

1:登录注册IO版本案例(掌握)

要求,对着写一遍。

 cn.itcast.pojo User
 cn.itcast.dao UserDao
 cn.itcast.dao.impl UserDaoImpl(实现我不管)
 cn.itcast.game GuessNumber
 cn.itcast.test UserTest
package cn.itcast.pojo;(1)
/**
 * 这是用户基本描述类
 * 
 * @author 风清扬
 * @version V1.1
 * 
 */
public class User {
 // 用户名
 private String username;
 // 密码
 private String password;
 public User() {
 }
 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;
 }
}
package cn.itcast.dao;(2)
import cn.itcast.pojo.User;
/**
 * 这是针对用户进行操作的接口
 * 
 * @author 风清扬
 * @version V1.1
 * 
 */
public interface UserDao {
 /**
  * 这是用户登录功能
  * 
  * @param username
  *            用户名
  * @param password
  *            密码
  * @return 返回登录是否成功
  */
 public abstract boolean isLogin(String username, String password);
 /**
  * 这是用户注册功能
  * 
  * @param user
  *            要注册的用户信息
  */
 public abstract void regist(User user);
}
package cn.itcast.dao.impl;(3)
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 cn.itcast.dao.UserDao;
import cn.itcast.pojo.User;
/**
 * 这是用户操作的具体实现类(IO版)
 * 
 * @author 风清扬
 * @version V1.1
 * 
 */
public class UserDaoImpl implements UserDao {
 // 为了保证文件一加载就创建
 private static File file = new File("user.txt");
 static {
 try {
 file.createNewFile();
 } catch (IOException e) {
 System.out.println("创建文件失败");
 // e.printStackTrace();
 }
 }
 @Override
 public boolean isLogin(String username, String password) {
 boolean flag = false;
 BufferedReader br = null;
 try {
 // br = new BufferedReader(new FileReader("user.txt"));
 br = new BufferedReader(new FileReader(file));
 String line = null;
 while ((line = br.readLine()) != null) {
 // 用户名=密码
 String[] datas = line.split("=");
 if (datas[0].equals(username) && datas[1].equals(password)) {
 flag = true;
 break;
 }
 }
 } catch (FileNotFoundException e) {
 System.out.println("用户登录找不到信息所在的文件");
 // e.printStackTrace();
 } catch (IOException e) {
 System.out.println("用户登录失败");
 // e.printStackTrace();
 } finally {
 if (br != null) {
 try {
 br.close();
 } catch (IOException e) {
 System.out.println("用户登录释放资源失败");
 // e.printStackTrace();
 }
 }
 }
 return flag;
 }
 @Override
 public void regist(User user) {
 /*
  * 为了让注册的数据能够有一定的规则,我就自己定义了一个规则: 用户名=密码
  */
 BufferedWriter bw = null;
 try {
 // bw = new BufferedWriter(new FileWriter("user.txt"));
 // bw = new BufferedWriter(new FileWriter(file));
 // 为了保证数据是追加写入,必须加true
 bw = new BufferedWriter(new FileWriter(file, true));
 bw.write(user.getUsername() + "=" + user.getPassword());
 bw.newLine();
 bw.flush();
 } catch (IOException e) {
 System.out.println("用户注册失败");
 // e.printStackTrace();
 } finally {
 if (bw != null) {
 try {
 bw.close();
 } catch (IOException e) {
 System.out.println("用户注册释放资源失败");
 // e.printStackTrace();
 }
 }
 }
 }
}
package cn.itcast.game;(4)
import java.util.Scanner;
/**
 * 这是猜数字小游戏
 * 
 * @author 风清扬
 * @version V1.1
 * 
 */
public class GuessNumber {
 private GuessNumber() {
 }
 public static void start() {
 // 产生一个随机数
 int number = (int) (Math.random() * 100) + 1;
 // 定义一个统计变量
 int count = 0;
 while (true) {
 // 键盘录入一个数据
 Scanner sc = new Scanner(System.in);
 System.out.println("请输入数据(1-100):");
 int guessNumber = sc.nextInt();
 count++;
 // 判断
 if (guessNumber > number) {
 System.out.println("你猜的数据" + guessNumber + "大了");
 } else if (guessNumber < number) {
 System.out.println("你猜的数据" + guessNumber + "小了");
 } else {
 System.out.println("恭喜你," + count + "次就猜中了");
 break;
 }
 }
 }
}
package cn.itcast.test;(5)
import java.util.Scanner;
import cn.itcast.dao.UserDao;
import cn.itcast.dao.impl.UserDaoImpl;
import cn.itcast.game.GuessNumber;
import cn.itcast.pojo.User;
/**
 * 用户测试类
 * 
 * @author 风清扬
 * @version V1.1
 * 
 */
public class UserTest {
 public static void main(String[] args) {
 // 为了能够回来
 while (true) {
 // 欢迎界面,给出选择项
 System.out.println("--------------欢迎光临--------------");
 System.out.println("1 登录");
 System.out.println("2 注册");
 System.out.println("3 退出");
 System.out.println("请输入你的选择:");
 // 键盘录入选择,根据选择做不同的操作
 Scanner sc = new Scanner(System.in);
 // 为了后面的录入信息的方便,我所有的数据录入全部用字符接收
 String choiceString = sc.nextLine();
 // switch语句的多个地方要使用,我就定义到外面
 UserDao ud = new UserDaoImpl();
 // 经过简单的思考,我选择了switch
 switch (choiceString) {
 case "1":
 // 登录界面,请输入用户名和密码
 System.out.println("--------------登录界面--------------");
 System.out.println("请输入用户名:");
 String username = sc.nextLine();
 System.out.println("请输入密码:");
 String password = sc.nextLine();
 // 调用登录功能
 // UserDao ud = new UserDaomImpl();
 boolean flag = ud.isLogin(username, password);
 if (flag) {
 System.out.println("登录成功,可以开始玩游戏了");
 System.out.println("你玩吗?y/n");
 while (true) {
 String resultString = sc.nextLine();
 if (resultString.equalsIgnoreCase("y")) {
 // 玩游戏
 GuessNumber.start();
 System.out.println("你还玩吗?y/n");
 } else {
 break;
 }
 }
 System.out.println("谢谢使用,欢迎下次再来");
 System.exit(0);
 // break; //这里写break,结束的是switch
 } else {
 System.out.println("用户名或者密码有误,登录失败");
 }
 break;
 case "2":
 // 欢迎界面,请输入用户名和密码
 System.out.println("--------------注册界面--------------");
 System.out.println("请输入用户名:");
 String newUsername = sc.nextLine();
 System.out.println("请输入密码:");
 String newPassword = sc.nextLine();
 // 把用户名和密码封装到一个对象中
 User user = new User();
 user.setUsername(newUsername);
 user.setPassword(newPassword);
 // 调用注册功能
 // 多态
 // UserDao ud = new UserDaoImpl();
 // 具体类使用
 // UserDaoImpl udi = new UserDaoImpl();
 ud.regist(user);
 System.out.println("注册成功");
 break;
 case "3":
 default:
 System.out.println("谢谢使用,欢迎下次再来");
 System.exit(0);
 break;
 }
 }
 }
}

2:数据操作流(操作基本类型数据的流)(理解)

(1)可以操作基本类型的数据

(2)流对象名称

DataInputStream

DataOutputStream

package cn.itcast_01;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 可以读写基本数据类型的数据
 * 数据输入流:DataInputStream
 *  DataInputStream(InputStream in)
 * 数据输出流:DataOutputStream
 *  DataOutputStream(OutputStream out) 
 */
public class DataStreamDemo {
 public static void main(String[] args) throws IOException {
 // 写
 // write();
 // 读
 read();
 }
 private static void read() throws IOException {
 // DataInputStream(InputStream in)
 // 创建数据输入流对象
 DataInputStream dis = new DataInputStream(
 new FileInputStream("dos.txt"));
 // 读数据
 byte b = dis.readByte();
 short s = dis.readShort();
 int i = dis.readInt();
 long l = dis.readLong();
 float f = dis.readFloat();
 double d = dis.readDouble();
 char c = dis.readChar();
 boolean bb = dis.readBoolean();
 // 释放资源
 dis.close();
 System.out.println(b);
 System.out.println(s);
 System.out.println(i);
 System.out.println(l);
 System.out.println(f);
 System.out.println(d);
 System.out.println(c);
 System.out.println(bb);
 }
 private static void write() throws IOException {
 // DataOutputStream(OutputStream out)
 // 创建数据输出流对象
 DataOutputStream dos = new DataOutputStream(new FileOutputStream(
 "dos.txt"));
 // 写数据了
 dos.writeByte(10);
 dos.writeShort(100);
 dos.writeInt(1000);
 dos.writeLong(10000);
 dos.writeFloat(12.34F);
 dos.writeDouble(12.56);
 dos.writeChar('a');
 dos.writeBoolean(true);
 // 释放资源
 dos.close();
 }
}

3:内存操作流(理解)

(1)有些时候我们操作完毕后,未必需要产生一个文件,就可以使用内存操作流。

(2)三种

A:ByteArrayInputStream,ByteArrayOutputStream

B:CharArrayReader,CharArrayWriter

C:StringReader,StringWriter

package cn.itcast_02;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
/*
 * 内存操作流:用于处理临时存储信息的,程序结束,数据就从内存中消失。
 * 字节数组:
 *  ByteArrayInputStream
 *  ByteArrayOutputStream
 * 字符数组:
 *  CharArrayReader
 *  CharArrayWriter
 * 字符串:
 *  StringReader
 *  StringWriter
 */
public class ByteArrayStreamDemo {
 public static void main(String[] args) throws IOException {
 // 写数据
 // ByteArrayOutputStream()
 ByteArrayOutputStream baos = new ByteArrayOutputStream();
 // 写数据
 for (int x = 0; x < 10; x++) {
 baos.write(("hello" + x).getBytes());
 }
 // 释放资源
 // 通过查看源码我们知道这里什么都没做,所以根本需要close()
 // baos.close();
 // public byte[] toByteArray()
 byte[] bys = baos.toByteArray();
 // 读数据
 // ByteArrayInputStream(byte[] buf)
 ByteArrayInputStream bais = new ByteArrayInputStream(bys);
 int by = 0;
 while ((by = bais.read()) != -1) {
 System.out.print((char) by);
 }
 // bais.close();
 }
}

4:打印流(掌握)

(1)字节打印流,字符打印流

(2)特点:

A:只操作目的地,不操作数据源

B:可以操作任意类型的数据

C:如果启用了自动刷新,在调用println()方法的时候,能够换行并刷新

D:可以直接操作文件

问题:哪些流可以直接操作文件呢?

看API,如果其构造方法能够同时接收File和String类型的参数,一般都是可以直接操作文件的

 package cn.itcast_03;
import java.io.IOException;
import java.io.PrintWriter;
/*
 * 打印流
 * 字节流打印流 PrintStream
 * 字符打印流 PrintWriter
 * 
 * 打印流的特点:
 *  A:只有写数据的,没有读取数据。只能操作目的地,不能操作数据源。
 *  B:可以操作任意类型的数据。
 *  C:如果启动了自动刷新,能够自动刷新。
 *  D:该流是可以直接操作文本文件的。
 *  哪些流对象是可以直接操作文本文件的呢?
 *  FileInputStream
 *  FileOutputStream
 *  FileReader
 *  FileWriter
 *  PrintStream
 *  PrintWriter
 *  看API,查流对象的构造方法,如果同时有File类型和String类型的参数,一般来说就是可以直接操作文件的。
 * 
 *  流:
 *  基本流:就是能够直接读写文件的
 *  高级流:在基本流基础上提供了一些其他的功能
 */
public class PrintWriterDemo {
 public static void main(String[] args) throws IOException {
 // 作为Writer的子类使用
 PrintWriter pw = new PrintWriter("pw.txt");
 pw.write("hello");
 pw.write("world");
 pw.write("java");
 pw.close();
 }
}
package cn.itcast_03;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/*
 * 1:可以操作任意类型的数据。
 *  print()
 *  println()
 * 2:启动自动刷新
 *  PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true);
 *  还是应该调用println()的方法才可以
 *  这个时候不仅仅自动刷新了,还实现了数据的换行。
 * 
 *  println()
 * 其实等价于于:
 * bw.write();
 * bw.newLine(); 
 * bw.flush();
 */
public class PrintWriterDemo2 {
 public static void main(String[] args) throws IOException {
 // 创建打印流对象
 // PrintWriter pw = new PrintWriter("pw2.txt");
 PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true);
 // write()是搞不定的,怎么办呢?
 // 我们就应该看看它的新方法
 // pw.print(true);
 // pw.print(100);
 // pw.print("hello");
 pw.println("hello");
 pw.println(true);
 pw.println(100);
 pw.close();
 }
}

(3)打印流复制文本文件

 BufferedReader br = new BufferedReader(new FileReader("a.txt"));
 PrintWriter pw = new PrintWriter(new FileWriter("b.txt"),true);
 String line = null;
 while((line=br.readLine())!=null) {
 pw.println(line);
 }
 pw.close();
 br.close();
package cn.itcast_03;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/*
 * 需求:DataStreamDemo.java复制到Copy.java中
 * 数据源:
 *  DataStreamDemo.java -- 读取数据 -- FileReader -- BufferedReader
 * 目的地:
 *  Copy.java -- 写出数据 -- FileWriter -- BufferedWriter -- PrintWriter
 */
public class CopyFileDemo {
 public static void main(String[] args) throws IOException {
 // 以前的版本
 // 封装数据源
 // BufferedReader br = new BufferedReader(new FileReader(
 // "DataStreamDemo.java"));
 // // 封装目的地
 // BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));
 //
 // String line = null;
 // while ((line = br.readLine()) != null) {
 // bw.write(line);
 // bw.newLine();
 // bw.flush();
 // }
 //
 // bw.close();
 // br.close();
 // 打印流的改进版
 // 封装数据源
 BufferedReader br = new BufferedReader(new FileReader(
 "DataStreamDemo.java"));
 // 封装目的地
 PrintWriter pw = new PrintWriter(new FileWriter("Copy.java"), true);
 String line = null;
 while((line=br.readLine())!=null){
 pw.println(line);
 }
 pw.close();
 br.close();
 }
}

5:标准输入输出流(理解)

(1)System类下面有这样的两个字段

in 标准输入流

out 标准输出流

package cn.itcast_04;
import java.io.PrintStream;
/*
 * 标准输入输出流
 * System类中的两个成员变量:
 * public static final InputStream in “标准”输入流。
 *  public static final PrintStream out “标准”输出流。
 * 
 *  InputStream is = System.in;
 *  PrintStream ps = System.out;
 */
public class SystemOutDemo {
 public static void main(String[] args) {
 // 有这里的讲解我们就知道了,这个输出语句其本质是IO流操作,把数据输出到控制台。
 System.out.println("helloworld");
 // 获取标准输出流对象
 PrintStream ps = System.out;
 ps.println("helloworld");
 ps.println();
 // ps.print();//这个方法不存在
 // System.out.println();
 // System.out.print();
 }
}

(2)三种键盘录入方式

A:main方法的args接收参数

B:System.in通过BufferedReader进行包装

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

C:Scanner

 Scanner sc = new Scanner(System.in);
package cn.itcast_04;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/*
 * System.in 标准输入流。是从键盘获取数据的
 * 
 * 键盘录入数据:
 *  A:main方法的args接收参数。
 *  java HelloWorld hello world java
 *  B:Scanner(JDK5以后的)
 *  Scanner sc = new Scanner(System.in);
 *  String s = sc.nextLine();
 *  int x = sc.nextInt()
 *  C:通过字符缓冲流包装标准输入流实现
 *  BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 */
public class SystemInDemo {
 public static void main(String[] args) throws IOException {
 // //获取标准输入流
 // InputStream is = System.in;
 // //我要一次获取一行行不行呢?
 // //行。
 // //怎么实现呢?
 // //要想实现,首先你得知道一次读取一行数据的方法是哪个呢?
 // //readLine()
 // //而这个方法在哪个类中呢?
 // //BufferedReader
 // //所以,你这次应该创建BufferedReader的对象,但是底层还是的使用标准输入流
 // // BufferedReader br = new BufferedReader(is);
 // //按照我们的推想,现在应该可以了,但是却报错了
 // //原因是:字符缓冲流只能针对字符流操作,而你现在是字节流,所以不能是用?
 // //那么,我还就想使用了,请大家给我一个解决方案?
 // //把字节流转换为字符流,然后在通过字符缓冲流操作
 // InputStreamReader isr = new InputStreamReader(is);
 // BufferedReader br= new BufferedReader(isr);
 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 System.out.println("请输入一个字符串:");
 String line = br.readLine();
 System.out.println("你输入的字符串是:" + line);
 System.out.println("请输入一个整数:");
 // int i = Integer.parseInt(br.readLine());
 line = br.readLine();
 int i = Integer.parseInt(line);
 System.out.println("你输入的整数是:" + i);
 }
}

原文发布于微信公众号 - Java帮帮(javahelp)

原文发表时间:2016-12-13

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏你不就像风一样

Java之文本文件的创建和读取(含IO流操作)

1222
来自专栏IT大咖说

Getting started with Kotlin on Android

摘要 Kotlin是一门与Swift类似的静态类型JVM语言,由JetBrain设计开发并开源,与Java相比,Kotlin的语法更简洁,更具表达性,而且提供了...

2845
来自专栏mathor

FileInput(Output)Stream

1294
来自专栏微信公众号:Java团长

这些年一直记不住的 Java I/O

  该文中的内容来源于 Oracle 的官方文档。Oracle 在 Java 方面的文档是非常完善的。对 Java 8 感兴趣的朋友,可以从这个总入口 Java...

1242
来自专栏日常分享

网络通信中基于套接字输入流和输出流的创建

  (2)由套接字对象Socket调用getInputStream()或getOutputStream()方法,分别返回具有套接字通信的基础输入流InputSt...

1042
来自专栏Golang语言社区

厚土Go学习笔记 | 33. 利用数据流实现密码代换功能

利用 go 语言的 io.Reader 包裹另一个 io.Reader 的模式,修改数据流中的字符串(密码)代换功能。 提供一个字母和数字组合的字符串,对这个字...

40012
来自专栏Java编程

详细讲解Java中的IO流

1.java.io包中的类对应两类流,一类流直接从指定的位置(如磁盘文件或内存区域)读或写,这类流称为结点流(node stream),其它的流则称为过滤器(f...

6930
来自专栏个人随笔

当Java遇到XML 的邂逅+dom4j

1652
来自专栏高性能服务器开发

这些年一直记不住的 Java I/O

阅读目录 参考资料 前言 从对立到统一,字节流和字符流 从抽象到具体,数据的来源和目的 从简单到丰富,使用 Decorator 模式扩展功能 Java 7 中引...

3585
来自专栏Phoenix的Android之旅

只用一行代码的单例模式

作为Android开发者对Kotlin语言应该不会陌生, 下面这个单例模式就是用Kotlin写的,

1343

扫码关注云+社区

领取腾讯云代金券