A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© zgq_2012 初级黑马   /  2018-12-19 22:30  /  617 人查看  /  0 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

1、函数式编程:强调做什么,而不是以什么形式做
2、New thread( (可带参数)->{方法体sout(直接打印的信息);});
3、Lambda只有函数式接口可以使用,替换内部类,只有一个抽象方法的
4、Lambda的表达式标准格式
(1)一些参数(列表中的数据类型可以省略不写,如果只有一个参数,类型和()都可以省略)
(2)一个箭头
(3)一段代码,// 只有一行代码的时候,{}和;都可以省略,而且无论是否有返回值都可以省略{},return,分号,但是要省略就一起省略
(4)(参数列表)->{一些重写方法的代码}
①()接口中抽象方法的参数列表,没有就空着,多个参数,隔开
②->把参数传递给后面方法体
③{}重写接口的抽象方法的方法体
5、lambda的使用前提:
(1)函数式接口
(2)必须可以推导出来
6、线程池
(1)线程池是一个容纳多个线程的容器,可反复使用,省区了频繁创建线程对象的操作,无需反复创建线程而消耗过多资源
(2)提高相应的速度
(3)提高了线程的可管理性
7、线程池的代码操作
(1)ExecutorService a=Executors.newFixedThreadPool(nThreads:5);
a.submit(线程接口new Rannable(){重写run()方法});// 增加一个线程,并开启,用完了之后放回到线程池
a.shutdown();// 销毁线程池,后面再次调用线程池线程将报错
1、与系统有关的分隔符
(1)String S=File.pathSeparator;// 在Windows系统结果是 ; 而Linux系统则是:
(2)String s=File.separator;// winodws中是\,而Linux中是/,故为了都能用所以格式
用的是C:\der\wfgr\a.txt
转变为”C:”+File.separator+”der”+File.separator+”wfgr”+File.separator+”a.txt”格式
2、”\”转义符,因为双引号或者反斜杠在代码中被看作是字符,所以需要打印直接输入的时候需要转义符,例如sout( “D:\\asd\\as\\a.txt”);//输出结果为 D:\asd\as\a.txt
3、绝对路径:以盘符开始的路径,如:C:\\ad\\asdaf\\a.txt;
4、相对路径:一个简化的路径,相对指相当于当前项目的根目录,
如:C:\\ad\\asdaf\\a.txt,相对的时候->  a.txt;
5、File的方法
(1)File fi=new File(“C:\\aef\\efsg\\ss\\a.txt”);// 不考虑路径真假情况,只是把字符转封装为File对象,重写了toString()方法,相对,绝对路径都可以存
(2)File fi=new File(“C:\\aef\\efsg”,”asd\\ss\\x\\z.txt”);// 输出结果为字符串的拼接
参数为父路径和子路径,使用灵活,都可以变化
(3)File fi2=new File(fi,”ada\\a\\z.txt”); // 输出还是为fi路径与字符串的拼接,这样父路径可以单独写
(4)File fi=new File(“\\efsg\\z.txt”);
①fi.getAbsolutePath();// 获取当前对象的绝对路径C:\aef\efsg\z.txt
②fi.getPath();// 获取当前file对象构造中传入的路径 efsg\z.txt
③fi.fetName();// 获取当前文件的名称 z.txt
④long length=fi.length(); // 当前文件的大小 0
// 文件夹没有大小,只有文件才有大小。
6、File类判断方法
File fi=new File(“C:\\aef\\efsg\\ss\\a.txt”);
(1)Boolean b=fi.exists(); // 判断该路径是否真实存在,真true假false,相对与绝对路径都可以判断
(2)Boolean b2=fi.isDirectory();// 判断给的路径是否以文件夹结尾
(3)Boolean b3=fi.isFile(); // 判断给的路径是否以文件结尾,与上面是互斥的,
因为电脑硬盘中只有文件或者文件夹,使用前提,路径存在
7、File类创建与删除方法
File fi=new File(“C:\\aef\\efsg\\ss\\a.txt”);
(1)Boolean b=fi.createNewFile(); // true文件不存在,fi传递的文件a.txt创建成功,false则表示文件已存在,不会创建,此方法只能创建文件 ,不能创建文件夹,但是创建的文件路径必须存在,否则报错
File fi=new File(“C:\\aef\\efsg”);
(2)Boolean b=fi.mkdir();// 创建单级文件夹,不存在则建,存在则false
File fi=new File(“C:\\aef\\efs\\111\\222\\333”)
(3)Boolean b=fi.mkdirs();// 创建多级文件夹,也可以创建单级的
(4)Boolean b=fi.delet();// 删除文件/文件夹,但是文件夹里面有文件时,文件夹不能直接删除,会输出false,必须先删除文件,并且此删除不走回收站,硬盘中直接删除,谨慎



