java-IO-编程练习题

1、最高效读写文件

public class Test {

 /**
  * 最高效的读写文件
  * @throws IOException
  */
 public static void main(String[] args) throws IOException {
  //创建文件和文件夹
  String filePath="d:\\gm\\gtm\\ss.txt";
  File file=new File(filePath);
  File parentFile=file.getParentFile();
  if(!parentFile.exists()){
   System.out.println("文件夹不存在");
   parentFile.mkdirs();
  }else{
   System.out.println("文件夹存在");
   deleteFolder(file);
   parentFile.mkdirs();
   System.out.println("创建文件夹成功");
  }
  try {
   file.createNewFile();
   System.out.println("创建文件成功");
  } catch (IOException e) {
   e.printStackTrace();
  }
  BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(path),"utf-8"),1024);
  BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(filePath),"utf-8"),1024);
  String line=null;
  while((line=bufferedReader.readLine())!=null){
   bufferedWriter.write(line);
   bufferedWriter.newLine();
   bufferedWriter.flush();
  }
  bufferedWriter.close();
  bufferedReader.close();
 }
 
 public static void deleteFolder(File folder){
  File[] file=folder.listFiles();
  if(file !=null){
   for(File f:file){
    if(f.isDirectory()){
     deleteFolder(f);
    }else{
     f.delete();
    }
   }
  }
  folder.delete();
  System.out.println("删除成功");
 }

2、最高效读写媒体文件

public class Test {

 /**
  * 最高效率读写媒体文件，只能使用buffered字节流，因为使用字符流的话，读取的时候还是先独到字节，再根据unicode码表去找对应的字符，
  * 找不到的就会随便用一个字符代替，这样就会乱码
  */
 public static void main(String[] args) {
  String picPath="D:"+File.separator+"Pictures"+File.separator+"个人照片"+File.separator+"DSCF4505A.jpg";
  String newPath="D:"+File.separator+"gm"+File.separator+"gtm"+File.separator+"123.jpg";
  BufferedInputStream bufferedInputStream = null;
  BufferedOutputStream bufferedOutputStream = null;
  try {
   bufferedInputStream=new BufferedInputStream(new FileInputStream(picPath));
   bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(newPath));
   int len=0;
//   byte[] b=new byte[1024]; 不需要使用,因为缓冲流自带缓冲区，也就是这个字节数组
   try {
    while((len=bufferedInputStream.read())!=-1){
     bufferedOutputStream.write(len);
    }
   } catch (IOException e) {
    e.printStackTrace();
   }
  } catch (FileNotFoundException e) {
   e.printStackTrace();
  }finally{
   if(bufferedOutputStream!=null){
    try {
     bufferedOutputStream.close();
    } catch (IOException e) {
     e.printStackTrace();
    }
   }
   if(bufferedInputStream!=null){
    try{
    bufferedInputStream.close();
    }catch(IOException e){
     e.printStackTrace();
    }
   }
  }
  
 }

3、文件清单列表

public class Test {

 /**
  * 功能：建立一个指定扩展名的文件的列表
  * 获取指定目录下，指定扩展名的文件（包含子目录中的文件），将这些文件的绝对路径写入到一个文本文件中
  * 思路：
  *   1、深度遍历文件，将指定后缀名的文件遍历出来，然后将文件对象存入到list中
  *   2、对list中的内容进行遍历并将绝对路径写入到文件中
  */
 public static void main(String[] args) {
  String path="F:"+File.separator+"eclipse_workspace";
  File file = new File(path);
  FilenameFilter filenameFilter = new FilenameFilter() {
   @Override
   public boolean accept(File dir, String name) {
    return name.endsWith(".java");
   }
  };
  List linkedList = new LinkedList();
  getFilesList(file,filenameFilter,linkedList);
  File destFile = new File(file, "文件列表.txt");
  writeFile(linkedList, destFile);
  
 }
 
