Megalomania

C.E.P.J.

0%

【Java】Java学习笔记（7）Java文件操作作业函数题

发表于 更新于 分类于 阅读次数：
本文字数： 7.5k 阅读时长 ≈ 7 分钟

学校小学期Java课程的练习题，留个档便于以后需要时候有例子可以回忆，写的烂的地方请多多包含

1、打印文件的属性

  • 描述：从键盘输入路径和文件名，打印文件的可读性、长度、绝对路径。
  • 代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import java.io.*;
import java.util.Scanner;
public class Example10_1_1 {
   public static void main(String args[]) {
        Scanner reader = new Scanner(System.in);
      //创建文件并初始化路径和文件名
      /*
        输出格式：
        a.txt是可读的吗:false
        a.txt的长度:0
        a.txt的绝对路径:c:\1.txt
      */
      // TODO：
        String path = reader.next();
        String name = reader.next();
        File file = new File(path+"/"+name);
        System.out.println( file.getName() +"是可读的吗:"+ file.canRead());
        System.out.println( file.getName()+"的长度:"+file.length());
        System.out.println( file.getName()+"的绝对路径:"+ file.getAbsolutePath());
   }
}

2、创建文件

  • 描述：从键盘输入要创建文件的名字，成功后输出创建成功。
  • 代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.io.*;
import java.util.Scanner;
public class Example10_1_2 {
   public static void main(String args[]) {
	   Scanner reader = new Scanner(System.in);
      File file = new File(reader.nextLine());
      System.out.println("在当前目录下创建新文件"+file.getName());
      if(!file.exists()) {
         try {
              //创建文件
			  // TODO：
			    file.createNewFile();
                System.out.print("创建成功");
         }
         catch(IOException exp){}
      }else{
    	  System.out.print("文件已经存在");
      }
   }
}

3、向文件中写入内容

  • 描述：：从键盘输入两个字符串，每输入一个字符串按回车结束，将两个字符串依次写入文件中，并输出两次写入后的文件大小。
  • 代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import java.io.*;
import java.util.Scanner;
public class Example10_5 {
   public static void main(String args[]) {
	  Scanner reader = new Scanner(System.in);
      byte [] a = reader.nextLine().getBytes();
      byte [] b = reader.nextLine().getBytes();
      File file = new File("a.txt");                         //输出的目的地
      try{
            OutputStream out=new FileOutputStream(file);      //指向目的地的输出流
            System.out.println(file.getName()+"的大小:"+file.length()+"字节");//a.txt的大小:0字节
            //向目的地写a数据
		    // TODO：
		    out.write(a);
            out.close();
            out.close();
            //准备向文件尾加内容
		    // TODO：
            out = new FileOutputStream(file, true);
            System.out.println(file.getName()+"的大小:"+file.length()+"字节");///a.txt的大小:8字节
            //向目的地写b数据
		    // TODO：
            out.write(b);
            System.out.println(file.getName()+"的大小:"+file.length()+"字节");///a.txt的大小:8字节
            out.close();
        }
      catch(IOException e) {
          System.out.println("Error "+e);
      }
  }
}

4、倒叙输出文件内容

  • 描述：从键盘输入一个文件名称，按回车结束，创建该文件，定义一个数组data，内容是1-10，将数组内容写入文件，然后倒叙输出文件内容。
  • 代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import java.io.*;
import java.util.Scanner;
public class Example10_8 {
   public static void main(String args[]) {
	   Scanner reader = new Scanner(System.in);
      RandomAccessFile inAndOut=null;
      int data[]={1,2,3,4,5,6,7,8,9,10};
      try{ inAndOut=new RandomAccessFile(reader.nextLine(),"rw");
           for(int i:data) {
              //将数组内容写入文件
              // TODO:
              inAndOut.write(i);
           }
           for(int i=data.length-1;i>=0;i--) {
               //一个int型数据占4个字节，inAndOut从文件的第36个字节读取最后面的一个整数，每隔4个字节往前读取一个整数
              // TODO:
              System.out.printf("%d ", data[i]);
           }
           inAndOut.close();
      }
      catch(IOException e){
          e.printStackTrace();
      }
   }
}

5、打印内存中的数据

  • 描述：从键盘输入一个字符串，按回车结束，使用字节数组流和字符数组流将字符串写入内存，再从内存读取曾写入的数据，并打印。
  • 代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import java.io.*;
import java.util.Scanner;
public class Example10_10 {
   public static void main(String args[]) {
       Scanner reader = new Scanner(System.in);
       String str = reader.nextLine();
      try {
            // 字节数组流写入内存
            ByteArrayOutputStream outByte = new ByteArrayOutputStream();
            byte [] byteContent = str.getBytes();
            outByte.write(byteContent);
            //读取内存字符串（字节）
            // 字节数组流读取内存
            // TODO：
            ByteArrayInputStream inByte= new ByteArrayInputStream(outByte.toByteArray());
            byte [] backByte = new byte[byteContent.length];
            inByte.read(backByte);
            System.out.println(new String(backByte));
            // 字符数组流写入内存
            CharArrayWriter outChar = new CharArrayWriter();
            char [] charContent=str.toCharArray();
            outChar.write(charContent);
            //读取内存字符串（字符）
            // 字符数组流读取内存
            // TODO：
            CharArrayReader inChar = new CharArrayReader(outChar.toCharArray());
            char backChar [] = new char[charContent.length];
            inChar.read(backChar);
            System.out.print(new String(backChar));
      }
      catch(IOException exp){}
  }
}

