Java集合 Collection、Set、Map

集合框架

概念：

集合是一种工具类，对象的容器，存储任意数量的 具有共同属性的对象，实现了对对象的操作

位置：java.util.*

作用：

• 在类的内部，对数据进行组织
• 简单而快速的搜索大数量的条目
• 有的集合提供了一系列排列有序的元素，并且可以在序列中间快速的插入或删除有关元素

和数组的区别：

• 数组长度是固定的，集合长度不固定
• 数组可以存储基本类型和引用类型，集合只能存储引用类型

Collection体系

Collection父接口

特点：代表一组任意类型的对象，无序，无下标，不能重复

创建集合对象：

Collection collection = new ArrayList();

常用方法

1. 添加元素：

   collection.add()
   

2. 删除元素:

   collection.remove();
   collection.clear();
   

3. 遍历元素：

   //使用增强for（因为无下标，无法使用for遍历）
   for(Object obj : collection){
       System.out.println(obj);
   }
   
   
   //使用迭代器遍历元素
   //haNext(); 有没有下一个元素
   //next(); 获取下一个元素
   //remove(); 删除当前元素
   Iterator it = collection.iterator();
   while(it.hasNext()){
     String object = (String)it.next(); //强转
     // 可以使用it.remove(); 进行移除元素
     // collection.remove(); 不能用collection其他方法 会报并发修改异常
   }
   

4. 判断元素：

   collection.contatins(); //判断元素是否存在
   collection.isEmpty();  //判断元素是否为空
   

List子接口

特点：有序，有下标，元素可重复

创建集合对象：

List list = new ArrayList();

常用方法

1. 添加元素：

   list.add(); //会对基本类型进行自动装箱
   

2. 删除元素：

   list.remove(0); //可以使用元素下标进行删除
   
   //当删除数字与索引矛盾时 对数字强转
   list.remove((Object) 10) 或 list.remove(new Integer(10))
   

3. 遍历元素：

   //因为有下标，可以使用for进行遍历
   for(int i = 0; i < list.seiz(); i++){
       System.out.println(list.get(i));
   }
   
   //使用增强for遍历
   for(Object list : list){
       System.out.println(list);
   }
   
   //使用迭代器进行遍历
   Iterator it = list.iterator();
   while(it.hasNext()){
     String object = (String)it.next(); //强转
     // 可以使用it.remove(); 进行移除元素
     // collection.remove(); 不能用collection其他方法 会报并发修改异常
   }
   
   //使用列表迭代器
   ListIterator li = list.listIterator();
   while(li.hasNext()){
     System.out.println(li.nextIndex() + ":" + li.next()); //从前往后遍历
   }
   
   while(li.hasPrevious()){
     System.out.println(li.previousIndex() + ":" + li.previous()); //从后往前遍历
   }
   

4. 获取元素：

   list.indexOf();
   

5. 返回子集合：

   sublist(x, y); //左闭右开
   
   List subList = list.subList(1, 3); //返回索引 1、2
   

List实现类

• ArrayList【重点】
  • 数组结构实现，必须要连续空间，查询快，增删慢
  • 运行效率快，线程不安全
• Vector
  • 数组结构实现，查询快，增删慢
• LinkedList
  • 双向链表结构实现，无需连续空间，增删快，查询慢

ArrayList

1. 创建集合：ArrayList arrayList = new ArrayList();

2. 添加元素：arraylist.add();

3. 删除元素：arraylist.remove();

4. 遍历元素：

   //使用迭代器
   Iterator it = arrayList.iterator();
   while(it.hasNext()){
     Student s = (Student)it.next(); //强转
   }
   
   //使用列表迭代器
   ListIterator li = arrayList.listIterator();
   while(li.hasNext()){
     Student s = (Student)li.next(); //从前往后遍历
   }
   
   while(li.hasPrevious()){
     Student s = (Student)li.previous();//从后往前遍历
   }
   

5. 判断

   arrayList.contains(); //判断元素是否存在 
   arrayList.isEmpty();  //判断元素是否为空
   

Vector

1. 创建集合 Vector vector = new Vector<>();
2. 增加、删除、判断同上

LinkedList

1. 创建链表集合LinkedList li = new LinkedList<>();

泛型

