Java分割流，对象流，参与序列化，分割读取文件，对象输入或输出流等【诗书画唱】
自己写的题目：用分割流把一个Java文件分割读取，打印出每次读取的内容，要求每次读取打印500个字节。
package fenGeLiu;
import java.io.*;
public class lizi1 {
public static void main(String[] args) throws Exception{
//分割流:可以将大文件分割为小文件，然后在使用的时候，
//又可以将若干个小文件组合成一个大文件来使用
File File=new File("src/fenGeLiu/copy.java");
int zongDaXiao=(int)File.length();
System.out.println(zongDaXiao);
//startIndex：定义文件开始读取的位置下标，索引
int startIndex=0;
//lastIndexOrLength:默认每次读多少内容的长度或最后的索引
int lastIndexOrLength=500;
//ciShu：这个文件读的次数
int ciShu=(zongDaXiao/lastIndexOrLength)+1;
//遍历这个读的次数：
for(int i=0;i<ciShu;i++){
startIndex=i*lastIndexOrLength;
//startIndex：最后一次读的内容
if(i!=ciShu-1){
// 如果i不为可以达到的最大值，就一直-500（这里的lastIndex）
// 为的是让lastIndexOrLength在最后可以求出其部分的最后的下标
// zongDaXiao：总大小
zongDaXiao-=lastIndexOrLength;
}else {
lastIndexOrLength=zongDaXiao;
}
System.out.println("第"+(i+1)+"次读取的内容为：");
// 调用方法：
fenGeFangFa(File.getAbsolutePath(),
startIndex,lastIndexOrLength);
// File.getAbsolutePath()为路径
// startIndex：为开始的要截取部分的最小的索引，下标
// lastIndex：为最后的要截取部分的最大的索引，下标
}
/*File f=new File("copy.java");
File f1=new File("ww");
// 执行一个位置，设置读取为只读
// 1600个字节大小
// 每次读300个，要读6次
System.out.println(f.length());
//求一下要读几次
int daxiao=(int)f.length();
int meicidu=600;
int start=0;
int duojici=(daxiao/meicidu)+1;
for(int i=0;i<duojici;i++){
start=meicidu*i;//0,600,1200.....6000 235
if(i!=(duojici-1)){//i!=10
daxiao-=meicidu;//6235-600-600-600...10=235
}else{
meicidu=daxiao;
}
System.out.println("第"+(i+1)+"次读取的内容为");
File ff=new File(f1,i+".java");
putong1(f,start,meicidu,ff);
}
*/
}
private static void fenGeFangFa(String FileSrc,
int startIndex,int length)
throws FileNotFoundException,
IOException {
RandomAccessFile readFengGe=new RandomAccessFile(FileSrc,"r");
readFengGe.seek(startIndex);
byte[] byteArray=new byte[length];
readFengGe.read(byteArray);
System.out.println(new String(byteArray));
readFengGe.close();
}
//下面的是可以在主函数直接调用的方法：
// private static void fenGeReadfangFa(File read,int startIndex,
// int lengthSize,File write) throws FileNotFoundException,
// IOException {
//
//
//
//
// RandomAccessFile readFenGe=new RandomAccessFile(read,"r");
//// r：是固定不可变的“key”一般的，代表read的部分
// RandomAccessFile writeFenGe=new RandomAccessFile(write,"rw");
//
//// rw：是固定不可变的“key”一般的，代表read后的write的部分
// readFenGe.seek(startIndex);//设置读取的位置是100的位置
// byte[] byteArray=new byte[lengthSize];
// int len;
// readFenGe.read(byteArray);
// writeFenGe.write(byteArray);
//
// readFenGe.close();
// }
}
储存对象的姓名等内容，之后就去读取和打印读取的内容（要求单个后单行等的打印，与用循环遍历的方法把储存到自己创建的new.txt的文件中的所有的对象【可以用“点某个文件，之后点鼠标的右键，之后点最后一个选项，之后就可以改文件的格式，让txt和java文件都为UTF-8等的格式，防止中文乱码，但设置“chengJi（成绩）”等变量为transient，用transient来让成绩（chengJi）不参与序列化，这样的话存在txt文件后就会仍出现乱码等，以上是个人的理解或猜测的仍出现乱码的原因等】：
package fenGeLiu;
import java.io.*;
import java.util.Date;
public class duiXangLiu {
public static void main(String[] args) throws Exception{
// ObjectInputStream:对象输入流
// ObjectOutputStream:对象输出流
// 特点:
// 以前的流可以存储文本，其他类型数据，但是不可以存储
// 对象，这个流唯一特点就是可以存储对象。
// 为什么要存储对象:
// 因为在传输内容的时候，如果传输的是普通流，一旦
// 内容被获取到，其他人可以通过转码将数据转会源码,
// 但是对象流一旦被别人获取到，别人要需要将其转换为相应
// 的对象格式，才可以看到里面的内容
student duiXiang1=new student(4,"诗书画唱",100.0f);
student duiXiang2=new student(5,"三连",99.9f);
student duiXiang3=new student(6,"关注",99.9f);
File f=new File("new.txt");
//传入地址
FileOutputStream fis=new FileOutputStream(f);
//传入字节流
ObjectOutputStream oos=new ObjectOutputStream(fis);
oos.writeObject(duiXiang1);
oos.writeObject(duiXiang2);
oos.writeObject(duiXiang3);
oos.writeObject(null);
oos.close();
System.out.println("存储成功");
// ——————————————————————————————
// //读单个对象：
File FileOne=new File("new.txt");
FileInputStream byteInputOne=new FileInputStream(FileOne);
//传入字节输入流：
ObjectInputStream byteDuiXiangInput
=new ObjectInputStream(byteInputOne);
Object duiXiangOne=byteDuiXiangInput.readObject();
Object duiXiangTwo=byteDuiXiangInput.readObject();
//用“(student)”的转型，将读取到的内容转为原先的类型：
student duiXiangOneOld=(student)duiXiangOne;
student duiXiangTwoOld=(student)duiXiangTwo;
byteDuiXiangInput.close();
System.out.println("打印第一行的对象的内容为\t编号："
+duiXiangOneOld.bianHao+"；姓名 : "
+duiXiangOneOld.name+"；成绩 : "+duiXiangOneOld.chengJi);
System.out.println("打印第二行的对象的内容为\t"
+" 编号: "
+duiXiangTwoOld.bianHao+"；名字: "
+duiXiangTwoOld.name+"；成绩"
+ "(被设置为不显示\n真实成绩，默认为0.0)："
+duiXiangTwoOld.chengJi+"\n");
// System.out.println(duiXiangTwo.toString());
// ——————————————————————
// 下面是打印所有的存在new.txt的文件的对象的内容：
File File=new File("new.txt");
//传入字节输入流：
FileInputStream byteInputAll=new FileInputStream(File);
// duiXiangInput【“拼音+英文”的自己的命名】（对象输入流）。
ObjectInputStream duiXiangInput
=new ObjectInputStream(byteInputAll);
Object duiXiang="";
while((duiXiang=duiXiangInput.readObject())!=null){
System.out.println(duiXiang.toString());
}
duiXiangInput.close();
}
}
//——————————————————————————
//下面为知识点：
//一个类可以实现多个接口，接口一旦被实现后就必须实现接口中的抽象方法
//serializable：
//英[ˈsɪərɪəlaɪzəbl]
//美[ˈsɪˌriəˌlaɪzəbl]
//[词典] 【计】可串行化的;
//Serializable:序列化接口，它没有其他的作用，接口中也没有抽象方法
//transient关键字介绍:如果想让某个对象的某个字段不参与序列化，
//可以加上transient关键字进行修饰。
//transient 英[ˈtrænziənt]
//美[ˈtrænʃnt]
//adj. 短暂的; 转瞬即逝的; 倏忽; 暂住的; 过往的; 临时的;
//n. 暂住某地的人; 过往旅客; 临时工;
//——————————————————————
class student implements Serializable{
int bianHao;
String name;
transient float chengJi;
// 这里用transient来让成绩（chengJi）不参与序列化,
// 就是后面用toString方法返回的时候，
// 不会打印出传入的真实成绩放的内容。
public student(int bianHao, String name, float chengJi) {
this.bianHao = bianHao;
this.name = name;
this.chengJi = chengJi;
}
@Override
public String toString() {
return "student [bianhao=" +
bianHao + ", name=" + name + ", chengji（"
+ "被transient设置为不能打印"
+ "\n出来的成绩默认为0.0）：" +chengJi+ "]\n";
}
}
这里的”行“可以理解为”个“的意思：
