RandomAccessFile&IO流&排序&方法论

RandomAccessFile&IO流&排序&方法论

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

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

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

——尼采 《快乐的知识》

RandomAccessFile

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

  1 package Zhang;
  2 
  3  
  4 
  5 import java.io.File;
  6 
  7 import java.io.IOException;
  8 
  9 import java.io.RandomAccessFile;
 10 
 11 import java.util.Arrays;
 12 
 13  
 14 
 15 public class RandomAccessFileTest {
 16 
 17       public static void main(String[] args) throws IOException {
 18 
 19            
 20 
 21             File demo=new File("demo");//相对路径
 22 
 23             if(!demo.exists()) demo.mkdir(); //如果目录不存在创建目录
 24 
 25            
 26 
 27             File file=new File(demo,"raf.dat");
 28 
 29             if(!file.exists()) file.createNewFile();//如果文件不存在,创建文件
 30 
 31            
 32 
 33             RandomAccessFile raf=new RandomAccessFile(file,"rw");
 34 
 35             //指针的位置
 36 
 37             System.out.println(raf.getFilePointer());
 38 
 39             raf.write('A');//只写了一个字节
 40 
 41             System.out.println(raf.getFilePointer());
 42 
 43             raf.write('B');
 44 
 45            
 46 
 47             int i=0x7fffffff;
 48 
 49             //底层的处理方法用write方法每次只能写一个字节,如果要把i写进去就要写四次
 50 
 51             raf.write(i>>>24);//右移24,把高八位写进去。>>>无符号右移
 52 
 53             raf.write(i>>>16);
 54 
 55             raf.write(i>>>8);
 56 
 57             raf.write(i);
 58 
 59             System.out.println(raf.getFilePointer());
 60 
 61             //其实可以直接写一个int
 62 
 63             raf.writeInt(i);//此处可以查看writeInt()的实现方法,与上面的基本一样。
 64 
 65            
 66 
 67             String s="中"; 
 68 
 69             byte[] gbk=s.getBytes("gbk");//gbk的中文占两个字节
 70 
 71             raf.write(gbk);
 72 
 73             System.out.println(raf.getFilePointer());//查看此时指针的位置
 74 
 75             System.out.println(raf.length());//查看文件的长度
 76 
 77            
 78 
 79             //读文件,必须把指针移动到文件的开始位置
 80 
 81             raf.seek(0);
 82 
 83             //一次性读取,把文件的内容都读取到字节数组中
 84 
 85             byte[] buf=new byte[(int)raf.length()];//字节数组的长度与文件的长度一致
 86 
 87             raf.read(buf);//读取到字节数组当中
 88 
 89             System.out.println(Arrays.toString(buf));
 90 
 91            
 92 
 93             String s1=new String(buf);//把字节数组构造成为字符串
 94 
 95             System.out.println(s1);
 96 
 97             //以十六进制的形式输出
 98 
 99             for(byte b:buf){
100 
101                   System.out.print(Integer.toHexString(b&0xff)+" ");
102 
103             }
104 
105            
106 
107             byte [] b=new byte[2];
108 
109             raf.seek(10);
110 
111             raf.read(b,0,2);
112 
113             String content=new String(b,"gbk");
114 
115             System.out.println(content);//输出 “中”
116 
117             raf.close();//关闭
118 
119       }
120 
121 }

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------->具体实现了在文件上读取数据

