04java集合

集合

1. 数组其实也是一个集合。集合实际上就是一个容器，可以容纳其他类型的数据

2. 集合是一个容器一个载体，可以一次容纳多个对象

3. 在实际开发中，假设连接数据库，数据库中有10条记录，那么假设把这10条记录查询出来，在Java程序中会将10条数据封装成10个Java对象，然后将10个Java对象放到某一个集合中。将集合传到前端，然后遍历集合，将一个数据一个数据展现出来。

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

5. 注意：

• 集合在java中本身是一个容器，是一个对象
• 集合在任何时候存储的都是引用

6. 在java中每一个不同的集合，底层会对应不同的数据结构。往不同的集合中存储元素，等于将数据放到了不同的数据结构中什么是数据结构？数据存储的结构就是数据结构。不同的数据结构，数据存储方式不同。例如：

​ 数组、二叉树、链表、哈希表。。。图

​ 以上这些都是常见的数据结构。

​ 你往集合c1中放数据，可能放在数组上了。使用不同的集合等同于使用了不同的数据结构。

7. 集合在Java JDK中哪个包下：

• java.util.*;所有的集合类和集合接口都在这个java.util包下

8. 为了更好的掌握集合这块内容，最好可以将集合的继承结构图背会！！！

9. 在Java中集合分为两大类：

   • 一类是单个方式存储元素：单个方式存储元素，这一类集合中超级父接口：java.util.Collection
   • 一类是以键值对儿的方式存储元素：键值对儿的方式存储元素，这一类集合中超级父接口：java.util.Map

Iterator it= “Collection 对象”.iterator（）；it是迭代器对象。

所有集合继承Iterable的含义是，所有集合都是可迭代的。遍历就是迭代

10. List集合存储元素的特点：有序可重复，存储的元素有下标，有序实际上是存进去是这个顺序，取出来还是这个顺序，这里的顺序不是按照大小排序。List集合都有下标，下标从0开始
11. Set集合存储元素的特点：无序不可重复，存进去进去是这个顺序，取出来不一定是这个顺序了，另外Set集合中元素没有下标，Set集合中的元素不能重复。
12. ArrayList：ArrayList集合底层采用了数组这种数据结构。ArrayList集合是非线程安全的。
13. LinkedList：LinkedList集合底层采用了双向链表数据结构
14. Vector：Vector集合底层采用了数组这种数据结构，Vector集合是线程安全的，Vector所有的方法都有synchronized关键字修饰的，所以线程安全，但是效率较低，现在保证线程安全有别的方案，所以Vector使用较少了。
15. HashSet：实际上HashSet集合在new的时候，底层实际上new了一个HashMap集合，向HashSet集合中存储元素，实际上向HashMap存储元素。HashMap集合是一个哈希表数据结构
16. TreeSet：TreeSet集合底层实际上是TreeMap，new TreeSet集合的时候，底层实际上new了一个TreeMap集合。往TreeSet集合中放数据的时候实际上将数据到TreeMap集合中了。TreeMap集合底层采用了二叉树数据结构。

17. SortedSet：这是一个接口，SortedSet集合存储元素特点：由于继承Set集合，它也是无序不可重复，但是放到SortedSet集合中的元素可以自动排序，我们称为可排序集合，放到该集合中的元素是自动按照大小排序的

18. Map集合和Collection集合没有关系。Map集合以key和value的这种键值对的方式存储元素。key和value都是存储java对象的内存地址。所有Map集合的key特点：无序不可重复。Map集合的key和Set集合存储元素特点相同。

19. HashMap集合：底层是哈希表数据结构，是非线程安全的。

20. Hashtable集合：底层是哈希表数据结构。是线程安全的，其中所有的方法都带有synchronized关键字，效率低，现在使用较少了，现在有控制线程安全更好的方案。

21. 总结：

ArrayList：底层是数组

LinkedList：底层双向链表

Vector：底层数组，线程安全，效率较低，使用较少

HashSet：底层HashMap，放到HashSet的元素，等同于放到HashMap集合key部份了

TreeSet：底层是TreeMap，放到TreeSet集合的元素等同于放到TreeMap集合的key部份

HashMap：底层哈希表，

Hashtable：底层哈希表，线程安全，效率较低，使用较少

Properties：线程安全，key和value只能存储字符串String

TreeMap：底层二叉树，TreeMap的key可以自动按照大小顺序排序

List集合存储元素特点：有序可重复，这里的有序指的是：存进去的顺序和取出来的顺序相同。

Set集合存储元素的特点：无序不可重复。

SortedSet集合存储元素的特点：首先无序不可重复，元素是可排序的。

Map集合的key，就是一个Set集合。往Set集合中放数据，实际上放到Map集合的key部份。

