Java学习笔记（集合）

集合
一.体系概述

集合类：

为什么出现集合类？

面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。

数组和集合类同是容器，有何不同？

数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。

集合类的特点：

集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

插入图片：集合框架的构成及分类.jpg



插入图片：集合框架的体系结构.jpg



二.共性方法

1.add方法的参数类型是Object，以便于接受任意类型对象。

2.集合中存储的都是对象的引用（地址）。

创建一个集合容器，使用collection接口的子类。ArrayList

例：ArrayListal=new ArrayList();

打印集合

打印集合对象al，就直接打印出集合中所有的元素,用中括号括起来。（例：[......]）

a.添加元素

al.add("java01");

al.add("java02");

al.add("java03");

al.add("java04");

b.获取个数。集合长度。

al.size(); //返回当前集合中元素的数量

c.删除元素

al.remove("java02");

al.clear(); //清空集合

d.判断元素

al.contains("java03"); //判断java03是否存在

al.isEmpty(); //判断集合是否为空？



例：

public static void method_2()

{

ArrayListal1=new ArrayList();

al1.add("java01");

al1.add("java02");

al1.add("java03");

al1.add("java04");

ArrayListal1=new ArrayList();

al2.add("java01");

al2.add("java02");

al2.add("java05");

al2.add("java06");



al1.retainAll(al2); //去交集，all中只会保留和al2中相同的元素。（al1的结果是：java01，java02；如何没有公共元素的话，al1的值就是空）

al1.removeAll(al2); //移除与al2中相同的元素（al1结果就是：java03，java04）

}



三.迭代器

什么是迭代器？

其实就是集合的取出元素的方式。

插入图片：迭代器的特点.jpg



取出集合中的元素

Iteratorit=al.iterator(); //迭代器接口，返回Iterator接口的子类对象。获取迭代器，用于取出集合中的元素。

it.next(); //返回迭代的下一个元素，从第一个元素开始，取出一个元素，一次只能取一个元素

it.hasNext(); //如何任有元素迭代，返回true

while（it.hasNext()）

{

sop(it.next());

}



for(Iteratorit=al.iterator();it.hasNext();)

{

sop(it.next());

}

四.List集合共性方法

Collection

|--List:元素是有序的，元素可以重复，因为该集合体系有索引。

|--ArrayList：底层的数据结构使用的是数组结构。特点：查询速度很快，但是增删稍慢，线程不同步。

|--LinkedList：底层使用的链表数据结构。特点：增删速度很快，查询稍慢。

|--Vector：底层是数组数据结构。线程同步。被ArrayList替代了。

|--Set:元素是无序，元素不可以重复。

List:

特有方法，凡是可以操作角标的方法都是该体系特有的方法。

增

add(index,element);

addAll(index,Collection);



删

remove(index);

改

set(index,element);

查

get(index);

subList(from,to);

listIterator();

intindexOf(obj):获取指定元素的位置。

ListIteratorlistIterator();

例：

publicstatic void main(String[] args)

{

ArrayListal=new ArrayList();

//添加元素

al.add("java01");

al.add("java02");

al.add("java03");

//在指定位置添加元素。

al.add(1,"java09"); //在下标为1的地方添加"java09"

//删除指定位置的元素。

al.remove(2); //删除下标为2的元素

//修改元素

al.set(2,"java007"); //将下标为2的元素的值修改为“java007”

//通过角标获取元素。

al.get(1); //获取角标为1的元素的值

//获取所有元素。

for(intx=0;x<al.size();x++)

{

System.out.println("al("+x+")="+al.get(x));

}

//迭代器的获取所有元素

Iteratorit=al.iterator();

while(it.hasNext())

{

sop("next:"+it.next());

}

}

五.ListIterator

//通过indexof获取对象的位置。

sop("index="+al.indexof("java02")); //获取"java02"元素的下标

Listsub=al.subList(1,3); //返回子列表中指定范围的值。获取元素包含头不包含尾（获取角标为1和2的元素）

列表迭代器

//在迭代过程中，准备添加或者删除元素。

Iterator it=al.iterator();

while(it.hasNext())

{

Objectobj=it.next();



if(obj.equals("java02"))

//al.add("java08"); //不能进行添加

it.remove(); //将java02的引用从集合中删除了。

}



List集合特有的迭代器，ListIterator是Iterator的子接口。

在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生ConcurrentModificationException（并发修改异常）异常，所以，在迭代时，只能用迭代器的方法操作元素，可是Iterator方法是有限的。

如果想要其他的操作如添加，修改等，就需要使用其

子接口，ListIterator。该接口只能通过List集合ListIterator方法获取。

例：

ListIterator元素中都带角标所以具有增删改查的功能。

