java基础语法（二十一）集合

集合概述

1、什么是集合，有什么用
数组其实就是一个集合。集合实际上就是一个容器，可以容纳其它类型的数据。
集合为什么说在开发中使用较多？
集合是一个容器，是一个载体，可以一次容纳多个对象。在实际开发中，假设链接数据库，数据库当中有10条记录，
假设把这10条记录查询出来，在java程序中会将10条记录封装成10个java对象，然后将10个java对象放到某一个集合当中，将集合传到前端，然后遍历集合，将一个数据一个数据展现出来。
2、集合不能直接存储基本数据类型，另外集合也不能直接存储java对象，集合当中存储的都是java对象的内存地址。（或者说集合中存储的是引用）

    list.add(100);//自动装箱Integer
 ==注意：==
        集合在java中本身是一个容器，是一个对象。
        集合在任何时候存储的都是"引用"

3、在java中每一个不同的集合，底层会对应不同的数据结构。往不同的集合中存储元素，等于将数据
放到了不同的数据结构当中。使用不同的集合等同于使用不同的数据结构。
new ArrayList(); 创建一个集合，底层是数组。
new LinkedList(); 创建一个集合，底层是链表。
new TreeList(); 创建一个集合，底层是二叉树。
…
4、集合在java JDK中哪个包下？
java.util.*;
所有的集合类和集合接口都在java.util包下。
5、在java中集合分为两大类：
一类是以单个方式存储元素：
单个方式存储元素，这一类集合中超级父接口：java.util.Collection
一类是以键值对的方式存储元素
以键值对的方式存储元素，这一类集合中超级父接口：java.util.Map;
总结（所有的实现类）：
ArrayList:底层是数组
LinkedList:底层是双向链表
Vector:底层是数组，线程是安全的，效率较低，使用较少
HashSet:底层是HashMap，放到HashSet集合中的元素等同于放到HashMap集合key部分了。
TreeSet:底层是TreeMap,放到TreeSet集合中的元素等同于放到TreeMap集合key部分了。
HashMap:底层是哈希表。
Hashtable:底层也是哈希表，只不过线程是安全的，效率较低，使用较少。
Properties:是线程安全的，并且key和value只能存储字符串String
TreeMap:底层是二叉树。TreeMap集合的key可以自动按照大小顺序排序。
List集合存储元素的特点：有序可重复。
（有序：存进去的顺序和取出的顺序相同，每一个元素都有下标。可重复：存进去1，可以再存储一个1）
Set集合存储元素的特点：无序不可重复
（无序：存进去的顺序和取出的顺序不一定相同。另外Set集合中元素没有下标。不可重复：存进去1，不能再存储1了）
SortedSet集合存储元素的特点：首先是无序不可重复的，但是SortedSet集合中的元素是可排序的。
（可排序：可以按照大小顺序排列）
Map集合的key，就是一个Set集合。在Set集合中放数据，实际上放到了Map集合的Key部分。

collection接口常用方法

1、Collection中都能存放什么元素
    没有使用"泛型"之前，Collection中可以存储Object的所有子类型.
    使用了"泛型"之后，Collection中只能存储某个具体的类型。
    强调：集合中不能直接存储基本数据类型，也不能存java对象，只是存储java对象的内存地址。
2、Collection中的常用方法
    boolean add(Object e) 向集合中添加元素
    int size()  获取集合中元素的个数
    void clear() 清空集合
    boolean contains(Object o)判断当前集合中是否包含元素o
    boolean remove(Object o)删除集合中某个元素
    boolean isEmpty() 判断集合当中元素的个数是否为0
    Object[] toArray() 调用这个方法可以把集合转换成数组

public class collectionTest01 {
    public static void main(String[] args) {
        //创建一个集合对象
        //Collection c = new Collection();//接口是抽象的，无法实例化。
        //多态
        Collection c = new ArrayList();
        //测试Collection接口中常用的方法
        c.add(1200);//自动装箱，实际上是存进去了一个对象的内存地址 Integer x = new Integer(1200);
        c.add(new Student());
        c.add(new Object());
        c.add(true);//自动装箱
        //获取集合中元素的个数
        System.out.println("集合中元素个数是："+c.size());//4

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

        //再向集合中添加元素
        c.add("hello");//"hello"对象的内存地址放到了集合当中
        c.add("world");
        c.add("Kitty");

        //判断集合当中是否包含"hello"
        System.out.println(c.contains("hello"));//true

        //删除集合中某个元素
        c.remove("kitty");

        //判断集合是否为空（集合中是否存在元素）
        System.out.println(c.isEmpty());//false
        c.clear();
        System.out.println(c.isEmpty());//true

        c.add("abc");
        c.add("def");
        c.add(100);
        c.add("helloworld");
        c.add(new Student());//由于学生类没有重写toString()方法，所以遍历的时候输出的是该对象的内存地址
        Object[] objs=c.toArray();
        for(int i =0;i<objs.length;i++){
            Object o =objs[i];
            System.out.println(o);
        }

    }
}
class Student{

}

关于集合遍历/迭代遍历

