黑马程序员-----Java基础-----IO流-3

-----<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

IO流学习-3

import java.io.*;
public class test1
{
public static void main(String[] args) throws IOException
{
// TODO Auto-generated method stub
//将a.txt 封装成file对象。可以将已有的和未出现的文件或者文件夹封装成对象
File f1 =new File ("a.txt");

File f2 = new File("c:\\adc","b.txt");

File d = new File("c:\\abc");
File f3 =new File(d,"c.txt");
//Fil.separator跨平台分隔符。
File f4 =new File("c:"+File.separator+"abc"+File.separator+"d.txt");

//show3();
//listRootsDemo();
listDemo();

}

File类常见用法：
1，创建
boolean createNewFile();在指定位置创建文件，如果该文件存在，创建失败，返回false
和输出流不一样，输出流会覆盖原有文件。

2，删除
boolean delete(); 删除失败返回false
void deleteOnExit(); 在程序退出时删除指定文件。

boolean mkdir(); 创建文件夹
boolean mkdirs();创建多级文件夹

3，判断
boolean exists(); 文件是否存在。
isFile(); 是否是文件
ifDirectory(); 是否是文件夹
isHidden(); 是否是隐藏文件
isAbsolute(); 相对路径还是绝对路径

4.获取信息
getName();获取名称
getPath();获取路径
getParent();

getAbsolute();
getModified();
length();

renameTO();//相当于剪切

public static void show3()throws IOException
{
File f =new File("file.txt");
sop(f.getPath());
sop(f.getAbsolutePath());
sop(f.getParent());//相对路径返回空。绝对路径返回父目录。
}

public static void show2()throws IOException
{
File f =new File("r.java");
sop(f.exists());//是否存在
sop(f.canExecute());

File dir = new File("adc");
sop(dir.mkdir());
}
public static void show1()throws IOException
{
File f =new File("e.txt");

//f.createNewFile();
//f.canExecute()//是否可执行、
//f.mkdir();//建立文件夹、
sop(f.isDirectory());//必须建立文件夹后才可以判断出来真假。
sop(f.isFile());//必须建立文件后才可以判断出来真假。
}
public static void show()throws IOException
{
File f =new File("file.txt");
sop(f.createNewFile());
f.deleteOnExit();
f.delete();
}
public static void sop(Object obj)
{
System.out.println(obj);
}

public static void listRootsDemo()
{
File[] files = File.listRoots();
for(File f :files)
System.out.println(f);//打印盘符
}
public static void listDemo()
{
File f =new File("c:");
String[] names =f.list();//调用list的 file对象必须是封装了一个目录。
for(String s :names) //如果是一个文件返回为空。
System.out.println(s);

}
}
----------
package IO3;
import java.io.*;
public class test2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//file();
file1();
}
public static void file1()
{
File dir =new File("D:\\");
File[] files =dir.listFiles();

for(File f :files)
{
System.out.println(f.getName()+"--"+f.length());
}

}
public static void file()
{
File dir =new File("D:\\迅雷下载");
String[] arr =dir.list(new FilenameFilter()
{
public boolean accept(File dur,String name)
{
return true;
//return name.endsWith(".mp4");//返回只有.MP4文件。
}
});
System.out.println(arr.length);
for(String name : arr){
System.out.println(name);
}
}
}
-------------
package IO3;
//列出指定目录下文件或者文件夹，包含子目录中的内容

因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
在列出过程中出现的还是目录的话，还可以再次调用本功能。
也就是函数自身调用自身。
这种形式，或者变成手法，称为递归。

递归要注意

1.限定条件

2.要注意递归次数，尽量避免内存溢出。

import java.io.*;
public class test3 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//File dir =new File("d:\\迅雷下载");
//showDir(dir);

//toBin(6);

System.out.println(getSum(5000));

}
public static int getSum(int n) {
if(n==1)
return 1;
return n+getSum(n-1);
}

public static void toBin(int num) {
//将6转换成2进制，下面是循环方法，在下面是递归方法。
// while(num >0)
// {
// System.out.println(num%2);
// num = num/2;
// }
if(num >0)
{
toBin(num/2);
System.out.println(num%2);
}
}

