黑马程序员---java集合与框架

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

>> List

。 Set  无序、不可重复，  List  有序、可以重复 

。ArrayList 底层是一个 Object[] ，   对于 XxxList 的遍历 可以使用 迭代器，也可以使用 for   例:
List l = new ArrayList() ;    
l.add(123) ;
l.add(321) ;
l.add("kingowe") ;
l.add("kongchao") ;
for(int i=0; i<l.size(); i++)
{
  System.out.println(l.get(i) ) ;
}

。在 Arrays 工具类中有一个方法 asList(T... a) ) 可以将一个 数组转换成一个 List(ArrayList) 集合，可以方便对数组的操作，
但是不可以使用 List集合中的 增加 删除 等操作，因为数组长度是固定的， 使用了 这些方法 会 抛出异常

|--ArrayList：底层的数据结构是数组,线程不同步，ArrayList替代了Vector，查询元素的速度非常快。

|--LinkedList：底层的数据结构是链表，线程不同步，增删元素的速度非常快。

》》--》》   对 迭代器 iterator 的详解: 

package com.kingowe;

import java.util.* ;
import java.util.AbstractList.Itr;

public class CollectionTest01 {

public static void main(String[] args) {
Collection c = new ArrayList() ;
c.add(7) ;
c.add(new Float(3.14)) ;
c.add(true) ;
c.add("kingowe") ;

Iterator it = c.iterator() ; // 相当于 Iterator it = new Itr() ;
/* 迭代器的源码
* public Iterator<E> iterator() {
return new Itr();
}
*/
while( it.hasNext() )
{
System.out.println(it.next());
}
}
}

/*
* Itr 类的实现，对迭代器对象 iterator 的创建 其实是创建的 private class Itr 的实例对象
* private class Itr implements Iterator<E> {

int cursor = 0;
int lastRet = -1;
int expectedModCount = modCount;

public boolean hasNext() {
return cursor != size();
}

public E next() {
checkForComodification();
try {
E next = get(cursor);
lastRet = cursor++;
return next;
} catch (IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}

public void remove() {
if (lastRet == -1)
throw new IllegalStateException();
checkForComodification();

try {
AbstractList.this.remove(lastRet);
if (lastRet < cursor)
cursor--;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException e) {
throw new ConcurrentModificationException();
}
}

final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}

*
*/

/*
* 类关系继承图
*
* public abstract class AbstractCollection<E> implements Collection<E>
*
* public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E>
*
* public interface List<E> extends Collection<E>
*
* public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable

*/

。 对于 List 的实现类 有一个 ListIterator 迭代器， 它可以完成 对 List 的实现类 在迭代过程中的 增删改查 操作，
对于 Iterator 迭代器 如果在迭代过程中 对元素进行了修改 将会 抛出 CurrentModifierException， 但是使用
ListIterator 不会，ListIterator li = list.listiterator() ;

。使用 Iterator 迭代器 和 使用 ListIterator 迭代器时，在 使用它们的 next() 遍历集合中的元素的时候 指针会后移，
比如 ArrayList 集合中存放了 "孔超" "kingowe" "20", 当第一次使用 next() 后 指针会后移到 "kingowe"

》》--》》  对 contains 方法的详解

package com.kingowe;

import java.util.* ;

class Demo
{
String name ;
int no ;
public Demo(String name, int no)
{
this.name = name ;
this.no = no ;
}
}
class Person
{
String name ;
int age ;
public Person(String name, int age)
{
this.name = name ;
this.age = age ;
}
public boolean equals(Object o)
{
if(this == o)
return true ;
if(o instanceof Person)
{
Person p = (Person)o ;
if( p.name.equals(this.name) && p.age==this.age )
return true ;
}
return false ;
}
}
public class CollectionTest01 {

public static void main(String[] args) {
Collection c = new ArrayList() ; // 如果这里换成 XxxSet 以下结果将为 true false true false
// Set 无序、不可重复， List 有序、可以重复 。
Demo d1 = new Demo("kongchao", 141) ;
c.add(d1) ;
System.out.println(c.contains(d1)); // true
Demo d2 = new Demo("kongchao", 141) ;
System.out.println(c.contains(d2)); // false 在 Demo 类中没有重写 equals 方法，所以结果为 false

Person p1 = new Person("kingowe", 20) ;
c.add(p1) ;
System.out.println( c.contains(p1) ) ; // true
Person p2 = new Person("kingowe", 20) ;
System.out.println( c.contains(p2) ); // true Person类重写了 equals 方法，所以结果为 true

}
}

