fileinputstream读取文件,为什么fileinputstream可以读取xls临时文件,读取不了xlsx临时文件？
fileinputstream读取文件,为什么fileinputstream可以读取xls临时文件,读取不了xlsx临时文件？详细介绍
本文目录一览： 接收键盘输入的字符串，用FileOutputStream类将字符串写入文件，用FileInputStream类读出文件内容并显示
import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;public class FileOperation { public static void main(String[] args) { try { System.out.println("Pleaseinput:"); File myfile = new File("save.txt"); byte[] outCh = new byte[100]; int bytes = System.in.read(outCh, 0, 100); FileOutputStream Fout = new FileOutputStream(myfile); Fout.write(outCh,0,bytes); byte[] inCh = new byte[bytes]; FileInputStream Fin = new FileInputStream(myfile); Fin.read(inCh); System.out.println(new String(inCh)); } catch (IOException e) { System.out.println(e.toString()); } }}
1、创建一个控制台应用程序，用于演示string类的Contains包含方法。
2、在Main方法中定义一个string变量var str = "Hello, Hello World!"。
3、使用Contains方法，检测字符串str中是否含有he，Contains方法查找到指定内容就返回true，否则返回false。
4、使用Contains方法，检测字符串str中是否含有He。
5、在调试模式下运行，可以看到结果是“存在”，这就表示Contains方法判断存在是区分大小写的。
注意事项：
字符串或串(String)是由数字、字母、下划线组成的一串字符。一般记为 s=“a1a2···an”(n>=0)。它是编程语言中表示文本的数据类型。
java 输入流类FileInputStream下的read()是什么意思？
两个都属于字节流读取方式。
char 的范围是0~255
byte 的范围是-128~127
用char型就能读出该数据的ASCII字符,
如果用byte读出来就将是数字，并且有可能是负数。
而你这个例子，无疑是想打印出该文件中，各个字节的ASCII码。所以转成了char型，再把char转成int型。
一般纯文本文件，我们都可以用char来读取。
但对于非文本文件，我们就最好用byte来读了，因为我们读到的那个字节很可能不是正数。
你看的那个read只是FileInputStream的一个实现，这个read方法被overload了
text[count]=( (char) fileobject.read());
用的是下面这个没有参数的read方法
read
public int read()
throws IOException
Reads a byte of data from this input stream. This method blocks if no input is yet available.
返回的是一个int值, 是从文本里面读出来的一个字节
你的程序给强制转换为char是为了方便打印
read()当然就是读了`
也看你read里加不加参数 不加就是一个一个个的读
你写了一句话``比如
"abc"
那打印的就是 97 98 99
你试试 按 住alt键不放 右手再按数字键上的 这些数字 是不是打的abc
那read 就是将这些 字符串 转换为数字 (可以这样理解)
然后char
可以将他们还原 显示为对应的字母
如97 --a
FileInputStream的read() 默认情况下 返回 ASCII码
读取文件的时候 这样来做比较好点
FileInputStream file=new FileInputStream("filename");
InputStreamReader isr=new InputStreamReader(file);
BufferedReader br=new BufferedReader(isr);
try{
String show=br.readLine();
while(show!=null){
//String show=br.readLine();
System.out.println(show);
show=br.readLine();
}
}
是的发个
该类意思是：从InputStream中派生出来的简单输入类。
一、构造方法
FileInputStream(String name); //使用给定的文件名创建对象
FileInputStream(File file); //使用File对象创建FileInputStream对象
二、读取文件
1.使用文件输入流读取文件
FileInuputStream istream=new FileInputStream("myfile.dat");
或：
File f=new File("myfile.dat");
FileInputStream istream=new FileInputStream(f);
构造方法可能会产生异常IOException,故为了把一个文件输入流对象与一个文件关联起来，需：
try { FileInputStream ins=new FileInputStream("myfile.dat");}
catch (IOException e){ System.out.println("File read error:"+e);}
2.从输入流中读取字节
int read(); //从输入流中读取单个字节数据（0~255），如到输入流末尾则返回-1
int read(byte b[]); //读多个字节
int read(byte b[],int off,int len);
3.关闭流
Java在程序结束时自动关闭所有打开的流，但显式关闭任何打开的流是一个好习惯。
close();
java的几种IO流读取文件方式
一、超类：
字节流： InputStream（读入流） OutputStream(写出流）
字符流： Reader（字符 读入流） Writer （字符写出流）
二、文件操作流
字节流： FileInputStream ，FileOutputStream
字符流： FileReader, FileWriter(用法与字节流基本相同，不写）
//1.指定要读 的文件目录及名称
File file =new File("文件路径");
//2.创建文件读入流对象
FileInputStream fis =new FileInputStream(file);
//3.定义结束标志,可用字节数组读取
int i =0 ;
while((i = fis.read())!=-1){
//i 就是从文件中读取的字节，读完后返回-1
}
//4.关闭流
fis.close();
//5.处理异常
//1.指定要写到的文件目录及名称
File file =new File("文件路径");
//2.创建文件读入流对象
FileOutputStream fos =new FileOutputStream(file);
//3.定义结束标志
fos.write(要写出的字节或者字节数组);
//4.刷新和关闭流
fos.flush();
fos.close();
//5.处理异常
三、缓冲流：
字节缓冲流： BufferedInputStream,BufferedOutputStream
字符缓冲流：BufferedReader ,BufferedWriter
缓冲流是对流的操作的功能的加强，提高了数据的读写效率。既然缓冲流是对流的功能和读写效率的加强和提高，所以在创建缓冲流的对象时应该要传入要加强的流对象。
//1.指定要读 的文件目录及名称
File file =new File("文件路径");
//2.创建文件读入流对象
FileInputStream fis =new FileInputStream(file);
//3.创建缓冲流对象加强fis功能
BufferedInputStream bis =new BufferedInputStream(fis);
//4.定义结束标志,可用字节数组读取
int i =0 ;
while((i = bis.read())!=-1){
//i 就是从文件中读取的字节，读完后返回-1
}
//5.关闭流
bis.close();
//6.处理异常
//1.指定要写到的文件目录及名称
File file =new File("文件路径");
//2.创建文件读入流对象
FileOutputStream fos =new FileOutputStream(file);
//3.创建缓冲流对象加强fos功能
BufferedOutputStream bos=new BufferedOutputStream(fos);
//4.向流中写入数据
bos.write(要写出的字节或者字节数组);
//5.刷新和关闭流
bos.flush();
bos.close();
//6.处理异常
四、对象流
ObjectInputStream ,ObjectOutputStream
不同于以上两种类型的流这里只能用字节对对象进行操作原因可以看上篇的编码表比照原理
ObjectOutputStream对象的序列化：
将java程序中的对象写到本地磁盘里用ObjectOutputStream
eg：将Person类的对象序列化到磁盘
创建Person类
注1：此类要实现Serializable接口，此接口为标志性接口
注2：此类要有无参的构造函数
注3：一旦序列化此类不能再修改
class Person implements Serializable{
public Person(){}
}
2.创建对象流对象
注：要增强功能可以将传入文件缓冲流
ObjectOutputStream oos =new ObjectOutputStream(
new FileOutputStream(new File("文件路径")));
3.写入对象 ，一般会将对象用集合存储起来然后直接将集合写入文件
List
list =new ArrayList<>();
list.add(new Person());
...(可以添加多个）
oos.writeObject(list);
4.关闭流，处理异常
oos.flush();
oos.close();
五、转换流：
这类流是用于将字符转换为字节输入输出，用于操作字符文件，属于字符流的子类，所以后缀为reader，writer；前缀inputstream，outputstream；
注 ：要传入字节流作为参赛
InputStreamReader: 字符转换输出流
OutputStreamWriter：字符转换输入流
//1.获取键盘输入的字节流对象
inInputStream in =Stream.in;
/*2.用转换流将字节流对象转换为字符流对象，方便调用字符缓冲流的readeLine()方法*/
InputStreamReader isr =new InputStreamReader(in);
/*5.创建字符转换输出流对象osw，方便把输入的字符流转换为字节输出到本地文件。*/
OutputStreamWriter osw =new OutputStreamWriter(newFileOutputStream(new File("文件名")));
/*3.现在isr是字符流，可以作为参数传入字符缓冲流中*/
BufferedReader br =new BufferedReader(isr);/*4.可以调用字符缓冲流br的readLine()方法度一行输入文本*/
String line =null;
while((line =br.readLine()){
osw.write(line);//osw是字符流对象，可以直接操作字符串}
注：InputStreamReader isr =new InputStreamReader(new "各种类型的字节输入流都行即是：后缀为InputStream就行");
OutputStreamWriter osw =new OutputStreamWriter(new"后缀为OutputStream就行");
六、区别记忆
1.对象流是可以读写几乎所有类型的只要是对象就行，而字节字符流，只能读写单个字节字符或者字节字符数组，以上没有读写字节字符数组的；注意对象流只有字节流！
2.字符和字节循环读入的结束条件int i=0; (i =fis.read())!=-1用字符数组复制文件(fr 读入流 ，fw写出流）,字节流也是相同的用法
int i = 0; char[] c = new char[1024];
while((i = fr.reade()) !=-1)）{
fw.write(c,0,i);
}
123456
3.对象流里面套缓冲流的情景：
new ObjectInputStream(new BufferedInputStream(new FileInputStream(new File(“文件路径”))));
4.记忆流及其功能的方法：
前缀表示功能，后缀表示流的类型；
比如说FileInputStream 前缀：File,表示操作的磁盘，后缀：intputstream,表示是字节输入流。
同理 FileReader：表示操作文件的字符流
ObjectInputStream ：操作对象的字节输入流
5.拓展：获取键盘输入的字符的缓冲流的写法：
new BufferedReader(new InputStreamReader(System.in)));
将字节以字符形式输出到控制台的字符缓冲流的写法：
new BufferedWriter（ new OutputStreamWriter（System.out))
java 用FileInputStream中read方法读取文件出现乱码
read方法读取的是字节流（每次读取一个字节），如果是中文，就是两个字节，就会出现乱码的。
可以通过BufferedReader 流的形式进行流缓存，之后通过readLine方法获取到缓存的内容。
BufferedReader bre = null;
try {
String file = "D:/test/test.txt";
bre = new BufferedReader(new FileReader(file));//此时获取到的bre就是整个文件的缓存流
while ((str = bre.readLine())!= null) // 判断最后一行不存在，为空结束循环
{
System.out.println(str);//原样输出读到的内容
}；
备注： 流用完之后必须close掉，如上面的就应该是：bre.close()，否则bre流会一直存在，直到程序运行结束。
额，仔细看了下，你用int来接本来就不对。byte和int是不同的
byte是1字节，int是4字节。。。。
while(is.read()!=-1){ b[i]=(byte) is.read(); i++;}这里是错的，当判断is.read() != -1的时候这个字节就已经被读取了，于是b[i] = (byte) is.read();这里读取的就是后面一个字节，自然会乱码。解决方法如下：
byte c = (byte)is.read();while(c != -1){ b[i] = c i++; c = (byte)is.read();}还有一种更方便的：
byte[] b = new byte[is.available()];is.read(b);
FileInputStream读取中文
读的时候用utf-8编码，写的时候也用utf-8编码
可以直接转为String。
String parent = "D:\\JavaDemo";
String child = "dong.txt";
File file = new File(parent, child);
FileInputStream input = new FileInputStream(file);
byte[] bt = new byte[1024];
int red = -1;
while((red = input.read(bt)) != -1) {
System.out.println("长度： "+red);
System.out.println(new String(bt));
}
仅供参考
InputStreamReader read = new InputStreamReader(new FileInputStream(file), "gb2312");
通过InputStreamReader转下编码，自己处理异常！
有问题再追问，good luck！~
File f = new File("文件路径");
FileInputStream fis = new FileInputStream(f);//创建一个输入流，读取f中的内容到程序中来
//System.out.println(fis.read());
byte[] b = new byte[1024];//定义一个数组，保存读取的类容
int hasRead = 0;//用 来记录读取了多长
hasRead=fis.read(b);
String s = new String(b,0,hasRead);
System.out.println(s);
java如何用FileIputStream按行读取csv文件 求代码
FileInputStream是按字节读取文件的
按行读取的话，用BufferedReader
BufferedReader br = null;
try {
br = new BufferedReader(new FileReader("ss.csv"));
String str = "";
while (null != (str = br.readLine())) {
System.out.println(str);
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
if (br!= null) {
try {
br.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
用的相对路径,ss.csv和类放在一个文件夹里了
是要用BufferedReader来读取一行，
判断不好，
用
while (br.ready()) {
str = br.readLine();
System.out.println(str);
}
解析的话，用str.split(",");
注意编辑的转换，
基本就这些了。
为什么fileinputstream可以读取xls临时文件,读取不了xlsx临时文件？
因为他们规定的文件类型不一样
因为，xlsx不是一个简单的文件，而是一个压缩文件，是一系列（文件+文件夹）经过zip压缩以后，改名为xlsx。
读写xlsx需要先通过zip解压，然后找到真正需要读写的文件再操作。
Java 如何读取目录下的文件内容
获得目录下的文件只需要File类即可！
File dir = new File("d:\\");
File[] files = dir.listFiles();
for(int i=0;i
<files.length;i++){
System.out.println((files[i].isDirectory()?"目录：":"文件：")+files[i].getName());
}
File dist = new File("你想要的路径");
用dist就行了
Java读取目录下的文件内容，使用的是java的文件类，示例如下：
import java.io.BufferedReader;import java.io.File;import java.io.FileInputStream;import java.io.FileReader;import java.io.IOException;import java.io.InputStream;import java.io.InputStreamReader;import java.io.RandomAccessFile;import java.io.Reader; public class ReadFromFile { /** * 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。 * * @param fileName * 文件的名 */ public static void readFileByBytes(String fileName) { File file = new File(fileName); InputStream in = null; try { System.out.println("以字节为单位读取文件内容，一次读一个字节："); // 一次读一个字节 in = new FileInputStream(file); int tempbyte; while ((tempbyte = in.read()) != -1) { System.out.write(tempbyte); } in.close(); } catch (IOException e) { e.printStackTrace(); return; } try { System.out.println("以字节为单位读取文件内容，一次读多个字节："); // 一次读多个字节 byte[] tempbytes = new byte[100]; int byteread = 0; in = new FileInputStream(fileName); ReadFromFile.showAvailableBytes(in); // 读入多个字节到字节数组中，byteread为一次读入的字节数 while ((byteread = in.read(tempbytes)) != -1) { System.out.write(tempbytes, 0, byteread); } } catch (Exception e1) { e1.printStackTrace(); } finally { if (in != null) { try { in.close(); } catch (IOException e1) { } } } } /** * 以字符为单位读取文件，常用于读文本，数字等类型的文件 * * @param fileName * 文件名 */ public static void readFileByChars(String fileName) { File file = new File(fileName); Reader reader = null; try { System.out.println("以字符为单位读取文件内容，一次读一个字节："); // 一次读一个字符 reader = new InputStreamReader(new FileInputStream(file)); int tempchar; while ((tempchar = reader.read()) != -1) { // 对于windows下，\r\n这两个字符在一起时，表示一个换行。 // 但如果这两个字符分开显示时，会换两次行。 // 因此，屏蔽掉\r，或者屏蔽\n。否则，将会多出很多空行。 if (((char) tempchar) != '\r') { System.out.print((char) tempchar); } } reader.close(); } catch (Exception e) { e.printStackTrace(); } try { System.out.println("以字符为单位读取文件内容，一次读多个字节："); // 一次读多个字符 char[] tempchars = new char[30]; int charread = 0; reader = new InputStreamReader(new FileInputStream(fileName)); // 读入多个字符到字符数组中，charread为一次读取字符数 while ((charread = reader.read(tempchars)) != -1) { // 同样屏蔽掉\r不显示 if ((charread == tempchars.length) && (tempchars[tempchars.length - 1] != '\r')) { System.out.print(tempchars); } else { for (int i = 0; i < charread; i++) { if (tempchars[i] == '\r') { continue; } else { System.out.print(tempchars[i]); } } } } } catch (Exception e1) { e1.printStackTrace(); } finally { if (reader != null) { try { reader.close(); } catch (IOException e1) { } } } } /** * 以行为单位读取文件，常用于读面向行的格式化文件 * * @param fileName * 文件名 */ public static void readFileByLines(String fileName) { File file = new File(fileName); BufferedReader reader = null; try { System.out.println("以行为单位读取文件内容，一次读一整行："); reader = new BufferedReader(new FileReader(file)); String tempString = null; int line = 1; // 一次读入一行，直到读入null为文件结束 while ((tempString = reader.readLine()) != null) { // 显示行号 System.out.println("line " + line + ": " + tempString); line++; } reader.close(); } catch (IOException e) { e.printStackTrace(); } finally { if (reader != null) { try { reader.close(); } catch (IOException e1) { } } } } /** * 随机读取文件内容 * * @param fileName * 文件名 */ public static void readFileByRandomAccess(String fileName) { RandomAccessFile randomFile = null; try { System.out.println("随机读取一段文件内容："); // 打开一个随机访问文件流，按只读方式 randomFile = new RandomAccessFile(fileName, "r"); // 文件长度，字节数 long fileLength = randomFile.length(); // 读文件的起始位置 int beginIndex = (fileLength > 4) ? 4 : 0; // 将读文件的开始位置移到beginIndex位置。 randomFile.seek(beginIndex); byte[] bytes = new byte[10]; int byteread = 0; // 一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。 // 将一次读取的字节数赋给byteread while ((byteread = randomFile.read(bytes)) != -1) { System.out.write(bytes, 0, byteread); } } catch (IOException e) { e.printStackTrace(); } finally { if (randomFile != null) { try { randomFile.close(); } catch (IOException e1) { } } } } /** * 显示输入流中还剩的字节数 * * @param in */ private static void showAvailableBytes(InputStream in) { try { System.out.println("当前字节输入流中的字节数为:" + in.available()); } catch (IOException e) { e.printStackTrace(); } } public static void main(String[] args) { String fileName = "C:/temp/newTemp.txt"; ReadFromFile.readFileByBytes(fileName); ReadFromFile.readFileByChars(fileName); ReadFromFile.readFileByLines(fileName); ReadFromFile.readFileByRandomAccess(fileName); }}
</files.length;i++){
java中的FileInputStream类中的read()方法是读取一个数据字节，那么读取完一个字节后还会自动读取下一个
该类意思是：从InputStream中派生出来的简单输入类。
一、构造方法
FileInputStream(String name); //使用给定的文件名创建对象
FileInputStream(File file); //使用File对象创建FileInputStream对象
二、读取文件
1.使用文件输入流读取文件
FileInuputStream istream=new FileInputStream("myfile.dat");
或：
File f=new File("myfile.dat");
FileInputStream istream=new FileInputStream(f);
构造方法可能会产生异常IOException,故为了把一个文件输入流对象与一个文件关联起来，需：
try { FileInputStream ins=new FileInputStream("myfile.dat");}
catch (IOException e){ System.out.println("File read error:"+e);}
2.从输入流中读取字节
int read(); //从输入流中读取单个字节数据（0~255），如到输入流末尾则返回-1
int read(byte b[]); //读多个字节
int read(byte b[],int off,int len);
3.关闭流
Java在程序结束时自动关闭所有打开的流，但显式关闭任何打开的流是一个好习惯。
close();
读出来的是一个一个的byte
read()需要写循环方法才能把数据挨着读出来。与指针没关系。
read只会读取一个字节 不会自动读取下一个 只会读第一个字节 和指针不是一回事
如果想用字节流读完文件 一般用一个字节数组的缓冲区 比如200
byte[] buffer = new byte[200];//创建字节数组
int length = 0;
while(-1 != (length = is.read(buffer, 0, buffer.length))){
String str = new String(buffer,0,length);
System.out.println(str);
}