------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
1.
import java.io.*;
class FileDemo2
{
public static void main(String[] args)throws IOException
{
//listFiles() ;
test();
}
//File对象必须是封装了一个目录，该目录必须存在
public static void ListDemo()
{
//如果文件d.txt下面没有其他文件，则输出空
File f = new File("f:\\d.txt");
String[] lists = f.list();
for(String s:lists)
{
sop(s);
}
}
//列出所有盘符
public static void listRoots()
{
File[] f1 = File.listRoots();
for(File f:f1)
{
sop(f);
}
}
//过滤出指定格式的文件
public static void list()
{
File f = new File("c:\\");
String[] arr = f.list(new FilenameFilter(){
public boolean accept(File dir, String name)
{
//sop("dir:"+dir+" name:"+name);
return name.endsWith(".java");
}
});
sop("length:"+arr.length);
for(String s:arr)
{
sop(s);
}
}
//返回指定路径名目录下的文件对象
public static void listFiles()
{
File f = new File("F:\\java系列教程视频\\黑马教学视频");
File[] files = f.listFiles();
for(File ff:files)
{
sop("名称:"+ff.getName());
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}2.
/*
列出指定目录下文件或者文件夹，包含子目录的内容。
因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
在列出过程中出现的还是目录的话，还可以再次调用本功能。也就是函数自身调用自身。
这种表现形式，或者编程手法，称为递归。
递归注意：
1.限定条件
2.注意递归次数，避免内存溢出
*/
import java.io.*;
class FileDemo3
{
public static void main(String[] args)
{
File f = new File("F:\\java系列教程视频\\黑马教学视频\\java练习代码");
show(f,0);
}
public static String getLevel(int level)
{
StringBuilder sb = new StringBuilder();
for(int x = 0;x<level;x++)
{
sb.append("|--");
}
return sb.toString();
}
//递归出指定文件下的所有目录
public static void show(File f,int level)
{
sop(getLevel(level)+f.getName());
level++;
File[] files = f.listFiles();
for(int x = 0;x<files.length;x++)
{
if(files[x].isDirectory())
{
show(files[x],level);
}else{
//输出的是文件的绝对路径名
sop(getLevel(level)+files[x]);
}
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}3.
/*
删除一个带内容的目录
删除原理：
在windows中，删除目录从里面往外删除的
既然从里到外删除，就需要用到递归
*/
import java.io.*;
class RemoveDir
{
public static void main(String[] args)
{
File f = new File("f:\\d.txt");
removeDir(f);
}
//删除带内容的目录
public static void removeDir(File f)
{
File[] dir = f.listFiles();
for(int x = 0;x<dir.length;x++)
{
//如果是目录，就继续递归
if(dir[x].isDirectory())
{
removeDir(dir[x]);
}else {
sop(dir[x]+"---file---"+dir[x].delete());
}
}
//删除完文件，就把此目录删除掉
sop(f+"---dir---"+f.delete());
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}4.
/*
练习：
将一个指定目录下的java文件的绝对路径，存储到一个文本文件中
建立一个java文件列表文件
思路：
1.对指定的目录进行递归
2.获取递归过程所有的java文件的路径
3.将这些路径存储到集合中
4.将集合中的数据写到一个文件中。
*/
import java.io.*;
import java.util.*;
class JavaFileList
{
public static void main(String[] args)
{
File f = new File("F:\\java系列教程视频\\黑马教学视频\\java练习代码");
List<File> list = new ArrayList<File>();
fileToList(f,list);
sop(list.size());
File javaFileList = new File(f,"javaFileList.txt");
writeToFile(list,javaFileList.toString());
}
/*
将.java文件的绝对路径存储到集合中
利用递归
*/
public static void fileToList(File dir,List<File> list)
{
File[] files = dir.listFiles();
for(File f:files)
{
if(f.isDirectory())
{
fileToList(f,list);
} else {
if(f.toString().endsWith(".java"))
{
list.add(f);
}
}
}
}
//将集合中的数据写到指定文件中
public static void writeToFile(List<File> list,String fileName)
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(fileName));
for(File f:list)
{
bw.write(f.getAbsolutePath());
bw.newLine();
bw.flush();
}
}catch(IOException e)
{
throw new RuntimeException("error");
}finally
{
bw.close();
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}5.Properties的用法
/*
Properties是hashtable的子类
也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。
是集合中和IO技术相结合的集合容器。
该对象的特点，可以用于键值对形式的配置文件
加载数据时，需要数据有固定格式： 键=值
*/
import java.util.*;
import java.io.*;
class PropertiesDemo
{
public static void main(String[] args) throws IOException
{
//method_01();
loadDemo();
}
public static void loadDemo() throws IOException
{
//从输入流中读取属性列表
FileInputStream fis = new FileInputStream("F:\\java系列教程视频\\黑马教学视频\\java练习代码\\info.txt");
Properties prop = new Properties();
prop.load(fis);
sop(prop);
prop.setProperty("wangwu","99");
//将属性列表写入输出流
FileOutputStream fos = new FileOutputStream("F:\\java系列教程视频\\黑马教学视频\\java练习代码\\info.txt");
prop.store(fos,"shuchu");
fis.close();
fos.close();
}
//将info.txt文件中的键值存储到集合中
public static void method_01() throws IOException
{
BufferedReader br = new BufferedReader(new FileReader("F:\\java系列教程视频\\黑马教学视频\\java练习代码\\info.txt"));
String temp = null;
Properties pro = new Properties();
while((temp=br.readLine())!=null)
{
String[] arr = temp.split("=");
pro.setProperty(arr[0],arr[1]);
}
sop(pro);
br.close();
}
//Properties的Set和Get方法
public static void setAndGet()
{
Properties prop = new Properties();
prop.setProperty("zhangsan","20");
prop.setProperty("lisi","22");
sop(prop);
String value = prop.getProperty("lisi");
sop("value:"+value);
Set<String> name = prop.stringPropertyNames();
for(String s:name)
{
sop("key："+s+" value:"+prop.getProperty(s));
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}6.用于记录应用程序运行次数。如果使用次数已到，那么给出注册提示。
/*
用于记录应用程序运行次数。
如果使用次数已到，那么给出注册提示。
很容易想到的是计数器。
但是随着程序的结束，计数值在内存中也消失。
所以要建立一个配置文件，用于记录该软件的使用次数。
使用键值对的形式，这样便于操作数据。使用数据。
键值数据是map集合，数据是以文件形式存储，使用IO技术
map加IO就是properties
配置文件可以实现应用程序数据的共享。
*/
import java.io.*;
import java.util.*;
class RunCount
{
public static void main(String[] args) throws IOException
{
//配置文件info.ini
File f = new File("info.ini");
//如果文件不存在就创建文件
if(!f.exists())
f.createNewFile();
//读取配置文件
FileInputStream fis = new FileInputStream(f);
Properties prop = new Properties();
prop.load(fis);
int count = 0;
//获取文件的配置信息
String value = prop.getProperty("time");
if(value != null)
count = Integer.parseInt(value);
count++;
//如果达到使用上限则返回
if(count == 5){
System.out.println("使用次数已到");
return;
}
//更改配置信息，并写入配置文件中
prop.setProperty("time",count+"");
FileOutputStream fos = new FileOutputStream(f);
prop.store(fos,"");
fis.close();
fos.close();
}
}
7.
/*
打印流：
该流提供了打印方法，可以将各种数据类型的数据都原样打印
字节打印流
PrintStream
构造函数可以接收的类型：
1.File对象 File
2.字节输出流 OutputStream
3.字符串路径 String
字符打印流
PrintWriter
构造函数可以接收的类型：
1.File对象 File
2.字节输出流 OutputStream
3.字符串路径 String
4.字符输出流 Writer
*/
import java.io.*;
class PrintStreamDemo
{
public static void main(String[] args) throws IOException
{
//键盘读取的格式！！！1
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
//printWriter输出，此构造方法意思，会自动将数据刷新到print.txt文件中
PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter(new File("print.txt"))),true);
String temp = null;
while((temp=bufr.readLine())!=null)
{
pw.println(temp);
}
bufr.close();
pw.close();
}
}
8.序列流将多个读取流合并成一个流 SequenceInputStream
/*
序列流将多个读取流合并成一个流
*/
import java.util.*;
import java.io.*;
class SequenceDemo
{
public static void main(String[] args) throws IOException
{
Vector<InputStream> v = new Vector<InputStream>();
v.add(new FileInputStream("1.txt"));
v.add(new FileInputStream("2.txt"));
v.add(new FileInputStream("3.txt"));
//获取枚举，类型是InputStream
Enumeration<InputStream> en = v.elements();
//将两个以上的流合并成一个流，构造函数必须为InputStream的枚举类型
SequenceInputStream sis = new SequenceInputStream(en);
PrintStream ps = new PrintStream(new FileOutputStream(new File("4.txt")));
byte[] buff = new byte[1024];
//获取数组的长度
int len = 0;
while((len=sis.read(buff))!=-1)
{
ps.write(buff,0,len) ;
ps.println();
ps.flush();
}
sis.close();
ps.close();
}
}
9.
/*
文件的切割，与合并
合并时，利用SequenceInputStream,但是不适用Vector效率低，适用ArrayList
*/
import java.io.*;
import java.util.*;
class SplitFile
{
public static void main(String[] args) throws IOException
{
//splitFile();
merge();
}
//切割文件
public static void splitFile()throws IOException
{
BufferedInputStream bufr = new BufferedInputStream(new FileInputStream(new File("splitFile\\a.jpg")));
byte[] b = new byte[1024*1024];
int len = 0;
int count = 1;
while((len=bufr.read(b))!=-1)
{
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(new File("splitFile\\"+(count++)+".part")));
bos.write(b,0,len);
bos.close();
}
bufr.close();
}
//合并文件，利用ArrrayList获得枚举数据
public static void merge() throws IOException
{
ArrayList<FileInputStream> arr = new ArrayList<FileInputStream>();
arr.add(new FileInputStream(new File("splitFile\\1.part")));
arr.add(new FileInputStream(new File("splitFile\\2.part")));
final Iterator<FileInputStream> it = arr.iterator();
Enumeration<FileInputStream> en = new Enumeration<FileInputStream>(){
public boolean hasMoreElements()
{
return it.hasNext();
}
public FileInputStream nextElement()
{
return it.next();
}
};
SequenceInputStream sis = new SequenceInputStream(en);
FileOutputStream fos = new FileOutputStream("splitFile\\6.jpg");
byte[] b = new byte[1024];
int len = 0;
while((len=sis.read(b))!=-1)
{
fos.write(b,0,len);
}
sis.close();
fos.close();
}
}10.静态不能序列化。
修饰符：transient,修饰变量后，此变量也不能被序列化。只能存在堆内存中
对象的序列化。
import java.io.*;
class ObjectStreamDemo
{
public static void main(String[] args) throws Exception
{
//writeObj();
readObj();
}
public static void readObj()throws Exception
{
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));
Person p = (Person)ois.readObject();
System.out.println(p);
ois.close();
}
public static void writeObj()throws IOException
{
ObjectOutputStream oos =
new ObjectOutputStream(new FileOutputStream("obj.txt"));
oos.writeObject(new Person("lisi0",399,"kr"));
oos.close();
}
}11.RandomAccessFile
该类不算是IO体系中子类、
而是直接继承Object.
但是他是IO包中成员，因为它具备读和写的功能。
内部封装了一个数组，而且通过指针对数据的元素进行操作。
可以通过getFilePointer获取指针位置。
同时，可以通过seek改变指针的位置。
其实完成读写的原理就是内部封装了字节流输入和输出流。
通过构造函数可以看出，该类只能操作文件，而且操作文件还有模式。
只读r 读写rw等。
如果模式为只读r，不会创建文件，会去读取一个已存在文件，果然该文件不存在，会出现异常。
如果模式为rw,操作的文件不存在则创建，存在也不会被覆盖.
import java.io.*;
class RandomAccessFileDemo
{
public static void main(String[] args) throws IOException
{
//writeFile_2();
//readFile();
//System.out.println(Integer.toBinaryString(258));
}
public static void readFile()throws IOException
{
RandomAccessFile raf = new RandomAccessFile("ran.txt","r");
//调整对象中指针。
//raf.seek(8*1);
//跳过指定的字节数
raf.skipBytes(8);
byte[] buf = new byte[4];
raf.read(buf);
String name = new String(buf);
int age = raf.readInt();
System.out.println("name="+name);
System.out.println("age="+age);
raf.close();
}
public static void writeFile_2()throws IOException
{
RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");
raf.seek(8*0);
raf.write("周期".getBytes());
raf.writeInt(103);
raf.close();
}
public static void writeFile()throws IOException
{
RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");
raf.write("李四".getBytes());
raf.writeInt(97);
raf.write("王五".getBytes());
raf.writeInt(99);
raf.close();
}
}12.DataInputStream 可以用于操作基本数据类型
/*
DataInputStream与DataOutputStream
可以用于操作基本数据类型的数据的流对象。
*/
import java.io.*;
class DataStreamDemo
{
public static void main(String[] args) throws IOException
{
//writeData();
//readData();
//writeUTFDemo();
// OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("gbk.txt"),"gbk");
//
// osw.write("你好");
// osw.close();
// readUTFDemo();
}
public static void readUTFDemo()throws IOException
{
DataInputStream dis = new DataInputStream(new FileInputStream("utf.txt"));
String s = dis.readUTF();
System.out.println(s);
dis.close();
}
public static void writeUTFDemo()throws IOException
{
DataOutputStream dos = new DataOutputStream(new FileOutputStream("utfdate.txt"));
dos.writeUTF("你好");
dos.close();
}
public static void readData()throws IOException
{
DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
int num = dis.readInt();
boolean b = dis.readBoolean();
double d = dis.readDouble();
System.out.println("num="+num);
System.out.println("b="+b);
System.out.println("d="+d);
dis.close();
}
public static void writeData()throws IOException
{
DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
dos.writeInt(234);
dos.writeBoolean(true);
dos.writeDouble(9887.543);
dos.close();
}
}
13.管道类PipedInputStream
import java.io.*;
class Read implements Runnable
{
private PipedInputStream in;
Read(PipedInputStream in)
{
this.in = in;
}
public void run()
{
try
{
byte[] buf = new byte[1024];
System.out.println("读取前。。没有数据阻塞");
int len = in.read(buf);
System.out.println("读到数据。。阻塞结束");
String s= new String(buf,0,len);
System.out.println(s);
in.close();
}
catch (IOException e)
{
throw new RuntimeException("管道读取流失败");
}
}
}
class Write implements Runnable
{
private PipedOutputStream out;
Write(PipedOutputStream out)
{
this.out = out;
}
public void run()
{
try
{
System.out.println("开始写入数据，等待6秒后。");
Thread.sleep(6000);
out.write("piped lai la".getBytes());
out.close();
}
catch (Exception e)
{
throw new RuntimeException("管道输出流失败");
}
}
}
class PipedStreamDemo
{
public static void main(String[] args) throws IOException
{
PipedInputStream in = new PipedInputStream();
PipedOutputStream out = new PipedOutputStream();
in.connect(out);
Read r = new Read(in);
Write w = new Write(out);
new Thread(r).start();
new Thread(w).start();
}
}
扫一扫
627
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
