黑马程序员_集合框架（上）-单列集合类

---------- android培训、java培训、期待与您交流！
----------

1.集合特点：1.是一个可以存储多个元素的容器(不能全用StringBuffer存储，因为它最终会将其全转为字符串);

2.用于存储不同类型的对象；

3.而且该容器的长度是可变的。

2.集合和数组的区别：

1.数组的长度是固定的，而集合的长度是可变的；

2.数组能存储引用数据类型(对象)和基本数据类型，而集合只能存储引用数据类型。

3.集合框架的由来：每个集合中的数据结构(数据在容器中存放的具体方式)都不一样，因而集合有很多中，但都具备

共性功能，就不断向上抽取，形成了集合框架，顶层为Collection接口。

4.Collection的基本方法：

1.添加：add(Object):返回boolean型，添加成功返回true，否则false；

addAll(ollection):需两个集合，将一个集合中的元素添加到另一个集合中，返回boolean型；

2.删除：remove(Object):删除一个元素，返回boolean型；

removeAll(collection):删除两个集合中相同的元素；

clear():清空集合中的元素，返回类型为void;

retainAll(collection):取交集，删除两个集合中不同的元素，保留相同元素，返回boolean；

c1调用此方法时，如果其中元素没有发生变化，则返回false；

3.判断：contains(Object):判断集合中是否包含此元素，返回类型为boolean；

containsAll(collection):判断一个集合是否包含另一个集合中的所有元素，返回类型为boolean；

isEmpty():判断集合是否为空，返回boolean；它依赖于size,size为0则返回true；

4.获取：size():获取集合的长度，返回int；

iterator():取出集合中的元素，返回Iterator接口；

5.转换：toArray():将集合转换成数组，返回Object类型的数组。

注意：添加和删除都会导致集合的长度变化。

5.迭代器：取出容器的元素方式，依赖于容器，因为容器不同取出方式则不同。

iterator()：获取迭代器，每个集合都具备，即取出容器中的元素，返回Iterator接口；

而Iterator接口有三个方法：

hasNext():返回boolean型，如果还有下一个元素，返回true；

next():自动向下取元素，若没判断，一直向下取，超出元素个数就会抛出NoElementException异常；

remove():移除集合中的最后一个元素。

6.迭代器的使用

for (Iterator i=collection.iterator();it.hasNext();) {
System.out.println(it.next());
}

7.LinkedList:链表数据结构，增删较快，特有方法都是带First和Last的。

特别的：getFirst和removeFirst的区别

在循环中，getFrist只能取出一个，而removeFirst能取出列表中的全部元素；

在循环外，都能获取，但getFirst取出不删除，removeFirst取出并删除。

8.两种数据结构：

堆栈：先进后出，FILO

队列：先进先出，FIFO

练习：需求：用LinkedList定义一个队列数据结构。

步骤：1.创建一个新队列；

2.定义一个存储到新队列的方法；

3.定义一个获取队列元素的方法；

4.判断队列是否为空。

注：在数据模型类中，通常都会覆写equals方法，依据该事物的属性，建立判断该事物相同的依据。

如：在Person类中，同姓名和同年龄视为相同对象，覆写equals方法

public boolean equals(Object o){
if(!(o instanceOf Person)){
throw new ClassCastException("类型转换异常");
Person p=(Person)o;
return this.name.equals(p.name) && this.age==p.age;
}
}

9.List集合: 有序（存入的顺序和取出的顺序一致）因为该字体系中的元素有索引或者角标，所以是可以存储重复元素的。

|-——->list子体系中的特有方法：

1、增加：void add(index,element)

2、删除：Object remove（index）

3、查找

4、修改：set(int index,element)返回值是当前被修改的对象

5、实现代码：

