java笔记数组和集合.docx

java笔记数组和集合.docx

《java笔记数组和集合.docx》由会员分享，可在线阅读，更多相关《java笔记数组和集合.docx（23页珍藏版）》请在冰豆网上搜索。

java笔记数组和集合

数组和集合:

数组（Array）：

相同类型数据的集合就叫做数组。

数组是一个对象

如何定义数组：

1）type[]变量名=newtype[数组长度]；eg：

int[]a=newint[4];或inta[]=newint[4];//表示定义了一个int类型数组，名字叫a，数组长度为4，赋初值：

a[0]=1;a[1]=2;a[2]=3;a[3]=4;

2）第2种：

定义并赋初值int[]a={1,2,3,4};或int[]a=newint[]{1,2,3,4};（这个newint后的“[]”中不能加上数，比如4）

Java中的每个数组都有一个名为length的属性，表示数组的长度。

length属性是public、final、int的。

数组长度一旦确定，就不能改变大小。

输出结果为100

且不能有

因为已定义了a数组长度为100

原生类型的：

int[]a=newint[10]，其中a是一个引用，它指向了生成的数组对象的首地址，数组中每个元素都是int类型，其中仅存放数据值本身。

没有为其赋值时，int型默认为0，boolean型默认为false等

a[0]=a[1]=a[2]=a[3]=0

引用类型：

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

{

System.out.println（p[i].age）;

}

}

}

classPerson

{

intage;

}

运行结果：

图示：

二维数组：

定义方式：

type[][]a=newtype[数组行数][数组列数]；

1）int[][]a=newint[2][3];//定义了一个2行3列的二维数组。

2）

表示的是:

3）二维数组比如

中a.length表示的是数组行数。

应用：

1）冒泡排序：

publicclassTest

{

publicstaticvoidmain（String[]args）

{

ArrayA=newArray（）;

int[]a=newint[]{4,7,2,9};

A.P（a）;

}

}

classArray

{

publicvoidP（int[]a）

{

for（inti=0;i

{

for（intj=0;j

{

if（a[j]>a[j+1]）

{

intt=a[j+1];

a[j+1]=a[j];

a[j]=t;

}

}

}

for（intk=0;k

{

System.out.println（a[k]）;

}

}

}运行结果：

2）二分查找（BinarySearch）：

首先要求查找的数组是有序的。

查找等值数的位置。

publicclassTest

{

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;

}

publicstaticvoidmain（String[]args）