 //第一步:深度遍历文件，将指定后缀名的文件遍历出来，然后将文件对象存入到list中
 public static void getFilesList(File file,FilenameFilter filter, List list){
  File[] files=file.listFiles();
  if(!"".equals(files) && files!=null){
   for(File f:files){
    if(f.isDirectory()){
     getFilesList(f, filter, list);
    }else{
     if(filter.accept(file, f.getName())){
      list.add(f);
     }
    }
   }
  }
 }
 
 //第二步：对list中的内容进行遍历并将绝对路径写入到文件中
 public static void writeFile(List list, File file){
  BufferedWriter bufw=null;
  try{
   bufw=new BufferedWriter(new FileWriter(file));
   for(File ff:list){
    bufw.write(ff.getAbsolutePath());
    bufw.newLine();
    bufw.flush();
   }
  }catch(IOException e){
   throw new RuntimeException("写入失败");
  }finally{
   if(bufw!=null){
    try{
     bufw.close();
    }catch(IOException e){
     throw new RuntimeException("流关闭失败");
    }
   }
  }
 }

4、最精炼读写文件

public class Test {

 /**
  * @param args
  * @throws IOException
  */
 public static void main(String[] args) throws IOException {
  BufferedInputStream fi=new BufferedInputStream(new FileInputStream("config.properties"));
  BufferedOutputStream fo=new BufferedOutputStream(new FileOutputStream("test.properties"));
  int len=0;
  while((len=fi.read())!=-1){
   fo.write(len);
  }
  fo.close();
  fi.close();
 }

}

5、properties练习题

public class TestProperties {

 /**
  * 获取一个应用程序运行的次数，如果超过5次，给出使用次数已到请注册的提示，并不要在运行程序。
  * @throws IOException
  * 思路：首先要有一个计数器，记录运行次数，那么这个计数器肯定是变量，每次运行，变量都会初始化，从0开始计数，
  * 所以需要持久化存起来，那么就可以考虑使用properties集合，存放进去，直到运行超过次之后，系统提示请注册
  */
 public static void main(String[] args) throws IOException {
  //第一步 创建配置文件对象
  String path="config.properties";
  File file=new File(path);
  if(!file.exists()){
   file.createNewFile();
  }
  //第二步：通过io流读取配置文件，通过集合加载io对象
  FileInputStream fileInputStream = new FileInputStream(file);
  Properties pro = new Properties();
  pro.load(fileInputStream);
  
  //第三步：从配置文件中读取运行次数的变量，并进行判断是否超了次
  String value=pro.getProperty("time");
  int count=0;
  if(!"".equals(value) && value!=null){
   count=Integer.parseInt(value);
   if(count>5){
    throw new RuntimeException("您已使用系统超过5次，请注册");
   }
  }
  count++;
  
  //第四步：将改变后的运行次数存入到集合中,集合通过输出流写入到文件中
  pro.setProperty("time", String.valueOf(count));
  FileOutputStream fileOutputStream = new FileOutputStream(file);
  pro.store(fileOutputStream,"将改变后的time存入到配置文件中");
  fileOutputStream.close();
  fileInputStream.close();
 }

6、文件过滤器

public class Test文件过滤器 implements FilenameFilter {
 
 private String suffix;
 
 public Test文件过滤器(String suffix){
  this.suffix=suffix;
 }

 @Override
 public boolean accept(File dir, String name) {
  return name.endsWith(suffix);
 }

}

public boolean accept(File dir, String name) {
  return name.endsWith(suffix);
 }

}

7、文件切割

public class Test文件切割 {

 /**
  * @param args
  */
 private static final int SIZE=1024*1024;
 