8、File文件夹的目录的遍历
(1)格式1:File fi=new File(“C:\\aef\\efsg”);// 会先判断文件夹存不存在,如果不存在会包异常,可以再次判断是否为文件夹,fi.isDirectory();
String [] arr1=fi.list(); // 返回的是String数组,元素是第一层的文件夹/文件名字
for(File f1:arr1){
sout(fi);// 直接打印绝对路径,
}
(2)格式2:File fi=new File(“C:\\aef\\efsg”);// 先判断是否为文件夹,fi.isDirectory();
File [] f2 = fi.listFiles();// 返回文件数组,存的是文件// 文件从硬盘存到内存中
For(File f:f2){
Sout(f);// fi.getName();就是打印文件(夹)名,隐藏文件都可以打印
// 在遍历中可以删除文件,不报并发异常,因为删除文件不影响数组长度变化,删除的是硬盘上的文件,数组中的是存在内存中的。
}
9、递归,当前方法内调用自己
(1)格式1:直接递归:main()调用a();,a()又调用a()自己;
(2)格式2:间接递归:main()调用a(),a()调用b(),b()又调用a();
使用注意,要保证递归能够停下来,不然会栈内存溢出,构造方法禁止递归,不然会创建无数个对象,而且递归的次数不能过多,否则也可能超出栈内存
10、用递归遍历给出的文件夹
(1)Public class Test01{
P s v m{
File fi=new File(“C:\\aaa\\afD\\xas”); // 给一个文件夹
getAllFile(fi); // 调用遍历方法
}
Public static void getAllFile(File f1){
Sout(fi); // 打印一下该文件夹的名字
File [] f2=f1.listFiles(); // 把给定的文件夹,文件数组化
for(File f:f2){   // 遍历
if(fi.isDirectory){  // 是文件夹则true
getAllFile(fi);  // 是文件夹就再次递归,来遍历此文件夹
} else {
Sout(f); // 不是文件夹,就直接打印,可以f.getName();打印名字
// 如果要获得特定结尾的文件,就需要获取名字,然后小写化(需要的话)f.getName().toLowerCase().endsWith(“\.txt”);指定打印以.txt结尾的文件,
}
}
}
}
// 输出的就是此文件夹之下的所有文件




