java i/o操作

//控制台读取(Console)

//过滤器

//文件后缀过滤器

package test.File;


import java.io.File;
import java.io.FileFilter;


/**
* @author liuzhongbing
* 括展名过滤器
*/
public class ExtensionFilter implements FileFilter {


// 扩展名
private String extension;


public ExtensionFilter(String extension) {
this.extension = extension;
}


public boolean accept(File file) {
// 如果是目录则返回false
if (file.isDirectory()) {
return false;
}


// 取得文件名
String name = file.getName();
// 扩展名前的符号“.”
int index = name.lastIndexOf(".");
if (index == -1) { // 没有扩展名则返回false
return false;
} else if (index == name.length() - 1) { // 以点号结尾则返回false
return false;
} else { // 如果括展名相同，则返回true
return this.extension.equals(name.substring(index + 1));
}
}
}

//图片后缀过滤器

package test.File;


import java.io.File;
import java.io.FilenameFilter;


/**
* @author liuzhongbing
* 图片过滤器
*/
public class ImageFilter implements FilenameFilter {


/**
* gif文件
* @param filename 文件名
* @return
*/
public boolean isGif(String filename) {
if (filename.toLowerCase().endsWith(".gif")) {
return true;
} else {
return false;
}
}


/**
* jpg文件
* @param filename 文件名
* @return
*/
public boolean isJpg(String filename) {
if (filename.toLowerCase().endsWith(".jpg")) {
return true;
} else {
return false;
}
}


/**
* png文件
* @param filename 文件名
* @return
*/
public boolean isPng(String filename) {
if (filename.toLowerCase().endsWith(".png")) {
return true;
} else {
return false;
}
}


public boolean accept(File dir, String filename) {
return (isGif(filename) || isJpg(filename) || isPng(filename));
}
}

//使用代码

package test.File;
import java.io.File;
public class TestFile {
public static void main(String[] args) {
File file = new File("D:/demo"); // 目录实例
ExtensionFilter txtFilter = new ExtensionFilter("txt"); // 创建一个txt过滤器
File[] files = file.listFiles(txtFilter); // 使用过滤器查找txt文件
// 输出查找的文件列表
for (int i = 0; i < files.length; i++) {
System.out.println(files[i].getAbsolutePath());
}
ImageFilter imageFilter = new ImageFilter();// 创建一个图片过滤器
File[] images = file.listFiles(imageFilter);// 使用过滤器查找图片文件
// 输出查找的文件列表
for (int i = 0; i < images.length; i++){
System.out.println(images[i].getAbsolutePath());
}
}
}

//随机访问文件内容

