java自学笔记之集合框架

集合框架：

出现的原因：每一个容器对数据的存储方式都不同，这个存储方式成为：数据结构。

Collection：

List：元素师有序的，元素可以重复，应为该集合体系有索引

ArrayList:底层数据结构使用的数组结构， 特点：查询速度很快，但增删很慢。线程不同步。

LinkedList：底层使用的链表结构， 特点：增删速度很快，查询慢。

Vector：老版本的ArrayList，功能同ArrayList，线程同步

Set：元素是无序的，元素不可以重复。

HashSet：底层数据结构哈希表。

是通过元素的两个方法，hashCode和equals来完成。

如果元素的HashCode值不同，才会判断equals是否为true。

如果元素的hashcode值不同，不会调用equals

注意，对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。

TreeSet：可以对Set集合中的元素进行排序。

底层数据结构是二叉树，

保证元素的唯一性依据：compareTo方法return 0；

TreeSet排序的第一种方式：让元素自身具备比较性。元素需要实现Compaarable接口，覆盖compareTo方法，

这种方式也成为元素的自然顺序，或者叫做默认排序。

第二种排序方式，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性，在集合初始化时，就有了比较方式。 

当元素自身不具备比较性，或者具备的比较性不是所需要的。这时需要让容器自身具备比较性。定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

当两种排序都存在时，以比较器为主。

第一一个类，实现Comparator接口，覆盖compare方法。

import java.util.*;

class Person
{
private String name ;
private int age ;
Person(String name ,int age)
{
this.name = name ;
this.age  = age  ;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public int hashCode()
{
// System.out.println(this.name+"..."+hash.code);
return name.hashCode()+age;
}
public boolean equals(Object obj)
{
if( !(obj instanceof Person))
return false;

Person p = (Person)obj;
System.out.println(this.name + "..equals.." +p.name);
return this.name.equals(p.name) && this.age == p.age;

}
}
class HashSetTest_2
{
public static void main(String args[])
{
HashSet hs = new HashSet();

hs.add(new Person("a1",11));
hs.add(new Person("a2",12));
hs.add(new Person("a3",13));
hs.add(new Person("a1",11));

Iterator it = hs.iterator();
while (it.hasNext())
{
Person p = (Person)it.next();
sop(p.getName()+"::::"+p.getAge());
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}

框架集合（泛型机制）

泛型：JDK1.5版本以后出现的新特性。用于解决安全问题，是一个类型安全机制。

好处： 将运行时出现问题ClassCastException，转移到了编译时期，方便于程序员解决问题，让运行时期问题减少，安全。避免了强制转换麻烦

例如：ArrayList<String> al = new ArrayList<String>();    将ArrayList规定为String类型的数据。用尖括号< String>;

当类中要操作的引用数据类型不确定时，早期定义Object来完成扩展，现在定义泛型类来完成扩展。

泛型类定义的泛型，在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有操作的类型就已经固定了。

为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。

特殊之处：静态方法不可以访问类上定义的泛型，如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

？通配符。也可理解为占位符

泛型的限定：

？ extends E:可以接受E类型或者E的子类型。上限。

？ super E：可以接受E类型或者E的父类型。下限。

Map集合：该集合存储键值对，一对一对的往里面存，而且要保证键的唯一性。

|-------Hashtable:底部是哈希表数据结构，不可以存入null键null值，该集合是线程同步的。

|-------HashMap：底部是哈希表数据结构，允许使用null键和nulll值，该集合是不同步的。

|-------TreeMap：底层是二叉树数据结构，线程不同步，可以用于给Map集合中的键排序。

Map集合的两种取出方式。

1 、Set<k> keySet : 将map中所有的键存入到Set集合，因为set具备迭代器。所有可以迭代方式取出所有的键，在根据get方法获取每一个对应的值。

Map集合的取出原理：将Map集合转成set集合，在通过迭代器取出。

2、     Set<Map.Entry<k.v>>entrySet:将map集合中的映射关系存入到了set集合中，而这个关系的数据类型就是：Map.Entry

import java.util.*;

class MapDemo2{
public static void main (String args[])
{
HashMap<String,String> hm = new HashMap<String,String>();

hm.put("01","youxiang1");
hm.put("02","youxiang2");
hm.put("03","youxiang3");
hm.put("04","youxiang4");

Set<Map.Entry<String,String>>entrySet = hm.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);

// Iterator<String>  it = keyset.iterator();

// while(it.hasNext())
// {
// 	String key = it.next();
// 	String value = hm.get(key);
// 	System.out.println("key:"+key+"value:"+value);

}
}
}