[关闭]
@Sarah 2015-06-22T14:14:34.000000Z 字数 6675 阅读 1041

JAVA LESSON 8

  1. //上堂课我的作业更正版本
  2. package file;
  4. import java.io.*;
  6. public class file {
  8.     public static void main(String[] args) throws Exception {
  9.         {
  10.             try {
  11.                 FileWriter fw = new FileWriter("File.txt");
  12.                 InputStreamReader x = new InputStreamReader(System.in);
  13.                 BufferedReader y = new BufferedReader(x);
  15.                 int i=1;
  16.                 for (i++) {
  17.                     System.out.print(i+":");
  18.                     String s = y.readLine();
  19.                     if (s.equals("[end]")) {
  20.                         fw.close();
  21.                         break;
  22.                     }  else {
  23.                         fw.write(s+"\n");
  24.                     }
  25.                 }
  26.             } catch (Exception e) {
  27.             }
  29.         }
  30.     }
  31. }

File Filter 控制文件的信息

可以同时写入和读取文件 rw
可以显示文件最后一次修改的时间
可以把这个时间格式化成年月日格式
可以用f.mkdirs新建一组文件夹“\a\b\c\d”
可以从第几个开始读取 遍历之后的内容
FileNameFilter()

  1. //读取abc.txt里第几个字符
  2. import java.io.*;
  3. public class RandomAccess {
  4.     public static void main(String[] args) {
  5.         try {
  6.             RandomAccessFile af=new RandomAccessFile("abc.txt", "rw");
  7.             //rw可以读取和写入
  8.             for(int i=0;i<256;i++)
  9.                 af.write(i);
  10.             af.seek(0);//从第0个开始
  11.             int s=af.readInt();
  12.             System.out.println(s);//第0个是什么？
  13.             af.skipBytes(65);//第65个？ E
  14.             System.out.println((char)af.readByte());
  15.             af.skipBytes(-5);//输出的是第67个F
  16.             System.out.println((char)af.readByte());
  17.             af.close();
  18.         } catch (Exception e) {
  19.             e.printStackTrace();
  20.         } 
  21.     }
  22. }

✨额外的大案例

  1. import java.io.*;
  2. public class DisplayFile {
  4.     public static void main(String[] args) {
  5.         // TODO Auto-generated method stub
  6.         if(args.length<1){
  7.             System.out.println("Usage:JAVA DisplayFile <filename> [-l length] [-t]");
  8.             System.out.println("\t-l:length of file contents to display.");
  9.             System.out.println("\t-t:display content with text mode.");
  10.             System.exit(-1);
  11.         }
  12.         String filename=args[0];
  13.         boolean hex=true;
  14.         int length=256;
  15.         for(int i=1;i<args.length;i++){
  16.             if(args[i].toLowerCase().equals("-l")){
  17.                 if(args.length<i+2){
  18.                     System.out.println("please tell me length of file content.");
  19.                     System.exit(-2);
  20.                 }
  21.                 else
  22.                     try{
  23.                         length=Integer.parseInt(args[i+1]);
  24.                     }
  25.                     catch(NumberFormatException e){
  26.                         System.out.println(e);
  27.                         System.exit(-3);
  28.                     }
  29.                 i++;
  30.                 continue;
  31.             }
  32.             if(args[i].toLowerCase().equals("-t"))
  33.                 hex=false;
  34.         }
  35.         byte[] content=new byte[length];
  36.         try {
  37.             FileInputStream fis=new FileInputStream(filename);
  38.             length=fis.read(content);
  39.             if(hex)
  40.                 displayHex(content,length);
  41.             else
  42.                 displayText(content,length);
  43.         } catch (FileNotFoundException e) {
  44.             // TODO Auto-generated catch block
  45.             e.printStackTrace();
  46.         } catch (IOException e) {
  47.             // TODO Auto-generated catch block
  48.             e.printStackTrace();
  49.         }
  50.     }
  55.     private static void displayText(byte[] c,int length){
  56.         System.out.print(new String(c,0,length));
  57.     }
  58.     private static void displayHex(byte[] c,int length){
  59.         int i=0;
  60.         System.out.print(" Offset");
  61.         for(int j=0;j<5;j++)
  62.             System.out.print("   ");
  63.         System.out.print("Content(hex. format)");
  64.         for(int j=0;j<6;j++)
  65.             System.out.print("   ");
  66.         System.out.print("Content(text format)\n");
  67.         for(int j=0;j<80;j++)
  68.             System.out.print("-");
  69.         System.out.println();
  70.         while(i<length){
  71.             int j=0,k=0;
  72.             System.out.printf("%08X   ", i);
  73.             while(j<16){
  74.                 System.out.printf("%02X ", c[i+j]);
  75.                 j++;
  76.                 if(i+j==length)
  77.                     break;
  78.             }
  79.             if(j<16)
  80.                 for(k=0;k<16-j;k++)
  81.                     System.out.print("   ");
  82.             k=0;
  83.             System.out.print("   ");
  84.             while(k<j){
  85.                 System.out.print((char)(c[i+k]>=32 && c[i+k]<=126?c[i+k]:'.'));
  86.                 k++;
  87.             }
  88.             System.out.println();
  89.             i+=16;
  90.         }
  91.     }
  92. }
  1. import java.io.*;
  2. import java.util.Date;
  3. import java.text.SimpleDateFormat;
  4. class FileFilterTest{
  5.      public static void main(String args[]){
  6.            File dir=new File("./");
  7.            Filter filter=new Filter(".class");
  8.            String files[]=dir.list();
  9.            for(int i=0;i<files.length;i++){
  10.                 File f=new File(files[i]);
  11.                 Date d=new Date(f.lastModified());
  12.                 String df="yyyy-MM-dd  HH:mm:ss";
  13.                 String sdf=new SimpleDateFormat(df).format(d);
  14.                 System.out.print(sdf+"\t");
  15.                 if (f.isFile())
  16.                     System.out.print("\t"+f.length()+"\t");
  17.                 else
  18.                     System.out.print("<DIR>\t\t");
  19.                 System.out.print(f.getName()+"\n");
  20.            }
  21.      }
  22. }
  24. class Filter implements FilenameFilter{
  25.      String extent;
  26.      Filter(String extent){
  27.            this.extent=extent;
  28.      }
  29.      public boolean accept(File dir,String name){
  30.            return name.endsWith(extent);
  31.      }
  32. }

