黑马程序员-学习日记
黑马程序员_JAVA中集合框架1（Collection，List，Set及其子类和迭代器的应用）
------- android培训、java培训、期待与您交流！ ----------
一：集合是用于存储对象的一个工具。
集合和数组的特点：
1.相同点：
集合和数组都一个容器。
2.集合：
1，可以存储对象，只能存储对象。
2，集合的长度的是可变的。
3.数组：
1，可以存储对象，也可以存储基本数据类型值。
2，数组长度的是固定的。
注意：CollectionDemo.java 使用了未经检查或不安全的操作。注意：要了解详细信息，请使用 -Xlint:unchecked 重新编译。
Java编译器认为该成存在安全隐患。友情提示:但并不是编译失败，所以可以不用理会。
其实是因为类型的原因导致的，用了泛型以后，就没有该提示了。
二:集合中的一般方法：
importjava.util.*;
classCollectionDemo{
public static void main(String[] args){
Collection coll = new ArrayList();//创建了一个集合对象.也就是一个容器。
//添加元素。add();
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
System.out.println("集合的元素："+coll);
//删除元素。
boolean b =coll.remove("abc2");
System.out.println("b="+b);
//获取集合的长度。
int size = coll.size();
System.out.println("size="+size);
//清除集合中的所有元素。
coll.clear();
//判断：
boolean b = coll.isEmpty();//其实内部依据的是size()方法。如果size()=0，就返回true。
System.out.println("b="+b);
boolean b=coll.contains("abc1");
System.out.println("b="+b);
//简单的获取集合所有元素。直接将集合的元素打印到控制台。
System.out.println("操作后的集合："+coll);
}
}
三：Collection中带All的方法用法集合：
import java.util.*;
class CollectionDemo2 {
public static void main(String[] args) {
Collection coll = new ArrayList();//创建了一个集合对象.也就是一个容器。
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
System.out.println("集合的元素："+coll);
Collection co2 = new ArrayList();
co2.add("abc3");
co2.add("abc2");
co2.add("abc1");
co2.add("abc4");
Collection co3 = new ArrayList();
co3.add("abc7");
co3.add("abc8");
//添加一堆元素。
//coll.addAll(co2);//将co2中的元素添加到coll集合中。[abc1, abc2, abc3, abc5, abc]
//判断一堆元素是否存在。
boolean b = coll.containsAll(co3);
System.out.println("b="+b);
//删除一堆元素。
boolean b1 =coll.removeAll(co3);//removeAll会将coll中包含的和co3相同的元素删除。
System.out.println("b1="+b1);
//获取两个集合的交集。
boolean b=coll.retainAll(co2);//retainAll会将coll和co2中相同的元素保留在coll中。
//所以coll中存储就是交集的元素。当coll集合中的元素变化时，retainAll方法返回true。
//当coll集合中的元素本身就是交集元素，不发生变化。那么返回false。
System.out.println("b="+b);
System.out.println(coll);
}
}
四：Collection集合中对元素的获取方法：
import java.util.*;
class IteratorDemo{
public static void main(String[] args) {
Collection coll = new ArrayList();
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
//只要是Collection集合体系，迭代器就是通用取出方式。
/*
Iterator it = coll.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
*/
for(Iterator it = coll.iterator() ;it.hasNext(); ){
System.out.println(it.next());
}
}
}
五：LinkedList的特有方法：
1:addFirst();
addLast();
在jdk1.6以后被
offerFirst();
offerLast();替代
2:获取元素，集合的长度不改变:
如果集合中没有元素，那么该方法会发生异常NoSuchElementException
getFirst():
getLast();
在jdk1.6以后被
peekFirst();
peekLast();替代
如果集合元素没有，该方法不会抛出异常，而是返回null。
3:获取元素，但是该元素会被删除出集合，集合的长度会改变:
如果集合中没有元素，那么该方法会发生异常NoSuchElementException
removeFirst():
removeLast();
在jdk1.6以后被:
pollFirst();
pollLast();替代
如果集合元素没有，该方法不会抛出异常，而是返回null。
import java.util.*;
class LinkedListDemo {
public static void main(String[] args) {
LinkedList link = new LinkedList();
link.addFirst("abc1");
link.addFirst("abc2");
link.addFirst("abc3");
link.addFirst("abc4");
System.out.println(link.getFirst());
System.out.println(link.removeFirst());
System.out.println(link);
while(!link.isEmpty()){
System.out.println(link.removeFirst());
}
}
}
六：List集合中常见的共性方法:List:该容器的元素是有序的(存储的顺序和取出的顺序一致) 该集合中的元素都有索引(角标).该集合可以存储重复的元素。
1，添加元素:add();
2，删除元素:remove();
3，修改元素: set();
4，获取元素:get();
import java.util.*;
class ListDemo{
public static void main(String[] args){
List list = new ArrayList();
list.add("abc1");
list.add("abc2");
list.add("abc3");
System.out.println("原集合："+list);
//添加功能。在指定位置插入元素。
list.add(1,"haha");//在1索引为插入元素 haha.其他元素依次顺延。
//按照指定索引删除元素。会返回被删除的元素。
System.out.println("remove(1):"+list.remove(1));
//最指定位置的元素进行修改。会返回被修改掉的元素.
System.out.println("set(0,kk)="+list.set(0,"kk"));
//通过索引获取指定元素。
System.out.println("get(1):"+list.get(1));
//通过元素获取到第一次出现位置。
System.out.println("indexOf(abc2)="+list.indexOf("abc2"));
//根据头尾角标获取子列表。
List newList = list.subList(0,2);//全取list.subList(0,list.size());
System.out.println("自列表是："+newList);
//通过List特有的方式，获取集合中所有的元素。
for(int x=0; x<list.size(); x++){
System.out.println(list.get(x));
}
System.out.println("操作后："+list);
}
}
七：List:有序，可重复，有索引:
|--ArrayList:底层数据结构是数组结构。线程不安全的。所以ArrayList的出现替代了Vector.但是查询的速度很快.
|--Vector:底层数据结构是数组结构。jdk1.0版本。线程安全的。无论增删还是查询都非常慢。
|--LinkedList:底层是链表数据结构。线程不安全的，同时对元算的增删操作效率很高
可变长度的数组:
ArrayList内部封装了一个默认长度为10的数组；当超出长度时，集合内部会自动生成一个新的数组；将原数组中的元素复制到新数组中，在将新元素添加到新数组。
新数组的长度：
ArrayList 50%延长。
Vector 100%延长。
Vector中提供了一个独特的取出方式，就是枚举Enumeration；此接口Enumeration的功能与 Iterator 接口的功能是重复的
Enumeration的名称和方法的名称过程，书写很麻烦；所以被Iterator所取代，郁郁而终。
import java.util.*;
class VectorDemo{
public static void main(String[] args) {
Vector v = new Vector();
v.addElement("abc1");
v.addElement("abc2");
v.addElement("abc3");
v.addElement("abc4");
Enumeration en = v.elements();
while(en.hasMoreElements()){
System.out.println(en.nextElement());
}
Iterator it = v.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
八：列表迭代器的应用：
在进行迭代过程中，如果出现了迭代器和容器同时对元素进行操作的情况很容易引发ConcurrentModificationException并发修改异常.
解决：要么使用集合的方法操作元素，要么使用迭代器的方法操作元素；不要同时使用。
但是 迭代器Iterator中只有三个操作，判断hasNext，获取next，删除remove。
想要其他的操作时，比如添加，这个迭代器就不可以使用了。这时对于List集合，有一个新的迭代方式， 就是ListIterator 列表迭代器。
ListIterator本身也是Iterator的子接口。并提供了更多的迭代过程中的操作在迭代过程中，如果需要增删改查元素的操作，需要列表迭代器。
但是注意：该迭代器，只能用于List集合。
import java.util.*;
class ListIteratorDemo{
public static void main(String[] args) {
List list = new ArrayList();
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
ListIterator lit = list.listIterator();
System.out.println(lit.hasPrevious());
while(lit.hasNext()){
String s = (String)lit.next();
if(s.equals("abc2"))
//lit.add("haha");
lit.set("qq");
}
System.out.println(list);
System.out.println(lit.previous());
Iterator it = list.iterator();
while(it.hasNext()){
String s =(String)it.next();
if(s.equals("abc2"))
list.add("haha");//ConcurrentModificationException
System.out.println("s="+s);
}
System.out.println(list);
}
}
九：List和Set的用法区别：
A.|--List:有序(存的顺序和取的顺序一致。),元素可以重复，元素都有索引。
|--ArrayList:
|--LinkedList:
|--Set:无序，不可以重复元素。Set接口的方法和Collection中的方法一致。
Set接口取出元素的方法只有迭代器。
|--HashSet:底层数据结构是哈希表。哈希表这种结构，其实就是对哈希值的存储。
而且每一个对象都有自己的哈希值。因为Object类中的有一个方法hashCode方法。
B.如何保证元素唯一性的呢？
通过判断元素的hashCode方法，和equals方法完成的;
当hashCode值相同是，会在判断一次euqals方法的返回只是是否为true。
如果hashCode值不相同，就确定元素的哈希表中的位置，就不用在判断equals了。
当哈希表中有一个桶结构。每一个桶都有一个哈希值，当哈希值相同，但是equals为false时，表示为不同元素。
原理：这些元素都存放一个桶里。
|--TreeSet:可以对Set集合中的元素进行排序：
数据结构是二叉树数据结构。这种结构，可以提高排序性能。
1.它又是如何保证元素唯一性的呢？
是根据比较方法的返回值确定的：只要返回的是0,就代表元素重复。
2.HashSet集合保证元素唯一性的原因：
HashSet集合保证元素唯一性，依赖的是元素的hashCode方法和euqals方法。
当元素的哈希值不同时，元素都有自己的独立位置，不需要在判断元素的equals方法;
3.当元素的哈希值相同时，这时元素在哈希表中位置相同，这时就需要在判断一次元素的内容是否相同；就需要调用元素的equals方法进行一次比较。如果equals返回是true，那么视为两个元素为重复元素，只储存一个。如果返回是false，那么这两个元素不是重复元素，会存储在同一个哈希值上。
4.为了建立自定义对象判断元素是否重复的依据：
需要覆盖hashCode方法，和equals方法：而且最好依据对象的特有条件来建立hashcode和euqals的实现。
ArrayList：判断包含，以及删除，都是依据元素的equals方法。
HashSet:判断包含，以及删除，都是依据元素的hashCode方法。当hashCode值相同时，在判断一次equals方法。
实用小技巧：
ArrayList: 数组
LinkedList:链表
HashSet:哈希表
TreeSet:二叉树
看到Array就要想到数组,就要想到角标,就要想到查询很快.
看到Link就要想到链表.就要想要增删很快.最好再想到 addFirst(offerFirst)
看到Hash就要想要哈希表，就要想到元素的hashCode方法，和equals方法。
看到Tree,就要想要二叉树，就要想要排序。就要想到两个接口 Comparable 和Comparator。
需要明确的是什么时候List，什么时候用Set？
保证元素唯一，就用Set集合；不需要就使用List集合；实在搞不清楚，就用ArrayList。
Treeset集合使用于给元素进行排序的；那么自定义元素本身不具备比较性，Treeset集合是无法对元素进行排序的；
所以，在自定义对象时，需要对象具备一个扩展功能，用于比较的，
而java已经提供了接口，可以让实现它的对象具备比较性；那么自定义类，要想被Treeset排序，就需要实现Comparable接口；以具备比较功能。
比较的时候，要注意，主要条件和次要条件；如果主要条件相同，一定要比较次要条件。
当Treeset集合中存储的元素不具备比较功能；或者具备的比较功能不是所需要的。
例如：Person对象中的自然排序是按照年龄排序。
但是现在需求是想安装姓名排序。该源代码这种方式想都不要想。有这种想法就是犯罪。
该如何解决这个问题？
既然元素具备的比较方式不满足应用；这时，可以让集合自身具备比较性。
需要集合一初始化就具备比较功能。因为要在添加元素前具备。
就需要在构造函数进行初始化。
只要将一个实现了Comparator接口的子类对象作为参数传递给TreeSet集合的构造函数即可。
这样该集合就具备了比较功能。
建议使用第二种排序方式。
应用：
TreeSet排序方式有两种。
1，让元素自身具备比较性。
其实是让元素实现Comparable接口，覆盖compareTo方法。
这称为元素的自然排序。
2，当元素自身不具备比较性，或者元素具备的比较性不是所需要的，
可以让集合自身具备比较性。
定义一个比较器：
其实就是定义一个类，实现Comparator接口。覆盖compare方法。
将Comparator接口的子类对象作为参数传递给TreeSet的构造函数。
当元素自身具备比较性，同时TreeSet集合也具备比较器，这时以比较器为主。
十：学习了这么多，来一个总体总结：
一般在描述一个对象时,如果该对象封装了具体的数据,会出现很多这样的对象比如:员工,学生对象等.
这时就需要进行容器的存储.那么描述该类对象时,一定要复写几个方法：
1,hashCode()
2,equals()
3,toString()
4,最好实现Comparable接口让该类具备自然排序功能。
建立对象自身判断是否相同的依据，同时让对象具备基本的比较性。
代码体现：
class TreeSetDemo3{
public static void main(String[] args) {
TreeSet ts = new TreeSet(newCompareByName());
ts.add(new Person("lisi1",21));
ts.add(new Person("lisi4",29));
ts.add(new Person("lisi2",67));
ts.add(new Person("lisi8",28));
ts.add(new Person("lisi0",20));
System.out.println(ts);
}
}
//自定义一个比较器。
classCompareByName implements Comparator{
public int compare(Object o1,Object o2){
Person p1 = (Person)o1;
Person p2 = (Person)o2;
int num =p1.getName().compareTo(p2.getName());
returnnum==0?p1.getAge()-p2.getAge():num;
}
}
class Personimplements Comparable{
private String name;
private int age;
Person(String name,int age){
this.name = name;
this.age = age;
}
//人的自然排序是按照年龄排序
public int compareTo(Object obj){
Person p = (Person)obj;
int num = newInteger(this.age).compareTo(new Integer(p.age));
returnnum==0?this.name.compareTo(p.name):num;
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
public String toString(){
return name+"::"+age;
}
}
------- android培训、java培训、期待与您交流！ ---------- 详细请查看：http://edu.csdn.net/heima/