6、从文件读取不同类型的数据

  • 描述：从键盘输入一个文件名，按回车结束，创建该文件，向文件中写入6种类型的数据，再根据类型从文件中读取，并打印。
  • 代码（听我同学说用C写，Java的我也没写出来，有想法的欢迎评论区回复）

7、将字符串加密

  • 描述：从键盘输入一个字符串，按回车结束，以EncryptAndDecrypt类给出的加密形式加密该字符串，将加密字符串以数据流写入secret文件，并打印加密字符串，再以数据流读取secret文件，进行解密，并打印解密字符串。
  • 代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
/*
* 类给出的加密形式加密该字符串，将加密字符串以数据流写入secret文件，
* 并打印加密字符串，再以数据流读取secret文件，进行解密，并打印解密字符串。
*/
public class Example10_12 {
   public static void main(String args[]) {
      Scanner reader = new Scanner(System.in);
      String command = reader.nextLine();
      EncryptAndDecrypt person = new EncryptAndDecrypt();
      String password = "Tiger";
      String secret = person.encrypt(command,password); 
      File file=new File("secret.txt");
      try{
          //将加密字符串以数据流写入secret.txt文件
          // TODO:
            FileOutputStream fos = new FileOutputStream(file);
            DataOutputStream outData = new DataOutputStream(fos);
          // 将UTF-8类型的值写入到“数据输出流”中
          // TODO:
            outData.writeUTF(secret);
            System.out.println("加密命令:"+secret);
            fos.flush();
            outData.flush();
            fos.close();
            outData.close();
       }
       catch(IOException e){}
       try{
          //以数据流读取secret.txt文件内容
          // TODO:
            FileInputStream fis = new FileInputStream(file);
            DataInputStream inData =  new DataInputStream(fis);
          // “数据输出流”中读取UTF-8类型的值
          // TODO:
            secret = inData.readUTF();
            String mingwen = person.decrypt(secret,password);//解密字符串
            System.out.println("解密命令:"+mingwen);
            fis.close();
            inData.close();
       }
       catch(IOException e){
           e.printStackTrace();
       }
   }
}
class EncryptAndDecrypt{
    // 加密
    String encrypt(String sourceString,String password){
        char [] p = password.toCharArray();
        int n = p.length;
        char [] c = sourceString.toCharArray();
        int m = c.length;
        for(int k = 0;k<m;k++){
            int mima = c[k]+p[k%n];
            c[k] = (char)mima;
        }
        return new String(c);
    }
    // 解密
    String decrypt(String sourceString,String password){
        char [] p = password.toCharArray();
        int n = p.length;
        char [] c = sourceString.toCharArray();
        int m = c.length;
        for(int k = 0;k<m;k++){
            int mima = c[k]-p[k%n];
            c[k] = (char)mima;
        }
        return new String(c);
    }
}

8、实现对象的写入读取到文件中

  • 描述：从键盘输入一个文件名，按回车结束，并创建文件，用TV类定义一个对象changhong,将对象chnaghong以对象流写入文件中，再通过对象流读取文件中的对象赋值给用TV类定义的xinfei对象，给xinfei对象属性赋值，最后输出changhong对象和xinfei对象的属性值。
  • 代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
import java.io.*;
import java.util.Scanner;
public class Example10_13 {
    public static void main(String args[]) {
        Scanner reader = new Scanner(System.in);
        //用TV类定义一个对象changhong,
        TV changhong = new TV();
        changhong.setName("长虹电视");
        changhong.setPrice(5678);
        File file=new File(reader.nextLine());
        try{
            // 将对象chnaghong以对象流写入文件中
            // TODO：
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
            oos.writeObject(changhong);
            //读取file文件中的对象赋值给xinfei
            // TODO：
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
            TV xinfei = (TV)ois.readObject();
            xinfei.setName("新飞电视");
            xinfei.setPrice(6666);
            System.out.println("changhong的名字:"+changhong.getName());
            System.out.println("changhong的价格:"+changhong.getPrice());
            System.out.println("xinfei的名字:"+xinfei.getName());
            System.out.println("xinfei的价格:"+xinfei.getPrice());
        }
        catch(ClassNotFoundException event) {
            System.out.println("不能读出对象");
        }
        catch(IOException event) {
            System.out.println(event);
        }
    }
}
// 对象序列化
// TODO:
class TV implements Serializable {
    String name;
    int price;
    public void setName(String s) {
        name=s;
    }
    public void setPrice(int n) {
        price=n;
    }
    public String getName() {
        return name;
    }
    public int getPrice() {
        return price;
    }
}
-------- 本文结束 感谢阅读 --------