 public static void main(String[] args) throws Exception {
  //System.getProperty("path.separator")不管是用path还是file一直错误
  String pathName="D:"+File.separator+"路灯下的小姑娘.mp3";//使用pathSeparator错误
  System.out.println(pathName);
  File file = new File(pathName);
  splitFile(file);
 }
 public static void splitFile(File file) throws IOException{
  //1、用流读取关联源文件
  FileInputStream fileInputStream = new FileInputStream(file);
  //2、定义一个1M的缓存区
  byte[] buf = new byte[SIZE];
  //3、创建目的
  FileOutputStream fileOutputStream = null;
  //4、创建存放分割后的文件的目录
  String path="D:"+File.separator+"存放分割文件的文件夹";
  File f= new File(path);
  if(!f.exists()){
   f.mkdirs();
  }
  //5、分割文件写入到输出流中
  int len=0;
  int count=1;//分割后文件名称
  while((len=fileInputStream.read(buf))!=-1){
   fileOutputStream = new FileOutputStream(new File(f,(count++)+".part"));
   fileOutputStream.write(buf, 0, len);
   fileOutputStream.close();//每次写完一个文件应该关闭一次
  }

  /**
   * 切割文件时，必须记录住切割文件的名称，以及切割出来文件的个数，以便于合并
   * 而切割文件多时，总需要一个key去表示唯一性，所以想到properties,使用key-value方式记录这些信息
   */
  Properties pro = new Properties();
  //6、将被切割的文件名称和切割的文件个数记录下来,实现持久化
  pro.setProperty("文件个数", String.valueOf(count));
  pro.setProperty("被切割文件名", file.getName());
  fileOutputStream = new FileOutputStream(new File(path,count+".properties"));
  //7、将properties集合中的数据存储到文件中
  pro.store(fileOutputStream, "记录切割文件信息");
  fileOutputStream.close();
  fileInputStream.close();
 }

8、文件合并

public class Test文件合并 {

 /**
  *合并文件思路：1、获取指定目录下的配置文件   2、获取配置文件中的信息（被分割文件名称和分割之后的文件个数）
  *  3、获取当前文件夹下面的所有分割之后的文件
  * 4、将切割文件和流关联，并存储到集合中  5、将多个流合并成一个序列流，通过序列流读取，字节输出流写入到合并文件
  */
 public static void main(String[] args) throws IOException {
  String path="D:"+File.separator+"存放分割文件的文件夹";
  File dir= new File(path);
  mergeFile(dir);
 }
 public static void mergeFile(File dir) throws IOException{
  //1、获取指定目录下的配置文件
  File[] files=dir.listFiles(new Test文件过滤器(".properties"));
  //这个properties文件必须唯一
  if(files.length!=1){
   throw new RuntimeException(dir+",该目录下没有properties扩展名的文件或者文件不唯一");
  }
  File config = files[0];
  
  //2、获取配置文件中的信息
  Properties pro = new Properties();
  FileInputStream fileInputStream = new FileInputStream(config);
  pro.load(fileInputStream);
  String fileName= pro.getProperty("被切割文件名");
  int count=Integer.parseInt(pro.getProperty("文件个数"));
  
  //3、获取当前文件夹下面的所有分割文件
  File[]  partFile=dir.listFiles(new Test文件过滤器(".part"));
  if(partFile.length!=(count-1)){
   throw new RuntimeException("切割文件的个数不对，应该是"+count+"个");
  }
  
  //4、将切割文件和流关联，并存储到集合中
  ArrayList list = new ArrayList();
  for(int i=0;i    list.add(new FileInputStream(partFile[i]));
  }
  
  //5、将多个流合并成一个序列流
  Enumeration en=Collections.enumeration(list);
  SequenceInputStream sis = new SequenceInputStream(en);
  //在当前目录下面生成合并后的文件，名称是filename
  FileOutputStream fos = new FileOutputStream(new File(dir,fileName));
  byte[] buf=new byte[1024];
  int len=0;
  while((len = sis.read(buf))!=-1){
   fos.write(buf, 0, len);
  }
  fos.close();
  sis.close();
 }

9、控制台输入字符写入到文件中

public class Test控制台输入到文件中 {