/* 对 contains 方法的实现
* public boolean contains(Object o) { // 在以上程序中传入的是 d1 与 d2，即为 Object o = b1, 或者 Object o = b2
return indexOf(o) >= 0;
}

public int indexOf(Object o) {
if (o == null) { // 这里 如果传入的对象引用为 null， 那么在 ArrayList中查找是否有 null这个元素，
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
for (int i = 0; i < size; i++)
if (o.equals(elementData[i])) // 这里调用了 当前传入的对象的 equals 方法， 如果该对象所属
<span style="white-space:pre"> </span> //的类没有 重写 equals 方法，则会调用 Object 中的 equals 方法
return i;
}
return -1;
}
*/

>> Set
。Set接口中的方法和Collection中方法一致的。Set接口取出方式只有一种，迭代器。

》!*!*!*!》  存储于集合中的对象都要重写 equals 方法, 存放在 HashSet 或存放在 HashMap中的key位置的对象 要重写
equals方法 和 hashCode 方法（HashMap中的key也是 Set --> 无序不可以重复）   例:

public class Employee

{

    String name ;

    String no ;

    public Employee(String name, St
4000
ring no)

    {
this.name = name ;
this.no = no ;

    }

}

Set s = new HashSet() ;
Employee e1 = new Employee("kingowe", 130141) ;
Employee e2 = new Employee("kingowe", 130141) ;
s.add(e1) ;
s.add(e2) ;
System.out.println(s.size()) ;  // 在 Employee 类 没有重写 hashCode 和 equals 方法时 输出结果为 2

解释: 因为 new 了 两个Employee 对象，虽然是同一个人，但是 HashCode 的值却不相等， 在执行 add() 方法时，会先
比较 要添加的对象的 HashCode 值 与 已经添加的对象的 hashCode 的值是否一样，如果不一样将会直接加进
该集合中，如果hashCode值与集合中已经添加的某个对象的 hashCode 的值相等，将会调用equals方法，
所以 要将 hashCode 方法 与 equals 方法重写

在本例中的 hashCode方法 的重写可以根据每个人的编号来重写,因为编号是 String 类的，且String类已经重写了
hashCode方法，所以可以  public int hashCode(){ return no.hashCode() ; }
hashCode 值 即为该对象在集合中存放的位置的索引

。 HashSet集合保证元素唯一性：通过元素的hashCode方法，和equals方法完成的。

当元素的hashCode值相同时，才继续判断元素的equals是否为true。
如果为true，那么视为相同元素，不存。如果为false，那么存储。
如果hashCode值不同，那么不判断equals，从而提高对象比较的速度。

· 对于ArrayList集合，判断元素是否存在，或者删元素底层依据都是equals方法。
· 对于HashSet集合，判断元素是否存在，或者删除元素，底层依据的是hashCode方法和equals方法。

》》--》》  TreeSet implements  SortedSet<E> 

。TreeSet集合中的元素是不可重复的，但是所有的元素会根据大小来排序，如果添加的是 基本数据类型对象，String类对象，或者 Date类
对象，那么遍历时会按大小顺序进行遍历输出， 因为这些类都实现了 Comparable 接口中的 compareTo 方法，但是如果添加的是
自定义类 而且没有实现 Cpmparable 接口 在运行时将会出现 ClassCastException

。 在向 TreeSet 集合中 add 元素的时候 会调用 compareTo 方法， 如果在实现 compareTo 方法的时候 直接 return 0 ; 那么执行 add
方法 无论 add 多少个元素 只能将第一次 add 的 对象添加进去， 因为 return 0; 表示 所添加的元素 相等，Set 不允许重复

。 TreeSet底层的数据结构就是二叉树。

package com.kingowe;