Collection接口中常用的方法

关于java.util.Collection接口中常用的方法

1. Collection中能放什么元素
   没有使用“泛型”之前，Collectiom中可以存放Object的所有子类型
   使用了“泛型”之后，Collection中只能存放某个具体的类型。
   （集合中不能存储基本数据类型，也不能存储Java对象，只能存储Java对象的内存地址）

2. Collection中的常用方法
   boolean add(Object e)//向集合中添加元素
   int size()获取集合中元素个数
   void clear() 从此集合中删除所有元素（可选操作）
   boolean contains(Object o) 如果此集合包含指定的元素，则返回 true
   boolean remove(Object o) 从该集合中删除指定元素的单个实例（如果存在）（可选操作）。
   boolean isEmpty() 如果此集合不包含元素，则返回 true 。
   Object[] toArray() 返回一个包含此集合中所有元素的数组。

Iterator iterator() 返回此集合中的元素的迭代器。

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

public class CollectionTest01 {
    public static void main(String[] args) {
        //创建一个集合对象
        //Collection collection = new Collection;接口不能创建对象，接口时抽象的，无法实例化
        //多态
        Collection c= new ArrayList();
        //测试Collection接口中常用的方法
        c.add(1200);//自动装箱（Java5新特性），实际上放进去一个对象地址。Integer x = new Integer(1200);
        c.add(3.14);
        c.add(new Object());
        c.add(new Student());
        c.add(true);//自动装箱
        //获取集合中元素个数
        System.out.println("集合中元素个数是："+c.size());//5个元素，不是length（）
        c.clear();
        System.out.println("集合中元素个数是："+c.size());

        c.add("hello");//“hello”对象的内存地址放到集合中
        c.add("world");
        c.add("浩克");
        c.add("绿巨人");
        c.add(1);

        //判断集合中是否包含“绿巨人”
        boolean flag = c.contains("绿巨人");
        System.out.println(flag);//true
        boolean flag2 = c.contains("绿巨人2");
        System.out.println(flag2);//false

        System.out.println(c.contains("1"));//true

        //删除集合中某个元素
        c.remove(1);
        //判断集合是否为空
        System.out.println(c.isEmpty());//false

        //转换成数组
        Object[] objs= c.toArray();
        for (int i = 0; i < objs.length; i++) {
            //遍历数组
            System.out.println(objs[i]);//这里自动调用toString（）
        }

    }
}

关于集合遍历，迭代专题（重点）

迭代器是一个对象。迭代器对象有两个方法，hasNext（）和next（）

/*
 *关于集合遍历，迭代专题（重点）
 *Iterator<E>  iterator() 返回此集合中的元素的迭代器。
 */
public class CollectionTest02 {
    public static void main(String[] args) {
        //注意：一下讲解的遍历方式/迭代方式，是所有的Collection通用的一种方式
        //在Map集合中不能使用，在所有的Collection以及子类中使用。
        //创建集合对象
        Collection c = new ArrayList();//后面的集合无所谓，主要看前面的Collection接口
        //添加元素
        c.add("abc");
        c.add("def");
        c.add(100);
        c.add(new Object());
        //对集合Collection遍历/迭代
        //第一步：获取对象的迭代器对象 Itertor
        Iterator it = c.iterator();
        //第二步，通过以上获取的迭代器对象开始迭代/遍历集合
        /*
        以下方法是迭代器Iterator中的方法：
        boolean    hasNext()  如果迭代具有更多元素，则返回 true 。
        Object     next() 返回迭代中的下一个元素。
        default void   remove() 从底层集合中删除此迭代器返回的最后一个元素（可选操作）。
        * */
        boolean hasNext = it.hasNext();
        if(hasNext){
            //不管你存进去什么取出来统一是Object
            Object obj = it.next();
            System.out.println(obj);
        }
        if(hasNext){
            //不管你存进去什么取出来统一是Object
            Object obj = it.next();
            System.out.println(obj);
        }
        if(hasNext){
            //不管你存进去什么取出来统一是Object
            Object obj = it.next();
            System.out.println(obj);
        }
        if(hasNext){
            //不管你存进去什么取出来统一是Object
            Object obj = it.next();
            System.out.println(obj);
        }



    }
}

/*
* 关于集合的遍历/迭代
* */
public class CollectionTest03 {
    public static void main(String[] args) {
        //创建集合对象
        Collection c1 = new ArrayList();//ArrayList集合：有序可以重复
        //添加元素
        c1.add(1);
        c1.add(2);
        c1.add(3);
        c1.add(4);
        c1.add(1);
        //迭代集合
        Iterator it = c1.iterator();
        while(it.hasNext()){
            //存进去什么类型，取出来是什么类型，只是在输出的时候，peintln会调用toString（）方法
            System.out.println(it.next());
        }

        //HashSet集合：无序不可重复
        Collection c2 = new HashSet();
        //无序：存进去，和取出来的顺序不一定相同。
        c2.add(100);
        c2.add(200);
        c2.add(90);
        c2.add(20);
        c2.add(300);
        c2.add(50);
        c2.add(100);
        Iterator it1 = c2.iterator();
        while(it1.hasNext()){
            System.out.println(it1.next());
        }

    }
}

