java笔记数组和集合文档格式.docx
《java笔记数组和集合文档格式.docx》由会员分享，可在线阅读，更多相关《java笔记数组和集合文档格式.docx（23页珍藏版）》请在冰豆网上搜索。
引用类型：
publicclassTest
{
publicstaticvoidmain（String[]args）
Person[]p=newPerson[3];
p[0]=newPerson（）;
p[1]=newPerson（）;
p[2]=newPerson（）;
p[0].age=20;
p[1].age=21;
p[2].age=22;
for（inti=0;
i<
p.length;
i++）
System.out.println（p[i].age）;
}
classPerson
intage;
}
运行结果：
图示：
二维数组：
定义方式：
type[][]a=newtype[数组行数][数组列数]；
1）int[][]a=newint[2][3];
//定义了一个2行3列的二维数组。
2）
表示的是:
3）二维数组比如
中a.length表示的是数组行数。
应用：
1）冒泡排序：
ArrayA=newArray（）;
int[]a=newint[]{4,7,2,9};
A.P（a）;
}
classArray
publicvoidP（int[]a）
a.length-1;
for（intj=0;
j<
a.length-i-1;
j++）
if（a[j]>
a[j+1]）
intt=a[j+1];
a[j+1]=a[j];
a[j]=t;
}
}
}
for（intk=0;
k<
a.length;
k++）
System.out.println（a[k]）;
}运行结果：
2）二分查找（BinarySearch）：
首先要求查找的数组是有序的。
查找等值数的位置。
publicstaticintarray（int[]a,intvalue）
intlow=0;
inthigh=a.length-1;
intmiddle;
while（low<
=high）
middle=（low+high）/2;
if（a[middle]==value）
returnmiddle;
if（a[middle]>
value）
low=middle-1;
if（a[middle]<
high=middle+1;
return-1;
int[]a={2,4,5,6,7,9,14,17,21};
intvalue=7;
System.out.println（array（a,value））;
}运行结果：
4
集合（类集-collection）：
在java.util包中，
1）集合中存放的依然是对象的引用而不是对象本身。
2）集合当中只能放置对象的引用，无法放置原生数据类型，我们需要使用原生数据类型的包装类才能加入到集合当中。
3）集合当中放置的都是Object类型，因此取出来的也是Object类型，那么必须要使用强制类型转换将其转换为真正的类型（放置进去的类型）。
4）看下面图1和图2：
————————————————————————————————————————————
的实现类
a）ArrayList底层采用数组实现，当使用不带参数的构造方法生成ArrayList对象时，实际上会在底层生成一个长度为10的Object类型数组。
b）使用ArrayList.add（）方法增加元素，如果增加的元素个数超过10个，那么ArrayList底层会新生成一个数组，长度为原数组的1.5倍+1，然后将原数组的内容复制到新数组当中，并且后续增加的内容都会放到新数组当中。
当新数组无法容纳增加的元素时，重复该过程。
c）对于ArrayList元素的删除操作，需要将被删除元素的后续元素向前移动，代价比较高。
1）ArrayList中某些方法的应用：
importjava.util.ArrayList;
publicstaticvoidmain（String[]args）
{
ArrayListarray=newArrayList（）;
array.add（"
cwj"
）;
/*集合下只能放置对象，此处不能放原生数据类型（如写array.add
（2）;
是错误的）这里要把它包装成Integer类型的对象（可以去参看包装类型：
有8类）*/
array.add（newInteger
（2））;
Stringa=（String）array.get（0）;
Integerb=（Integer）array.get
（1）;
System.out.println（a）;
System.out.println（b.intValue（））;
2）ArrayList中的某些方法：
array.add（newInteger（4））;
array.add（newInteger（7））;
intsum=0;
array.size（）;
{
intvalue=（（Integer）array.get（i））.intValue（）;
sum+=value;
System.out.println（sum）;
13
3）ArrayList中的某些方法：
array.add（newInteger
（1））;
array.add（newInteger（3））;
/*
*不能将Object[]转换为Integer[]，即下面那语句不能写成：
Integer[]in=（Integer[]）array.toArray（）;
*/
Object[]in=array.toArray（）;
in.length;
System.out.println（（（Integer）in[i]）.intValue（））;
}
链表：
Nodenode1=newNode（"
meng"
Nodenode2=newNode（"
huan"
Nodenode3=newNode（"
xi"
Nodenode4=newNode（"
you"
node1.next=node2;
node2.next=node3;
node3.next=node4;
node4.next=null;
//此句可有可无
System.out.println（node1.next.date）;
classNode
Stringdate;
Nodenext;
publicNode（Stringdate）
this.date=date;
huan
关于ArrayList与LinkedList的比较分析：
1）ArrayList底层采用数组实现，LinkedList底层采用双向链表实现。
2）当执行插入或删除操作时，采用LinkedList比较好。
3）当执行搜索操作时，采用ArrayList比较好。
4）当向ArrayList添加一个对象时，实际上是将该对象放置到了ArrayList底层所维护的数组当中；
当向LinkedList中添加一个对象时，实际上LinkedList内部会生成一个Entry对象，该Entry对象的结构为：
Entry
Entryprevious;
Objectelement;
Entrynext;
}
其中的Object类型的元素element就是我们向LinkedList中所添加的元素，然后Entry又构造好了向前与向后的引用previous、next，最后将生成的这个Entry对象加入到了链表当中。
换句话说，LinkedList中所维护的是一个个Entry对象。
应用1：
用LinkedList实现队列：
importjava.util.LinkedList;
privateLinkedListlink=newLinkedList（）;
publicvoidput（Objecto）
link.addLast（o）;
publicObjectget（）
{
returnlink.removeFirst（）;
publicbooleanisEmpty（）
returnlink.isEmpty（）;
Testt=newTest（）;
t.put（"
one"
two"
three"
System.out.println（t.get（））;
System.out.println（t.isEmpty（））;
当使用HashSet时，hashCode（）方法就会得到调用，判断已经存储在集合中的对象的hashcode值是否与增加的对象的hashcode值一致；
如果不一致，直接加进去；
如果一致，再进行equals方法的比较，equals方法如果返回true，表示对象已经加进去了，就不会再增加新的对象，否则加进去。
使用原本Object中的hashCode及equals方法（这里有疑问）：
importjava.util.HashSet;
HashSetset=newHashSet（）;
Students1=newStudent（"
zhangsan"
Students2=newStudent（"
set.add（s1）;
set.add（s2）;
System.out.println（set）;
classStudent
Stringname;
publicStudent（Stringname）
this.name=name;
修改过hashCode及equals方法后：
publicinthashCode（）//重写hashCode方法
returnthis.name.hashCode（）;
publicbooleanequals（Objectobj）//重写equals方法
if（this==obj）
returntrue;
if（null!
=obj&
&
objinstanceofStudent）
Students=（Student）obj;
if（name.equals（s.name））
{
returntrue;
returnfalse;
HashSet下的interator（）方法：
，返回一个Iterator（接口）类型值。
迭代和遍历意思一样，用迭代的方式获得集合，set中的每个元素。
使用迭代函数：
在通过迭代函数访问类集之前，必须得到一个迭代函数。
每一个Collection类都提供一个iterator（）函数，该函数返回一个对类集头的迭代函数。
通过使用这个迭代函数对象，可以访问类集中的每一个元素，一次一个元素。
通常，使用迭代函数循环通过类集的内容，步骤如下：
1）通过调用类集的iterator（）方法获得对类集头的迭代函数。
2）建立一个调用hasNext（）方法的循环，只要hasNext（）返回true，就进行循环迭代。
3）在循环内部，通过调用next（）方法来得到每一个元素。
importjava.util.Iterator;
set.add（"
c"
w"
j"
Iteratoriter=set.iterator（）;
while（iter.hasNext（））
Stringvalue=（String）iter.next（）;
System.out.println（value）;
//或用下面这段代码代替
//for（Iteratoriter=set.iterator（）;
iter.hasNext（）;
）
//{
//Stringvalue=（String）iter.next（）;
//System.out.println（value）;
//}
HashSet源代码深度剖析：
HashSet底层是使用HashMap实现的，当使用add方法将对象添加到Set当中时，实际上是将该对象作为底层所维护的Map对象的key，而value则都是同一个Object对象（该对象我们用不上）；
1）
importjava.util.TreeSet;
TreeSetset=newTreeSet（）;
b"
a"
d"
for（Iteratoriter=set.iterator（）;
importjava.util.Comparator;
/*TreeSet（Comparator<
?
superE>
comparator）构造一个新的空TreeSet，它根据指定比较器进行排序，其中的Comparator是接口类型*/
TreeSetset=newTreeSet（newMyComparator（））;
classMyComparatorimplementsComparator
publicintcompare（Objectarg0,Objectarg1）
Stringstr0=（String）arg0;
Stringstr1=（String）arg1;
returnpareTo（str0）;
//String类型下的comparaTo（）方法
3）
Personp1=newPerson（10）;
Personp2=newPerson（40）;
Personp3=newPerson（30）;
set.add（p1）;
set.add（p3）;
set.add（p2）;
Personvalue=（Person）iter.next（）;
System.out.println（value.score）;
intscore;
publicPerson（intscore）
this.score=score;
publicStringtoString（）//不写toString（）方法也可以
returnString.valueOf（this.score）;
Personp1=（Person）arg0;
Personp2=（Person）arg1;
returnp1.score-p2.score;
Map（映射）
Map的keySet（）方法会返回key的集合，因为Map的键是不能重复的，因此keySet（）方法的返回类型是Set；
而Map的值是可以重复的，因此values（）方法的返回类型是Collection，可以容纳重复的元素。
importjava.util.HashMap;
HashMapmap=newHashMap（）;
升级会员 