public class Demo1 {
private double price ;
public Demo1(){}
public Demo1(double price){
this.price = price ;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() { // 不要忘了Override toString 方法
return "Demo1 [price=" + price + "]";
}
}

package com.kingowe;
import java.util.Comparator;
// 专用于 Demo1 的比较器

public class Demo1Comparator implements Comparator {

/*在 java.util.Comparator 接口中定义了 两个方法:
* boolean equals(Object obj)
* int compare(T o1, T o2)
* 因为 所有类都继承自 Object， 在 Object 中已经有了 equals 方法
* 所以本类中已经有了继承自 Object类的 equals方法
* 因此 如果在该类中用不到 equals 方法，则可以只重写 compare 方法
* 如果一个非abstract类只重写了一个接口中的部分方法，那么别的方法一定
* 已经在他的 父类 中实现了
*/

@Override
public int compare(Object o1, Object o2) {
double price1 = ( (Demo1)o1 ).getPrice() ;
double price2 = ( (Demo1)o2 ).getPrice() ;
if(price1 > price2){
return 1 ;
}
else if(price1 < price2){
return -1 ;
}
else
return 0 ;
}
/*
* 注意: 在此程序中 对 double 类型的比较设计的不合理，因为double型在
* 内存中存储时是按近似值存储的，因此有可能出现 两个价格都为17.17 却不会
* 返回 0
*/
}

package com.kingowe;
import java.util.* ;

public class TreeSetTest {
public static void main(String[] args) {
// TreeSet(Comparator<? super E> comparator)
// 通过传入一个比较器来完成 add时对象之间的比较
SortedSet ss = new TreeSet(new Demo1Comparator()) ;
ss.add(new Demo1(34.5)) ;
ss.add(new Demo1(12.3)) ;
ss.add(new Demo1(67.8)) ;
ss.add(new Demo1(45.6)) ;
ss.add(new Demo1(33.4)) ;
ss.add(new Demo1(56.7)) ;
Iterator it = ss.iterator() ;
while(it.hasNext()){
System.out.println(it.next());
}
}
}


>> Map
。 存储在 Map集合 中的 key 值元素要重写 equals 方法 和 hashCode 方法，如果 key 值是String类型，则可以不重写，
因为在 String 类中已经重写了这两个方法

。 Set<K> keySet()  因为 key 值不可以重复，所以要返回 Set ，   Collection<V> values()  因为 vlaue 值可以重复，所以
要返回 Collection

。 |--Hashtable：底层是哈希表数据结构，是线程同步的。不可以存储null键，null值。
   |--HashMap：底层是哈希表数据结构，是线程不同步的。可以存储null键，null值。替代了Hashtable.

  values 方法解释: 

package com.kingowe;
import java.util.*;

public class MapTest {
public static void main(String[] args) {
Map m = new HashMap();
m.put("1000", "kingowe");
m.put("1001", "kongchao");
Collection c = m.values() ;
Iterator it = c.iterator() ;
while(it.hasNext())
{
System.out.println(it.next()) ;
}
System.out.println(c.size());
System.out.println(c.isEmpty());
}
}

java.util.HashMap 中 values() 的源码:

public Collection<V> values() {
Collection<V> vs = values;
return (vs != null ? vs : (values = new Values()));
}

// AbstractCollection<E>定义: public abstract class AbstractCollection<E> implements Collection<E>
// 属性 values 的声明 : transient volatile Collection<V> values = null;

// Values 内部类
private final class Values extends AbstractCollection<V> {
public Iterator<V> iterator() {
return newValueIterator();
}
public int size() {
return size;
}
public boolean contains(Object o) {
return containsValue(o);
}
public void clear() {
HashMap.this.clear();
}
}

》》--》》  遍历 Map 中的 key - value
/方法一（通常使用该方法，比较灵活）:

package com.kingowe;
import java.util.*;

public class MapTest {
public static void main(String[] args) {
Map m = new HashMap();
m.put("1000", "kingowe");
m.put("1001", "kongchao");
m.put("1005", "kong");
m.put("1002", "king");
Set s = m.keySet() ; // 通过该方法获得 Map集合 中的 key值 的 Set集合
Iterator it = s.iterator() ; // 获得 set 集合的迭代器，
while(it.hasNext()) {
Object k = it.next(); // 取出 Map集合中的 key 值
Object v = m.get(k) ; // 通过得到的 key 值 来获取相对应的 value
System.out.println(k+" --> "+v); // 最后将 key - value 对输出
}
}
}方法二（不灵活，输出格式只能是 key=value）:
package com.kingowe;
import java.util.*;

public class MapTest {
public static void main(String[] args) {
Map m = new HashMap();
m.put("1000", "kingowe");
m.put("1001", "kongchao");
m.put("1005", "kong");
m.put("1002", "king");
// 通过 Set entrySet() 来获取 key=value
Set s = m.entrySet() ;
Iterator it = s.iterator() ;
while(it.hasNext()) {
System.out.println(it.next());
}
}
}