java零基础11--Collection集合

集合概述

什么是集合：数组其实就是一个集合，集合是一个容器，可以一次容纳多个对象。每一个不同集合中，底层会对应不同的数据结构，往不同的集合中当数据，就是把数据放到不同数据结构中，不同的集合等同于不同的数据结构。java中已经将这种数据结构写好了，我们只需要知道怎么用就行了。

集合的分类：Map和Collection两个大类

Collection集合

集合继承结构图

Collection集合的常用方法

boolean add (Object a),向集合中添加元素
int size (),获取集合中元素的个数
void clear(),清空集合
boolean contains (Object o)，判断集合中是否包含元素
boolean remove(Object o),删除某个元素
boolean isEmpty(),判断集合是否为空
Object[] toArray() 把集合转换为数组,注意返回值是一个Object数组

Collection集合的遍历

public class Collection的iterator方法 {
    public static void main(String[] args) {
        //以下遍历方式是所有Collection通用的，Map不行！
        Collection c = new ArrayList();//ArrayList有序且可重复
        c.add("abc");
        c.add("100");
        c.add(new Object());
        c.add("100");
        //迭代
        //第一步，获取集合对象的迭代器，负责遍历集合元素
        Iterator it = c.iterator();//迭代器it最初并没有指向第一个元素！
        //第二步，通过迭代器对象迭代集合
        /*
        * 迭代器的方法
        * boolean hasNext(),如仍然有元素可迭代，返回true
        * Object next()，返回迭代的下一个元素，并让迭代器前进前进一维
        * */

        //遍历的方法！
        while (it.hasNext()){
            Object obj = it.next();
            System.out.println(obj);
        }
        System.out.println("===================================");


        Collection c2 = new HashSet();//无序不可重复,存进和取出的顺序不一定相同，存储100不能再存储100
        c2.add(100);
        c2.add(200);
        c2.add(300);
        c2.add(90);
        c2.add(100);
        c2.add(222);
        Iterator ccc = c2.iterator();
        while (ccc.hasNext()){
            Object obj = ccc.next();
            //注意这里next的返回值必须是Object
            System.out.println(obj);
        }
    }
}

输出结果：

abc
100
java.lang.Object@723279cf
100
===================================
100
200
90
300
222

contains方法

直接看栗子

public class Collextion的contains详解 {
    public static void main(String[] args) {
        person c1 = new person("jack");
        person c2 = new person("jack");
        Collection s = new HashSet();
        s.add(c1);
        System.out.println(s.contains(c2));

        //没重写equals时
        //c1.equals(c2)是false
        //通过contains查看集合中是否存在某一个元素，是通过调用其equals方法来完成的，若不进行重写，默认的equals方法就是比较两个对象的地址
        //remove的执行机制与这个类似！

        //重点：放在集合中的对象要重写equals方法！
    }
}

class person{
    String name;

    public person(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof person)) return false;
        person person = (person) o;
        return Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return 0;
    }
}

List集合概念

List存储元素特点是：有序可重复，并且有下标，同0开始以1递增
List是Collection下的一个子接口

List集合中的常用方法

• void add(int index,Object element) 在指定下标添加元素
  Object get(int index) 获得指定下标的元素
  int indexOf(Object o) 获取对象第一次出现处的索引
  int lastIndexOf(Object o) 获取对象最后一次出现处的索引
  Object remove (int index) 删除指定下标的元素
  Object set (int index,Object element) 设置执行下标的元素

栗子

public class List接口常用方法 {
    public static void main(String[] args) {
        List mylist = new ArrayList();
        mylist.add("A");
        mylist.add("B");
        mylist.add("C");
        //在列表指定位置插入元素，其余元素后移
        mylist.add(1,"king");
        mylist.add("king");
        Iterator c = mylist.iterator();
        while (c.hasNext()){
            Object elt =c.next();
            System.out.println(elt);
        }

        Object first = mylist.get(0);
        System.out.println(first);

        //List特有的迭代
        for (int i = 0;i<mylist.size();i++){
            Object aa = mylist.get(i);
            System.out.println(aa);
        }

        //获取指定对象第一次出现处的索引
        System.out.println(mylist.indexOf("king"));

        //最后一次出现的索引
        System.out.println(mylist.lastIndexOf("king"));

        //删除指定下标的元素
        mylist.remove(0);
        System.out.println(mylist.size());

        //修改指定位置的元素
        mylist.set(2,"soft");
        for (int i = 0;i<mylist.size();i++){
            Object aa = mylist.get(i);
            System.out.println(aa);
        }
    }
}

输出结果：

A
king
B
C
king
A
A
king
B
C
king
1
4
4
king
B
soft
king

ArrayList与Linklist

前者：底层是一个数组
后者：底层是一个双向链表
如果需要平凡增删，后者效率明显高于前者

Linklist底层的双向链表

Set集合

Set集合也是Collection下的一个分支，其与list集合大致类似，区别在于：元素无序不可重复，添加重复的元素会添加失败且返回false，并且存进去的顺序与取出来的顺序可能会存在不同，且元素没有下标，实现类有HashSet和TreeSet。

泛型机制

public class text{
 public static void main(String[] args) {
        //使用泛型,指定list集合中只能存储animal
        List<animal>myList = new ArrayList<animal>();
        animal a = new animal();

        //获取迭代器，表示迭代的是animal类型
        Iterator<animal> it = myList.iterator();
        while (it.hasNext()){
            animal obj = it.next();
            obj.move();
        }
    }
}

class animal {
    public void move (){
        System.out.println("动物在移动");
    }
}

输出结果：

动物在移动