数组排序

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

  1 package Zhang;
  2 
  3 import java.util.Arrays;
  4 
  5 public class ArrayTest {
  6 
  7      /**
  8 
  9      * 冒泡排序
 10 
 11      * @param arrays 数组
 12 
 13      * @author zhang
 14 
 15      * */
 16 
 17      public static void sort(int [] arrays){
 18 
 19           for(int i=1;i<arrays.length;i++){
 20 
 21                for(int j=0;j<arrays.length-i;j++){
 22 
 23                     if(arrays[j]>arrays[j+1]){
 24 
 25                          int tmp=arrays[j];
 26 
 27                          arrays[j]=arrays[j+1];
 28 
 29                          arrays[j+1]=tmp;
 30 
 31                     }
 32 
 33                }
 34 
 35           }
 36 
 37      }
 38 
 39      /**
 40 
 41      * 直接排序
 42 
 43      * @param arrays 数组
 44 
 45      * @author zhang
 46 
 47      * */
 48 
 49      public static void sort2(int [] arrays){
 50 
 51           for(int i=0;i<arrays.length-1;i++){
 52 
 53                for(int j=i+1;j<arrays.length;j++){
 54 
 55                     if(arrays[i]<arrays[j]){
 56 
 57                          int tmp=arrays[i];
 58 
 59                          arrays[i]=arrays[j];
 60 
 61                          arrays[j]=tmp;
 62 
 63                     }
 64 
 65                }
 66 
 67           }
 68 
 69      }
 70 
 71      /**
 72 
 73      *  快速排序
 74 
 75      * @param a 数组
 76 
 77      * @param low开始的位置
 78 
 79      * @param high结束的位置
 80 
 81      * @author zhang
 82 
 83      *
 84 
 85      * */
 86 
 87      public static void sort3(int[] a,int low,int high){
 88 
 89           if(low>=high) return;
 90 
 91           int first=low;
 92 
 93           int last=high;
 94 
 95           int key=a[first];
 96 
 97           while(first<last){
 98 
 99                while(first<last&&a[last]>=key){
100 
101                     last--;
102 
103                }
104 
105                a[first]=a[last];
106 
107                while(first<last&&a[first]<=key){
108 
109                     first++;
110 
111                }
112 
113                a[last]=a[first];
114 
115           }
116 
117           a[first]=key;
118 
119           sort3(a,low,first-1);//当这个函数递归结束时下面的high是上一个函数的first-1.所以low与high不能写成0与a.length-1。
120 
121           sort3(a,first+1,high);
122 
123      }
124 
125     
126 
127      public static void main(String[] args) {
128 
129           int a[]={8,4,3,2,7,5,4,9,67,89,32,7,0,99,12};
130 
131           sort3(a,0,a.length-1);
132 
133           System.out.println(Arrays.toString(a));
134 
135           Arrays.fill(a,100);
136 
137           System.out.println(Arrays.toString(a));
138 
139           Arrays.fill(a,3,6,200);
140 
141           System.out.println(Arrays.toString(a));    
142 
143      }
144 
145 }

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

方法论

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

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

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

2016-10-10

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Albert陈凯

Scala简介:面向对象和函数式编程的组合

Scala简介 “Scala是一门现代的多范式编程语言,志在以简练、优雅及类型安全的方式来表达常用编程模式。它平滑地集成了面向对象和函数语言的特性。” Sc...

2686
来自专栏Java呓语

工厂方法模式(延迟到子类来选择实现)

1、工厂方法模式理念介绍 2、它与简单方法模式的区别 3、推荐使用工厂方法的场景 4、在Android 源码中的应用

744
来自专栏take time, save time

你所能用到的数据结构(八)

十一、不能被应用的理论不是好研究 前面介绍了堆栈的一些小小的理论模型,那么这样一个东西有什么作用呢?实际中不可能有那么一辆停在站台前方堵死的火车的,即使有,也...

2694
来自专栏我杨某人的青春满是悔恨

《编程的智慧(初稿)》读后感

王垠更新了文章,加入了Optional跟Union比较的内容,所以我也来更新一下。垠神认为Optional并没有什么卵用,Java8的Optional我不是很了...

1022
来自专栏编程

Python利器之迭代器

各位小伙伴们 大家周四愉快 今天要和大家探讨一个 Python的特色功能 也是Python有别于其他变成语言的 强大利器 迭代器 迭代这一个词可能有的小伙伴不理...

1907
来自专栏JAVA高级架构开发

Java 程序员必须掌握的 8 道数据结构面试题,你会几道?

瑞士计算机科学家Niklaus Wirth在1976年写了一本书,名为《算法+数据结构=编程》。

1.6K0
来自专栏杨建荣的学习笔记

通过java程序模拟实现地铁票价2+2=12(r3笔记第94天)

地铁票价在这周六开始就要上涨了,这几天做地铁明显感觉人比平常多了很多。大家也都在默默的等待这一刻的到来,尽管很不情愿,但是终究会来。 到时候肯定吐槽的人一抓一大...

2646
来自专栏大史住在大前端

javascript基础修炼(2)——What's this(上)

this是javascript关键字之一,是javascript能够实现面向对象编程的核心概念。用得好能让代码优雅高端,风骚飘逸,用不好也绝对是坑人坑己利器。我...

811
来自专栏C语言及其他语言

[每日一题]平移运动

估计大家今天忙开学迎新什么的都忙不过来了吧,今天介绍的这题呢,跟之前的题很像,也是数组的题 题目描述 有n个整数,使前面各数顺序向后移m个位置,最后m个数变成...

2765
来自专栏从流域到海域

《笨办法学Python》 第35课手记

《笨办法学Python》 第35课手记 本节课讲函数和分支的,实际上是一次综合练习,代码有点长,请先纠正代码中的错误使脚本能够运行。 原代码中使用三个空格来进行...

20810

扫码关注云+社区