• 本质是参数化类型，把类型作为参数传递
• 常见形式有泛型类、泛型接口、泛型方法
• 语法 T成为类型占位符，表示一种引用类型，可以写多个逗号隔开
• 好处 1. 提高代码重用性 2. 防止类型转换异常，提高代码安全性

泛型类

//创建泛型类
public class MyGeneric<T>{
  //使用泛型T
  //1 创建变量
  T t;
  //2 泛型作为方法的参数
  public void show(T t){
    sout(t);
  }
  //3 泛型作为方法的返回值
  public T getT(){
    return t;
  }
}


//使用泛型类
public class TestGeneric{
  public static void main(String[] args){
    //使用泛型类创建对象
    // 注意： 1. 泛型只能使用引用类型
    //			 2. 不用泛型类型对象之间不能相互赋值
    MyGeneric<String> myGeneric = new MyGeneric<String>();
    myGeneric.t = "hello";
    myGeneric.show("hello world!");
    String string = myGeneric.getT();
    
    MyGeneric<Integer> myGeneric2 = new MyGeneric<Integer>();
    myGeneric2.t = 100;
    myGeneric2.show(200);
    Integer integer = myGeneric2.getT();
    
  }
}

泛型接口

• 语法：接口名
• 不能泛型静态，常量

泛型方法

• 语法：返回值类型

public class MyGenericMethod{
  //泛型方法
  public <T> T show(T t){
    sout("泛型方法" + t);
    return t;
  }
}

//调用
MyGenericMethod myGenericMethod = new MyGenericMethod();
myGenericMethod.show("字符串");// 自动类型为字符串
myGenericMethod.show(200);// integer类型
myGenericMethod.show(3.14);// double类型

泛型集合

概念：参数化类型、类型安全的集合，强制集合元素的类型必须一致

• 编译时即可检查，而非运行时抛出异常
• 访问时，不必类型转换（拆箱）
• 不同泛型之间应用不能相互赋值，泛型不存在多态

Set集合

特点：无序，无下标，元素不可重复

方法：全部继承Collection中的方法，增加，删除，遍历，判断与Collection一致

HashSet

存储结构：哈希表（数组+链表+红黑树）

存储过程（重复依据）

1. 根据HashCode计算保存的位置，如果位置为空，直接保存，若不为空，进行第二步

2. 在执行equals方法，如果equals为true，则认为是重复的，否则形成链表

常用方法

新建集合：HashSet hashSet = new HashSet();

添加元素：hashSet.add();

删除元素：hashSet.remove()

遍历元素：

//使用增强for
for( type type : hashSet){
    
}

//使用迭代器
Iterator<String> it = hashSet.iterator( );
while(it.hasNext()){
  System.out.println(it.next());
}

判断元素：

hashSet.contains( ); //判断元素是否存在
hashSet.isEmpty(); //判断元素是否为空

TreeSet

• 基于排列顺序实现元素不重复
• 实现SortedSet接口，对集合元素自动排序
• 元素对象的类型必须实现Comparable接口，指定排序规则
• 通过CompareTo方法确定是否为重复元素

Map集合

Map接口的特点

• 用于存储任意键值对（key - value）
• 键：无序，无下标，不允许重复
• 值：无序，无下标，允许重复

方法

1. V put(K key, V value) 将对象存到集合中，关联键值
2. bject get(Object key) 根据键获得对应的值
3. Set 返回所有的Key
4. Collection values() 返回包含所有值的Collection集合
5. Set<Map.Entry<K, V>> 键值匹配的Set集合

Map接口的使用

Map<String,String> map = new HashMap();

//添加元素
map.put("cn","中国");
    
//删除元素
map.remove("cn");

/ 遍历
// 使用KeySet()
//Set<String> keyset = map.keySet(); // 所有Key的set集合
for(String key : map.keyset){
  sout(key + "---" + map.get(key));
}

// 使用entrySet()
//Set<Map.Entry<String, String>> entries = map.entrySet();
for(Map.Entry<String, String> entry : map.entries){
  sout(entry.getKey() + "---" + entry.getValue();
}
       

HashMap

• 存储结构：哈希表（数组+链表+红黑树）
• 使用key可使hashcode和equals作为重复
• 增、删、遍历、判断与上述一致

Hashtable:线程安全，运行效率慢；不允许null作为key或是value

Properties:hashtable的子类，要求key和value都是string，通常用于配置文件的读取

TreeMap:实现了SortedMap接口（是map的子接口），可以对key自动排序