集合泛型

集合

概念：对象的容器，实现了对对象常用的操作

与数组的区别：

1. 数组长度固定，集合长度不固定
2. 数组可以存储基本类型和引用类型，集合只能存储引用类型

Collection:

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

创建集合 ​​Collection collection = new ArrayList();​​

常用方法：

1. 添加元素collection.add();
2. 删除元素
   ​​collection.remove();​​​​collection.clear();​​
3. 遍历元素

1. 使用增强for（因为无下标）
   ​​for(Object object : collection){ }​​
2. 使用迭代器

Iterator it = collection.iterator();
while(it.hasNext()){
  String object = (String)it.next();
}

1. 判断
   collection.contains();判断字符串中是否包含指定的字符或字符串 collection.isEmpty(); 是否为空

List

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

创建集合对象 ​​List list = new ArrayList<>( );​​

常用方法：

1. 添加元素list.add( ); 会对基本类型进行自动装箱
2. 删除元素 可以用索引list.remove(0)
   当删除数字与索引矛盾时 对数字强转
   ​​list.remove((Object) 10)​​ 或 list.remove(new Integer(10))
3. 遍历

1. 使用for遍历

for(int i = 0; i < lise.size(); i++){
  sout(list.get(i)); 
}

1. 使用增强for
   ​​for(Object list: collection){ }​​
2. 使用迭代器

Iterator it = collection.iterator();
while(it.hasNext()){
  String object = (String)it.next(); //强转
  // 可以使用it.remove(); 进行移除元素
  // collection.remove(); 不能用collection其他方法 会报并发修改异常
}

1. 使用列表迭代器 （注意和迭代器区别）

ListIterator li = list.listIterator();
while(li.hasNext()){
  System.out.println(li.nextIndex() + ":" + li.next()); //从前往后遍历
}

while(li.hasPrevious()){
  System.out.println(li.previousIndex() + ":" + li.previous()); //从后往前遍历
}

1. 获取list.indexOf( );

List实现类

ArrayList

数组结构实现，必须要连续空间，查询快、增删慢

jdk1.2版本，运行效率块、线程不安全

LinkedList

双向链表结构实现，无需连续空间，增删快，查询慢

ArrayList

创建集合 ​​ArrayList<> arrayList = new ArrayList<>();​​

1. 添加元素​​arrayList.add();​​
2. 删除元素​​arrayList.remove(new Student("name", 10));​​

3.判断

​​arrayList.contains();​​​ 和 ​​arrayList.isEmpty();​​

4.查找

​​arrayList.indexof();​​

LinkedList

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

常用方法与List一致

泛型

• 本质是参数化类型，把类型作为参数传递
• 常见形式有泛型类、泛型接口、泛型方法
• 语法 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. 泛型只能使用引用类型
    //          
    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();
    
  }
}

Set集合

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

方法：全部继承自Collection中的方法

增、删、遍历、判断与collection一致

HashSet

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

存储过程（重复依据）

1. 根据hashCode计算保存的位置，如果位置为空，直接保存，若不为空，进行第二步
2. 再执行equals方法，如果equals为true，则认为是重复，否则形成链表

新建集合 ​​HashSet<String> hashSet = new HashSet<String>();​​

添加元素 ​​hashSet.add( );​​

删除元素 ​​hashSet.remove( );​​

遍历操作

1. 增强for ​​for( type type : hashSet)​​

2. 迭代器 ​​Iterator<String> it = hashSet.iterator( );​​

判断 ​​hashSet.contains( );​​​ ​​hashSet.isEmpty();​​

TreeSet

特点

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

存储结构：红黑树

创建集合 ​​TreeSet<String> treeSet = new TreeSet<>()​​

添加元素 ​​treeSet.add();​​

删除元素 ​​treeSet.remove();​​

遍历 1. 增强for 2. 迭代器

判断 ​​treeSet.contains();​​

补充：TreeSet集合的使用

Comparator 实现定制比较（比较器）

Comparable 可比较的

Map

Map接口的特点

1. 用于存储任意键值对（key - value）
2. 键：无序、无下标、不允许重复（唯一）
3. 值：无序、无下标、允许重复

HashMap

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

使用key可使hashcode和equals作为重复

增、删、遍历、判断与上述一致

1. HashMap刚创建时，table是null，节省空间，当添加第一个元素时，table容量调整为16
2. 当元素个数大于阈值（16*0.75 = 12）时，会进行扩容，扩容后的大小为原来的两倍，目的是减少调整元素的个数
3. jdk1.8 当每个链表长度 >8 ，并且数组元素个数 ≥64时，会调整成红黑树，目的是提高效率
4. jdk1.8 当链表长度 <6 时 调整成链表
5. jdk1.8 以前，链表时头插入，之后为尾插入

Hashtable

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

Properties

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

TreeMap

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