黑马程序员java学习，IO字节流及File

字节流

抽象基类InputStream OutputStream

public static void writeFile(){

 FileOutputStream fos=new FileOutputStream("fos.txt");

 fos.write("ddh".getBytes());

 fos.close();

}

public static void readFile(){

 FileInputStream fis=new FileInputStream("fos.txt");

 int ch=0;

 while((ch=fis.read())!=-1){

  System.out.println((char)ch);

 }

 fis.close();

}

public static void readFile_2(){

 FileInputStream fis=new FileInputStream("fos.txt");

 byte[] buf=new byte[1024];

 int len=0;

 while((len=fis.read(buf))!=-1){

  System.out.println(new String(buf,0,len));

 }

 fis.close();

}

//定义一个刚刚好的缓冲区，不在循环

//当数据太大的时候，容易发生内存溢出

byte[] buf=new byte[fis.available()];

fis.read(buf);

System.out.println(new String(buf));

fis.close();

 

拷贝一个图片

public static void copyPicture(){

 FileOutputStream fos=null;

 FileInputStraam fis=null;

 try{

  fos=new FileOutputStream("c:\\2.jpg");

  fis=new FileInputStream("c:\\1.jpg");

  byte[] buf=new byte[1024];

  int len=0;

  while((len=fis.read(buf))!=-1){

   fos.write(buf,0,len);

  }

 }catch(IOException e){throw new RuntimeException("Error");}

 finally{

  try{if(fis!=null) fis.close();}

  catch(IOException e){throw new RuntimeException("Error");}

  try{if(fos!=null) fos.close();}catch(IOException e){throw new RuntimeException("Error");}

 }

}

字节流缓冲区

BufferedInputStream bufis=new BufferedInputStream(new FileInputStream("1.jpg"));

BufferedOutputStream bufos=new BufferedOputStream(new FileOutputStream("2.jpg"));

int by=0;

while((by=bufis.read())!=-1){

 bufos.write(by);

}

bufos.close();

bufis.close();

  自定义字节流的缓冲区 read和write的特点

class MyBufferedInputStream{

 private InputStream in;

 private int pos=0,count=0;

 private byte[] buf=new byte[1024];

 MyBufferedInputStream(InputStream in){

  this.in=in;

 }

 //一个读取一个字节，从缓冲区(字节数组)获取

 public int myRead(){

  //通过in对象读取硬盘上的数据，并存储在buf中

  if(count==0){

   count=in.read(buf);

   if(count<0)

      return -1;

   pos=0;

   byte b=buf(pos);

   

   count--;

   pos++;

   return b;

  }

  else if(count>0){

   byte b=buf[pos];

   count--;

   pos++;

   return b;

  }

  return -1;

 }

 public void myClose(){

  in.close();

 }

} 

读取键盘录入数据，当录入一行数据后，就将该行数据进行打印

如果录入的数据时over，那么停止录入

class ReadIn{

 public static void main(String[] args)throws IOException

{

 InputStream in=System.in;

 StringBuild sb=new StringBuilder();

 while(true){

  int ch=in.read();

  if(ch=='\r')

   continue;

  if(ch=='\n'){

   String s=sb.toString();

   if("over".equals(s))

    break;

   System.out.println(s.toUpperCase());

   sb.delete(0,sb.length());

  }

  else

   sb.append((char)ch);

 }

 

 } 

}

通过刚才的键盘录入数据并打印其大写，发现其实就是读一行数据原理，就是readLine

readLine方法是BufferedReader类中的方法

而键盘录入的read方法是字节流InputStream的方法

将字节流对象转换成字符流对象，使用转换流，InputStreamReader

public static void main(String[] args){

 //获取键盘录入对象

 InputStream in=System.in;

 //将字符流对象转成字符流对象，使用转换流InputStreamReader

 InputStreamReader isr=new InputStreamReader(in);

 //为了提高效率，将字符串进行缓冲区技术高效操作，使用BufferedReader

 //可以将三句话定义成一句话

 //BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));

 BufferedReader bufr=new BufferedReader(isr);

 String line=null;

 while((line=bufr.readLine())!=null){

  if("over".equals(line))

   break;

  System.out.println(line.toUpperCase());

 }

 bufr.close();

}

写入转换流流OutStreamWriter

OutputStream out=System.out;

OutputStreamWriter osw=new OutputStreamWriter(out);

BufferedWriter bufw=new BufferedWriter(osw);

String line=null;

while((line=bufr.readLine())!=null){

 if("over".equals(line))

   break;

 bufw.write(line.toUpperCase());

 bufw.newLine();

 bufw.flush();

}

bufr.close();

 流操作规律

1.明确源和目的

  源：输入流，InputStream Reader

  目的:输出流，OutputStream Writer

2.操作的数据是否是纯文本

  是：字符流

  不是：字节流

3.当体系明确后，在明确要使用的哪个具体对象

通过设备来进行区分：

  源设备：内存，硬盘，键盘

  目的设备：内存，硬盘，控制台

 

 键盘：对应的对象时System.in(字节流)，可以将键盘字节流转换成字符流来操作

 InputStreamReader isr=new InputStreamReader(System.in);

 

 需要提高效率，BufferedReader

 BufferedReader bufr=new BufferedReader(isr);

 

 存储时，需要加入指定的编码表，而指定的编码表只有转换流可以指定

所以要使用的对象是OutputStreamWriter,而该转换流对象要接受一个字节输出流，而且还可以操作的文件的字节输出流FileOutputStream

OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8");

 