ListIterator li=al.listIterator();

while(li.hasNext())

{

Objectobj=li.next();



if(obj.equals("java02"))

li.add("java09"); //在指定的元素后面添加相应的值（在java02后面添加java09）

li.set("java006"); //修改指定的元素（将java02修改为java006）



}

hasPrevious（） 如果以逆向编译列表，列表迭代器有多个元素，则返回true。（hasPrevious是看前面有没有元素，hasNext是看后面有没有元素）

li.hasPrevious(); //看前面是否有元素

while(li.hasPrevious())

{

sop("pre::"+li.previous()); //从后向前依次取出元素

}

六.List集合具体对象的特点

Collection

|--List:元素是有序的，元素可以重复，因为该集合体系有索引。

|--ArrayList：底层的数据结构使用的是数组结构。特点：查询速度很快，但是增删稍慢，线程不同步。

|--LinkedList：底层使用的链表数据结构。特点：增删速度很快，查询稍慢。

|--Vector：底层是数组数据结构。线程同步。被ArrayList替代了。

|--Set:元素是无序，元素不可以重复。

List:

特有方法，凡是可以操作角标的方法都是该体系特有的方法。

七.Vector中的枚举

枚举就是Vector特有的取出方式。

发现枚举和迭代器很像。

其实枚举和迭代是一样的。

因为枚举的名称以及方法的名称都过长，所以被迭代器取代了。枚举郁郁而终了。

例：

import java.util.*;

class VectorDemo

{

publicstatic void main(String[] args)

{

Vectorv=new Vector();

v.add("java01");

v.add("java02");

v.add("java03");

v.add("java04");

Enumerationen=v.elements();

while(en.hasMoreElements())

{

System.out.println(en.nextElement);

}

}



}



八.集合框架(LinkedList)

LinkedList:特有方法。

addFirst();

addLast();



getFirst();

getLast();

获取元素，但是不删除元素。如果集合中没有元素，会出现NoSuchElementException



removeFirst();

removeLast();

获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException



在JDK1.6出现了替代方法。



offerFirst();

offerLast();



peekFirst();

peekLast();

获取元素，但是不删除元素。如果集合中没有元素，会返回null。



pollFirst();

pollLast();

获取元素，但是元素被删除。如果集合中没有元素，会返回null。



九.集合框架（HashSet）

Set：元素是是顺序不一定一致），元素不可以重复。

HashSet：底层数据结构是哈希表。

HashSet是如何保证元素唯一性的？

是通过元素的两个方法，hashCode和equals是否为true。

如果元素的hashCode值不同，不会调用equals。

注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。

TreeSet：

Set集合的功能和Collection的功能是一致的。

例：

class HashSetDemo

