corejava流的笔记.docx
《corejava流的笔记.docx》由会员分享，可在线阅读，更多相关《corejava流的笔记.docx（24页珍藏版）》请在冰点文库上搜索。
corejava流的笔记
IO+Thead+Net
一．IO四大家族
1.InputStreamOutputStream
字节输入流：
IO中的InputStream为抽象类，返回一个字节，
Intread（）:
8bit-----低8位
Intread（byte[]b）;---FileInputStream
字节输出流：
IO中的OutputStream为抽象类，输出一个字节，截取int类型b的低8位voidwrite（intb）
Voidwrite（byte[]b）;---FileInputStream
voidwrite（byte[]b,index,length）;---FileInputStream
1）FileInputStream和FileOutputStream
【案例1】创建一个Eson.txt，用IO写一些文字“HelloWorld”，用IO读出来
//条件传一个String-------》得到FileInputStream
Filefile=newFile（"D:
/Eson.txt"）;
FileInputStreamfis=newFileInputStream（file）;
FileOutputStreamfos=newFileOutputStream（file）;
//先写
Stringstr="HelloWorld";
byte[]b=str.getBytes（）;
fos.write（b）;
//在读
inta=-1;
while（（a=fis.read（））!
=-1）{
System.out.print（（char）a）;
}
fis.close（）;
fos.close（）;
a的值表示：
一个一个的字节，所以我们可以把一个一个的字节变成字符char显示出来
注意：
FileInputStream传一个File进去的时候。
有就会使用当前的文件，若没有会自动的创建文件。
而FileOutputStream则不会
若使用缓冲：
//在读
inta=-1;
byte[]by=newbyte[1024];//一次读1K
while（（a=fis.read（by））!
=-1）{
System.out.print（a）;
}
a的值表示：
读取的总字节数，满1024个Byte，就返回1024，若不满就返回当前的字节数（如刚才读出来的是10个字节，也就是文件的大小）
FileInputStream{
PrivateFilefile=null;
PublicFileInputStream（Filefile）{
This.file=file;
}
PublicFileInputStream（Stringname）{
This.file=newFile（name）;
}
}
2.WriterReader
1）InputStreamReader和OutputStreamReader
Reader:
intreade（）返回char类型，占int的低16位
Writer:
intwrite（intb）输出一个char，为参数int的低16位
【案例2】即能将英文字节变成字符，也能将中文字节变成字符
InputStreamReaderisr=newInputStreamReader（
newFileInputStream（"D:
/Eson.txt"））;
//HelloWorld李顺
//72,101,108,108,111,87,111,114,108,100,192,238,203,179,
//在读
inta=-1;
while（（a=isr.read（））!
=-1）{
System.out.print（（char）a）;
}
isr.close（）;
【案例3】完成文件的复制：
将D盘Eson.txt，复制到E盘
方式1：
纯一个一个字节的去复制，效率很慢
FileInputStreamfis=newFileInputStream（newFile（"D:
/Eson.txt"））;
FileOutputStreamfos=newFileOutputStream（newFile（"E:
/Eson.txt"））;
intb=-1;
while（（b=fis.read（））!
=-1）{
fos.write（b）;
}
fis.close（）;
fos.close（）;
方式2：
使用byte[]数组去复制，效率比较高
FileInputStreamfis=newFileInputStream（newFile（"D:
/Eson.txt"））;
FileOutputStreamfos=newFileOutputStream（newFile（"E:
/Eson.txt"））;
intb=-1;
byte[]by=newbyte[1024];//2.5K
while（（b=fis.read（by））!
=-1）{
fos.write（by,0,b）;
}
fis.close（）;
fos.close（）;
方式3：
使用BufferedInputStream和BufferedOutputStream去复制
BufferedInputStreambis=newBufferedInputStream（new
FileInputStream（newFile（"D:
/Eson.txt"）））;
BufferedOutputStreambos=newBufferedOutputStream（new
FileOutputStream（newFile（"E:
/Eson.txt"）））;
intb=-1;
while（（b=bis.read（））!
=-1）{
bos.write（b）;
}
bis.close（）;
bos.close（）;
方式4：
针对文件复制的时候，一般不适用这种类似的流，适用于程序需要用到文件里面的字符串数据的时候，读进较大的文件
BufferedReader和BufferedWriter
//字节（水分子）---》字符（一滴水）---》字符串（一桶水）
BufferedReaderbr=newBufferedReader（newInputStreamReader（
newFileInputStream（"D:
/Eson.txt"）））;
BufferedWriterbw=newBufferedWriter（newOutputStreamWriter（
newFileOutputStream（"E:
/Eson2.txt"）））;
intb=-1;
while（（b=br.read（））!
=-1）{
bw.write（b）;
System.out.print（（char）b）;
}
br.close（）;
bw.close（）;
2）FileReader和FileWriter
FileReader=newInputStreamReader（newFileInputStream（"D:
/Eson.txt"））
FileWriter=newOutputStreamWriter（newFileOutputStream（"E:
/Eson2.txt"））
区别在于：
使用FileReader不能改变编码，它使用的是默认的编码
3.Properties
publicclassConnectionUtils{
privatestaticPropertiesprop=newProperties（）;
static{
try{
//方式1：
针对于本地文件，不在项目中的文件
//prop.load（newFileInputStream（newFile（"E:
/db1.properties"）））;
//prop.load（newFileReader（"src/db.properties"））;
ClassLoaderloader=ConnectionUtils.class.getClassLoader（）;
//类加载器将db.properties变成一个一个字节流
//方式2：
针对于本项目中的文件
//prop.load（loader.getResourceAsStream（"db.properties"））;
//方式3：
针对于网络中的文件
//URLurl=newURL（"E:
/db1.properties"）;
URLurl=loader.getResource（"db.properties"）;
prop.load（url.openConnection（）.getInputStream（））;
}catch（Exceptione）{
e.printStackTrace（）;
}
}
publicstaticStringgetValue（Stringname）{
returnprop.getProperty（name）;
}
}
测试类：
publicstaticvoidmain（String[]args）throwsException{
ConnectionUtilsconn=newConnectionUtils（）;
Stringname=conn.getValue（"name"）;
Stringpasssword=conn.getValue（"password"）;
System.out.println（name+":
"+passsword）;
}
打印的结果：
lishun:
123
注意：
方式1和方式2的区别：
主要是服务器的内存消耗，如几百万人访问该程序，如果使用方式1，那么FileInputStream会不停的创建，若使用ClassLoader则只会创建一次
【问题2】解决Properties中文乱码的问题
使用JDK/bin下的工具命令：
native2ascii.exe
name=\u674e\u987a
password=123
或者使用Java程序手动的变成16进制编码
类加载的顺序：
1.去当前目录下去加载（String.class）
2.去我们JDK系统类库（tools.jar/rt.jar/dt.jar）中寻找
3.最后去ClassPath下去寻找
Thead
一，神马叫线程和进程？
Main入口函数是主线程。
classMyThread1extendsThread{
@Override
publicvoidrun（）{
System.out.println（"******MyThread2*******"）;
}
}
classMyThread2implementsRunnable{
@Override
publicvoidrun（）{
System.out.println（"******MyThread2*******"）;
}
}
二，比较奇特的创建方式：
//变种1
newThread（）{
publicvoidrun（）{};
}.start（）;
//变种2
newThread（newRunnable（）{
@Override
publicvoidrun（）{
//TODOAuto-generatedmethodstub
}
}）.start（）;
newThread（newMyThread2（））.start（）;
//变种3
newThread（newRunnable（）{
@Override
publicvoidrun（）{
System.out.println（"*****Hello********"）;
}
}）{
publicvoidrun（）{
System.out.println（"*****World********"）;
};
}.start（）;
三，线程的几种状态
阻塞状态
3种：
就绪状态---运行状态
sleep（）IO阻塞wait（）
四，问题：
a）start（）和run（）的区别？
b）线程的同步（对象锁）
c）设计模式：
生产者与消费者
【案例1】创建一个监听器，每当用户输入我的时候，替换成自己的名字
publicclassThreadDemo2{
privatestaticStringname=null;
publicstaticvoidmain（String[]args）throwsException{
Scannerscanner=newScanner（System.in）;
while（true）{
System.out.print（"请输入：
"）;
name=scanner.nextLine（）;
newThread（）{
@Override
publicvoidrun（）{
if（"我".equals（name））{
name="Eson";
}
}
}.start（）;
Thread.sleep（1000）;
if（"exit".equals（name））{
System.out.println（"欢迎下次使用！
"）;
break;
}
System.out.println（name）;
}
}
}
网络
一、网络的层结构
二、网络编程的HelloWorld
服务器：
publicclassServer{
privatestaticfinalintport=8887;
privateServerSocketss=null;
privateSockets=null;//这个Socket可以理解成：
取代所有的Client
//newServer（）----》代表服务器开启
publicServer（）throwsException{
ss=newServerSocket（port）;
}
publicvoidstart（）throwsIOException{
//建立一个连接
System.out.println（"服务器已经开启···"）;
s=ss.accept（）;
Stringstr="HelloWorld";
BufferedWriterbw=newBufferedWriter（newOutputStreamWriter（s.getOutputStream（）））;
bw.write（str）;
bw.close（）;
}
publicstaticvoidmain（String[]args）throwsException{
newServer（）.start（）;
}
}
客户端：
publicclassClient{
privateSockets=null;
privatestaticfinalStringip="localhost";
privatestaticfinalintport=8887;
//newClient（）--实质是创建一个Socket
publicClient（）throwsException{
s=newSocket（ip,port）;
}
//表明客户端运行
publicvoidgoing（）throwsIOException{
//写一些相应的业务逻辑的代码
System.out.println（"客户端在运行···"）;
BufferedReaderbr=newBufferedReader（
newInputStreamReader（s.getInputStream（）））;
Stringstr=br.readLine（）;
System.out.println（str）;
br.close（）;
}
publicstaticvoidmain（String[]args）throwsException{
newClient（）.going（）;
}
}
反射
一．概念：
怎么形容一个类？
Class类里面的属性的信息，能够完整的描述一个类。
它的实例化，是不能够new的，是有我们的编译器，在编译完成后，类加载的时候创建出来的一个来描述本类的对象。
Class没有公共构造方法。
Class对象是在加载类时由Java虚拟机以及通过调用类加载器中的defineClass方法自动构造的。
classClass{
包结构（package）
构造方法（constructor）
属性（Filed）
方法（Method）
···
}
二．反射的类型
Java的数据类型：
引用类型，8种基本数据类型，空类型
Person.classInteger.classint.classvoid.class
三，得到Class对象的方式
Classc1=java.lang.String.class;
Classc2="abc".getClass（）;
Classc3=Class.forName（"java.lang.String"）;
System.out.println（c1==c2）;
System.out.println（c2==c3）;//String.class
8种基本数据类型：
得到方式：
Classc1=int.class;
单例设计模式（原则：
就是构造方法的私有化）----》Spring
贪心式:
不管用不用，都会去创建
classSingle{
privatestaticSinglesingle=newSingle（）;
privateSingle（）{
}
PublicstaticSinglegetSingle（）{
returnsingle;
}
}
懒汉式：
只有用到的时候，才会去创建-------）Hibernate----lazy
classSingle{
privatestaticSinglesingle=null;
privateSingle（）{
}
PublicstaticSinglegetSingle（）{
if（single==null）{
single=newSingle（）;
}
returnsingle;
}
}
Single.getSingle（）;
三．如何通过反射去创建一个对象？
1）调用无参构造方法
方式一：
Class.forName（"com.refection.Person"）.newInstance（）;
方式二：
得到构造方法constructor对象
Constructor
getDeclaredConstructor（Class
>... parameterTypes）
返回一个Constructor对象，该对象反映此Class对象所表示的类或接口的指定构造方法。
Constructor
>[]
getDeclaredConstructors（）
返回Constructor对象的一个数组，这些对象反映此Class对象表示的类声明的所有构造方法。
（Person）cls.getConstructor（）.newInstance（）;
2）调用有参的构造方法
//newPerson（"Eson","tarena"）;
Constructorconstructor=cls.getConstructor（String.class,String.class）;
Personperson=（Person）constructor.newInstance（"Eson","tarena"）;
System.out.println（person.getName（）+":
"+person.getSchool（））;
作业：
用反射创建
newString（“abc”）和newString（newStringBuffer（“abc”））;
//1.5
Classcls=Class.forName（"java.lang.String"）;
Stringstr=（String）cls.getConstructor（String.class）.newInstance（"abc"）;
System.out.println（str）;
//1.4
Stringstr1=（String）cls.getConstructor（newClass[]{String.class}）.newInstance（"abc"）;
System.out.println（str1）;
*****************************************
Classcls1=Class.forName（"java.lang.StringBuffer"）;
StringBufferstr2=（StringBuffer）cls1.getConstructor（String.class）.newInstance（"abc"）;
Classcls=Class.forName（"java.lang.String"）;
Stringstr=（String）cls.getConstructor（StringBuffer.class）.newInstance（str2）;
System.out.println（str）;
四．
8月3日
一，周考知识点
1.File类的功能
1）File代表文件和目录
Length（）getName（）getPath（）lastModified（）exists（）
2）File判断是否文件和目录
boolean
isDir
升级会员 