 /**
  * 控制台输入数据，写入到指定目录的文件中
  */
 public static void main(String[] args) {
//  String path="D:"+System.getProperty("path.separator")+"gtm"+System.getProperty("path.separator")+"testIO.txt";
  String path="d:\\gtm\\testIO.txt";
  File file= new File(path);
  File fileParent = file.getParentFile();
  if(fileParent.exists()){
   fileParent.delete();
   System.out.println("111111");
   fileParent.mkdirs();
  }
  try {
   file.createNewFile();
  } catch (IOException e2) {
   e2.printStackTrace();
  }
  BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
  //outputStream 和inputStream都是抽象类，不能new，可以作为声明使用
  OutputStream outputStream = null;
  BufferedWriter bufferedWriter =null;
  try {
   outputStream = new FileOutputStream(file);
  } catch (FileNotFoundException e1) {
   e1.printStackTrace();
  }
  try {
    bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream, "gbk"));
   try {
    String line=null;
    while((line=bufferedReader.readLine())!=null){
     bufferedWriter.write(line);
     bufferedWriter.newLine();
     bufferedWriter.flush();
    }
   } catch (IOException e) {
    e.printStackTrace();
   }
   try {
    bufferedWriter.close();
   } catch (IOException e) {
    e.printStackTrace();
   }
  } catch (UnsupportedEncodingException e) {
   e.printStackTrace();
  }
  
  try {
   bufferedReader.close();
  } catch (IOException e) {
   e.printStackTrace();
  }
  
 }

10、控制台输入输出

public class Test控制台输入输出 {

 /**
  * @description  控制台输入任意字符，然后变成大写在控制台输出，直到输入over结束输出
  */
 public static void main(String[] args) {
  InputStream inputStream = System.in;
  InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
  BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
  BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(System.out));
  try {
   String line=null;
   while((line=bufferedReader.readLine())!=null){
    if("over".equals(line)){
     break;
    }
    bufferedWriter.write(line.toUpperCase());
    bufferedWriter.newLine();
    bufferedWriter.flush();
   }
  } catch (IOException e) {
   e.printStackTrace();
  }
  
 }

}

11、编码解码

public class Test编码解码 {

 /**
  * @param args
  * @throws IOException
  */
 public static void main(String[] args) throws IOException {
  String str="ab绯绯绯ab绯cdcs";
  String str2="ab你好cd谢谢";
  /*byte[] b=str.getBytes();
  for(byte bb:b){
   System.out.println(Integer.toBinaryString(bb & 255));
  }
  int len = str.getBytes("UTF-8").length;
  for(int i=0;i    System.out.println("UTF-8编码和解码截取第"+(i+1)+"个字节结果是"+getStringByteByU8(str, i+1));
  }*/
  int len2 = str2.getBytes("gbk").length;
  for(int i=0;i    System.out.println("GBK编码解码截取第"+(i+1)+"个字节结果是"+getStringByteByGBK(str2, i+1));
  }
 }
 //UTF8进行编码，通过UTF8解码得到对应的string
 public static String getStringByteByU8(String str, int len) throws IOException{
  byte[] bytes=str.getBytes();
  int count=0;
  for(int i=len-1;i>=0;i--){
   if(bytes[i]<0)
    count++;
   else
    break;
  }
  if(count%3==0){
   return new String(bytes,0,len,"UTF-8");
  }else if(count%3==1){
   return new String(bytes,0,len-1,"UTF-8");
  }else{
   return new String(bytes,0,len-2,"UTF-8");
  }
 }

 public static String getStringByteByGBK(String str, int len) throws IOException{
  byte[] bytes=str.getBytes();
  int count=0;
  for(int i=len-1;i>=0;i--){
   if(bytes[i]<0)
    count++;
   else
    break;
  }
  if(count%2==0){
   return new String(bytes,0,len,"gbk");
  }else {
   return new String(bytes,0,len-1,"gbk");
  }
 }
}