public class collectionTest02 {
    public static void main(String[] args) {
        //注意：以下讲解的遍历/迭代方式，是所有Collection通用的一种方式
        //在Map集合中不能用。在所有的Collection以及子类中使用。
        //创建集合对象
        Collection c = new ArrayList();//后面的集合无所谓，主要是看前面的Collection接口怎么遍历/迭代
        //ArrayList有序可重复
        //添加元素
        c.add("abc");
        c.add("def");
        c.add(100);
        c.add(new Object());
        //对集合Collection进行遍历/迭代
        //第一步：获取集合对象的迭代器对象Iterator
        Iterator it = c.iterator();
        //第二步：通过以上获取的迭代器对象开始迭代/遍历集合
        /*
            以下两个方法是迭代器对象Iterator中的方法
                boolean hasNext() 如果仍然有元素可以迭代，则返回true;
                Object next() 返回迭代的下一个元素
         */

        while (it.hasNext()){
            //不管当初存进去的是什么，取出来统一都是Object
            Object obj = it.next();
            System.out.println(obj);

        }


    }
}

深入Collection集合的contains方法

深入Collection集合的contains方法
boolean contains(Object o)
    判断当前集合中是否包含元素o
    如果包含返回true,不包含返回false
contains方法是用来判断集合中是否包含某个元素的方法。
那么它在底层是怎么判断集合中是否包含某个元素呢？
    调用了equals方法进行比对。
    equals方法返回true，就表示包含这个元素。

结论:存放在一个集合中的类型，一定要重写equals方法。

public class collectionTest03 {
    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);
        //集合中元素的个数
        System.out.println("元素的个数"+c.size());
        //创建新的String对象
        String x = new String("abc");
        //c集合中是否包含x?
        System.out.println(c.contains(x));//true

        //创建结合对象
        Collection c2 = new ArrayList();
        //创建用户对象
        User u1 = new User("jack");
        User u2 = new User("jack");
        //加入集合
        c2.add(u1);
        //判断集合中是否包含u2
        //没有重写equals之前：结果是false
        //System.out.println(c2.contains(u2));//false
        //重写之后，返回的结果是true
        System.out.println(c2.contains(u2));//true

        Integer a = new Integer(1000);
        c.add(a);
        Integer b = new Integer(1000);
        //Integer类重写了equals方法
        System.out.println(c.contains(b));//true

        //在重写了equals之后可以删除，重写之前无法删除，重写之前调用的是object类的equals，比较的是对象的内存地址
        c2.remove(u2);
        System.out.println(c2.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( o == null || !(o instanceof  User)) return  false;
        if( o == this) return true;
        User u = (User)o;
        return u.name.equals(this.name);
     }


 }

以上代码对应的Collections的contains方法的原理图：

关于集合元素的remove

关于集合元素的remove
  当集合的结构发生改变时，迭代器必须重新获取，如果还是用以前的迭代器，
  会出现异常：java.util.ConcurrentModificationException

重点：在迭代集合元素的过程当中，不能调用集合对象的remove方法，删除元素；
    c.remove(o);迭代过程中不能这样，会出现ava.util.ConcurrentModificationException

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

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

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

        //获取迭代器
        //Iterator it = c.iterator();//此时获得的迭代器，指向的是集合中有元素状态下的迭代器
        /*while(it.hasNext()){
            //编写代码时next()方法返回值类型必须是Object。
            Object obj = it.next();
            System.out.println(obj);
        }*/
        Collection c2 = new ArrayList();
        c2.add("abc");
        c2.add("def");
        c2.add("xyz");

        Iterator it2 = c2.iterator();//在创建迭代器的同时，给原集合拍了一张快照，对快照进行遍历，快照要和原集合保持一致，原集合一旦改变，就和快照中的不同，就会出现异常
        while (it2.hasNext()){
            Object o = it2.next();
            //删除元素
            //删除元素之后，集合的结构发生了变化，应该重新获取迭代器

            //直接通过集合删除元素，没有通知迭代器。（导致迭代器的快照和原集合状态不同）
            //c2.remove(o);//通过集合删除，出现问题，根本原因是：集合中元素删除了，但是没有更新迭代器。（迭代器不知道集合变化了）
            //System.out.println(o);//java.util.ConcurrentModificationException

            //使用迭代器来删除
            //快照和原集合同时删除该元素，快照和原集合仍保持一致，所以运行正常。
            //即迭代器删除时，会自动更新迭代器，并且更新集合。（删除集合中的该元素）
            it2.remove();//删除的一定是迭代器指向的当前元素，通过迭代器删除，运行正常
            System.out.println(o);
        }
        System.out.println(c2.size());
    }
}

collection和collections

java.util.Collection集合接口
jova.util.Collections集合工具类,方便集合的操作。

public class CollectionsTest {
    public static void main(String[] args) {
        // Arraylist集合不是线程安全的。
        List<String> list = new ArrayList<>();
        //变成线程安全的
        Collections.synchronizedList(list);
        //排序
        list.add("abf");
        list.add("abx");
        list.add("abc");
        list.add("abe");
        //注意:对list集合中元素排序,需要保证List集合中的元素实现了: Comparable接口。
        Collections.sort(list);
        for (String s : list) {
            System.out.println(s);
        }

        //对set集合怎么排序呢?
        Set<String> set = new HashSet<>();
        set.add("king");
        set.add("kingsoft");
        set.add("king2");
        set.add("king1");
        //将Set集合转换成List集合
        List<String> myList = new ArrayList<>(set);
        Collections.sort(myList);
        for (String s:myList){
            System.out.println(s);
        }

    }
}