contains方法解析

深入Collection集合的contains方法

• boolean contains(Object o) 如果此集合包含指定的元素，则返回 true
• contains方法是用来判断集合中是否包含某个元素的。
• 它在底层调用了equals方法进行比对。Con

public class CollectionTest04 {
    public static void main(String[] args) {
        //创建集合对象
        Collection c = new ArrayList();
        //向集合中存储元素

        String s1= new String("abc");
        c.add(s1);
        String s2 = new String("def");
        c.add(s2);


        //创建新的对象
        String x = new String("abc");
        //集合中是否包含X?
        System.out.println(c.contains(x));//判断集合中是否包含“abc”，true，contains底层使用了equals（）



    }
}

Collection接口中remove方法和contains方法底层都会调用equals方法。它们都需要重写了equals方法。

/*
* 测试contains方法
* 结论：存放在一个集合中的类型，一定要重写equals方法。
* */
public class CollectionTest05 {
    public static void main(String[] args) {
        //创建集合对象
        Collection c = new ArrayList();
        //创建用户对象
        User u1=new User("jack");
        User u2=new User("jack");
        c.add(u1);
        //判断集合中是否包含u2
       // System.out.println(c.contains(u2));//false，没有重写equals方法
        System.out.println(c.contains(u2));//true，重写了equals方法，比较多的时候会比较内容

        Integer x=new Integer(10000);
        c.add(x);
        Integer y=new Integer(10000);
        System.out.println(c.contains(y));//true
        //Integer类中equals方法重写了

        Collection cc = new ArrayList();
        String s1 = new String("hello");
        cc.add(s1);
        String s2 = new String("hello");
        cc.remove(s2);
        System.out.println(cc.size());//0个元素

    }
}

class User{
    private String name;
    public User(){}
    public User(String name){
        this.name=name;
    }
    //重写equals方法
    //将来调用equals方法的时候，一定是调用这个重写的equals方法。

    //这个equals方法的比较原理是：只有姓名一样就表示同一个用户。
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return Objects.equals(name, user.name);
    }

}

关于集合元素的删除

package com.javase.collection;

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

/*
 * 关于集合元素的remove
 * 重点：当集合结构发生了改变，迭代器必须重新获取
 * 在迭代元素的过程中，不能调用集合对象的remove方法，删除元素，一定要使用迭代器Iterator的remove方法，删除元素。
 * */
public class CollectionTest06 {
    public static void main(String[] args) {
        //创建元素
        Collection c= new ArrayList();

        //注意：此时获取的迭代器，指向的是那是集合没有获得元素状态下的迭代器。
        //一定要注意：集合结构一旦发生改变，迭代器必须要重新获取。
        //当集合结构发生了改变，迭代器没有重新获取的时候，调用next（）方法时： java.util.ConcurrentModificationException
        // Iterator it =c.iterator();

        c.add(1);//这里存储的不是1，是new Integer的地址
        c.add(2);//Integer类型
        c.add(3);

        //获取迭代器
        Iterator it =c.iterator();

        while(it.hasNext()){
            //编写代码时next（）方法返回值类型必须是Object。
            //Integer i = it.next();
            Object obj = it.next();

            //删除元素，不能用c.remove(obj),这样会使集合结构发生变化
            //可以使用迭代器的remove
            it.remove();//删除的一定是迭代器指向的当前元素。
            System.out.println(obj);

        }
    }
}

List

List接口常用方法

LIst集合存储元素特点：有序可重复

void add(int index, E element) 将指定的元素插入此列表中的指定位置（可选操作）。
E get(int index)返回此列表中指定位置的元素。
int indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
int lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
E remove(int index) 删除该列表中指定位置的元素（可选操作）。
E set(int index, E element) 用指定的元素（可选操作）替换此列表中指定位置的元素。

bj);

    }
}

}

## List

### List接口常用方法


 LIst集合存储元素特点：有序可重复

void add(int index, E element)  将指定的元素插入此列表中的指定位置（可选操作）。
E get(int index)返回此列表中指定位置的元素。
int   indexOf(Object o)   返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
int   lastIndexOf(Object o)  返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
E remove(int index) 删除该列表中指定位置的元素（可选操作）。
E set(int index, E element)  用指定的元素（可选操作）替换此列表中指定位置的元素。