11、文件过滤器,获得指定结尾的文件,以FileFilter接口实现的,实现类中重写其中的
accept()方法(过滤方法),其中传入遍历的文件,
Public class GuoLvQi {  
Psvm(){
File dir=new File(“C:\\aaa\\afD\\xas”); // 获取一个文件夹
getAllFile(dir);  // 调用方法
}
Public static void getAllFile(File dir){
File fi=dir.listFiles(new FileFilterimpl()),// listFiles带参数的重载方法,new实现类
For(File f:fi){  // 遍历
If(f.isDirectory()){ // 是否为文件夹
getAllFiles(f); // 递归调用
}else {
Sout(f); // 是文件则直接打印
}
}
}
}
实现类:
Public class fileimpl implement FileFilter{ // 实现FileFilter接口
@override
Public boolean accept(File f){  // 重写accept()方法
If(f.isDirectory()){  
Return true; // 是文件夹返回true
}
Return f.getName().toLowerCase().endsWith(“\.txt”); // 是文件则判断结尾并返
}
}
listFiles它会对构造方法中传递的目录进行遍历,获取文件(夹)封装为File对象,并调用accept方法,且会把遍历得到的每一个File对象,传递给accept方法的参数,然后返回一个布尔值,如果是true,就会把File对象保存到File[] fi中,否则不存。所以过滤器规则就写在accept()方法中
1、IO流:输入输出流,从硬盘(读取到)->内存就是输入,从内存->(写入到)硬盘就是输出。
2、一个字符等于2个字节,一个字节=8个二进制位
图片,视频,音频,都是字节保存的,都用字节流,不用字符流(可能会出错)
3、字节输出流(保存):OutputStream顶层父类(抽象类),
FileOutputStream(子类),(往文件中写数据)文件字节输出流
常用方法步骤:
先要创建对象,
FileOutputStream fos=new FileOutputStream(name:”11/aaa.txt”,append:teue);参数:指定路径创建一个文件,但是文件是在关闭流(有fos.close)的时候才创建的,不关流也可以创建。后面加append:true,是续写,不会覆盖之前的数据;加append:false,指创建一个新的文件,覆盖原文件
new FileOutputStream可以默认创建一个文件
(1)fos.write(int a);// 写入一个字节,数据写入文件
(2)fos.write(byte[] bytes);//写入一个字节数组
可用(String类型) str.getBytes();字符串转字节数组
如果写的第一个字节是负数,第一和第二字节会组成一个中文显示,2字节=1中文
(3)fos.write(bytes,int off,int len);// 写入字节数组中的一部分,bytes是数组,off是数组起始的索引值,len是写入几个字节(数据的长度)
(4)fos.close();// 写入完毕必须要关闭流,清空->为了释放资源,因为流会占用内存,
如果不用fos.write()写入数据直接创建,此空文件就会覆盖同名文件,但是有append的时候就只是没有新的数据续写而已,文件不会被覆盖为空
(5)写换行,windows格式:fos.write( “\r\n”.getBytes()); //跳到下一行开头  linux:/n   mac:/r
4、字节输入流:FileInputStream,把硬盘中的数据读取到内存中使用
常用方法使用步骤:
(1)创建FileInputStream对象,绑定要读取的数据源
①FileInputStream fis=new FileInputStream(“a.txt”);// 读取数据源
(2)Int a1=fis.read();// 返回的是一个字节,读取到文件的末尾(没有元素了)返回-1;读取的时候,取完元素后,指针会向后移动一位,                                                                              因为是重复,可用while循环
①Int len=0;// 需要变量,否则容易漏读等,read()一次就读写一次,故此谨慎
②While ((len=fis.read())!=-1){ // 读取一个字节,赋值给变量,判断=-1否,并且指针指向下一个字节,
Sout((char)len);// int转换为字符输出
}
3)Byte [] bytes=new byte[1024];// 定义一个字节数组,读取多个字节,起到了缓冲的作用,数组长度可以小于要读取的文件字节总数,fis.read(bytes);小于的时候就是长度为几,就先读取几个,后面再继续,通常定义1024个字节或其整数倍
本质也是一个一个的读,先从硬盘(一个一个)到内存(字节数组),再从内存(数组)到JVM(数组),提高的效率在于从内存到JVM的过程
4)Int len = fis.read(bytes); // 读取文件的字节,并保存到字节数组中,len接收返回的读取的字节个数,
5)Sout(len);
6)Sout(new String(bytes,0,len));// 读取的字节数组字符串化,从索引0开始,输出        len个字符(减去索引值起始位置之后,不能超出数组的长度)
读取可以用while循环,直到读完。(读取中文的时候容易出错)
(3)fis.close();// 同理关流。
5、字符输入流:Reader抽象类,用其子类FileReader文件字符输入流,
主要用来输入中文,常用方法,步骤
(1)FileReader fr=new FileReader(文件路径); // 建一个对象
(2)Char[] ch=new char[1024]; // 建一个char数组
(3)Int len=0; // 变量来接收读取的字符个数
(4)While((len=fr.read(ch))!=-1){ // 判断读取的字符个数=-1否,数组到最后取完字符的时候,下一次会跳到结束指令符,直接返回-1,而不是取到的字符长度
Sout(new String(ch,0,len)); // 以字符串的形式输出
Sout((char)len);// 或者直接以字符输出,一个一个读的时候用
}
fr.close(); // 关闭流
6、字符输出流:FileWrite extends OutputSream类
(1)FileWrite fw=new FileWrite (写入数据目的地文件路径);
(2)fw.write(); // 写入字符
(3)fw.write(“xfezfes”);// 字符串可以直接写入字符
(4)fw.flush();// 把内存缓冲区的数据,刷新到文件中,输出流都有该方法,而输入流没有,刷新后流还可以继续使用,
(5)fw.close();// 把内存缓冲区的数据,刷新到文件中,并且关闭流
7、Properties  HashTable的子类,唯一和IO流相结合的集合(数据用=或:都可以)
(1)双列集合,单线程,一键一值,K和V默认都是字符串
(2)Properties prop = new Properties();// 建立一个prop集合
(3)Prop.setProperty(K,V);// 向集合中存入元素,取值方法就是getProperty()
(注:setProperties()方法其实此方法改变了prop集合的长度,+1然后又-1,所以遍历prop集合的时候要注意)
(4)Set<String> set = prop.Stringproperties();// 然后遍历
(5)Prop.store(fos,”对此代码的注释,如SAVE Date”);// 数据写入到硬盘,不常用
(6)

