黑马程序员_集合框架

集合框架
数组和集合的区别：
数组的长度是固定的，集合的长度是可变的
数组可以存储基本数据类型，也可以存储对象，而集合只能存储对象，
集合里面存储的都是引用类型
学习集合框架需要掌握如何把对象存储进集合中，如何获取集合中的对象，掌握集合中每一个类的特点
集合框架图
collection接口
List接口（列表）
ArrayList类（数组）  LinkedList类（链表）  Vector类（数组）
Set接口（集）
HashSet类（哈希表）  
LinkedHashSet类（基于链表的哈希表）
TreeSet类（二叉树）
Map接口
HashMap类（映射哈希表）
LinkedHashMap（基于链表哈希表）
TreeMap类（红黑树）
Hashtable类（映射哈希表）
Properties类
Collection
方法：
  存储：add(E e)将元素存储到集合中
addAll（Collection c）将集合存储到另一个集合中
  移除：boolean remove（Object o）将集合中的元素删除，成功则返回true
boolean removeAll（Collection c）移除两个集合的交集，成功则返回true
  其他方法：
void clear（）删除集合中的所有元素
in   size（）返回集合中元素的个数
boolean  contains（Object o）判断集合中是否有这个元素
boolean  containsAll（Collection c）判断集合是否包含另一集合
boolean  retainAll（Collection c）获取两个集合的交集
迭代器
List list=new ArrayList（）;//创建集合
Iterator it=list.iterator();//获取迭代器
while(it.hasNext()){//判断集合中是否还有元素
it.next();//获取几个中的元素
}
一次迭代中，不能出现多次next方法，否则可能出现异常，出现数据错乱
List派系
特点：有序的（存、储顺序一致）   具有下标   允许存储重复元素
特有方法：
   add（int index，Object obj）在指定索引上插入元素
   Object  get（int index）获取指定下标上的元素
   Object  remove（int index）移除指定下标上的元素，并返回该元素
   Object  set（int index，Object obj）修改指定下标上的元素，并返回修改前的元素
   List    subList（int start，int end）获取集合中的一部分，包含头，不包含尾
ArrayList
特点：底层实现数组结构
     线程不安全 运行效率高
     底层是可变数组   查询快  增删慢
     数组大小默认为10个位置  每次增长50%
存储自定义对象并取出
class Person{
String name;
Person(String name){
this.name=name;
}
public String toStrng(){
return name;
}
}
class ArrayListTest{
public static void main(String[] args){
List list=new ArrayList();//创建集合
list.add(new Person("rr"));//存储对象
list.add(new Person("ww"));
list.add(new Person("ss"));
Iterator it =list.iterator();//创建迭代器
while(it.hasNext()){//判断是否有元素可以被取出
System.out.println(it.next());//取出元素
}
}




}
Vector类
集合框架在JDK1.2版本后出现，Vector类在JDK1.0版本出现
运行效率慢，线程安全，每次扩容100%，被ArrayList取代
LinkedList类
底层结构链表实现，记录对象的地址
查询慢 增删快，线程不安全，效率高
特有方法：
   addFirst（Object obj）在集合的开头添加元素
   addLast（Object obj）在集合的结尾添加元素
   getFirst（Object obj）获取集合的开头
   getLast（Object obj）获取集合的结尾
   removeFirst（） 删除集合的开头，并返回该元素
   removeLast（）删除集合的结尾，并返回该元素
