RandomAccessFile&IO流&排序&方法论

RandomAccessFile&IO流&排序&方法论

我们总觉得历史是极其遥远的东西，与我们并无关联，又觉得历史隐藏在图书馆的旧书之中。

然而，我们每个人都有真真切切的历史。那便是每日的历史。今天自己做了些什么，又是怎么做的，都会成为你历史中的一页。

是畏缩不前、碌碌无为，还是勇猛挑战，花心思比昨天做的更好。每种态度，都会写就属于你的历史。

——尼采 《快乐的知识》

RandomAccessFile

以下是昨天对RandomAccessFile的具体练习：

 package Zhang;

 import java.io.File;

 import java.io.IOException;

 import java.io.RandomAccessFile;

 import java.util.Arrays;

 public class RandomAccessFileTest {

       public static void main(String[] args) throws IOException {

             File demo=new File("demo");//相对路径

             if(!demo.exists()) demo.mkdir(); //如果目录不存在创建目录

             File file=new File(demo,"raf.dat");

             if(!file.exists()) file.createNewFile();//如果文件不存在，创建文件

             RandomAccessFile raf=new RandomAccessFile(file,"rw");

             //指针的位置

             System.out.println(raf.getFilePointer());

             raf.write('A');//只写了一个字节

             System.out.println(raf.getFilePointer());

             raf.write('B');

             int i=0x7fffffff;

             //底层的处理方法用write方法每次只能写一个字节，如果要把i写进去就要写四次

             raf.write(i>>>24);//右移24，把高八位写进去。>>>无符号右移

             raf.write(i>>>16);

             raf.write(i>>>8);

             raf.write(i);

             System.out.println(raf.getFilePointer());

             //其实可以直接写一个int

             raf.writeInt(i);//此处可以查看writeInt()的实现方法，与上面的基本一样。

             String s="中"; 

             byte[] gbk=s.getBytes("gbk");//gbk的中文占两个字节

             raf.write(gbk);

             System.out.println(raf.getFilePointer());//查看此时指针的位置

             System.out.println(raf.length());//查看文件的长度

             //读文件，必须把指针移动到文件的开始位置

             raf.seek(0);

             //一次性读取，把文件的内容都读取到字节数组中

             byte[] buf=new byte[(int)raf.length()];//字节数组的长度与文件的长度一致

             raf.read(buf);//读取到字节数组当中

             System.out.println(Arrays.toString(buf));

             String s1=new String(buf);//把字节数组构造成为字符串

             System.out.println(s1);

             //以十六进制的形式输出

             for(byte b:buf){

                   System.out.print(Integer.toHexString(b&0xff)+" ");

             }

             byte [] b=new byte[2];

             raf.seek(10);

             raf.read(b,0,2);

             String content=new String(b,"gbk");

             System.out.println(content);//输出 “中”

             raf.close();//关闭

       }

 }

IO流

下面是对明天即将进一步学习IO流做的准备：

IO流（输入流、输出流）

字节流、字符流（也就是以字节为单位，或者以字符为单位）

字节流：InputStream、OutputStream两个抽象类

InputStream抽象了应用程序读取数据的方式

OutputStream抽象了应用程序写出数据的方式

EOF=End 读到-1就读到结尾

重要的方法。in与out视为对象

输入流 键盘是一个输入

输入流基本方法：

lint b=in.read();读取一个byte到流，b的底8位

lin.read(byte[] buf);读取一个byte数组

lin.read(byte buf,int start,int size);从byte数组的start位置读取长度为size的字节

输出流基本方法：

lout.write(int b)写出一个byte到流，b的底八位。

lout.write(byte[] buf)将buf字节数组都写到流

lout.write(byte[] buf,int start,int size)字节数组buf从start位置开始写size长度的字节到流。

InputStream、OutputStream两个抽象类的第一组子类

FileInputStream------->具体实现了在文件上读取数据

数组排序

今天课上我简单的练习了数组的常用排序：

 package Zhang;

 import java.util.Arrays;

 public class ArrayTest {

      /**

      * 冒泡排序

      * @param arrays 数组

      * @author zhang

      * */

      public static void sort(int [] arrays){

           for(int i=1;i<arrays.length;i++){

                for(int j=0;j<arrays.length-i;j++){

                     if(arrays[j]>arrays[j+1]){

                          int tmp=arrays[j];

                          arrays[j]=arrays[j+1];

                          arrays[j+1]=tmp;

                     }

                }

           }

      }

      /**

      * 直接排序

      * @param arrays 数组

      * @author zhang

      * */

      public static void sort2(int [] arrays){

           for(int i=0;i<arrays.length-1;i++){

                for(int j=i+1;j<arrays.length;j++){

                     if(arrays[i]<arrays[j]){

                          int tmp=arrays[i];

                          arrays[i]=arrays[j];

                          arrays[j]=tmp;

                     }

                }

           }

      }

      /**

      *  快速排序

      * @param a 数组

      * @param low开始的位置

      * @param high结束的位置

      * @author zhang

      *

      * */

      public static void sort3(int[] a,int low,int high){

           if(low>=high) return;

           int first=low;

           int last=high;

           int key=a[first];

           while(first<last){

                while(first<last&&a[last]>=key){

                     last--;

                }

                a[first]=a[last];

                while(first<last&&a[first]<=key){

                     first++;

                }

                a[last]=a[first];

           }

           a[first]=key;

           sort3(a,low,first-1);//当这个函数递归结束时下面的high是上一个函数的first-1.所以low与high不能写成0与a.length-1。

           sort3(a,first+1,high);

      }

      public static void main(String[] args) {

           int a[]={8,4,3,2,7,5,4,9,67,89,32,7,0,99,12};

           sort3(a,0,a.length-1);

           System.out.println(Arrays.toString(a));

           Arrays.fill(a,100);

           System.out.println(Arrays.toString(a));

           Arrays.fill(a,3,6,200);

           System.out.println(Arrays.toString(a));    

      }

 }

更多的内容如果以后用的到，自己就去查阅官方说明文档。

方法论

学 习一个新知识，首先要对这个新的知识百度一下或者其他方式了解，这种新知识是为了解决什么问题而出现的。然后是知道些这种知识技术解决问题的原理，使用这 种知识的规则以及常用技术与思想。通过网上视频教程简单入门，深入下去是找权威书籍与官方的说明文档去阅读。之间要进行必要的练习，最后在实际的应用中灵 活运用。复杂的问题也是由简单的组成的，仔细分析他们是怎么系统的组成在一起的，互相之间是怎么起作用的，在注重基础的同时也不要在舒适区停留，不断的向 新的内容进军旧的知识才能更牢固和发挥力量。探索学习自己未知的是不容易的，但那也是走出没有新鲜感的唯一途径。对于卓越的人，自己不被理解是别人的问 题，对于最求卓越的自己，不能或不去理解卓越的人的成果是件悲哀的事。不进步不痛快！以我现在的时间和我根据自己的学习经历总结的学习方法，我应该下一步 做什么呢？先把前几天审视思考总结出来的问题在解决吧，问题是复杂的，自己就不要想太多给自己添乱了。

欲多则心散，心散则志衰，志衰则思不达。——《鬼谷子》

对的，当考虑整体的时候就不要深陷细节，专注细节的时候就不要过多分心其他。

2016-10-10