课程6 1905

(1)

import java.io.*;

public class FileInputStreamTest {

    public static void main(String[] args) throws IOException {
        //创建字节输入流
        FileInputStream fis = new FileInputStream("D:\\1.txt");
        //创建一个长度为1024的“竹筒”
        byte[] bbuf = new byte[1024];
        //用于保存实际读取的字节数
        int hasRead = 0;
        //使用循环来重复“取水”过程
        while ((hasRead = fis.read(bbuf)) > 0) {
            //取出“竹筒”中水滴（字节），将字节数组转换成字符串输入！
            System.out.print(new String(bbuf, 0, hasRead));
        }
        fis.close();
    }
}

（2）

import java.io.*;

public class FileReaderTest
{
 public static void main(String[] args) throws IOException
 {
  FileReader fr = null;
  try
  {
   //创建字符输入流
   fr = new FileReader("D:\\1.txt");
   //创建一个长度为32的“竹筒”
   char[] cbuf = new char[32];
   //用于保存实际读取的字符数
   int hasRead = 0;
   //使用循环来重复“取水”过程
   while ((hasRead = fr.read(cbuf)) > 0 )
   {
    //取出“竹筒”中水滴（字节），将字符数组转换成字符串输入！
    System.out.print(new String(cbuf , 0 , hasRead));
   }
  }
  catch (IOException ioe)
  {
   ioe.printStackTrace();
  }
  finally
  {
   //使用finally块来关闭文件输入流
   if (fr != null)
   {
    fr.close();
   }
  }
 }
}

（3）使用输入流比较两个文件内容