import java.util.*;
class Person{
String name;
Person(String name){
this.name=name;
}
public String toString(){
return name;
}
}
class LinkedListTest{
public static void main(String[] args){
LinkedList list=new LinkedList();
list.addFirst(new Person("rr"));//在集合开头添加元素
list.addLast(new Person("ww"));//在集合结尾添加元素
list.addFirst(new Person("ss"));
System.out.println(list.getFirst());//获取集合开头的元素并打印
System.out.println(list.removeLast());//删除集合结尾元素
System.out.println(list);//打印集合
}




}
Set派系
特点：不允许存储重复元素
没有下标
无序
Set接口中的方法和Collection接口中的方法一致
HashSet
特点：底层数据结构哈希表
HashSet本身没有功能，功能来自HashMap
HashSet调用的是HashMap的功能
无序
允许存储null
线程不安全，执行效率高
因为HashSet不允许存储重复元素，因而在存储自定义元素是，需要重写hashCode（）和
equals（）方法，HashSet集合调用hashCode（）方法判断两个对象是否为同一元素
若哈希值相同，则调用equals（）方法进一步判断
import java.util.*;
class Person1{
String name;
int age;
Person1(String name,int age){
this.name=name;
this.age=age;
}
public String toString(){
return name+"..."+age;
}
public int hashCode(){//重写hashCode方法
return this.name.hashCode()+this.age*3;
}
public boolean equals(Object obj){//重写equals方法
if (obj==null) {
return false;
}
if (this==obj) {
return true;
}
if (obj instanceof Person1) {
Person1 p=(Person1)obj;
return this.name.equals(p.name)&&this.age==p.age;
}
return false;
}
}
class HashSetTest{
public static void main(String[] args){
Set set=new HashSet();
set.add(new Person1("aa",23));
set.add(new Person1("aa",23));
set.add(new Person1("bb",25));
set.add(new Person1("cc",29));
Iterator it =set.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}


}