{

publicstatic void sop(Object obj)

{

System.out.println(obj);

｝

publicstatic void main(String[] args)

{

HashSeths=new HashSet();

sop(hs.add("java01")); //输出ture

sop(hs.add("java01")); //输出false，因为数据已经存在所以不能重复。

hs.add("java02");

hs.add("java03");

hs.add("java03"); //重复数据只打印一次

hs.add("java04");

Iteratorit=hs.iterator();

while(it.hasNext())

{

sop(it.next); //打印时是无序的，不是按照存入的顺序打印的。

}

}

}



例：HashSet的存储、判断和删除

import java.util.*;

class HashSetTest

{

publicstatic void sop(Object obj)

{

System.out.println(obj);

}

publicstatic void main(String[] args)

{

HashSeths=new HashSet();

hs.add(newPerson("a1",11));

hs.add(newPerson("a2",12));

hs.add(newPerson("a3",13));

//hs.add(newPerson("a2",12));

hs.add(newPerson("a4",14));



//sop("a1:"+hs.contains(newPerson("a2",12))); //判断元素是否存在，先判断hashCode，再判断equals。

hs.remove(newPerson("a4",14));



Iteratorit=hs.iterator();

while(it.hasNext())

{

Personp=(Person)it.next();

sop(p.getName()+"::"+p.getAge());

}

}

}

class Person

{

privateString name;

privateint age;

Person(Stringname,int age)

{

this.name=name;

this.age=age;

}

publicint hashCode()

{

System.out.println(this.name+"...hashCode");

returnname.hashCode()+age*37; //乘以37的让哈希值定量不相同

}

publicboolean equals(Object obj)

{

if(!(objinstanceof Person))

returnfalse;

Personp=(Person)obj;

System.out.println(this.name+"...equals..."+p.name);

returnthis.name.equals(p.name)&&this.age==p.age;

}

publicString getName()

{

returnname;

}

publicint getAge()

{

returnage;

}

}



十.集合框架（TreeSet）

TreeSet:可以对Set集合中的元素进行排序。 （按照Ascll码值进行排序）

记住：排序时，当主要条件相同时，一定要判断一下次要条件。

例：

/*

需求：

往TreeSet集合中存储自定义对象学生。

想按照学生的年龄进行排序。

*/

import java.util.*;

class TreeSetDemo

{

publicstatic void main(String[] args)

{

TreeSetts=new TreeSet();

ts.add(newStudent("lisi02",22));

ts.add(newStudent("lisi007",20));

ts.add(newStudent("lisi09",19));

ts.add(newStudent("lisi08",19));

ts.add(newStudent("lisi007",20));

//ts.add(newStudent("lisi01",40));



Iteratorit=ts.iterator();

while(it.hasNext())

{

Studentstu=(Student)it.next();

System.out.println(stu.getName()+"..."+stu.getAge());

}



}

}



class Student implements Comparable //该接口强制让学生具备比较性。

{

privateString name;

privateint age;

Student(Stringname,int age)

{

this.name=name;

this.age=age;

}

publicint compareTo(Object obj)

{

if(!(objinstanceof Student))

thrownew RuntimeException("不是学生对象");

Students=(Student)obj;

System.out.println(this.name+"...compareto..."+s.name);

if(this.age>s.age)

return1;

if(this.age==s.age)

{

returnthis.name.compareTo(s.name);

}

return-1;



}

publicString getName()

{

returnname;

}

publicint getAge()

{

returnage;

}



}



List接口对Collection进行了简单的扩充，它的具体实现类常用的有ArrayList和LinkedList。

你可以将任何东西放到一个 List容器中，并在需要时从中取出。ArrayList从其命名中可以看出它是一种类似数组的形式进行存储，因此它的随机访问速度极快，而 LinkedList的内部实现是链表，它适合于在链表中间需要频繁进行插入和删除操作。在具体应用时可以根据需要自由选择。前面说的Iterator只能对容器进行向前遍历，而ListIterator则继承了Iterator的思想，并提供了对List进行双向遍历的方法。

(1) 面向位置的操作包括插入某个元素或Collection的功能，还包括获取、除去或更改元素的功能。在 List
中搜索元素可以从列表的头部或尾部开始，如果找到元素，还将报告元素所在的位置 :

voidadd(int index, Object element):在指定位置index上添加元素element

boolean addAll(int index, Collection c):将集合c的所有元素添加到指定位置index

Object get(int index):
返回List中指定位置的元素

intindexOf(Object o):
返回第一个出现元素o的位置，否则返回-1

intlastIndexOf(Object o)
：返回最后一个出现元素o的位置，否则返回-1

Object remove(int index)　：删除指定位置上的元素

Object set(int index, Object element)：用元素element取代位置index上的元素，并且返回旧的元素

(2) List 接口不但以位置序列迭代的遍历整个列表，还能处理集合的子集：

ListIterator listIterator() :返回一个列表迭代器，用来访问列表中的元素ListIterator listIterator(int index) :返回一个列表迭代器，用来从指定位置index开始访问列表中的元素List
subList(int fromIndex, int toIndex)：返回从指定位置fromIndex（包含）到toIndex（不包含）范围中各个元素的列表视图“对子列表的更改（如 add()、remove()和
set() 调用）对底层 List也有影响。”“ArrayList
和 LinkedList都实现 Cloneable
接口，都提供了两个构造函数，一个无参的，一个接受另一个Collection”。



LinkedList类

LinkedList类添加了一些处理列表两端元素的方法。

(1) void addFirst(Object o):将对象o添加到列表的开头

void addLast(Object o)：将对象o添加到列表的结尾

(2) Object getFirst():
返回列表开头的元素

Object getLast(): 返回列表结尾的元素

(3) Object removeFirst():
删除并且返回列表开头的元素

Object removeLast():删除并且返回列表结尾的元素

(4) LinkedList(): 构建一个空的链接列表

LinkedList(Collection c):
构建一个链接列表，并且添加集合c的所有元素

“使用这些新方法，您就可以轻松的把 LinkedList当作一个堆栈、队列或其它面向端点的数据结构。”



ArrayList类

ArrayList类封装了一个动态再分配的Object[]数组。每个ArrayList对象有一个capacity。这个capacity表示存储列表中元素的数组的容量。当元素添加到ArrayList时，它的capacity在常量时间内自动增加。

在向一个ArrayList对象添加大量元素的程序中，可使用ensureCapacity方法增加capacity。这可以减少增加重分配的数量。

(1)void ensureCapacity(int minCapacity):将ArrayList对象容量增加minCapacity

(2)void trimToSize():
整理ArrayList对象容量为列表当前大小。程序可使用这个操作减少ArrayList对象存储空间。