一名java培训生的学习笔记基础部分2.docx
《一名java培训生的学习笔记基础部分2.docx》由会员分享，可在线阅读，更多相关《一名java培训生的学习笔记基础部分2.docx（107页珍藏版）》请在冰豆网上搜索。
一名java培训生的学习笔记基础部分2
第十三章2007年6月17日星期日
授课教师：
学生：
第一节HashMap类常见的方法及其用法
publicclassTest{
publicstaticvoidmain（String[]args）{
//创建5个Bean的对象b1-b5并对它们进行初始化
Beanb1=newBean（）;
b1.setAge（23）;
b1.setName（"Bob"）;
Beanb2=newBean（）;
b2.setAge（23）;
b2.setName（"Bob"）;
Beanb3=newBean（）;
Beanb4=newBean（）;
b4.setAge（30）;
b4.setName（"Jack"）;
Beanb5=newBean（）;
b5.setAge（29）;
b5.setName（"wang"）;
HashMaph=newHashMap（）;
//创建HashMap类型对象h;
//并调用put方法，将它们取个key名（外号），加入到Map中
h.put（"1",b1）;
h.put（"2",b2）;
h.put（"3",b3）;
h.put（"4",b4）;
h.put（"5",b5）;
h.remove（"3"）;
//调用remove（）方法，将key值为"3"的元素移除HashMap
System.out.println（h.size（））;
//输出Map中的元素数
Beantemp=（Bean）h.get（"5"）;
//将key值为"5"的元素取出来，并恢复其Bean身份，并其引用返回给temp
System.out.println（temp.getAge（））;
System.out.println（temp.getName（））;
//输出key值为"5"的属性值
}
}
第二节equals方法和hashCode方法的重写
在处理两个对象之间关系时,有时会需要判断两个对象是否相等，如果他们的引用指向的是同一个对象，那么它们是相等的。
如Object中的equals方法。
如果它们指向的是同一类型的不同对象，但是他们的属性值是相等的，也就是说它们的内容是相等的，那么我们就需要重写equals方法，例如：
String中的equals方法就是Object中的equals方法的重写。
如果我们自己定义一个类，需要将自己写的类型的两个对象equals。
那么我们就需要在该类中重写Object中的equals方法。
重写完equals方法后还需要重写hashCode方法。
因为当我们用Hash容器（如HashMap、HashSet）装载这些对象时，例如，将一个对象用add方法加入Set时，会产生一个HashCode,当我们又创建一个同类型内容相同的对象时，又变成另外一个HashCode了，它们在容器中的HashCode是随机的生成的，那么你就无法取得该对象了。
如果我们要判断容器中是否装进了某种类型的对象，那么就需要重写hashCode方法，因为equals方法返回true的对象，它们的hashCode是相同的，重写hashCode方法就是让计算机在同一HashCode中寻找，否则计算机出于Hash容器的高效性考虑，不会去在已经存放该对象的hashCode中寻找，当然也就找不到了。
重写equals方法和hashCode
publicclassMoney{
//创建名叫Money这个类
publicintvalue=0;
//定义int型数据成员value，并初始化为0。
publicMoney（）{
//创建无参数的构造方法
}
publicMoney（inti）{
//带有参数的构造方法
value=i;
}
publicbooleanequals（Objectobj）{
//重写时需要注意重写的方法定义的要求
if（obj==null）{
//判断形参的是否为空。
如果是，返回false
returnfalse;
}
if（this==obj）{
//判断形参对象与调用该方法的当前对象是否指向同一对象，如果是返回true.
returntrue;
}
if（!
（objinstanceofMoney））{
//判断形参对象是否是Money的实例，如果不是，返回false.
returnfalse;
}
Moneymo=（Money）obj;
//将形参引用恢复成该对象的身份。
if（mo.value!
=this.value）{
//如果他们的内容不相等，返回false
returnfalse;
}
returnture;
如果都不是上面的情况返回true
}
publicinthashcode（）{
//重写hashcode方法，使它们的hashcode保持一致
returnvalue;
}
我们在eclipse中测试一下：
如果我们不重写hashCode方法。
那么输出的将会是flase
如果我们将每个对象都存放在同一hashCode中，那样查找的效率就会很低，但是我们还可以利用String中的hashCode的算法，去重新写hashCode方法。
publicinthashCode（）
{
Stringstr=String.valueOf（value）;
//将整型的value转化为String型的str
returnstr.hashCode（）;
//用String中的hashCode的算法，返回hashCode
}
第十四章2007年6月18日星期一
授课教师：
学生：
第一节如何创建一个文件对象
有三种方式：
1、Filemyfile=newFile（“d:
/java/a.txt”）;
2、Filemyfile1=newFile（“d:
/java”,a.txt”）;
3、Filemyfile2=newFile（“myfile1”,b.txt”）;
File类中常见的方法
举例说明：
importjava.io.File;
importjava.io.IOException;
//导入java.io包中的File和IOException两个类
publicclassFileName{
publicstaticvoidmain（String[]args）{
Filef1=newFile（"d:
/java111"）;
//创建一个文件对象f1
f1.mkdir（）;
//创建该文件对象的目录
Filef=newFile（"d:
/whjhg.txt"）;
//创建一个文件对象f
Fileff=newFile（f1,"www.txt"）;
//创建一个文件对象ff，利用File中的构造方法，将其目录设置为f1所指向的路径
//将文件名设置为www.txt。
try{
//处理创建文件时可能出现的异常
//如果两个文件不存在则创建这2个文件
ff.createNewFile（）;
f.createNewFile（）;
}catch（IOExceptione）{
//捕获异常
e.printStackTrace（）;
}
System.out.println（ff.canRead（））;
//ff所指向的这个文件是否可读？
System.out.println（ff.canWrite（））;
//ff所指向的这个文件是否可写入？
System.out.println（ff.exists（））;
//ff所指向的这个文件是否存在？
System.out.println（ff.getPath（））;
//输出ff对象的路径名
System.out.println（ff.isHidden（））;
//ff所指向的文件是否为隐藏文件？
System.out.println（ff.isFile（））;
//ff这个对象是一个文件吗？
System.out.println（f1.mkdir（））;
//f1这个对象路径创建成功了吗？
System.out.println（ff.isDirectory（））;
//ff这个对象是目录吗？
System.out.println（ff.lastModified（））;
//ff所指向的这个文件的最后修改时间
System.out.println（ff.length（））;
//ff所指向的这个文件的大小是多少
System.out.println（ff.delete（））;
//删除ff所指向的文件是否成功
System.out.println（f.renameTo（f1））;
//是否成功的将f所指向的文件重命名为f1
System.out.println（f.toString（））;
//以字符串的形式将f对象返回
}
}
在eclipse中测试一下结果：
第二节怎么样将一个创建好的文件写入一些内容
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.io.PrintStream;
//导入java.io包中的FileOutputStream、IOException、PrintStream
publicclassOutput{
//创建名叫Output的类
publicvoidwrite（Stringfilename）{
//创建一个带有参数的无返回值的方法write
//目的是将形参中所代表的路径名文件写入一些内容
FileOutputStreamfs=null;
PrintStreamps=null;
//分别创建两个FileOutputStream、PrintStream对象fs和ps。
//将它们初始化为null
try{
//处理在写入文件时可能出现的异常
fs=newFileOutputStream（filename）;
//将fs的引用指向用该方法形参作为构造方法参数的FileOutputStream对象
ps=newPrintStream（fs）;
//将ps的引用指向用fs作为构造方法参数的PrintStream对象
ps.println（"1234567890123"）;
//调用ps对象中的println方法，将字符串"1234567890123"写入到文件中
System.out.println（"文件写入成功"）;
//如果没有出现异常，输出文件写入成功。
}catch（Exceptione）{
//捕获异常
e.printStackTrace（）;
}finally{
//无论是否写入成功，都应该将fs和ps所指向的文件关闭
try{
if（ps!
=null）
ps.close（）;
}catch（Exceptione1）{
e1.printStackTrace（）;
}
try{
if（fs!
=null）
fs.close（）;
}catch（IOExceptione1）{
e1.printStackTrace（）;
}
}
}
}
在eclipse中测试一下
第三节怎么样读取一个文件的内容
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.IOException;
//导入java.io包中的File、FileInputStream、IOException
publicclassIn{
//创建名叫In的类
publicStringfun（Stringa）{
//创建带有参数的，返回值类型为String的方法fun
//其中形参a是字符串形式的文件路径
//该方法返回的是形参路径所指向的文件内容
Fileff=newFile（a）;
//创建用形参作为构造方法参数的File类型的对象ff
FileInputStreamfs=null;
//创建FileInputStream对象fs，并初始化为null
byte[]bb=newbyte[2];
//创建byte型的数组bb，并指定长度为2，指定了每次读取的字符数
Stringcon="";
//创建一个String类型的变量con，用来储存读取文件的内容
intn=0;
//定义一个局部变量。
初始化为0
try{
//处理在读取文件中可能存在的异常
fs=newFileInputStream（ff）;
//将fs的引用指向用该方法形参作为构造方法参数的FileInputStream对象
while（n!
=-1）{
//以是否读到文件尾为判断条件，进行while循环
if（n!
=0）{
//如果n不等于0，将读取bb数组中的n个字符
//并将其内容放入到temp临时字符串中
Stringtemp=newString（bb,0,n）;
//将内容累加到con中
con+=temp;
}
n=fs.read（bb）;
//用fs对象调用read方法将读取出的字符个数赋给n
}
}catch（Exceptione）{
//捕获异常
e.printStackTrace（）;
}finally{
//无论是否出现异常都应该将文件关闭
try{
//处理关闭文件时产生的异常
fs.close（）;
}catch（IOExceptione1）{
//捕获IOException异常
e1.printStackTrace（）;
}
}
returncon;
//返回调用该方法所读取的文件内容
}
}
我们在eclipse中测试一下，测试码如图：
第四节利用前两个程序中的方法拷贝一个文件
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.IOException;
//导入java.io包中的File、FileInputStream、FileOutputStream、IOException类
publicclassCopyFile{
//创建CopyFile类
publicvoidcopy（StringsrcName,StringdesName）{
//创建copy方法，其形式参数分别为源文件和目的文件
Filesrc=newFile（srcName）;
Filedes=newFile（desName）;
//分别由两个形参作为File构造方法的参数，创建两个File对象src和des
FileInputStreamfis=null;
FileOutputStreamfos=null;
//分别声明FileInputStream、FileOutputStream的对象fis和fos，并将其初始化为null
try{
//处理在文件copy的时候所产生的异常
des.createNewFile（）;
//创建形参des所指的目的文件
fis=newFileInputStream（src）;
fos=newFileOutputStream（des）;
//分别创建FileInputStream、FileOutputStream的对象fis和fos
intn=0;
//定义整形变量n，初始化为0
byte[]buf=newbyte[2];
//创建byte型的数组bb，并指定长度为2，指定了每次读取的字符数
while（（n=fis.read（buf））!
=-1）{
//调用fis的read方法读取源文件，并将其读取的字符数量赋给n
//定义循环条件为n!
=-1（未读到文件尾）
fos.write（buf,0,n）;
//将每次读取的内容写入到目的文件中
}
}catch（Exceptione）{
//捕获异常
e.printStackTrace（）;
}finally{
//为了安全起见，分别处理在文件关闭时的异常
try{
if（fos!
=null）
fos.flush（）;
}catch（IOExceptione1）{
e1.printStackTrace（）;
}
try{
if（fos!
=null）
fos.close（）;
}catch（IOExceptione2）{
e2.printStackTrace（）;
}
try{
if（fis!
=null）
fis.close（）;
}catch（IOExceptione3）{
e3.printStackTrace（）;
}
}
System.out.println（"文件copy成功"）;
}
}
在eclipse中测试,测试码如下图:
第十五章2007年6月20日星期三
授课教师：
学生：
第一节与文件操作相关的一些程序实例
一、实现FilenameFilter接口来过滤符合某些条件的文件或目录。
importjava.io.File;
importjava.io.FilenameFilter;
//导入java.io包中的File类和FilenameFilter接口
publicclassJavaFilterimplementsFilenameFilter{
//创建JavaFilter类实现FilenameFilter接口
publicbooleanaccept（Filedir,Stringname）{
//重写接口中的accept方法，以实现FilenameFilter接口
returnname.endsWith（".java"）;
//返回一以".java"结尾字符串
}
}
在eclipse中测试：
二、读取properties类型文件的内容：
properties类型文件叫属性文件，其中的内容不要写中文，否则会读出乱码，它的作用是实现程序和程序之间、程序和服务器之间的信息交换。
由于properties类型文件通常存放的是一些服务器的IP地址，或者存放程序实现所必须的目录或文件，所以可以利用文件返回的字符串来使维护程序更加方便。
下面举一个读取properties类型文件的内容的程序。
我们首先在硬盘上创建一个test.properties.用记事本打开写入内容如下图
其中url和name叫做标记，后面的部分叫内容
importjava.io.File;
importjava.io.FileInputStream;
importjava.util.Properties;
//导入java.io包中的File和FileInputStream类
//导入java.util中的Properties类
publicclassReadPro{
//创建ReadPro类
publicStringurl="";
publicStringname="";
//定义.properties类型文件中的内容标记url和name作为数据成员，初始化它们为""
publicReadPro（）{
//在构造方法中完成读取.propertie文件的操作
//使其创建该类对象时就已经将.propertie文件的内容赋给该类的成员变量
try{
//处理在读取文件中可能出现的异常
Propertiesprops=newProperties（）;
//创建Properties类的对象
Filef=newFile（"d:
/Test/test.properties"）;
//用.propertie文件路径作为参数的构造方法创建File类对象f
FileInputStreamin=newFileInputStream（f）;
//将f作为FileInputStream构造方法的参数创建其对象in
props.load（in）;
//将in作为参数用对象props调用Properties中的方法load
//将文件读取出来
in.close（）;
//关闭该文件
url=props.getProperty（"url"）;
name=props.getProperty（"name"）;
//用Properties类中的getProperty方法将标记作为参数，分别返回给数据成员
}catch（Exceptione）{
//捕获异常
e.printStackTrace（）;
}
}
}
我们在eclipse中测试。
测试码见下图：
第三节线程
一、基本概念：
1、进程：
通俗来讲就是指正在被cpu执行的代码叫进程。
2、线程：
等待被cpu执行的代码叫线程。
3、多线程：
指的是在单个程序中可以同时运行多个不同的线程，执行不同的任务。
由于cpu采用分时复用，每个线程都有机会得到执行，每个都执行1ms，我们看起来就像是同时执行。
二、创建线程：
线程的所有活动都是通过线程的run
升级会员 