LinkedHashSet
特点：有序，基于哈希表的链表实现，线程不安全，执行效率高
TreeSet
特点：底层数据结构二叉树
线程不安全，执行效率高
会对存储到集合的元素进行排序
注意：TreeSet是通过对元素的排序来保持存入集合的元素的唯一性的
存入TreeSet集合的元素本身需要有自然顺序，若没有则需要实现
Comparable接口，重写compareTo（）方法，或者自定义比较器，实现
Compartor接口，重写compare（）方法
比较器优先于自然顺序
import java.util.*;
class Person1 implements Comparable{
String name;
int age;
Person1(String name,int age){
this.name=name;
this.age=age;
}
public String toString(){
return name+"..."+age;
}
public int compareTo(Object obj){//重写了compareTo方法
Person1 p=(Person1)obj;
int num=this.name.compareTo(p.name);
return num==0?this.age-p.age:num;
}
}
class TreeSetTest1{
public static void main(String[] args){
Set set=new TreeSet(new MyComparator());
set.add(new Person1("ww",34));
set.add(new Person1("ee",24));
set.add(new Person1("ss",45));
set.add(new Person1("ww",34));
method(set);
}
public static void method(Set set){
Iterator it =set.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
class MyComparator implements Comparator{
public int compare(Object obj1,Object obj2){
Person1 p1=(Person1)obj1;
Person1 p2=(Person1)obj2;
int num=p1.age-p2.age;
return num==0?p1.name.compareTo(p2.name):num;
}


}
泛型
JDK1.5版本出现的一种安全机制
格式:
  集合类<数据类型> 变量 = new 集合类<数据类型>();
  数据类型，指定了这个集合，只能存储这个类型的对象


泛型的出现，将安全问题，由运行时期，提前到了编译时期
ArrayList<E>  boolean add(E e)  E:看成是一个变量
ArrayList<String>  所有的E都变成了String


好处，减少了代码，使用泛型避免类型的强制转换
泛型什么时候该写泛型：当你用一个类的时候，发现类的右边<>使用泛型了
注意：存储基本数据类型，泛型必须写8个对象包装类


import java.util.*;
public class MyGenericDemo {
public static void main(String[] args) {
Set<Person> set=new TreeSet<Person>(new MyCompartor());
set.add(new Person("小明",23));
set.add(new Person("小明",23));
set.add(new Person("王柳",23));
set.add(new Person("王柳",23));
set.add(new Person("小桥",28));
set.add(new Person("小明",26));
set.add(new Person("大桥",24));
Iterator<Person> it =set.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}


}
import java.util.Comparator;


public class MyCompartor implements Comparator<Person> {
public int compare(Person o1,Person o2){
int num=o1.getAge()-o2.getAge();
return num==0?o1.getName().compareTo(o2.getName()):num;
}
}
public class Person {
private String name;
private int age;
Person(){}
Person(String name,int age){
this.name=name;
this.age=age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int hashCode(){
return this.name.hashCode()+this.age*13;
}
public boolean equals(Object obj){
if (obj==null) {
return false;
}
if (this==obj) {
return  true;
}
if (obj instanceof Person) {
Person p=(Person)obj;
return this.name.equals(p.name)&&this.age==p.age;
}
return false;
}
public String toString(){
return "Person"+this.name+"....."+this.age;
}

}
Map集合
映射，键映射到值得集合，Map体系的集合，存储对象的时候，一次存储两个，
一个称作键，一个称作值，双列集合
特点：
一个键最多只能映射一个值
不允许出现重复键
方法：v put（k,v）将指定的键和值存入Map集合中，存储了重复的键，返回被覆盖前的值
v get（k）获取指定键的值，没有这个键，则返回null
v remove（k）删除指定的键，对应的值，返回被删除前的值，没有被删除成功
则返回null
boolean containsKey（k）判断集合是否包含指定的键，有则返回true
boolean containsValue（v）判断集合中是否包含指定的值，有则返回true
Collection value（）将集合中所有的值保存到Collection集合中
set<k> keySet()将几个中所有的键保存到set集合
set<Map.Entry<k,v>> entrySet()将集合中的键值对关系存储到Set集合
获取Map中键值对的方式
第一种：
利用Map集合的keySet（）方法，将键存储到Set集合中，再根据键获取值
Map<String,String> map=new HashMap<String,String>();
Set<String> set=map.keySet();
Iterator<String> it=set.iterator();
while(it.hasNext()){
String s=it.next();
System.out.println(s+"..."+map.get(s););
}
第二种：利用Map集合的entrySet（）方法，将键值对关系对象存储到Set集合
Map<Map.Entry<String,String>> map=new HashMap<String,String>();
Set<Map.Entry<String,String>> set=map.entrySet();
Iterator<Map.Entry<String,String>> it =set.iterator();
while(it.hasNext()){
Map.Entry<String,String> m=it.next();
String s1=m.getKey();
String s1=m.getValue();
System.out.println(s1+"..."+s2);
}
HashMap
底层也是哈希表，允许存储null值，null键
不同步，线程不安全，执行效率高
保证：存储到HashMap集合中的键，唯一性
自定义对象，保证唯一性，重写hashCode（）和equals（）方法
import java.util.*;
public class HashMapTest {
public static void main(String[] args) {
Map<Person,Integer> map=new HashMap<Person, Integer>();
map.put(new Person("张三",23), 001);
map.put(new Person("张三",23), 001);
map.put(new Person("李四",23), 002);
map.put(new Person("王五",23), 003);
method(map);

}
public static void method(Map<Person,Integer> map){
Set<Person> set=map.keySet();
Iterator<Person> it=set.iterator();
while(it.hasNext()){
Person p=it.next();
Integer s=map.get(p);
System.out.println(p+"..."+s);
}
}
}
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 void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString(){
return this.name+"..."+this.age;
}
//重写hashCode
public int hashCode(){
return this.name.hashCode()+this.age*this.age;
}
//重写equals方法
public boolean equals(Object obj){
if (this==obj) {
return true;
}
if (obj==null) {
return false;
}
if (obj instanceof Person) {
Person p=(Person)obj;
return this.name.equals(p.name)&&this.age==p.age;
}
return false;
}
}
LinkedHashMap
是HashMap的子类，特点是保证键的顺序，存储的键，怎么存的怎么取出来，不同步，线程不安全，执行效率高
底层结构基于哈希表的链表实现
TreeMap
底层结构红黑树，自然平衡二叉树
线程不同步，不安全，效率高
存储键，对键的自然顺序的排序，要求作为键的对象，必须具备自然顺序或者自定义比较器
存储时Set使用add，Map使用put


import java.util.*;
public class TreeMapTest {
public static void main(String[] args) {
Map<Person2,String> map=new TreeMap<Person2, String>();
map.put(new Person2("小明",17), "高中");
map.put(new Person2("大黄",10), "二年级");
map.put(new Person2("小明",17), "高中");
map.put(new Person2("王五",23), "大学");
map.put(new Person2("王五",23), "大学");
map.put(new Person2("赵六",17), "高中");
map.put(new Person2("小名",23), "高中");
Set<Person2> set=map.keySet();
Iterator<Person2> it=set.iterator();
while(it.hasNext()){
Person2 p=it.next();
String s=map.get(p);
System.out.println(p+"..."+s);
}
}
}
class Person2 implements Comparable<Person2>{
private String name;
private int age;
Person2(String name,int age){
this.name=name;
this.age=age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString(){
return this.name+"..."+this.age;
}
public int compareTo(Person2 p){
int num=this.name.compareTo(p.getName());
return num==0?this.age-p.getAge():num;
}
}