学习笔记：集合

• 学习内容：集合
• • 1. 集合概述
  • 2. Collection接口中的方法
  • 3. List
  • • 3.1、List接口中特有方法
    • 3.2 、ArrayList集合
    • 3.3 、linkedList集合
    • 3.4 、Vector
  • 4. Set
  • • 4.1 、HashSet集合
    • 4.2 、TreeSet集合
  • 5. Map
  • • 5.1、Map接口中常用方法：
    • 5.2、Map集合的遍历
    • 5.3、HashMap集合
    • 5.3、HashMap和Hashtable的区别
    • 5.4、Properties类（属性类）
    • 5.5、TreeMap

1、什么是集合？有什么用？
集合实际上就是一个容器。可以来容纳其他类型的数据。（数组其实就是一个集合）

1.2、集合不能直接存储基本数据类型，另外集合也不能直接存储java对象，集合当中存储的都是java对象的内存地址。（或者说集合中存储的是引用）

1.3、在java中没一个不同的集合，底层对应不同的数据结构。往不同的集合中存储元素，等于将数据放到了不同的数据结构当中。

1.4、所有的集合类和集合接口都在java.util包下。

1.5、集合的继承结构图。
Collection集合：

Map集合：

1.6、集合和数组的区别

2.1 Collection接口中的方法及运用

