一、集合框架:
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);
718
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