{

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;

publicclassTest

{

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中的某些方法：

importjava.util.ArrayList;

publicclassTest

{

publicstaticvoidmain（String[]args）

{

ArrayListarray=newArrayList（）;

array.add（newInteger

（2））;

array.add（newInteger（4））;

array.add（newInteger（7））;

intsum=0;

for（inti=0;i

{

intvalue=（（Integer）array.get（i））.intValue（）;

sum+=value;

}

System.out.println（sum）;

}

}运行结果：

13

3）ArrayList中的某些方法：

importjava.util.ArrayList;

publicclassTest

{

publicstaticvoidmain（String[]args）

{

ArrayListarray=newArrayList（）;

array.add（newInteger

（1））;

array.add（newInteger

（2））;

array.add（newInteger（3））;

array.add（newInteger（4））;

/*

*不能将Object[]转换为Integer[]，即下面那语句不能写成：

Integer[]in=（Integer[]）array.toArray（）;

*/

Object[]in=array.toArray（）;

for（inti=0;i

{

System.out.println（（（Integer）in[i]）.intValue（））;

}

}

}运行结果：

的实现类

链表：

publicclassTest

{

publicstaticvoidmain（String[]args）

{

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;

publicclassTest

{

privateLinkedListlink=newLinkedList（）;

publicvoidput（Objecto）

{

link.addLast（o）;

}

publicObjectget（）

{

returnlink.removeFirst（）;

}

publicbooleanisEmpty（）

{

returnlink.isEmpty（）;

}

publicstaticvoidmain（String[]args）

{

Testt=newTest（）;

t.put（"one"）;

t.put（"two"）;

t.put（"three"）;

System.out.println（t.get（））;

System.out.println（t.get（））;

System.out.println（t.get（））;

System.out.println（t.isEmpty（））;

}

}运行结果：

的实现类

当使用HashSet时，hashCode（）方法就会得到调用，判断已经存储在集合中的对象的hashcode值是否与增加的对象的hashcode值一致；如果不一致，直接加进去；如果一致，再进行equals方法的比较，equals方法如果返回true，表示对象已经加进去了，就不会再增加新的对象，否则加进去。

使用原本Object中的hashCode及equals方法（这里有疑问）：

importjava.util.HashSet;

publicclassTest

{

publicstaticvoidmain（String[]args）

{

HashSetset=newHashSet（）;

Students1=newStudent（"zhangsan"）;

Students2=newStudent（"zhangsan"）;

set.add（s1）;

set.add（s2）;

System.out.println（set）;

}

}

classStudent

{

Stringname;

publicStudent（Stringname）

{

this.name=name;

}

}运行结果：

修改过hashCode及equals方法后：

importjava.util.HashSet;

publicclassTest

{

publicstaticvoidmain（String[]args）

{

HashSetset=newHashSet（）;

Students1=newStudent（"zhangsan"）;

Students2=newStudent（"zhangsan"）;

set.add（s1）;

set.add（s2）;

System.out.println（set）;

}

}

classStudent

{

Stringname;

publicStudent（Stringname）

{

this.name=name;

}

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.HashSet;

importjava.util.Iterator;

publicclassTest

{

publicstaticvoidmain（String[]args）

{

HashSetset=newHashSet（）;

set.add（"c"）;

set.add（"w"）;

set.add（"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.Iterator;

importjava.util.TreeSet;

publicclassTest

{

publicstaticvoidmain（String[]args）

{

TreeSetset=newTreeSet（）;

set.add（"b"）;

set.add（"c"）;

set.add（"a"）;

set.add（"d"）;

for（Iteratoriter=set.iterator（）;iter.hasNext（）;）

{

Stringvalue=（String）iter.next（）;

System.out.println（value）;

}

}

}运行结果：

2）

importjava.util.Comparator;

importjava.util.Iterator;

importjava.util.TreeSet;

publicclassTest

{

publicstaticvoidmain（String[]args）

{

/*TreeSet（Comparator

superE>comparator）构造一个新的空TreeSet，它根据指定比较器进行排序，其中的Comparator是接口类型*/

TreeSetset=newTreeSet（newMyComparator（））;

set.add（"b"）;

set.add（"c"）;

set.add（"a"）;

set.add（"d"）;

for（Iteratoriter=set.iterator（）;iter.hasNext（）;）

{

Stringvalue=（String）iter.next（）;

System.out.println（value）;

}

}

}

classMyComparatorimplementsComparator

{

publicintcompare（Objectarg0,Objectarg1）

{

Stringstr0=（String）arg0;

Stringstr1=（String）arg1;

returnpareTo（str0）;//String类型下的comparaTo（）方法

}

}运行结果：

3）

importjava.util.Comparator;

importjava.util.Iterator;

importjava.util.TreeSet;

publicclassTest

{

publicstaticvoidmain（String[]args）

{

TreeSetset=newTreeSet（newMyComparator（））;

Personp1=newPerson（10）;

Personp2=newPerson（40）;

Personp3=newPerson（30）;

set.add（p1）;

set.add（p3）;

set.add（p2）;

for（Iteratoriter=set.iterator（）;iter.hasNext（）;）

{

Personvalue=（Person）iter.next（）;

System.out.println（value.score）;

}

}

}

classPerson

{

intscore;

publicPerson（intscore）

{

this.score=score;

}

publicStringtoString（）//不写toString（）方法也可以

{

returnString.valueOf（this.score）;

}

}

classMyComparatorimplementsComparator

{

publicintcompare（Objectarg0,Objectarg1）

{

Personp1=（Person）arg0;

Personp2=（Person）arg1;

returnp1.score-p2.score;

}

}运行结果：

的实现类

Map（映射）

Map的keySet（）方法会返回key的集合，因为Map的键是不能重复的，因此keySet（）方法的返回类型是Set；而Map的值是可以重复的，因此values（）方法的返回类型是Collection，可以容纳重复的元素。

importjava.util.HashMap;

publicclassTest

{

publicstaticvoidmain（String[]args）

{

HashMapmap=newHashMap（）;