import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.NoSuchFileException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class InputStreamTest {
    public boolean compareFiles(Path path1, Path path2) 
            throws NoSuchFileException {
        
        if (Files.notExists(path1)) {
            throw new NoSuchFileException(path1.toString());
        }
        if (Files.notExists(path2)) {
            throw new NoSuchFileException(path2.toString());
        }
        try {
            if (Files.size(path1) != Files.size(path2)) {
                return false;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        try (InputStream inputStream1 = Files.newInputStream(
                    path1, StandardOpenOption.READ);
            InputStream inputStream2 = Files.newInputStream(
                    path2, StandardOpenOption.READ)) {
            
            int i1, i2;
            do {
                i1 = inputStream1.read();
                i2 = inputStream2.read();
                if (i1 != i2) {
                    return false;
                }
            } while (i1 != -1);
            return true;
        } catch (IOException e) {
            return false;
        }
    }

    public static void main(String[] args) {
        Path path1 = Paths.get("D:\\1.txt");
        Path path2 = Paths.get("D:\\2.txt");
        InputStreamTest test = new InputStreamTest();
        try {
            if (test.compareFiles(path1, path2)) {
                System.out.println("Files are identical");
            } else {
                System.out.println("Files are not identical");
            }
        } catch (NoSuchFileException e) {
            e.printStackTrace();
        }
        
        // the compareFiles method is not the same as Files.isSameFile
        try {
            System.out.println(Files.isSameFile(path1, path2));
        } catch (IOException e) {
            e.printStackTrace();
        }
       

    }
}

（4）使用输出流复制文件

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class OutputStreamTest {
    public void copyFiles(Path originPath, Path destinationPath)
            throws IOException {
        if (Files.notExists(originPath) 
                || Files.exists(destinationPath)) {
            throw new IOException(
                    "Origin file must exist and " + 
                    "Destination file must not exist");
        }
        byte[] readData = new byte[1024];
        try (InputStream inputStream = Files.newInputStream(originPath, 
                StandardOpenOption.READ);
            OutputStream outputStream = Files.newOutputStream(destinationPath, 
                    StandardOpenOption.CREATE)) {
            int i = inputStream.read(readData);
            while (i != -1) {
                outputStream.write(readData, 0, i);
                i = inputStream.read(readData);
            }
        } catch (IOException e) {
            throw e;
        }
    }

    public static void main(String[] args) {
        OutputStreamTest test = new OutputStreamTest();
        Path origin = Paths.get("D:\\1.txt");
        Path destination = Paths.get("D:\\0.txt");
        try {
            test.copyFiles(origin, destination);
            System.out.println("Copied Successfully");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

（5）

import java.io.*;

public class PrintStreamTest {

    public static void main(String[] args) throws IOException {
        PrintStream ps = null;
        try {
            //创建一个节点输出流：FileOutputStream
            FileOutputStream fos = new FileOutputStream("D:\\1.txt");
            //以PrintStream来包装FileOutputStream输出流
            ps = new PrintStream(fos);
            //使用PrintStream执行输出
            ps.println("普通字符串");
            ps.println(new PrintStreamTest());
        } catch (IOException ioe) {
            ioe.printStackTrace(ps);
        } finally {
            ps.close();
        }
    }
}

（6）

import java.nio.file.FileSystems;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardWatchEventKinds;
import java.nio.file.WatchEvent;
import java.nio.file.WatchKey;
import java.nio.file.WatchService;
import java.util.HashMap;
import java.util.Map;

public class FileWatcherDemo {

 /**
  * @param args
  */
 public static void main(String[] args) {
  //创建一个WatchService对象，此对象将用于管理特定文件夹的变动信息队列。
  try(WatchService service=FileSystems.getDefault().newWatchService()) {
   //此集合可保存多个文件夹的监控信息，当前只使用了一个
   Map<WatchKey, Path> keyMap=new HashMap<>();
   Path path=Paths.get("D:\\1.test");
   //设置WatchService对象管理的内部队列，将保存指定的文件夹的创建、删除和修改事件信息
   //返回的WatchKey对象可用于从事件队列中获取事件对象
   WatchKey key=path.register(service, StandardWatchEventKinds.ENTRY_CREATE,
     StandardWatchEventKinds.ENTRY_DELETE,StandardWatchEventKinds.ENTRY_MODIFY);
   keyMap.put(key, path);
   
   do {
    //开始监控，阻塞等待，当感兴趣的事件发生时，take()方法返回。
    key=service.take();
    Path eventDir=keyMap.get(key);
    //从事件队列中提取所有的事件
    for (WatchEvent<?> event : key.pollEvents()) {
     //是什么类型的事件？
     WatchEvent.Kind<?> kind=event.kind();
     //是哪个对象发生了变动？
     Path eventPath=(Path)event.context();
     System.out.println(eventDir+":"+kind+":"+eventPath);
    }
   } while (key.reset()); //reset方法重置此对象，让其可以重新接收信息
   
  } catch (Exception e) {
   
  }

 }

}

（7）读取文件

import java.io.*;
import java.util.Arrays;

public class duqu {
 public static void main(String[] args) throws IOException {
  File f=new File("D:\\piao.txt");
  FileReader fr=new FileReader(f);
  BufferedReader bufr=new BufferedReader(fr);
  StringBuffer str=new StringBuffer();
  String Line=null;
        while((Line=bufr.readLine())!=null) {
            str.append(Line);
        }
  bufr.close();
  double cishux[]=new double[26];
  double cishud[]=new double[26];
  int count=0;
  for(int i=0;i<str.length();i++) 
  {
   char ch=str.charAt(i);
   if((ch>='A'&&ch<='Z')) 
   {
    for(int j=0;j<26;j++)
    {
     if((ch=='A'+j))
     {
      cishud[j]++;
      break;
     }
     
    }
    count++;
   }
   if((ch>='a'&&ch<='z')) 
   {
    for(int j=0;j<26;j++)
    {
     if((ch=='a'+j))
     {
      cishux[j]++;
      break;
     }
     
    }
    count++;
   }
  }
  double gailvd[]=new double[26];
  double gailvx[]=new double[26];
  System.out.println("一共有"+count+"个字母");
  for(int i=0;i<26;i++) 
   gailvd[i]=cishud[i]/count;
  for(int i=0;i<26;i++) 
   gailvx[i]=cishux[i]/count;
  double gailv[]=new double[52];
  double s[]=new double[52];
  for(int i=0;i<26;i++)
   {gailv[i]=gailvd[i];
   s[i]=gailvd[i];}
  for(int i=26;i<52;i++)
   {gailv[i]=gailvx[i-26];
    s[i]=gailvx[i-26];}
  Arrays.sort(gailv);
  for(int i=51;i>=0;i--) {
            int max=0;
            for(int j=0;j<52;j++) {
                if(gailv[i]==s[j])
                    max=j;
            }
            if(max>=26)
                System.out.print(((char)('a'+max-26))+"：");
            else
            System.out.print(((char)('A'+max))+"：");
            System.out.println(String.format("%.2f",gailv[i]*100)+'%');
        }

  
  //System.out.print(((char)('A'+i))+"：");
  //
}
}