public static void showDir(File dir) {
// TODO Auto-generated method stub
System.out.println(dir);
File[] files =dir.listFiles();
for (int i = 0; i < files.length; i++) {
if(files[i].isDirectory())
showDir(files[i]);
else
System.out.println(files[i]);
}
}
//调用showA输出CBA.
void showA()
{
showB();
sop("A");
}
void showB()
{
showC();
sop("B");
}
void showC()
{
sop("C");
}
public void sop(Object obj)
{
System.out.println(obj);
}
}
---------------
package IO3;
//打印分级目录文件
import java.io.File;

public class test4 {

public static void main(String[] args) {
// TODO Auto-generated method stub
File dir =new File("d:\\迅雷下载");
showDir(dir,0);
}
public static String getLevel(int level) {
StringBuilder sb =new StringBuilder();
for (int i = 0; i < level; i++) {
sb.append("| - - ");
}
return sb.toString();
}
public static void showDir(File dir,int level) {
// TODO Auto-generated method stub
System.out.println(getLevel(level)+dir.getName());
level++;
File[] files =dir.listFiles();
for (int i = 0; i < files.length; i++) {
if(files[i].isDirectory())
showDir(files[i],level);
else
System.out.println(getLevel(level)+files[i]);
}
}

}
-----------
package IO3;

删除一个带内容的目录
删除原理
在windows中，删除目录从里面往外删除的

既然是从里往外删除，就需要用到递归。

import java.io.*;
public class test5 {
public static void main(String[] args) {
File dir =new File("d:\\remove");
removeDir(dir);
}
public static void removeDir(File dir)
{
File[] files =dir.listFiles();
for (int i = 0; i < files.length; i++) {
if(files[i].isDirectory())//有隐藏文件，files[i].isHidden()&&files[i].isDirectory.
removeDir(files[i]);
else
System.out.println(files[i].toString()+"-file-"+files[i].delete());
}
System.out.println(dir+":dir:"+dir.delete());
}

}

将一个指定目录下的java文件的绝对路径，存储到一个文本文件中。
建立一个java文件列表文件。
思路：
1，对指定的目录进行递归。
2，获取递归过程中所有的java文件的路径。
3，将这些路径存储到集合中。
4，将集合中的数据写入到一个文件中。

import java.util.*;
import java.io.*;
public class test5
{
public static void main(String[] args) throws IOException
{

File dir = new File("d:\\java");
List<File> list = new ArrayList<File>();
fileToList(dir,list);
//System.out.println(list.size());

File file =new File(dir,"javalist.txt");
writeToFile(list,file.toString());
}

public static void fileToList(File dir,List<File> list)
{
File[] files = dir.listFiles();
for(File file :files)
{
if(file.isDirectory())
{

fileToList(file,list);
}
else
{

if(file.getName().endsWith(".java"))
{

list.add(file);
}
}

}
}
public static void writeToFile(List<File> list ,String javaListFile)throws IOException
{
BufferedWriter bfw =null;
try {
bfw =new BufferedWriter(new FileWriter(javaListFile));
for(File f :list)
{
String path = f.getAbsolutePath();
bfw.write(path);
bfw.newLine();
bfw.flush();
}
}
catch (IOException e)
{
throw e;
}
finally
{
try {
if(bfw!=null);
bfw.close();
} catch (IOException e) {
throw e;
}
}
}
}
---------------
package IO3;
import java.io.*;
import java.util.*;

Properties是hashtable的子类；
也就是说它具备map集合的特点，而且他里面存储的键值对都是字符串。

是集合和IO技术相结合的集合容器。
该对象的特点：
可以用于键值对形式的配置文本。
那么在加载数据时，需要数据有固定格式：键=值