例：

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Test01 {
    public static void main(String[] args){
        //创建一个集合对象
        //Collection c=new Collection(); 接口是抽象的，无法实例化。
        //多态
        Collection c =new ArrayList();
        //测试Collection接口中的常用方法：
        //boolean add(E e) 向集合中添加元素
        c.add(1200);//自动装箱，实际上是放进去了一个对象的内存地址。
        c.add(new Object());
        c.add(true);//自动装箱

        //boolean remove(Object o) 删除集合中的元素o，删除成功返回true
        System.out.println(c.remove(1200));//true

        //int size() 获取集合中元素的个数
        System.out.println("集合中元素的个数是："+c.size());//输出结果：3

        //void clear() 清空集合
        c.clear();
        System.out.println("集合中元素的个数是："+c.size());//输出结果：0

        //boolean contains(Object o) 判断当前集合中是否包含元素o，包含返回true，不包含返回false
        c.add("绿巨人");
        c.add("钢铁侠");
        c.add("蜘蛛侠");
        System.out.println(c.contains("绿巨人"));//true
        System.out.println(c.contains("美国队长"));//false

        //boolean isEmpty() 判断集合是否为空
        System.out.println(c.isEmpty());//false
        c.clear();
        System.out.println(c.isEmpty());//true

        //Object[] toArray() 调用这个方法可以把集合转换成数组
        c.add("abc");
        c.add("def");
        c.add(100);
        c.add("Serein");
        Object[] objs=c.toArray();
        for(int i=0;i 
2.2 注意：合结构只要发生改变，迭代器必须从重新获取。
 
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Test02 {
    public static void main(String[] args) {
        //创建集合
        Collection c=new ArrayList();

        //注意：此时获取的迭代器，指向的是那时集合中没有元素状态下的迭代器。
        Iterator it = c.iterator();
        //一定要注意：集合结构只要发生改变，迭代器必须从重新获取。
        //如果没有重新获取，调用next()方法时会发生异常：java.util.ConcurrentModificationException


        //添加元素
        c.add(1);
        c.add(2);
        c.add(3);

        //获取迭代器
        //Iterator it=c.iterator();
        while (it.hasNext()){
            Object obj=it.next();
            System.out.println(obj);
        }
    }
}
 
2.3 Iterator 中的remove()方法和Collection 中remove()方法的区别
 
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Test02 {
    public static void main(String[] args) {

        Collection c=new ArrayList();
        c.add("abc");
        c.add("def");
        c.add("xyz");

        Iterator it=c.iterator();
        while (it.hasNext()){
            Object obj=it.next();
            //删除元素
            //c.remove(obj);
            //删除元素之后，集合的结构发生了变化，应该重新去获取迭代器
            //但是，循环下一次的时候并没有获取迭代器，所有会出现异常：java.util.ConcurrentModificationException
            
            //使用迭代器来删除
            //迭代器去删除时，会自动更新迭代器，并且更新集合（删除集合中的元素）
            it.remove();//删除的一定是迭代器指向的当前元素
            System.out.println(obj);
        }
        System.out.println(c.size());//0
    }
}
 
3. List 
3.1、List接口中特有方法 
void add(int index,E element) 在列表指定位置插入指定元素
 
public class Test03 {
    public static void main(String[] args) {
        //创建List类型的集合
        //List mylist=new Vector();
        //List mylist=new linkedList();
        List mylist=new ArrayList();

        //添加元素
        mylist.add("A");
        mylist.add("B");
        mylist.add("C");
        mylist.add("C");
        mylist.add(1,"Serein");

        //迭代
        Iterator it=mylist.iterator();
        while (it.hasNext()){
            Object elt=it.next();
            System.out.println(elt);
        }
    }
}
 
 
E get(int index) 根据下标获取元素
 （以上述代码为例）
 
Object firstObj=mylist.get(0);
System.out.println(firstObj);//输出结果：A
 
int indexOf(Object o) 获取指定对象第一次出现处的索引。
 （以上述代码为例）
 
System.out.println(mylist.indexOf("Serein"));//输出结果：1
 
int lastIndexOf(Object o) 获取指定对象最后一次出现处的索引。
 （以上述代码为例）
 
System.out.println(mylist.lastindexOf("C"));//输出结果：4
 
E remove(int index) 删除指定下标位置的元素
 （以上述代码为例）（遍历省略，可用迭代器或者根据下标for循环）
 
mylist.remove(0);
 
 
E set(int index, E element) 修改指定位置的元素
 （以上述代码为例）（遍历省略，可用迭代器或者根据下标for循环）
 
mylist.set(1,"Pt");
 
 
3.2 、ArrayList集合 
1、默认初始化容量10
 2、集合底层是一个Object[]数组
 3、构造方法：ArrayList()、ArrayList(int initialCapacity)、ArrayList(Collection c)
 
//ArrayList() 构造一个初始容量为十的空列表。
//ArrayList(int initialCapacity) 构造具有指定初始容量的空列表。
List list1=new ArrayList();//初始化容量为10
List list2=new ArrayList(20);//初始化容量为20

//创建一个HashSet集合
Collection c=new HashSet();
c.add(100);
c.add(200);
//ArrayList(Collection c)
//通过这个构造方法就可以将HashSet集合转换成List集合
List mylist=new ArrayList(c);
 
4、ArrayList集合的扩容：原容量的1.5倍
 
3.3 、linkedList集合 
1、linkedList集合是双向链表
 2、对于链表数据结构来说，随机增删效率较高。检索效率较低
 3、链表中的元素在空间存储上，内存地址不连续
 
3.4 、Vector 
1、底层也是一个数组
 2、初始化容量是10
 3、Vector的扩容：原容量的2倍
 4、Vector中所有的方法都是线程同步的，都带有synchronized关键字，是线程安全的
 5、怎么将一个线程不安全的ArrayList集合转换成线程安全的呢？
 使用集合工具类：java.util.Collections
 注意区分（集合接口：java.util.Collection）
 
List mylist=new ArrayList();//非线程安全的
Collections.synchronizedList(mylist);
 
4. Set 
4.1 、HashSet集合 
1、存储时顺序和取出的顺序不同
 2、不可重复
 3、放到HashSet集合中的元素实际上是放到HashMap集合的key部分了。
 
4.2 、TreeSet集合 
1、无序不可重复的，但是存储的元素可以自动按照大小顺序排列！称为：可排序集合
 
import java.util.*;

public class Test03 {
    public static void main(String[] args) {
        Set strs=new TreeSet<>();
        strs.add("C");
        strs.add("Z");
        strs.add("K");
        strs.add("F");
        strs.add("A");
        //foreach遍历
        for (String s:strs) {
            System.out.println(s);
        }
    }
}
 
 
5. Map 
1、Map和Collection没有继承关系。
 2、Map集合以key和value的方式存储数据：键值对
 key和value都是引用数据类型
 key和value都是存储对象的内存地址
 key起到主导的地位，value是key的一个附属品
 
5.1、Map接口中常用方法： 
V put(K key, V value) 向Map集合中添加键值对
 
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

public class Test03 {
    public static void main(String[] args) {
        //创建Map集合对象
        Map map=new HashMap<>();

        //向Map集合中添加键值对
        map.put(1,"zhangshan");//这里的1进行了自动装箱
        map.put(2,"lisi");
        map.put(3,"wangwu");
        map.put(4,"zhaoliu");
    }
}

 
V get(Object key) 通过key获取value
 （以上述代码为例）
 
//通过key获取value
String value=map.get(2);
System.out.println(value);//输出结果：lisi
 
int size() 获取Map集合中键值对的个数
 （以上述代码为例）
 
//获取键值对的数量
System.out.println("键值对的数量："+map.size());//输出结果：4
 
V remove(Object key) 通过key删除键值对
 （以上述代码为例）
 
//通过key删除key-value
map.remove(2);
System.out.println("键值对的数量："+map.size());//输出结果：3
 
boolean containsKey(Object key) 判断Map中是否包含某个key
 （以上述代码为例）
 
//判断是否包含某个key
//contains方法底层调用的都是equals进行比对的，所有自定义的类型需要重写equals方法
System.out.println(map.containsKey(4));//输出结果：true
 
boolean containsValue(Object value) 判断Map中是否包含某个value
 （以上述代码为例）
 
//判断是否包含某个value
System.out.println(map.containsValue("wangwu"));//输出结果：true
 
Collection values() 获取Map集合中所有的value，返回一个Collection
 （以上述代码为例）
 
//获取所有的value
Collection values=map.values();
for(String s:values){
   System.out.println(s);
}
 
 
void clear() 清空Map集合
 （以上述代码为例）
 
//清空Map集合
map.clear();
System.out.println("键值对的数量："+map.size());//输出结果：0
 
boolean isEmpty() 判断Map集合中元素个数是否为0
 （以上述代码为例）
 
/判断是否为空
System.out.println(map.isEmpty());//输出结果：true
 
Set keySet() 获取Map集合所有的key（所有的键是一个set集合）
 （以上述代码为例）
 
Set keys=map.keySet();
 
Set> entrySet() 将Map集合转换成Set集合
 （以上述代码为例）
 
Set> set=map.entrySet();
 
5.2、Map集合的遍历 
第一种方式：获取所有的key，通过遍历key，来遍历value。
 
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Test04 {
    public static void main(String[] args) {
        Map map=new HashMap<>();
        map.put(1,"zhangshan");
        map.put(2,"lisi");
        map.put(3,"wangwu");
        map.put(4,"zhaoliu");

        //遍历Map集合
        //获取所有的key，所有的key是一个Set集合
        Set keys=map.keySet();
        //遍历key，通过key获取value
        //迭代器
        Iterator it=keys.iterator();
        while (it.hasNext()){
            //取出其中一个key
            Integer key= it.next();
            //通过key获取value
            String value=map.get(key);
            System.out.println(key+"="+value);
        }
        //foreach
        for (Integer key:keys) {
            System.out.println(key+"="+map.get(key));
        }
    }
}
 
 
第二种方式：Set> entrySet()。
 （以上述代码为例）
 
Set> set=map.entrySet();
        //迭代器
        Iterator> it2=set.iterator();
        while (it2.hasNext()){
            Map.Entry node=it2.next();
            Integer key= node.getKey();
            String value= node.getValue();
            System.out.println(key+"="+value);
        }
        //foreach
        //这种方式效率比较高，因为获取key和value都是直接从node对象中获取的属性值。
        for (Map.Entry node:set) {
            System.out.println(node.getKey()+"--->"+node.getValue());
        }
 
 
5.3、HashMap集合 
1、HashMap集合底层是哈希表/散列表的数据结构
 2、哈希表是一个怎样的数据结构呢？
 哈希表是一个数组和单向链表的结合体。
 数组：在查询方面效率很高，随机增删方面效率很低。
 单向链表：在随机增删方面效率较高，在查询方面效率较低。
 哈希表将以上的两种数据结构融合在一起，充分发挥它们各自的优点。
 3、主要掌握：
 map.put(k,v)和v=map.get(k)两个方法是实现原理
 
 4、HashMap集合的key部分特点：
 无序，不可重复。
 为什么无需？因为不一定挂到哪个单向链表上。
 不可重复是怎么保证的？equals方法来包装HashMap集合的key不可重复。
 如果key重复了，value会覆盖。
 
放在HashMap集合的key部分的元素其实就是放到HashSet集合中了。
 所以HashSet集合中的元素也需要同时重写hashCode()+equals()方法。
 
5、哈希表HashMap使用不当时无法发挥性能！
 假设将所有的hashCode()方法返回值固定为某个值，那么会导致底层哈希表变成了单纯的单向链表。这种情况我们称为：散列分布不均匀。
 
6、放在HashMap集合的key部分的元素，以及放到HashSet集合中的元素，需要同时重写hashCode()+equals()方法。
 
7、HashMap集合的默认初始化容量是16，默认加载因子是0.75.
 这个默认加载因子是当HashMap集合底层数组的容量达到75%的时候，数组开始扩容。
 
记住：HashMap集合初始化容量必须是2的倍数，这也是官方推荐到，这是因为达到散列均匀，为了提高HashMap集合的存取效率，所必须的。
 
5.3、HashMap和Hashtable的区别 
 
5.4、Properties类（属性类） 
Properties是一个Map集合，继承Hashtable，Properties的key和value都是String类型。
 Properties被称为属性类对象。
 Properties是线程安全的。
 Properties的两个方法：setProperty()（存）和getProperty()（取）
 
import java.util.Properties;

public class Test05 {
    public static void main(String[] args) {
        Properties pro=new Properties();
        pro.setProperty("username","admin");
        pro.setProperty("password","123");

        String user=pro.getProperty("username");
        String pass=pro.getProperty("password");
        System.out.println(user);
        System.out.println(pass);
    }
}
 
 
5.5、TreeMap 
1、TreeSet集合底层实际上是一个TreeMap
 2、TreeMap集合底层是一个二叉树
 3、放到TreeSet集合中的元素，等同于放到TreeMap集合key部分了。
 4、TreeSet集合中的元素：无需不可重复，但是可以按照元素的大小自动排序。称为可排序集合
 
TreeSet集合中元素可排序的两种方式
 
Collections工具类