package test.File;
import java.io.RandomAccessFile;
public class TestRandomAccessFile {
public static void main(String[] args) {
try {
RandomAccessFile file = new RandomAccessFile("D:/demo/test.txt", "rw");
// 定位读取位置
file.seek(1);
// 读取文件长度
long size = file.length();
System.out.println("文件大小："+size);
// 读取一个字节
int c = file.read();
System.out.println((char)c);
// 读取字节数组
byte[] b = new byte[3];
file.read(b);
String str = new String(b);
System.out.println(str);
// 读取字节数组
byte[] b2 = new byte[3];
file.read(b2, 1, 2);
String str2 = new String(b2);
System.out.println(str2);
// 读取一行数据
System.out.println(file.readLine());
// 写入一个字节
file.write(100);
// 写入字节数组
byte[] bw = new byte[3];
bw[0] = 100;
bw[1] = 101;
bw[2] = 102;
file.write(bw);
// 写入字节数组
file.write(bw, 1, 2);
// 写入字符串
file.writeBytes("AA");
file.writeChars("DD");
// 写入中文字符
file.writeUTF("中国");
// 关闭文件
file.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}

//输入流操作

//FileInputStream(文件输入流)

package test.InputStream;


import java.io.FileInputStream;
import java.io.IOException;


public class TestFileInputStream {


public static void main(String[] args) {
try {
// 创建输入流
FileInputStream is = new FileInputStream("D:/demo/test.txt");
// 从输入流读取数据
while (is.available() > 0) {
int c = is.read();
System.out.print((char)c);
}
// 关闭输入流
is.close();
} catch (IOException e) {
}
}
}

//BufferedInputStream(缓存输入流)

package test.InputStream;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class TestBufferedInputStream {
public static void main(String[] args) {
try {
// 创建输入流
FileInputStream is = new FileInputStream("D:/demo/test.txt");
BufferedInputStream bis = new BufferedInputStream(is);
// 从输入流读取数据
while (bis.available() > 0) {
int c = bis.read();
System.out.print((char)c);
}
// 关闭输入流
bis.close();
is.close();
} catch (IOException e) {
}
}
}

//DataInputStream 数据输入流

package test.InputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.DataInputStream;
public class TestDataInputStream {


public static void main(String[] args) {
try {
// 创建文件输入流
FileInputStream fis = new FileInputStream("D:/demo/data.tmp");
// 创建数据输入流
DataInputStream dis = new DataInputStream(fis);
// 读取对象数据
int i = dis.readInt();
boolean b = dis.readBoolean();
float f = dis.readFloat();
System.out.println("i=" + i);
System.out.println("b=" + b);
System.out.println("f=" + f);

// 关闭输入流
dis.close();
fis.close();
} catch (IOException e) {
}
}
}

//行号输入流（LineNumberInputStream），按行号来读取文件内容；

package test.InputStream;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.LineNumberInputStream;
public class TestLineNumberInputStream {
public static void main(String[] args) {
try {
// 创建文件输入流
FileInputStream fis = new FileInputStream("D:/demo/test.txt");
// 创建行号输入流
LineNumberInputStream lis = new LineNumberInputStream(fis);
// 创建数据输入流
DataInputStream dis = new DataInputStream(lis);
// 读取数据
String line;
while ((line = dis.readLine()) != null) {
System.out.println(lis.getLineNumber() + ":" + line);
}
// 关闭输入流
dis.close();
lis.close();
fis.close();
} catch (IOException e) {
}
}
}

//按行读取文件中json字符格式，第一行存在一个 空字符 问题解决

line.getBytes()[0]+255; //按字节读取出来

line.charAt(0);//按行读取出来

问题原因，文本编辑是用的是 utf-8格式，改成utf-8 无POM格式即可

try {
// 创建文件输入流
FileReader fis = new FileReader("D:/demo/test.txt");
// 创建行号输入流
LineNumberReader lis = new LineNumberReader(fis);
// 读取数据
String line;
while ((line = lis.readLine()) != null&&!((line = lis.readLine()).equals(""))) {
//System.out.println(lis.getLineNumber() + ":" + line);
//System.out.println( line);
 JSONObject jsonObject = new JSONObject(line.trim());
 System.out.println( jsonObject.getString("11"));
}
// 关闭输入流
lis.close();
fis.close();
} catch (IOException e) {
}

//对象输入流（ObjectInputStream）
package test.InputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.Date;
public class TestObjectInputStream {
public static void main(String[] args) {
try {
// 创建文件输入流
FileInputStream fis = new FileInputStream("D:/demo/test.tmp");
// 创建对象输入流
ObjectInputStream ois = new ObjectInputStream(fis);
// 读取对象数据
int i = ois.readInt();
String str = (String) ois.readObject();
Date date = (Date) ois.readObject();
System.out.println("i=" + i);
System.out.println("str=" + str);
System.out.println("date" + date);

// 关闭输入流
ois.close();
fis.close();
} catch (IOException e) {
} catch (ClassNotFoundException e) {
}
}
}

//管道输入输出流（PipedOutputStream）

package test.InputStream;
import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
public class TestPipedInputStream {
public static void main(String[] args) {
try {
// 创建管道输出流
PipedOutputStream os = new PipedOutputStream();
// 创建输入流
PipedInputStream is = new PipedInputStream(os);
// 从输出流写入数据
byte[] b = new byte[3];
b[0] = 100;
b[1] = 101;
b[2] = 102;
os.write(b);
// 从输入流读取数据
while (is.available() > 0) {
int c = is.read();
System.out.print((char)c);
}
// 关闭输入流
is.close();
// 关闭输出流
os.close();
} catch (IOException e) {
}
}
}

//推会输入流（PushbackInputStream）

package test.InputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.PushbackInputStream;
public class TestPushbackInputStream {
public static void main(String[] args) {
try {
// 创建文件输入流
FileInputStream fis = new FileInputStream("D:/demo/test.txt");
// 创建推回输入流
PushbackInputStream pis = new PushbackInputStream(fis);
// 读取对象数据
int c = pis.read();
System.out.print((char)c);
pis.unread(c);// 推回一个字节
c = pis.read();// 再次读取
System.out.print((char)c);
// 关闭输入流
pis.close();
fis.close();
} catch (IOException e) {
}
}
}

//序列输入流（SequenceInputStream）

package test.InputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;
public class TestSequenceInputStream {
public static void main(String[] args) {
try {
// 创建输入源数组
FileInputStream fis1 = new FileInputStream("D:/demo/test.txt");
FileInputStream fis2 = new FileInputStream("D:/demo/test2.txt");
Vector<FileInputStream> vector = new Vector<FileInputStream>();
vector.add(fis1);
vector.add(fis2);
Enumeration<FileInputStream> e = vector.elements();
// 创建序列输入源
SequenceInputStream is = new SequenceInputStream(e);
// 从输入流读取数据
while (is.available() > 0) {
int c = is.read();
System.out.print((char)c);
}
// 关闭输入流
is.close();
} catch (IOException e) {
}
}
}

//StringBufferInputStream(字符串缓存输入流)

package test.InputStream;


import java.io.IOException;
import java.io.StringBufferInputStream;


public class TestStringBufferInputStream {


public static void main(String[] args) {
try {
// 创建输入流
StringBufferInputStream is = new StringBufferInputStream("Hello,World!");

// 从输入流读取数据
while (is.available() > 0) {
int c = is.read();
System.out.print((char)c);
}

// 关闭输入流
is.close();
} catch (IOException e) {
}
}
}

//ByteArrayInputStream（数组输入流）

package test.InputStream;
import java.io.ByteArrayInputStream;
import java.io.IOException;
public class TestByteArrayInputStream {
public static void main(String[] args) {
// 初始化字节数组
byte[] buf = new byte[3];
buf[0] = 100;
buf[1] = 101;
buf[2] = 102;
try {
// 创建输入流
ByteArrayInputStream is = new ByteArrayInputStream(buf);
// 从输入流读取数据
byte[] b = new byte[3];
is.read(b);
System.out.println(new String(b));
// 关闭输入流
is.close();
} catch (IOException e) {
}
}
}

//输出流操作

// 系统输入输出（System）

//读写操作（Reader、Writer）