public class test6
{
//演示，如何将流中的数据存储到集合中
//想要将info.txt中键值数据存到集合中进行操作。

思路：
1,用一个流和info。txt文件关联
2，读取一行数据，将该行数据用=进行切割
3，等号左边为键，右边为值，存入到properties中即可。

public static void loadDemo()throws IOException
{
Properties prop = new Properties();

//FileInputStream fis = new FileInputStream("info.txt");
FileReader fis = new FileReader("info.txt");

//将流中的数据加载进集合。
prop.load(fis);
//修改数据,是内存中的。
prop.setProperty("wefi", "3900");
//保存修改后的数据
FileOutputStream fos =new FileOutputStream("info.txt");
prop.store(fos, "haha");

prop.list(System.out);
fis.close();
fos.close();
}
public static void show()throws IOException
{
BufferedReader bfr =new BufferedReader(new FileReader("info.txt"));
String line =null;
while((line =bfr.readLine())!=null)
{
String[] arr =line.split("=");
System.out.println(arr[0]+"---"+arr[1]);
//System.out.println(line);
}
bfr.close();
}
public static void main(String[] args)throws IOException
{
// TODO Auto-generated method stub
//setAndGet();
loadDemo();
//show();
}
//设置和获取元素
public static void setAndGet()
{
Properties prop = new Properties();

prop.setProperty("zhangsan", "30");
prop.setProperty("lisi", "39");

//System.out.println(prop);

String value =prop.getProperty("lisi");
//System.out.println(value);

//修改年龄
prop.setProperty("lisi", "90");
Set<String> names =prop.stringPropertyNames();
for(String s :names)
{
System.out.println(s+":"+prop.getProperty(s));//打印名字和年龄。
}
}

}
---------------
package IO3;

用于记录应用程序运行次数。
如果使用次数已到，那么给出注册提示。
思路：
很容易想到计数器，随着程序运行而在内存中存在，并
进行自增。
可是，随着该应用程序的推出，计数器也在内存中消失。

下一次再启动程序，又重新开始从0计数，不是想要的。

程序即使结束，该计数器的值，也是存在的，下次程序启动会
先加载计数器的值，并+1后重新存储起来。

所以要建立一个配置文件，用于记录该软件的使用次数。
该配置文件使用键值对的形式，
这样便于阅读数据，并操作数据。

键值对数据是map集合
数据是以文件形式存储，使用io技术
那么map+io————》properties

配置文件可以实现应用程序数据的共享

import java.io.*;
import java.util.*;
public class test7 {

public static void main(String[] args)throws IOException
{
Properties prop =new Properties();

File file =new File("count.ini");//封装对象，可以做判断，流做不了。
if(!file.exists())
file.createNewFile();

FileInputStream fis =new FileInputStream("count.ini");
prop.load(fis);//加载流中数据。

int count =0;
String value =prop.getProperty("time");
if(value!=null)
{
count = Integer.parseInt(value);//判断计数。
if(count >= 5)
{
System.out.println("你好，拿钱。");
return;
}
}

count++;

prop.setProperty("time", count+"");
FileOutputStream fos =new FileOutputStream(file);

prop.store(fos, "");

fis.close();
fos.close();
}
}
--------------
package IO3;

打印流
该流提供了打印方法，可以将各种数据类型的数据都原样打印。

PrintStream
构造函数可以接受的参数类型
1，file对象 File
2,字符串路径 String
3，字节输出流 OutputStream

PrintWriter
构造函数可以接受的参数类型
1，file对象 File
2,字符串路径 String
3，字节输出流 OutputStream
4，字符输出流 Writer

import java.io.*;
public class test8 {
public static void main(String[] args)throws IOException
{
BufferedReader bfr = new BufferedReader(new InputStreamReader(System.in));
// PrintWriter out = new PrintWriter(System.out);
// PrintWriter out = new PrintWriter(System.out,true);//自动刷新。
// PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true);//自动刷新。
//提高效率
PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("a.txt")),true) ;//自动刷新。