Public static void main(String[] args) {
List list=new ArrayList();
methodDemo();
}
Public static void methodDemo(List list){
List.add("abc1");
List.add("abc2");
List.add("abc3");
List.add("abc4");
Sop(list);

//添加：
List.add(1,"abc7");//[abc1,abc7,abc2,abc3]在角标1位置往后顺延。

//删除
Object obj=list.remove(2);//删除指定索引上的元素，根据角标删除会返回来被删对象
Sop(obj);//obj：abc2 [abc1,abc7,abc3]

//获取:获取指定角标上的元素并返回，这也是和remove的区别。
Object obj=list.get(1);
Sop(obj);//obj:abc1 [abc1,abc7,abc3]

//获取元素的索引，如果元素存在返回索引，不存在返回-1，依次还可以判断元素是否存在。
Int index=list.indexOf("abc1");
Sop(index);//index=1

//获取指定的子列表sublist(fromIndex,toindex)包含头不包含尾
List=list.sublist(1,2);//[abc1]

//修改：
Object obj=list.set(1,"haha");
Sop(obj);//[abc1,haha,abc3]

//记住：只有list集合支持增删改查。

}

6.listIterator,列表迭代器：想要在迭代的过程中进行元素的增加等动作，iterator就不行了，可以使用其子接口listaIterator，而且该接口的对象只有通过list集合的listIterator方法获取，是List集合特有的取出元素方式，它包含了增删改查的方法，而iterator只有hasNext()、next()、remove()方法;

实现代码：

Public static void main(String[] args)
{
List list=new ArrayList();
List.add("abc1");
List.add("abc2");
List.add("abc3");
List.add("abc4");
ListIterator it=list.listIterator();
While(it.hasNext())
{
Object obj=it.next();
If("abc2".equals(obj))
{
It.add("abc01");//添加元素
It.set("hehe");//修改元素
}
Else
{
Sop(obj);
}
}
}
Sop(it.hasNext());//false；

与iterator的区别：

实现代码：

Iterator it=list.iterator();//迭代器是集合的功能，知道集合中有多少元素。
While(it.hasNext())
{
Object obj=it.next();
//ConcurrentModificationException是多线程导致的，不能再同时遍历的时候进行删除，原因是迭代过程中，又使用集合对象对元素进					//行了操作导致了并发修改异常的发生，怎么去解决？迭代器的删除方式

If("abc2".equals(obj))
{
List.remove(obj);
It.remove();用迭代器的自身的方法。
}
Else
{
Sop(obj);
}
}

7.list体系结构：

|--ArrayList:低层数据结构是数组，不同步，有别于vector,替代了它，也是可延长数组，百分之五十，提升了空间的效率。查询很快，增删很慢。

|--LinkedList:低层数据结构是链表数据结构，查询速度慢，增删比较快，元素也是有角标的，以为内其父类list都有角标。

|--Vector:低层数据结构是数组结构，超过长度就会创建一个新数组，长度为前数组的一倍，对其进行重新赋值。同步 安全但是效率低。

|--特有方法：

Enumeration:枚举：支持枚举接口，但是该接口因为名称过长，被Iterator取代。

实现代码：

Public stati void main(String[] arsg)
{
Vector v=new Vector();
v.addElement("abc1");
v.addElement("abc2");
v.addElement("abc3");
v.addElement("abc4");
Enumeration en=v.elements();
While(en.hasNext())
{
Sop(en.nextElement());
}
}

注意：此接口和iteration接口的功能是重复的。

ArrryList和linkedList的内存分析比较：：当增删操作较多时用linkedlist。当查询较多的时候用ArrayList,自有增删有查询的还是Arraylist，因为后面还是查询的使用较多.

10.Set集合：不保证元素的有序性，却能保证唯一性，方法都是来自于Collection接口。

1. HashSet：哈希表数据结构，不同步的，能保证元素的唯一性；

在存储时首先按照哈希算法hashCode()算出元素的存储位置，若该位置没有其它元素，则存入；如该位置有元素即哈希码一致，这时就会

调用Object类中的equals方法判断两个元素是否是同一元素，若是则不再存入，若不是则通过拉链法顺延一个位置存入元素。

注意：HashCode集合中的元素在存储时必须有hashcode方法和equals方法，Object中以提供这两个方法；由于需求的不同，会对它们进行覆写。