4.是否需要效率

  是：BufferedReader BufferedWriter

========================================

 File类

用于文件或者文件夹封装成对象

方便对文件与文件夹的属性信息进行操作

File对象可以作为参数传递给流的构造函数

//将a.txt封装成file对象，可以将已有的和未出现的文件或者文件夹构成对象

File f=new File("a.txt");

String str="b.txt";

File f1=new File("c:\\abc",str);

File.separator 目录分隔符

boolean createNewFile();

在指定位置创建文件，如果该文件存在，则不创建，返回false

exists()文件是否存在

创建文件夹

File dir =new File("abc");

mkdir()只能创建文件夹

mkdirs()创建多级目录 

对文件对象是否是文件或者目录时，必须要先判断文件对象封装的内容是否

存在，通过exist()存在

isDirectory()

isFile() 

获取文件列表

File[]files= File.listRoots();

for(File f:files){

sop(f);

}

File f=new File("c:\\abc.txt");

String[] names=f.list(); 

--------

File dir=new File("d:\\java1223\\day18");

String[] arr=dir.list(new FilenameFilter(){

 public boolean accept(File dir,String name){

  return name.endsWith(".java");

 }

});

for(String name:arr){sop(name);}

列出当前目录下所有文内容包括子目录

public static void showDir(File dir){

 File[] files=dir.listFiles();

 for(int x=0;x<files.length;x++){

  if(files[x].isDirectory())

   showDir(files[x]);

  else

   System.out.println(files[x]);

 }

}

---------------------------------

pubic static String getLevel(int level){

 StrngBuilder sb=new StringBuilder();

 for(int x=0;x<level;x++){

  sb.append("|--");

 }

 return sb.toString();

}

public static void
4000
showDir(File dir,int level){

 

 System.out.println(getLevel(level)+dir.getName());

 

 level++;

 File[] files=dir.listFiles();

 for(int x=0;x<files.length;x++){

  if(files[x].isDirectory())

   showDir(files[x],level);

  else

   System.out.println(getLevel(level)+files[x]);

 }

}

---------------------

删除一个带内容的目录

在windows中，删除目录从里往外删

public static void removeDir(File file){

 File[] files=dir.listFiles();

 

 for(int x=0;x<files.length;x++){

  if(files[x].isDirectory())

   removeDir(files[x]);

  else

   System.out.println(files[x].toString()+files[x].delete());

 }

 System.out.println(dir+dir.delete());

}

----------------------------------------

建立java列表清单

1.对指定的目录进行递归

2.获取在递归过程中所有的java文件路径

3.将这些路径存储到集合

4.将集合中的数据写入到一个文件中

public static void main(String [] args){

 File dir=new file("d:\\javadd");

 List<File> list=new ArrayList<File>();

 fileToList(dir,list);

 

 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){

 BufferedWrite bufw=null;

 try

 {

  bufw=new BufferedWriter(new FileWriter(javaListFile));

  

  for(File f:list){

   String path=f.getAbsolutePath();

   bufw.write(path);

   bufw.newLine();

   bufw.flush();

  }

 }catch(IOException e ){

  throw d;

 }

 finally{

  try

  {

   if(bufw!=null)

    bufw.close();

  }

  catch(IOException e)

  {throw e;}

 }

}

--------------------------------------------------------------------------

Properties 是hashtable的子类，具备map集合的特点，而且里面存储的键值对是字符串

是集合中和IO技术想结合的集合容器

该对象的特点：可以用于键值对形式的配置文件

设置和获取元素

public static void setAndGt(){

 Properties prop=new Properties();

 

 prop.setProperty("john","10");

 prop.setProperty("jack","87");

 

 String value=prop.getProperty("jack");

 

 Set<String> names=prop.stringPropertyNames();

 

 for(String s:names){

  sop(prop.getProperty(s));

 }

}

--------

用于一个流和info.txt文件关联

读取一行数据，将进行数据用=进行切割

等号左边的作为键，右边的作为值，存入到Properties中

public static void method()throws IOException{

BuferedReader bufr=new BufferedReader(new FileReader("info.txt"));

String line=null;

Properties prop=new Properties();

while((line=bufr.readLine())!=null){

 String[] arr=line.split("=");

 prop.setProperty(arr[0],arr[1]);

}

bufr.close();

}

load()直接加载字符流，在1.6之后

public static void loadDemo{

 Properties prop=new Properties();

 FileInputStream fis=new FileInputStrream("info.txt");

 

 prop.load(fis);

 

 prop.setProperty("robbin","33");

 

 prop.list(System.out);

 fis.close();

}

----------------------- 

 Properties prop=new Properties();

 FileInputStream fis=new FileInputStrream("info.txt");

 

 prop.load(fis);

 

 prop.setProperty("robbin","33");

 

 FileOutputStream fos=new FileOutputStream("info.txt");

 prop.store(fos,"ojweop");

 fis.close();

 fos.close();

----------------------------------------- 

用于记录应用程序的运行次数 

 建立一个配置文件，用于记录该软件的使用次数

    键值对数据时map集合

    数据时以文件形式存储，使用io技术

Properties prop=new Properties();

File file=new File(""count.ini"");

if(!file.exists())

 file.createNewFile();

FileInputStream fis=new FileInputStream(file); 

prop.load(fis);

String value=prop.getProperty("time"); 

if(value!=null)

 count=Integer.parseInt(value);

count++;

prop.setProperty("time",count+"");

FileOutputStream fos=new FileOutputStream(file);

prop.store(fos,"");

fos.close();

fis.close();

-------------------------------------