难※ File.list(.)

(.)表示当前文件夹
mf.accept(File,String)

可以在制定文件夹里寻找后缀/文件夹名字是指定字符的文件，比如找.txt文件，是true的话就留着，是false就从遍历里去掉，然后返回符合的几个文件名字，

list(FilenameFilter m)
m.accept(s[i])
m.accept

  1. //输出文件最后修改的日期并shimiaofeng格式化为年月日十秒分格式
  2. import java.io.*;
  3. import java.text.SimpleDateFormat;
  4. public class FIleClassTest {
  5.     public static void main(String[] args) {
  6.         try{
  7.             File f=new File("./");
  8.             if(f.exists()){
  9.                 if(f.isFile()){
  10.                     SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  11.                     String s=sdf.format(f.lastModified());
  12.                     System.out.println(s);
  13. //                  FileReader fr=new FileReader(f);
  14.                 }else{
  15.                     MyFilter mf=new MyFilter();
  16.                     String files[]=f.list(mf);
  18.                     for(String s:files)
  19.                         System.out.println(s);
  21.                 }
  22.             }else{
  23.             }
  24.         }
  25.         catch(Exception e){
  26.                 System.out.println(e);
  27.         }
  28.     }
  29. }
  1. //为了实现FilenameFilter建立的接口
  2. import java.io.File;
  3. import java.io.FilenameFilter;
  6. public class MyFilter implements FilenameFilter {
  8.     @Override
  9.     public boolean accept(File arg0, String arg1) {
  10.         // TODO Auto-generated method stub
  11.         if(arg1.indexOf("a")>=0)
  12.             return true;
  13.         else
  14.             return false;
  15.     }
  17. }

增强版for循环

  1. //新写法
  2. for (int a : arr)
  3.    System.out.println(a);
  5.  //旧写法
  6. for (int i = 0; i < arr.length; i++)
  7.    System.out.println(arr[i]);

序列化

就是输出一排特别整齐的东西在terminal里那个！能显示出文件里的内容

try catch可以自动写 选中要try catch的代码 右键

