本文目录一览:
- 1、Java中有几种类型的流
- 2、mac系统,java编程中文件流的路径是如何写的
- 3、在java 中文件流和数据流的区别
- 4、java如何读取文件流是什么格式
- 5、java为什么要设计File和流的概念?
Java中有几种类型的流
在Java.io包中还有许多其他的流,主要是为了提高性能和使用方便。C/C++只能提供字节流。Java中的流分为两种,一种是字节流,另一种是字符流,分别由四个抽象类来表示(每种流包括输入和输出两种所以一共四个):InputStream,OutputStream,Reader,Writer。Java中其他多种多样变化的流均是由它们派生出来的.
字符流和字节流是根据处理数据的不同来区分的。字节流按照8位传输,字节流是最基本的,所有文件的储存是都是字节(byte)的储存,在磁盘上保留的并不是文件的字符而是先把字符编码成字节,再储存这些字节到磁盘。
1.字节流可用于任何类型的对象,包括二进制对象,而字符流只能处理字符或者字符串;
2. 字节流提供了处理任何类型的IO操作的功能,但它不能直接处理Unicode字符,而字符流就可以。
读文本的时候用字符流,例如txt文件。读非文本文件的时候用字节流,例如mp3。理论上任何文件都能够用字节流读取,但当读取的是文本数据时,为了能还原成文本你必须再经过一个转换的工序,相对来说字符流就省了这个麻烦,可以有方法直接读取。
字符流处理的单元为2个字节的Unicode字符,分别操作字符、字符数组或字符串,而字节流处理单元为1个字节, 操作字节和字节数组。所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的,所以它对多国语言支持性比较好!
1.字节流:继承于InputStream \ OutputStream。
OutputStream提供的方法:
void write(int b):写入一个字节的数据
void write(byte[] buffer):将数组buffer的数据写入流
void write(byte[] buffer,int offset,int len):从buffer[offset]开始,写入len个字节的数据
void flush():强制将buffer内的数据写入流
void close():关闭流
InputStream提供的方法:
int read():读出一个字节的数据,如果已达文件的末端,返回值为-1
int read(byte[] buffer):读出buffer大小的数据,返回值为实际所读出的字节数
int read(byte[] buffer,int offset,int len)
int available():返回流内可供读取的字节数目
long skip(long n):跳过n个字节的数据,返回值为实际所跳过的数据数
void close():关闭流
2.字符流,继承于InputStreamReader \ OutputStreamWriter。
字符流的类:1),BufferedReader是一种过滤器(filter)(extends FilterReader)。过滤
器用来将流的数据加以处理再输出。构造函数为:
BufferedReader(Reader in):生成一个缓冲的字符输入流,in为一个读取器
BufferedReader(Reader in,int size):生成一个缓冲的字符输入流,并指定缓冲区的大小为size
public class IOStreamDemo {
public void samples() throws IOException { //1. 这是从键盘读入一行数据,返回的是一个字符串
BufferedReader stdin =new BufferedReader(new InputStreamReader(System.in));
System.out.print("Enter a line:");
System.out.println(stdin.readLine());
//2. 这是从文件中逐行读入数据
BufferedReader in = new BufferedReader(new FileReader("IOStreamDemo.java"));
String s, s2 = new String();
while((s = in.readLine())!= null)
s2 += s + "\n";
in.close();
//3. 这是从一个字符串中逐个读入字节
StringReader in1 = new StringReader(s2);
int c;
while((c = in1.read()) != -1)
System.out.print((char)c);
//4. 这是将一个字符串写入文件
try {
BufferedReader in2 = new BufferedReader(new StringReader(s2));
PrintWriter out1 = new PrintWriter(new BufferedWriter(new FileWriter("IODemo.out")));
int lineCount = 1;
while((s = in2.readLine()) != null )
out1.println(lineCount++ + ": " + s);
out1.close();
} catch(EOFException e) {
System.err.println("End of stream");
}
} }
对于上面的例子,需要说明的有以下几点:
1. InputStreamReader是InputStream和Reader之间的桥梁,由于System.in是字节流,需要用它来包装之后变为字符流供给BufferedReader使用。
3. PrintWriter out1 = new PrintWriter(new BufferedWriter(new FileWriter("IODemo.out")));
这句话体现了Java输入输出系统的一个特点,为了达到某个目的,需要包装好几层。首先,输出目的地是文件IODemo.out,所以最内层包装的是FileWriter,建立一个输出文件流,接下来,我们希望这个流是缓冲的,所以用BufferedWriter来包装它以达到目的,最后,我们需要格式化输出结果,于是将PrintWriter包在最外层。
Java流有着另一个重要的用途,那就是利用对象流对对象进行序列化。
在一个程序运行的时候,其中的变量数据是保存在内存中的,一旦程序结束这些数据将不会被保存,一种解决的办法是将数据写入文件,而Java中提供了一种机制,它可以将程序中的对象写入文件,之后再从文件中把对象读出来重新建立。这就是所谓的对象序列化。Java中引入它主要是为了RMI(Remote
Method Invocation)和Java Bean所用,不过在平时应用中,它也是很有用的一种技术。
mac系统,java编程中文件流的路径是如何写的
看看这个,我昨天刚写的: import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;public class AddList {
private String filePath = "";
private String bakPath = "";
private String content = "";
Scanner sc = new Scanner(System.in);
public String readFile(){
content = "";
if (isNull(filePath)) {
System.out.println("文件存储路径:");
filePath = sc.nextLine();
}
File file = new File(filePath);
FileReader fr = null;
try {
if (file.exists()) {
fr = new FileReader(file);
char[] chars = new char[1024];
int n = 0;
while((n = fr.read(chars)) != -1){
String string = new String(chars, 0, n);
content = content + string;
}
} else {
System.out.println("文件不存在");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (fr != null) {
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return content;
}
public void writeFile(String path){
File file = new File(path);
FileOutputStream fos = null;
mkDirs(path);
try {
fos = new FileOutputStream(file);
BufferedOutputStream bos = new BufferedOutputStream(fos);
PrintWriter pw = new PrintWriter(bos, true);
pw.print(content);
pw.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} finally {
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public void writeFile(){
if (isNull(filePath)) {
System.out.println("文件存储路径:");
filePath = sc.nextLine();
}
File file = new File(filePath);
FileOutputStream fos = null;
mkDirs(filePath);
try {
fos = new FileOutputStream(file);
BufferedOutputStream bos = new BufferedOutputStream(fos);
PrintWriter pw = new PrintWriter(bos, true);
pw.print(content);
pw.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} finally {
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public void mkDirs(String filepath){
if (filepath.indexOf("\\") != -1) {
filepath = filepath.replaceAll("\\", "/");
}
int n = filepath.indexOf("//");
String path = filepath.substring(0, n) + "//";
filepath = filepath.substring(filepath.indexOf("//") + 1, filepath.length());
String[] files = filepath.split("/");
for (int i = 0; i files.length - 1; i++) {
path = path + files[i];
File file = new File(path);
if (!file.exists()) {
file.mkdir();
}
}
}
public void addImfor(){
System.out.println("--------增加记录---------");
String name = "";
String tel = "";
String email = "";
content = readFile();
while(true){
System.out.println("姓名:");
name = sc.next();
System.out.println("电话:");
tel = sc.next();
System.out.println("Email:");
email = sc.next();
content = content + name + "" + tel + "" + email +"==";
System.out.println("0、Exit 1、继续");
int i = sc.nextInt();
if (i == 0) {
break;
}
}
writeFile();
}
public void deleteImfor(){
System.out.println("---------删除记录---------");
String name = "";
String[] imfors = null;
content = readFile();
while(true){
System.out.println("你要删除的姓名是:");
name = sc.next();
if (content.indexOf(name) != -1) {
imfors = content.split("==");
for (int i = 0; i imfors.length; i++) {
if (imfors[i].indexOf(name) != -1) {
imfors[i] = "";
}
}
content = "";
for (int i = 0; i imfors.length; i++) {
if (!isNull(imfors[i])) {
content = content + imfors[i] + "==";
}
}
writeFile();
System.out.println("删除成功");
} else {
System.out.println("此人不存在");
}
System.out.println("0、Exit 1、继续");
int i = sc.nextInt();
if (i == 0) {
break;
}
}
}
public void viewAll(){
System.out.println("----------显示所有------------");
content = readFile();
if (!isNull(content)) {
String[] imfors = content.split("==");
System.out.println("姓名\t电话\tEmail");
for (int i = 0; i imfors.length; i++) {
String[] imfor = imfors[i].split("");
for (int j = 0; j imfor.length; j++) {
System.out.print(imfor[j] + "\t");
}
System.out.println();
}
} else {
System.out.println("暂时还没有记录");
}
}
public void queryImfor(){
System.out.println("----------查找记录-----------");
content = readFile();
if (!isNull(content)) {
String result = "";
String[] imfors = null;
String[] imfor = null;
String name = "";
boolean bool = false;
while(true){
result = "";
System.out.println("请输入关键字(按姓名查找):");
name = sc.next();
bool = false;
if (content.indexOf(name) != -1) {
imfors = content.split("==");
for (int i = 0; i imfors.length; i++) {
if (imfors[i].indexOf(name) != -1) {
imfor = imfors[i].split("");
if (imfor[0].equals(name)) {
bool = true;
result = result + imfors[i] + "==";
}
}
}
if (bool) {
imfors = result.split("==");
System.out.println("姓名\t电话\tEmail");
for (int i = 0; i imfors.length; i++) {
imfor = imfors[i].split("");
for (int j = 0; j imfor.length; j++) {
System.out.print(imfor[j] + "\t");
}
System.out.println();
}
} else {
System.out.println("无此人信息");
}
} else {
System.out.println("无此人信息");
}
System.out.println("0、Exit 1、继续");
int i = sc.nextInt();
if (i == 0) {
break;
}
}
} else {
System.out.println("文件还没有记录");
}
}
public void copy(){
System.out.println("----------备份-----------");
content = readFile();
if (isNull(bakPath)) {
System.out.println("备份全路径:");
bakPath = sc.next();
}
writeFile(bakPath);
System.out.println("备份成功");
}
public boolean isNull(String string){
if (null == string || "" == string || 0 == string.length()) {
return true;
} else {
return false;
}
}
public static void main(String[] args) {
AddList add = new AddList();
Scanner sc = new Scanner(System.in);
int operater = 0;
while(true){
System.out.println("选择功能:\n1、增加记录 2、删除记录 3、显示所有 4、查询记录 5、备份 6、退出");
operater = sc.nextInt();
if (1 == operater) {
add.addImfor();
} else if (2 == operater) {
add.deleteImfor();
} else if (3 == operater) {
add.viewAll();
} else if (4 == operater) {
add.queryImfor();
} else if (5 == operater) {
add.copy();
} else if (6 == operater) {
System.out.println("谢谢使用");
break;
}
}
}
}
在java 中文件流和数据流的区别
文件流是通过方法可以知道长度,名称等详细信息的数据流。主要用于文件操作,在文件流中有自己的适用于文件操作的数据格式。而数据流是一个统称,所有的流都可以称为数据流。文件流属于数据流的一种。
java如何读取文件流是什么格式
直接用fileinputstream读文件到内存,然后用outputstream输出到客户端,因为是二进制流操作,源文件是什么格式,输出的就是什么格式。
java为什么要设计File和流的概念?
两个操作不一样。
File是对文件操作。比如说,创建文件,复制文件,删除文件,判断文件是否存在等等。或者说这个操作的对象是文件整体。
文件流是对文件内容的操作。比如说,读取文件内容,写入文件内容等等。