小细节：ctrl+shift+s:重写hashCode()方法和equals()方法。

2.TreeSet：二叉树结构，不同步的，可以对集合中的元素按照自然顺序进行排序，能保证元素的唯一性;效率较HashSet低。

在排序过程中，是进行的折半比较，与中间元素进行比较大小，提高效率；

判断唯一性的方式：参照compareTo方法的返回值，若返回0则视为相同对象，不存储。

int temp=this.age-p.age;
return temp==0?this.name.compareTo(p.name):temp;

若要存入顺序和取出顺序一致，则在覆写compareTo方法中直接return 1，就可以了；反之改-1即可。

注意：排序比较时，别忘了一定要注重主要条件和次要条件。

3.两种排序方式：

1.自然顺序排序：让元素本身具备比较性，该元素实现了Comparable接口，覆写compareTo方法，让元素具备了自然排序；

2.比较器排序：元素本身没有比较性，让容器具备比较性，且在元素添加之前，所以在容器创建时就要明确比较性，定义一个Comparator子类实现

Comparator接口，覆写compare方法，此方法有两个参数，并将这个子类对象作为参数传给容器的构造函数。

class ComparatorZi implements Comparator{
public int compare(Object o1.Object o2){
Person p1=(Person)o1;
Person p2=(Person)o2;
int temp=p1.getName().compareTo(p2.geName());
return temp==0?p1.getAge()-p2.getAge():temp;
}
}

区别：前种排序方式有弊端，因为可能存在元素本身具备的自然排序不是所需的；而且可能元素本身就不具备自然排序；但较后种方便。

而后种比较器更为灵活，可以根据不同需求进行排序。

4.LinkedHashSet:数据结构是链表和哈希表，有序且速度快。

练习：用linkedlist模拟堆栈和队列？

import java.util.LinkedList;
//队列
class MyQueue1 {
private LinkedList list;
//创建一个队列；
public MyQueue1() {
list=new LinkedList();
}
//定义一个存储到队列中的方法；
public void myadd(Object o){
list.addFirst(o);
}
//定义一个获取队列元素的方法；
public Object myget(){
return list.removeLast();
}
//判断是否为空
public boolean isnull(){
return list.isEmpty();
}
}
public class MyQueue{
public static void main(String[] args){
MyQueue1 mq=new MyQueue1();
mq.myadd("11");
mq.myadd("12");
mq.myadd("13");
mq.myadd("14");
while (!mq.isnull()) {
System.out.println(mq.myget());
}
}
}
//堆栈
import java.util.LinkedList;

class MyZhan {
private LinkedList list;
//创建一个队列；
public MyZhan() {
list=new LinkedList();
}
//定义一个存储到队列中的方法；
public void myadd(Object o){
list.addFirst(o);
}
//定义一个获取队列元素的方法；
public Object myget(){
return list.removeFirst();
}
//判断是否为空
public boolean isnull(){
return list.isEmpty();
}
}
public class MyDuiZhan{
public static void main(String[] args){
MyZhan mq=new MyZhan();
mq.myadd("11");
mq.myadd("12");
mq.myadd("13");
mq.myadd("14");
while (!mq.isnull()) {
System.out.println(mq.myget());
}
}
}

11.查阅集合的技巧：

通过名称获得数据结构，前缀名是数据结构的名称，后缀名是所属体系的名称，凡是后缀名是体系名称的集合通常都是不同步的；

ArrayList:可变长度的数组，想到索引，查询速度快，不同步的；

LinkedList：链表结构，增删速度快，不同步的，而且要记得addFirst,getFirst,removeFirst,addLast,getLast,removeLast方法；

HashSet:哈希表结构，查询速度快，覆写hashCode和equals方法；

TreeSet：二叉树结构，按照自然顺序排序，较HashSet效率低，实现Comparable接口覆写compareTo方法，或者定义一个Comparator子类实现接口，覆写 compare方法.

---------- android培训、java培训、期待与您交流！
----------