序列化：我们可以通过序列化来保存一个对象的状态（实例变量）到文件中，也可以从这个格式化的文件中很容易地读取对象的状态从而可以恢复我们保存的对象。
用来实现序列化的类都在java.io包中，我们常用的类或接口有：
ObjectOutputStream:提供序列化对象并把其写入流的方法
ObjectInputStream：读取流并反序列化对象
Serializable：一个对象想要被序列化，那么它的类就要实现 此接口

  1. package Circle;
  3. import java.io.Serializable;
  5. public class Point  implements Serializable{
  6.     int x,y;
  7.     private Point(){
  8.         this(0,0);
  9.     }
  10.     public Point(int bb){
  12.     }
  13.     public Point(int x,int y){ 
  14.         this.x=x;
  15.         this.y=y;
  16.     }
  17.     Point getPoint(){
  18.         Point p=new  Point();
  19.         p.setX(-x);
  20.         p.setY(-y);
  21.         return p;
  23.     }
  24.     public void setX(long xx){
  25.         x=(int)xx;
  26.     }
  28.     void setX(int xx){
  29.         x=xx;
  30.     }
  31.     void setY(int yy){
  32.         y=yy;
  33.     }
  34.     Point getApoint(){   //新函数 返回值是point
  35.         Point q=new Point(-x,-y);
  37.         return q;
  38.     }
  39.     public double distance(Point p2){ //point是原来的点坐标，p2是另一点的坐标
  40.         double d=0;
  41.         d=Math.sqrt((x-p2.x)*(x-p2.x)+(y-p2.y)*(y-p2.y));
  42.         return d;
  43.     }
  44.     public boolean equals(Point p3){
  45.         if (p3.x==x && p3.y==y) {
  46.             return true;
  48.         }
  49.         else {
  50.             return false;
  51.         }
  52.     }
  54.     public String toString(){
  55.         return  "["+x+","+y+"]";
  56.     }
  57.     public int getX(){
  58.         return x;
  60.     }
  61.     public int getY() {
  62.         return y;
  63.     }
  65. }
  1. //创建一个接口
  2. package Circle;
  3. import java.io.*;
  4. public class SerializableTest {
  5.     public static void main(String[] args) {
  6.         try {
  7.             ObjectInputStream oi=new ObjectInputStream(new FileInputStream("point"));
  8.             Point p1=(Point)oi.readObject();
  9.             System.out.println(p1);
  10.         } catch (FileNotFoundException e) {
  11.             e.printStackTrace();
  12.         } catch (IOException e) {
  13.             e.printStackTrace();
  14.         } catch (ClassNotFoundException e) {
  15.             e.printStackTrace();
  16.         }
  17.     }
  18. }

线程

简单地程序都是一个线程
进程process
多线程的意思就是，程序可以边打字边数日期，两件事互相不干扰，各自进行。

  1. //在两个变量数数的同时读取键盘输入 主函数
  2. import java.io.*;
  3. public class Main {
  4.     public static void main(String[] args)throws Exception {
  5.         BufferedReader br=new BufferedReader(
  6.                 new InputStreamReader(System.in)
  7.                 );
  9.         MyThread t=new MyThread();
  10.         Thread r=new Thread(t);
  11.         r.start();
  12.         Thread.sleep(1500);
  14.         MyThread t1=new MyThread();
  15.         new Thread(t1).start();
  16.         while(true){
  17.             String s=br.readLine();
  18.             System.out.println(s);
  19.         }
  21.     }
  22. }
  1. //在两个变量数数的同时读取键盘输入 接口的函数
  3. //public class MyThread extends Thread {
  4. public class MyThread extends Object implements Runnable {
  5. //这里是个接口 因为有runnable所以不能写Thread的函数，不然有两个接口了
  7.     public void run(){
  8.         int i=0;
  9.         while(true){
  10.             System.out.println("\t"+i);
  11.             i++;
  12.             if(i==3)
  13.                 break;//i数数数到3就结束
  14.             try {
  15.                 Thread.sleep(3000);
  16.             } catch (InterruptedException e) {
  17.                 // TODO Auto-generated catch block
  18.                 e.printStackTrace();
  19.             }
  20.         }
  21.     }
  22. }

上面谁要用到接口来着 就是什么T没有函数不能直接用 但是必须叫这个名字 用一个函数调用 所以要自己写接口
可以自动构造函数 然后区别的地方调用一下就可以用了
貌似是list

作业
读取六级文档 并输入到一个数组string里面 可以设置范围是一万

总结

输入流/输出流
字节流/字符流
节点流/处理流

以后用的时候：依稀记得有这么一个buffer东西，然后打开API回去查一下。

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注