1,为什么会出现集合类？
面向对象语言对事物的体现都是以对象的方式，为了更方便对多个对象进行操作和存储，集合是存储对象最常用的方式。
2，数组和集合有何不同？
数组的长度是固定的，集合的长度是可变的。
数组可以操作基本数据类型和对象，集合只能操作对象。
同一个数组只能存储同一类型的数据，集合可以存储不同类型的对象。
Collection接口
常用共有方法：bollean add（）；
bollean addAll（）；
void clear（）；
bollean contains（）；
bollean isEmpty（）；
bollean remove（）；
bollean retainAll（）；//取交集，只保留此集合与指定集合相同的元素。
int size（）；//返回集合中的元素个数。
Object[] toArray（）；返回包含此集合元素的数组。
Iterator iterator（）；取出元素的方法，迭代器。
用法例如：
List al = new ArrayList()；
Iterator it = al.iterator();
while(it.hasNext()){
it.next();
}List集合
特点：元素是有序的，元素可以重复，有索引。
List集合的特有方法，包括可以操作角标的方法。
add（int index，element）； //在指定角标处添加元素。
addAll（int index，collection）；
remove（int index）； //移除指定角标的元素。
set（int index，element）；//用指定元素替换index位置的元素。
get（int index）；
subList（int from，int to）；//返回指定角标之间的子集合，包含头不包含尾。
listIterator（int index）；//返回列表的迭代器，从指定的角标位置开始迭代。
ListIterator接口：允许程序员按任意一方像遍历数组。特有方法：hasPrevious Previous.
注意错误：并发访问，当集合和迭代器同时操作一组数据时发生。
例如：
ArrayList al = new ArrayList()；
Iterator it = al.iterator()；
while(it.hasNext()){
if(it.next.equals("111"))
al.add("222"); //迭代器正在操作这组数据，集合同时也在操作这组数据，并发修改异常。
}List集合特有的迭代器，ListIterator，可以同过迭代器的方法对List集合进行增删改查
特有方法：add(obj); //将制定元素插入列表。
remove(); //从列表中移除next或previous返回的最后一个元素。
set(obj); //用指定元素替换next或previous返回的最后一个元素
previous(); //返回前一个元素
hasPrevious(); //还有没有前一个元素。
用法：
ArrayList al = new ArrayList();
ListIterator it = al.listIterator();
while(it.hasNext()){
if(it.next.equals("111"))
it.add("222");
}ArrayList:底层的数据结构数组结构。查询速度快，修改速度快，增删速度慢，线程不同步
LinkedList：底层使用的是链表数据结构。曾删速度快，查询速度慢。
LinkedList的特有方法：addFirst();
addLast();
removeFirst();//获取元素同时删除元素。没有要查寻的元素抛出异常。
removeLast();
getFirst();//获取元素但是不删除元素。没有要删除的元素抛出异常。
getLast();
1.6出现了替代方法，add-->offerFirst() offerLast();
get-->peekFirst() peekLast();获取元素不删除元素。没有要查寻的元素返回null。
remove-->pollFirst() pollLast();获取元素同时删除元素。没有要查寻的元素返回null。
Vector：底层数组数据结构。1.0版本，现在已被ArrayList替代。集合框架是1.2 版本出现的，线程同步，效率低。
去除List集合中重复元素的方法。
代码如下：
public ArrayList SingleElement(ArrayList al){
ArrayList newAl = new ArrayList();
Iterator it = al.iterator();
while(it.hasNext()){
Object obj = it.next();
if(!newAl.contains(obj))
newAl.add(obj);
}
return newAl;
}
List集合判断元素是否相同，底层依据的事equals()方法。如果List集合要求无重复对象，那么所要操作的对象需要覆写equals()方法。
Set集合
特点：元素无序（存入和取出的顺序不一定一致），不可以重复，无索引。
Set集合的方法和Collection是一样的，没有特有方法。
HashSet：底层结构式哈希表。判断元素是否相同首先判断两个元素的HashSet（地址）是否相同，如果相同再判断两个元素的equals()是否相同。
例如：
class Person{
private String name;
private int age;
Person(String name,int age){
this.name = name;
this.age = age;
}
public int hashCode(){
return 60; //假定所有Person对象的hashCode都是60.
}
public boolean equals(Object obj){
if(!(obj instanceof Person))
return false;
Person p = (Person)obj;
return this.name.equals(p.name)&&this.age==p.age;
}
}
class SetDemo{
public static void main(String[] args){
HashSet hs = new HashSet();
hs.add(new Person("www",12)); //new一个Person对象，首先生成这个对象的hashCode，然后查看集合中有无相同hashCode的对象
hs.add(new Person("eee",13)); //如果有的话，再调用equals方法比较两个对象是否相同，如果也相同则认为是同一元素。
hs.add(new Person("fff",15)); //
hs.add(new Person("ttt",16)); //
hs.add(new Person("ttt",16)); //先判断hashCode相同，然后equals也相同，所以不能存入。
}
}
TreeSet：存入与取出顺序不一样。
TreeSet中存的对象需要具有比较性，需要实现Comparable接口，覆盖compareTo方法。
例如：
public int compareTo(Object obj){
//比较方式
return
}
当对象不具备比较性或是比较性不是所需要的时候，这时就需要让集合自身具有比较性。需要定义一个比较器，做法如下：
class MyCompare implements Comparator{
public int compare(Object obj1,Object obj2){
// 比较方式
return
}
}
Map集合
Map中的常用共有方法：1，添加：put(k,v);
putAll(Map<? extends k,? extends v> t);
2，删除：clear();
remove(Objece k);
3，判断：containKey(Object k);
containValue(Object v);
isEmpty();
4，获取：get(Object k);//通过键返回值。
size(); //返回键值对个数。
values(); //返回键值对中所有的值。
Set<Map.entry<k,v>> entrySet(); //返回此映射中包含的映射关系的 set 视图。
Set keySet(); //返回此映射中包含的键的 set 视图。
注意：Map集合添加元素时，如果出现相同的键，那么后添加的值会覆盖原来的值，并返回原来的值。
Map集合的取出方式：1，先获得所有的键，将键存入Set集合，在通过键取出值。
实现方法如下：
Map<String,String> map = new HashMap<String,String>;
Set<String> keySet = map.keySet();
Iterator<String> it = keySet.iterator();
while(it.hasNext()){
String key = it.next();
String value = map.get(key);
System.out.println(key+"="+value);
}
2，将Map集合中的映射关系取出，存入Set集合中，再通过Set的迭代器取出键和值。
实现方法如下：
Map<String,String> map = new HashMap<String,String>;
Set<Map.Entry<String,String>> entrySet = map.entrySet();
Iterator<Map.Entry<String,String>> it = entrySet.iterator();
while(it.hasNext()){
Map.Entry<String,String> me = it.next();
String key = me.getKey();
String value = me.getValue();
System.out.println(key+"="+value);
} Hashtable：底层是哈希表结构，不可以存入null键，null值。是线程同步的。1.0 效率低
HashMap：底层是哈希表结构，可以使用null的键和值。是线程不同步的。1.2 效率高。
TreeMap：底层是二叉树结构，线程不同步，可以给Map集合中的键排序。 TreeMap都构造函数中可以传入一个比较器。
集合框架的工具类：
Collection：常用方法：binarySearch(List<? extends Comparable<? super T>> list,T key) //使用二分查找在List集合中查找。
binarySearch(List<? extends T> list, T key, Comparator<? super T> c) //使用指定比较器排列集合，再用二分查找查询。
max(Collection) //按照集合的自然顺序排序，并返回其中最大值。
max(Collection,Comparator c) //按照比较器的排序方式排序，并返回其中最大值。
min(Collection)
min(Collection,Comparator c)
replaceAll(List<T> list,T oldVal,T newVal) //使用新值替换集合中指定的所有旧值。
reverse(List<？> list) //翻转集合中的所有元素。
Comparator reverseOrder() //返回一个比较器，它强行反转实现 Comparable 接口那些对象 collection 上的自然顺序。
Comparator reverseOrder(Comparator c) //返回一个比较器，强行翻转指定比较器的比较顺序。
shuffle(List list) //随机重新排列指定集合的顺序。
sort(List list) //根据元素的自然顺序，对元素进行升序排序。
sort(List list,Comparator c) //按照指定比较器的顺序对集合进行排序。
swap(List list,int i,int j) //将指定角标的两个元素换位。
Arrays：常用方法：aslist(arr) //返回一个受指定数组支持的固定大小的集合。可以使用集合的思想操作数组，但是不能使用集合的增删方法，
因为数组的长度是固定的。
注意：当一个数组中的元素都是基本数据类型，要转成集合时，会把整个数组作为对象存入集合。
Collection方法：集合变数组：toArray(T[]) // 当定义的长度小于集合的size时，会创建一个新的数组长度为集合的size。
当大于集合的size时不创建新的数组，但是多出来的位置用null填充。
为什么要将集合变成数组使用？
为了限定集合的增删操作。
扫一扫
613
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