String line =null;
while((line =bfr.readLine())!= null)
{
if("over".equals(line))
{
break;
}
out.println(line.toUpperCase());
//out.flush();
}
out.close();
bfr.close();
}
}
------------
package IO3;
合并流
import java.util.*;
import java.io.*;
public class test9 {
public static void main(String[] args)throws IOException
{
// TODO Auto-generated method stub
Vector<FileInputStream> v =new Vector<FileInputStream>();

v.add(new FileInputStream("c:1.txt"));
v.add(new FileInputStream("c:2.txt"));
v.add(new FileInputStream("c:3.txt"));

Enumeration<FileInputStream> en =v.elements();

SequenceInputStream sis =new SequenceInputStream(en);

FileOutputStream fos =new FileOutputStream("c:4.txt");

byte []buf =new byte [1024];
int len =0;
while((len =sis.read())!= -1)
{
fos.write(buf ,0 ,len);
}
fos.close();
sis.close();
}
}
-----------------
package IO3;
切割流
import java.util.*;
import java.io.*;
public class test91
{
public static void main(String[] args) throws IOException
{
//split();//切割
merge();//合并
}

public static void merge() throws IOException
{
ArrayList<FileInputStream> al=new ArrayList<FileInputStream>();
for(int x =1;x <=4 ; x++)
{
al.add(new FileInputStream("split\\"+x+".part"));
}
final Iterator<FileInputStream> it =al.iterator();

Enumeration<FileInputStream> en =new Enumeration<FileInputStream>() {
//枚举
@Override
public FileInputStream nextElement() {
// TODO Auto-generated method stub
return it.next();
}

@Override
public boolean hasMoreElements() {
// TODO Auto-generated method stub
return it.hasNext();
}
};
SequenceInputStream sis =new SequenceInputStream(en);

FileOutputStream fos = new FileOutputStream("split\\0.jpg");
byte [] buf =new byte[1024];
int len =0;
while((len =sis.read(buf))!= -1)
{
fos.write(buf,0,len);

}
fos.close();//关闭流
sis.close();
}
public static void split() throws IOException
{
FileInputStream fis =new FileInputStream("1.jpg");
FileOutputStream fos = null;

byte[] buf = new byte[1024*1024];
int len =0;
int count =1;
while((len =fis.read(buf))!= -1)
{
fos=new FileOutputStream("split//"+(count++)+".part");
fos.write(buf,0,len);
fos.close();
}
fis.close();
}

}

黑马程序员-----Java基础-----IO流-3相关推荐

黑马程序员-JAVA基础-IO流之字符流和字符流缓冲区
------- android培训.java培训.期待与您交流!------- Java 的IO 流是实现输入和输出的基础,Java 中把不同的输入.输出源抽象表述为"流" (S ...
黑马程序员-JAVA基础-IO流之流操作规律及读写转换流
------- android培训.java培训.期待与您交流!------- 在操作IO流时,常常会迷惑:流对象很多,不知道该使用哪一个? 一.流操作的基本规律: 通过三个明确来完成: 1.明确'源 ...
黑马程序员——Java基础--IO流(一)---File类以及其他流对象
------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 一.File类 File类是将文件系统中的文件和文件夹封装成了对象.提供了更多的属性和行为可以对 ...
黑马程序员-JAVA基础-IO流中的装饰设计模式
------- android培训.java培训.期待与您交流!------- 装饰设计模式: 当想要对已有的对象进行功能增强时,可以定义类,将已有的对象传入,基于已有的功能,并提供加强功能.那么,自 ...
黑马程序员——Java基础---IO(下)
黑马程序员--Java基础---IO(下) ------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------ 一.概述 Java除了基本的字节流.字符流之外,还提供 ...
黑马程序员-java基础8--IO流(一)
------- android培训.java培训.期待与您交流! ---------- @@day(18)IO字符流之FileWriter.FileReader******************** ...
黑马程序员——Java基础---流程控制
黑马程序员--Java基础---流程控制 ------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------ 一．概述 Java提供了两种基本的流程控制结构:分支结构 ...
黑马程序员---java基础-Java之IO
------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 一.概念 1.概念 IO流用来处理设备之间的数据传输 Java对数据的操作是通过流的方式 Jav ...
黑马程序员--Java基础加强篇
开发工具使用 --------------------------------------------------------------------------------------------- ...

黑马程序员-----Java基础-----IO流-3

黑马程序员-----Java基础-----IO流-3相关推荐

最新文章

热门文章