一、集合框架:
1:集合框架
1)集合用来存数据,比数组方便;
2)可以存不同的数据,但是不建议,因此用泛型来约束;
3)利用泛型,好处:编译器就可检查元素类型是否匹配, 避免在运行出现错误;
2:父接口Collection
常用的子接口
1) List: 有序,可重复(元素之间调用equals比较)
2)Set:无序,不可重复(元素之间调用eqauls比较)
3:List子接口的实现类
1)ArrayList:
内部是一个动态数组,查找速度快,增删慢
2)LinkedList:
内部是一个链表,查找速度慢,增删快
ArrayList是一个动态数组,而LinkedList是一个双向链表
ArrayList擅长于随机访问。同时ArrayList是非同步的,
LinkedList不能随机访问,它所有的操作都是要按照双重链表的需要执行,也是非同步的。
3)Vector:
与ArrayList相似,但是Vector是同步的。所以说Vector是线程安全的动态数组。它的操作与ArrayList几乎一样。
二、集合
1:父接口Collection
常用方法:
1)add(Object e):增加元素
2)remove(Object obj):从此 collection 中移除指定元素的单个实例
3)addAll(Collection c):两个集合合并
4)removeAll(Collection c):移除两个集合的交集
5)retainAll(Collection c):保留交集
6)clear():清空集合
7)isEmpty():判断是否是空
8)size():返回集合元素的个数。
9)toArray():将集合对象转换成数组
10)iterator():返回在此 collection 的元素上进行迭代的迭代器
2:List子接口----线性表 Set
常用的实现类:
1)ArrayList:
是线性结构内部封装的是动态的数组。长度的增加和减少已经被封装。 可以理解为自动的。
查找快,增删慢 ;线程不安全,效率高
2)LinkedList:
是链表结构。一个元素里存了前一个元素的地址和后一个元素的地址。连到一起很像一链条。
增加删除快,查找慢
3)Vector: 线程安全,效率低。
与ArrayList相似,但是Vector是同步的。所以说Vector是线程安全的动态数组。它的操作与ArrayList几乎一样。
3. List接口提供的方法:
1)add(int index,E e):在列表的指定位置插入指定元素
2)add(E e);向列表的尾部添加指定的元素
3)get(int index):返回列表中指定位置的元素
4)remove(int index):移除列表中指定位置的元素
5)indexOf(Object obj):返回此列表中第一次出现的指定元素的索引;返回-1说明没有此元素
6)lastIndexOf(Object obj):返回此列表中最后出现的指定元素的索引;如果列表不包含此元素,则
返回 -1
7)contains(Object obj):如果列表包含指定的元素,则返回 true。
8)toArry():将集合转换成数组-
注意:要用Object[]接收,
String[]数组是Object类型
Object[]数组转换成String[]会出现
类造型异常ClassCastException
9)Arrays.asList(str):将数组str转换成集合,转换后的集合不能增删
否则会出现异常。
10)iterator:返回按适当顺序在列表的元素上进行迭代的迭代器
11)subList(int fromIndex,int toIndex);:是获取集合的子集合。
集合对象里存的就是这些元素的地址信息.
4.: 增强for循环,作用是用来遍历集合或者是数组。 是迭代的另外一种写法 。 编译器会将此循环编译成迭代写法。
结构:
for(元素类型 变量名: 集合或数组的变量){
。。。。。。。。。。。。。
}
还可以:利用迭代遍历 : 迭代器Iterator,是一个接口,作用是用 来遍历集合元素。List接口提供iterator方法
来获取迭代器实现类对象。
reg:
//使用迭代器遍历集合a
List list=[1,2,3,4,5,6];
Iterator it = list.iterator();
while(it.hasNext()){
Object obj = it.next();//获取下一个对象
if((Integer)obj==6){
it.remove();
//绝对不能使用list.remove(6);
}
System.out.println(obj);
}
5.Set集合
Set是一种不包括重复元素的Collection。它维持它自己的内部排序,所以随机访问没有任何意义。
与List一样,它同样允许null的存在但是仅有一个。由于Set接口的特殊性,所有传入Set集合中的元素都必须不同,
Set接口有三个具体实现类,分别是散列集HashSet、链式散列集LinkedHashSet和树形集TreeSet。
Set是一种不包含重复的元素的Collection,无序,即任意的两个元素e1和e2都有e1.equals(e2)=false,Set最多有一个null元素。需要注意的是:虽然Set中元素没有顺序,但是元素在set中的位置是由该元素的HashCode决定的,其具体位置其实是固定的。
常用方法:
方法摘要
boolean add(E e)
如果 set 中尚未存在指定的元素,则添加此元素(可选操作)。
boolean addAll(Collection<? extends E> c)
如果 set 中没有指定 collection 中的所有元素,则将其添加到此 set 中(可选操作)。
void clear()
移除此 set 中的所有元素(可选操作)。
boolean contains(Object o)
如果 set 包含指定的元素,则返回 true。
boolean containsAll(Collection<?> c)
如果此 set 包含指定 collection 的所有元素,则返回 true。
boolean equals(Object o)
比较指定对象与此 set 的相等性。
int hashCode()
返回 set 的哈希码值。
boolean isEmpty()
如果 set 不包含元素,则返回 true。
Iterator<E> iterator()
返回在此 set 中的元素上进行迭代的迭代器。
boolean remove(Object o)
如果 set 中存在指定的元素,则将其移除(可选操作)。
int size()
返回 set 中的元素数(其容量)。
Object[] toArray()
返回一个包含 set 中所有元素的数组。
实现方法:
1)HashSet
HashSet 是一个没有重复元素的集合。它是由HashMap实现的,不保证元素的顺序(这里所说的没有顺序是指:元素插入的顺序与输出的顺序不一致),而且HashSet允许使用null 元素。HashSet是非同步的,如果多个线程同时访问一个哈希set,而其中至少一个线程修改了该set,那么它必须保持外部同步。 HashSet按Hash算法来存储集合的元素,因此具有很好的存取和查找性能。
HashSet的实现方式大致如下,通过一个HashMap存储元素,元素是存放在HashMap的Key中,而Value统一使用一个Object对象。
HashSet使用和理解中容易出现的误区:
a.HashSet中存放null值
HashSet中是允许存入null值的,但是在HashSet中仅仅能够存入一个null值。
b.HashSet中存储元素的位置是固定的
HashSet中存储的元素的是无序的,这个没什么好说的,但是由于HashSet底层是基于Hash算法实现的,使用了hashcode,所以HashSet中相应的元素的位置是固定的。
c.必须小心操作可变对象(Mutable Object)。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true将导致一些问题。
(2)LinkedHashSet
LinkedHashSet继承自HashSet,其底层是基于LinkedHashMap来实现的,有序,非同步。LinkedHashSet集合同样是根据元素的hashCode值来决定元素的存储位置,但是它同时使用链表维护元素的次序。这样使得元素看起来像是以插入顺序保存的,也就是说,当遍历该集合时候,LinkedHashSet将会以元素的添加顺序访问集合的元素。
(3)TreeSet
TreeSet是一个有序集合,其底层是基于TreeMap实现的,非线程安全。TreeSet可以确保集合元素处于排序状态。TreeSet支持两种排序方式,自然排序和定制排序,其中自然排序为默认的排序方式。当我们构造TreeSet时,若使用不带参数的构造函数,则TreeSet的使用自然比较器;若用户需要使用自定义的比较器,则需要使用带比较器的参数。
注意:TreeSet集合不是通过hashcode和equals函数来比较元素的.它是通过compare或者comparaeTo函数来判断元素是否相等.compare函数通过判断两个对象的id,相同的id判断为重复元素,不会被加入到集合中。
5.:泛型机制。
5.1:泛型机制的本质是参数化类型。
在类,接口和方法的定义过程中,可以进行指定参数类型名。 在集合框架中,所有的集合类型都使用泛型机制。
好处:是在进行参数化类型后,就可以限制集合元素 的类型,编译器会通过指定的泛型进行检查。
减少代码在运行时的错误。
public class ArrayList<E>{
。。。。。。。。。。。。。。。
public boolean add(E e);
public E get(int index);
}
ArrayList使用泛型机制,E就是类型参数。 在具体使用时,得给E赋值,赋的值是类型名。
List<String> list = new ArrayList<String>();
注意: 泛型机制不能使用八大基本数据类型,只能用引用类型
6.:集合的存储:
集合元素都是引用类型。集合对象内 存的是元素的地址信息, 不是元素本身。
7:集合工具类:Collections(注意与Collection-的区别)
方法:sort(list):对集合进行排序;
Collections.sort(list);//直接对list对象排序;
总结:
1)集合有sort()方法,说明集合元素是可排序;
2)如何实现sort()方法? --方法1
1.实现Comparable接口;
2.重写compareTo(Object obj)方法;
3) compareTo(Object obj)方法: 就是用来进行元素之间的比较的 。
this>obj,返回>0的数
this<obj,返回<0的数
this=obj,返回 0的数
4)调用sort(p1);方法
5)Comparable:接口也是有泛型的,传参为实现类类型;
8:Comparable与Comparator的作用与区别
Comparable(adj.)---compareTo(Object a) ; Comparator(n.)---compare(Object a,Object b)
1)作用:都是用来排序的;
2) Comparator:在原有排序规则上,临时改变排序规则时, 使用的比较器接口。 调用集合的sort(p1,p2)方法
3)如何实现?
1.实现Comparator接口;
2.重写compare(Object ob1,Object ob2)方法;
4)调用sort(Collection coll,Comparator com);
5)使用:Collections.sort(coll,com);
例如:
案例:比较
List<Cell> list = new ArrayList<Cell>();
list.add(new Cell(1,2));
Collections.sort(list);
使用Comparator接口实现排序:
Comparator my = new MyComparator(); --方法1
Collections.sort(list, my);
//使用匿名内部类的写法创建比较器对象
Comparator<Point> my = new Comparator<Point>(){ --方法2
public int compare(Point p1, Point p2) {
int dis1 = p1.getX()*p1.getX()+p1.getY()*p1.getY();
int dis2 = p2.getX()*p2.getX()+p2.getY()*p2.getY();
return dis2-dis1;
}
};
Collections.sort(list,my);
System.out.println(list);