(7)Prop.load(fis传入输入流路经);// 获取流中的数据读取到集合中,常用方法
(8)然后遍历
(9)
1、★*缓冲流Buffered,内部自己维护了一个数组(有默认值),
高效率的原理在于,从硬盘->内存的过程就已经是数组化了,
1)BufferedOutputStream缓冲字节输出流,是输出流的子类,共用方法共享

FileOutputSream fos=new FOS(“aaa.txt”);// 要先建立字节输出流
BufferedOutputSream bos=new BOS(fos); //建立字节缓冲输出流对象,不能直接传入路          径
// 写的时候就已经是写到数组了,所以写得也很快
bos.write(字节); // 传入字节/字节数组,此时存到的是内存中
bos.flush();// 可以省略,此步才把写的数据存到硬盘
bos.close(); // 底层有flush()操作,并且关闭流,不用关闭fos,
2)BufferedInputStream 字节缓冲输入流,使用类似输出流
FileInputStream fis=new FIS(“aaa.txt”);// 建立输入流对象
BufferedIS bis=new BIS(fis); // 建立缓冲输入流对象
Byte[] by=new byte[1024]; // 是用来装内存中的数据到JVM中的,
// 硬盘(缓冲流数组)->内存((bis.read(by))byte数组)/((bis.read())一个一个读)->JVM
// 优化主要是硬盘到内存的效率,因为内存到JVM的速度本来就很快
bis.read(字节/字节数组);// 读取字节/数组,一个一个读是指内存到jvm
bis.close(); // 关闭流
3)BufferedWriter 字符缓冲输出流
特有成员方法:bw.newLine();// 换行,写入一个行分隔符,根据系统不同,获取不同

操作同FileWriter,
4)BufferedReader 字符缓冲输入流,操作同上
br.readline();// 特有的,返回的是字符串,一次读一行,循环的时候读到最后返回的就是(空)null

2、★*转换流
(1)字符集Charset 编码表,GBK,UTF-8
①乱码就是因为2边默认编码不一致
②FileReader可以读取默认编码格式(UTF-8)的文件
③它读取系统默认编码(中文GBK)会产生乱码
转换流可以自定义读写的编码->读任何编码格式的文件
(2)OutputStreamWriter :是字符通向字节流的桥梁,可以用指定的Charset将要写入流中的字符编码成字节

1)OutputSW osw=new OSW(new FOS(“a.txt”,”UTF-8”));// 指定以什么(utf-8)格式去编码输出,没有写就默认的是utf-8格式,
2)osw.write(“你好”); // 写入数据
3)osw.flush(); // 刷新数据到文件
4)osw.close();// 关闭流
(3)InputStreamReader 字节流通向字符流的桥梁(硬盘->内存输入(字节->字符))
1)InputStreamReader isr=new ISR(new FIS(“a.txt”,”utf-8”));// 以什么格式编码去读取什么格式的文件,必须相同,不然就乱码
2)
3)Int len=isr.read(); // 读取文件;
4)Isr.close(); // 关闭流
3、序列化流
序列化和反序列化的时候,会抛出‘没有序列化异常’
要进行序列化和反序列化的类必须实现Serializable接口,并标记,当进行(反)序列化的时候,就会检测是否含有这个标记,有就可以,无则抛异常,而且类的形式改变,这个值就改变,就会报错,可以用Static final来修饰,就会一直不变了。
(1)对象的序列化ObjectOutputStream,把对象以流的方式写到文件中保存

1)ObjectOutputStream oos=new OOS(new FOS(“a.txt”));
2)oos.writeObject(new 对象(属性));// 特有方法,写对象的
3)oos.close(); // 关闭流
(2)对象的反序列化,ObjectInputStream把文件中保存的对象,以流的方式读取出来,也叫做读对象

1)ObjectInputStream ois=new OIS(new Fis(“a.txt”));
2)Object 0=ois.readObject();// 用Object来接收类对象

3)Ois.close();
4)Sout(o);
5)对象 对象名=new 对象();
Sout(对象名(重写了toString()方法的));
4、transient 关键字 瞬态关键字
5、打印流 PrintStream
(1)只负责数据的输出,不负责数据的读取
(2)永远不会抛出IOException
(3)特有方法,print() ,println()(带有换行),输出任意类型的值

0 个回复

您需要登录后才可以回帖 登录 | 加入黑马