121 第十二天 魔乐java基础视频学习笔记.docx
《121 第十二天 魔乐java基础视频学习笔记.docx》由会员分享，可在线阅读，更多相关《121 第十二天 魔乐java基础视频学习笔记.docx（34页珍藏版）》请在冰点文库上搜索。
121第十二天魔乐java基础视频学习笔记
1、课程名称：
类集框架
2、知识点
2.1、上次课程的主要知识点
1、File类操作文件：
构造方法、exists（）、delete（）、mkdirs（）、getParentFile（）；
2、InputStream和OutputStream使用的文件拷贝程序；
3、输出数据使用打印流、输入数据使用Scanner（BufferedReader）；
4、对象如果需要传输，则对象所在的类必须实现java.io.Serializable接口，这个接口没有方法。
2.2、本次预计讲解的知识点
1、类集简介；
2、类集之中的核心操作接口以及核心代码的使用。
3、具体内容
3.1、认识类集（理解）
如果现在要想保存多个对象，肯定使用对象数组完成，但是对象数组本身有一个最大的问题在于其数据的长度，所以后来使用了链表完成了动态对象数组的开发，可是链表的开发难度实在是很大，而且如果一个链表要想真正去使用，只依靠之前所编写的还不够，还需要进行一些代码的调优。
而在JDK1.2之后正式引入了类集的概念，类集是一种动态的对象数组，属于各个数据结构的实现类，在整个类集之中主要的组成是一些核心的操作接口：
Collection、List、Set、Map、Iterator、Enumeration。
3.2、单值保存的最大父接口：
Collection（重点）
所谓的单值保存指的是每一次操作只会保存一个对象，就好像之前的链表程序一样，每一次只保存了一个对象，在Collection接口之中定义了如下的一些操作方法。
NO.
方法名称
类型
描述
1
publicbooleanadd（Ee）
普通
数据增加
2
publicvoidclear（）
普通
清除数据
3
publicbooleancontains（Objecto）
普通
查找数据是否存在
4
publicbooleanisEmpty（）
普通
判断是否为空集合
5
publicIteratorintegrator（）
普通
为Iterator接口实例化
6
publicbooleanremove（Objecto）
普通
删除数据
7
publicintsize（）
普通
取得集合的个数
8
publicObject[]toArray（）
普通
将集合变为对象数组
在Collection接口之中一共定义了15个方法，在所有的方法之中，只有两个方法最为常用：
add（）、interator（）。
不过从开发上讲，很少会去直接使用Collection，都会使用Collection的两个子接口：
List、Set。
3.3、允许重复的子接口：
List（重点，80%）
List是Collection的一个最为常用的子接口，首先这个接口的定义如下：
publicinterfaxeListextendsCollection
但是List接口对Collection接口进行了大量的扩充，但是扩充之后的主要方法：
NO.
方法名称
类型
描述
1
publicEget（intindex）
普通
取得指定索引位置上的数据
2
publicEset（intindex,Eelement）
普通
修改指定索引位置上的数据
3
publicListIteratorlistIterator（）
普通
为ListIterator接口实例化
但是以上的三个方法，只针对于List接口起作用，而List接口有两个常用子类：
ArrayList、Vector。
3.3.1、新的子类：
ArrayList（95%）
ArrayList是List子接口使用最多的一个子类，而这个类的定义如下：
publicclassArrayList
extendsAbstractList
implementsList,RandomAccess,Cloneable,Serializable
按照面向对象的概念来讲，现在使用ArrayList主要的目的是为List接口实例化，所有的操作方法都以List接口为主。
范例：
使用ArrayList进行List接口的功能验证。
packagecn.mldn.demo;
importjava.util.ArrayList;
importjava.util.List;
publicclassTestDemo{
publicstaticvoidmain（String[]args）throwsException{
Listall=newArrayList（）;
all.add（"Hello"）;
all.add（"Hello"）;//内容重复了
all.add（"World"）;
for（intx=0;xStringstr=all.get（x）;//get（）方法只有List接口有
System.out.print（str+"、"）;
}
}
}
在使用代码的时候可以发现，List集合之中即使存在了重复数据，也可以正常的保存，而且数据保存的顺序就是存入数据的顺序。
范例：
使用List集合修改之前的程序
packagecn.mldn.demo;
importjava.util.ArrayList;
importjava.util.List;
interfaceAnimal{//动物
publicStringgetName（）;
publicintgetAge（）;
}
classZoo{
privateListanimals=newArrayList（）;//多个动物
publicvoidadd（Animalani）{//增加动物
this.animals.add（ani）;
}
publicvoiddelete（Animalani）{
this.animals.remove（ani）;//需要equals（）
}
publicListsearch（StringkeyWord）{
Listresult=newArrayList（）;
Objectobj[]=this.animals.toArray（）;
for（intx=0;x{
Animalani=this.animals.get（x）;
if（ani.getName（）.contains（keyWord））//满足
{//满足
result.add（ani）;
}
}
returnresult;
}
}
classDogimplementsAnimal{
privateStringname;
privateintage;
publicDog（Stringname,intage）{
this.name=name;
this.age=age;
}
publicStringgetName（）{
returnthis.name;
}
publicintgetAge（）{
returnthis.age;
}
publicbooleanequals（Objectobj）{
if（this==obj）
{
returntrue;
}
if（obj==null）
{
returnfalse;
}
if（!
（objinstanceofDog））
{
returnfalse;
}
Dogdog=（Dog）obj;
if（this.name.equals（dog.name）&&this.age==dog.age）
{
returntrue;
}
returnfalse;
}
publicStringtoString（）{
return"【狗的信息】名字：
"+this.name+"，年龄：
"+this.age;
}
}
classTigerimplementsAnimal{
privateStringname;
privateintage;
publicTiger（Stringname,intage）{
this.name=name;
this.age=age;
}
publicStringgetName（）{
returnthis.name;
}
publicintgetAge（）{
returnthis.age;
}
publicbooleanequals（Objectobj）{
if（this==obj）
{
returntrue;
}
if（obj==null）
{
returnfalse;
}
if（!
（objinstanceofTiger））
{
returnfalse;
}
Tigert=（Tiger）obj;
if（this.name.equals（t.name）&&this.age==t.age）
{
returntrue;
}
returnfalse;
}
publicStringtoString（）{
return"【老虎的信息】名字：
"+this.name+"，年龄：
"+this.age;
}
}
classTestDemo{
publicstaticvoidmain（String[]args）{
Zoozoo=newZoo（）;//动物园
zoo.add（newDog（"花狗",1））;
zoo.add（newDog（"黄狗",1））;
zoo.add（newDog（"黑狗",1））;
zoo.add（newDog（"斑点狗",1））;
zoo.add（newTiger（"斑点虎",2））;
zoo.add（newTiger（"黑虎",2））;
zoo.add（newTiger（"花虎",2））;
zoo.delete（newDog（"斑点狗",1））;//删除
Listresult=zoo.search（"斑点"）;
for（intx=0;x{
System.out.println（result.get（x））;
}
}
}
至少此时的程序不再需要自己去开发链表了，所有的链表的实现类都有了。
3.3.2、旧的子类：
Vector（5%）
Vector类是在JDK1.0的时候就推出的一个最早的实现动态数组的操作类，实际上对于今天而言，有许多的类上依然还是在使用着Vector，不过从实际的开发来讲，现在设计的一些程序都是针对于接口的操作了。
packagecn.mldn.demo;
importjava.util.List;
importjava.util.Vector;
publicclassTestDemo{
publicstaticvoidmain（String[]args）throwsException{
Listall=newVector（）;
all.add（"Hello"）;
all.add（"Hello"）;//内容重复了
all.add（"World"）;
for（intx=0;xStringstr=all.get（x）;//get（）方法只有List接口有
System.out.print（str+"、"）;
}
}
}
因为所有的操作都是针对于接口完成的，接口定义的方法不变，子类随便变。
面试题：
请解释ArrayList和Vector的区别？
No.
区别
ArrayList
Vector
1
推出时间
JDK1.2
JDK1.0
2
性能
采用异步处理方式，性能更高
采用同步处理方式，性能相对较低
3
安全性
非线程安全
线程安全
4
输出
Iterator、ListIterator、foreach
Iterator、ListIterator、foreach、Enumeration
从实际开发而言，几乎都是开发异步程序，所以首选的肯定是ArrayList子类。
3.4、不允许重复的子接口：
Set（重点，20%）
Set也是一个Collection较为常用的子接口，这个接口的定义如下：
publicinterfaceSetextendsCollection
在Collection接口定义了15个方法，但是Set子接口并不像List子接口那样对Collection接口进行了大量的扩充，而是完整的继承了下来，那么就证明了在Set子接口之中是肯定无法使用get（）方法的。
那么在Set子接口之中常用的两个子类：
HashSet、TreeSet，下面分别说明。
3.4.1、散列存在的子类：
HashSet（80%）
Hash（哈希）属于一种算法，这种算法的核心意义指的是找空保存算法，所以只要一看见hash第一反应就是说没有顺序的保存。
范例：
观察Set接口使用
packagecn.mldn.demo;
importjava.util.HashSet;
importjava.util.Set;
publicclassTestDemo{
publicstaticvoidmain（String[]args）throwsException{
Setall=newHashSet（）;
all.add（"Hello"）;
all.add（"Hello"）;//内容重复了
all.add（"World"）;
System.out.print（all）;
}
}
保存数据再输出之后可以发现，重复的数据没有了，并且其本身的保存也是没有任何顺序的。
3.4.2、排序存放的子类：
TreeSet（20%）
如果现在希望Set集合之中保存的数据有顺序，那么就通过TreeSet进行Set接口的实例化。
范例：
使用TreeSet
packagecn.mldn.demo;
importjava.util.Set;
importjava.util.TreeSet;
publicclassTestDemo{
publicstaticvoidmain（String[]args）throwsException{
Setall=newTreeSet（）;
all.add（"D"）;
all.add（"A"）;
all.add（"B"）;
all.add（"B"）;
all.add（"C"）;
System.out.print（all）;
}
}
现在发现所有保存的数据没有重复并且有序排列。
3.4.3、关于TreeSet排序的说明（重点）
通过之前的程序可以发现，使用TreeSet实例化Set接口之中，所有保存的数据都是有序的，那么在这种情况下，那么如果使用的是一个自定义的类呢？
那么这个时候如果这个对象要进行排序的话，则这个类必须实现Comparable接口，设置比较规则。
但是在这种情况下有一点必须注意：
一旦使用了Comparable之后，类之中的所有属性都必须写进排序规则。
范例：
自定义类排序
packagecn.mldn.demo;
importjava.util.Set;
importjava.util.TreeSet;
classPersonimplementsComparable{
privateStringname;
privateintage;
publicPerson（Stringname,intage）{
this.name=name;
this.age=age;
}
publicStringtoString（）{
return"姓名：
"+this.name+"，年龄：
"+this.age+"\n";
}
publicintcompareTo（Persono）{
if（this.age>o.age）{
return1;
}elseif（this.agereturn-1;
}else{
returnpareTo（o.name）;
}
}
}
publicclassTestDemo{
publicstaticvoidmain（String[]args）throwsException{
Setall=newTreeSet（）;
all.add（newPerson（"张三",20））;
all.add（newPerson（"张三",20））;
all.add（newPerson（"李四",20））;
all.add（newPerson（"王五",19））;
all.add（newPerson（"赵六",21））;
System.out.println（all）;
}
}
TreeSet子类依靠Comparable中的compareTo（）方法的返回值是否为0来判断是否为重复元素。
3.4.4、关于重复元素的说明
那么TreeSet依靠Comparable进行重复元素判断，那么HashSet可以吗？
发现以上的程序换为了HashSet之后，该有的重复还是有，因为从真正的意义上来讲，判断重复元素依靠的不是Comparable（只有排序的时候才依靠Comparable），所有的重复元素的判断依靠于Object类的两个方法：
·hash码：
publicinthashCode（）；
·对象比较：
publicbooleanequals（Objectobj）。
在进行对象比较的过程之中，首先会先使用hashCode（）与已保存在集合之中的对象的hashCode（）进行比较，如果代码相同，则再使用equals（）方法进行属性的依次判断，如果全部相同，则为相同元素。
那么为了保证每一个对象的hashCode（）不一样，需要设计一组数学公式才可以，会吗？
范例：
重复元素
packagecn.mldn.demo;
importjava.util.HashSet;
importjava.util.Set;
importjava.util.TreeSet;
classPerson{
privateStringname;
privateintage;
publicPerson（Stringname,intage）{
this.name=name;
this.age=age;
}
publicStringtoString（）{
return"姓名：
"+this.name+"，年龄：
"+this.age+"\n";
}
@Override
publicinthashCode（）{
finalintprime=31;
intresult=1;
result=prime*result+age;
result=prime*result+（（name==null）?
0:
name.hashCode（））;
returnresult;
}
@Override
publicbooleanequals（Objectobj）{
if（this==obj）
returntrue;
if（obj==null）
returnfalse;
if（getClass（）!
=obj.getClass（））
returnfalse;
finalPersonother=（Person）obj;
if（age!
=other.age）
returnfalse;
if（name==null）{
if（other.name!
=null）
returnfalse;
}elseif（!
name.equals（other.name））
returnfalse;
returntrue;
}
}
publicclassTestDemo{
publicstaticvoidmain（String[]args）throwsException{
Setall=newHashSet（）;
all.add（newPerson（"张三",20））;
all.add（newPerson（"张三",20））;
all.add（newPerson（"李四",20））;
all.add（newPerson（"王五",19））;
all.add（newPerson（"赵六",21））;
System.out.println（all）;
}
}
至此，Object类之中的全部方法就讲解完成了。
3.5、集合的输出操作（重点）
在之前所介绍的都属于单值集合的基本操作，可是对于集合有一个最为重要的问题就是如何进行集合内容的输出操作，而这个问题在Java的类集框架之中给出了四种输出方式：
Iterator、ListIterator、Enumeration、foreach。
3.5.1、迭代输出：
Iterator（核心，95%）
Iterator是最为常用
升级会员 