Java 集合框架（一）Collection

Java 集合框架（容器）

为什么使用集合框架：如果并不知道程序运行时会需要多少对象，或者需要更加复杂的方式存储对象，可以使用JAVA集合框架。

java集合框架提供了一套性能优良、使用方便的接口和类，可以分为以下两类，如下图所示。均位于工具包java.util包中
Collection接口中存放的是单一的值
Map接口中存放的是键值对k-v

java集合框架：
特点：
1、可以存放不同类型的数据，而数组只能存放固定类型的数据
2、当使用arraylist子类实现的时候，初始化的长度是10，当长度不够的时候会自动进行扩容操作

---

Collection

api方法

1. 增加数据的方法
   add：要求必须传入的参数是Object对象，因此当写入基本数据类型的时候，包含了自动拆箱和自动装箱的过程
   addAll:添加另一个集合的元素到此集合中
2. 删除数据的方法
   clear:只是清空集合中的元素，但是此集合对象并没有被回收[]
   remove:删除指定元素
   removeAll：删除集合元素
3. 查询数据的方法
   contains:判断集合中是否包含指定的元素值
   containsAll:判断此集合中是否包含另一个集合
   isEmpty:判断集合是否等于空
   retainAll:若集合中拥有另一个集合的所有元素，返回true，否则返回false
   size:返回当前集合的大小
4. 集合转数组的操作
   toArray:将集合转换成数组

public class CollectionDemo {
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add(1);
        collection.add(true);
        collection.add(1.23);
        collection.add("abc");
        System.out.println(collection);
        ((ArrayList) collection).add(0,"mashibing");//强制类型转换
        System.out.println(collection);
        Collection collection1 = new ArrayList();
        collection1.add("a");
        collection1.add("b");
        collection1.add("c");
        collection1.add("d");
        collection.addAll(collection1);
        System.out.println(collection);
//        collection.clear();
//        System.out.println(collection);
        System.out.println(collection.contains("a"));
        System.out.println(collection.containsAll(collection1));
        System.out.println(collection.isEmpty());
//        collection.remove("a");
//        System.out.println(collection);
        System.out.println(collection1.retainAll(collection));
        Object[] objects = collection.toArray();
        collection.add("a");
        System.out.println(collection);


    }
}

List

List：存放的是单一值

有序指的是按照存入进去的顺序排列
ArrayList 和LinkedList根据需求选择用什么，如果关注遍历和随机访问，就用ArrayList,关注插入、删除，就用LinkedList.
LinkedList拥有更加丰富的方法实现，需要的时候查API,不需要记

List下还有一个子类，Vector不常用，其特点是：
1.也是List接口的一个子类实现
2.Vector跟ArrayList一样，其底层都是数组
3.面试经常问区别：
(1). ArrayList是线程不安全的，效率高，Vector是线程安全的效率低
(2). ArrayList在进行扩容的时候，是扩容1.5倍，Vector扩容的时候扩容原来的2倍

拓展：Iterable

在java代码中包含三种循环的方式

• do…while

• while

• for

• 还有一种增强for循环的方式，可以简化循环的编写

• （建议：除了简单的遍历并读出其中内容外，不建议使用增强for）

  所有的***集合类***都默认实现了Iterable的接口，实现此接口意味着具备了增强for循环的能力，也就是for-each
  增强for循环本质上使用的也是iterator的功能
  方法：
  iterator()
  foreach()
  在iterator的方法中，要求返回一个Iterator的接口子类实例对象
  此接口中包含了
  hasNext()
  next()
  iterators书写方式：

Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

或者：推荐使用下边这一种

for(Iterator iter = list.iterator(); iter.hasNext();){
            System.out.println(iter.next());
        }

在使用iterator进行迭代的过程中如果删除其中的某个元素会报错，并发操作异常，因此
如果遍历的同时需要修改元素，建议使用listIterator（），
ListIterator迭代器提供了向前(hasPrevious)和向后(hasNext)两种遍历的方式
始终是通过cursor和lastret的指针来获取元素值及向下的遍历索引
当使用向前遍历的时候必须要保证指针在迭代器的结果,即要先用hasNext向后遍历，否则无法获取结果值

```java
public class IteratorDemo {
    public static void main(String[] args) {
        ArrayList list= new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }

        //迭代器
        Iterator iterator = list.iterator();
//        ListIterator iterator = list.listIterator();
//        while(iterator.hasNext()){
//            Object o = iterator.next();
//            if(o.equals(1)){
//               iterator.remove();
//            }
//           System.out.println(o);
//        }
        System.out.println("-------------");
        while (iterator.hasPrevious()){
           System.out.println(iterator.previous());
       }
        for(Object i : list){
            System.out.println(i);
        }
    }

Set接口中的实现类

1、set中存放的是无序，唯一的数据
2、set不可以通过下标获取对应位置的元素的值，因为无序的特点
3、使用treeset底层的实现是treemap,利用红黑树来进行实现
4、设置元素的时候，如果是自定义对象，会查找对象中的equals和hashcode的方法，如果没有，比较的是地址

5、树中的元素是要默认进行排序操作的，如果是基本数据类型，自动比较，如果是引用类型的话，需要自定义比较器
比较器分类：
内部比较器*
定义在元素的类中，通过实现comparable接口来进行实现
外部比较器
定义在当前类中，通过实现comparator接口来实现，但是要将该比较器传递到集合中
注意：外部比较器可以定义成一个工具类，此时所有需要比较的规则如果一致的话，可以复用，而
内部比较器只有在存储当前对象的时候才可以使用
如果两者同时存在，使用外部比较器
当使用比较器的时候，不会调用equals方法

comparable举例

//主函数
public class SetDemo  {
    public static void main(String[] args) {
        TreeSet treeSet = new TreeSet();
        treeSet.add(new Person("lisi",15));
        treeSet.add(new Person("wangwu",13));
        treeSet.add(new Person("maliu",12));
        treeSet.add(new Person("zhangsan",19));
        treeSet.add(new Person("zhangsan",12));
        System.out.println(treeSet);
}
}

//实现比较器,定义在元素的类中
public class Person implements Comparable{
    private String name;
    private int age;

    public Person(){

    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {

        return Objects.hash(name, age);
    }

    /**
     * 此比较器按照name的长度来进行比较
     * @param o
     * @return
     */
    @Override
    public int compareTo(Object o) {
        Person p  = (Person) o;
        if (p.name.length()>this.name.length()){
            return -1;
        }else if(p.name.length()<this.name.length()){
            return 1;
        }else{
            return 0;
        }
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

comparator比较器

//外部比较器定义在当前类中
public class SetDemo implements Comparator<Person> {
    public static void main(String[] args) {


        TreeSet treeSet = new TreeSet(new SetDemo());//y要将比较器传入到当前集合中
        treeSet.add(new Person("lisi",15));
        treeSet.add(new Person("wangwu",13));
        treeSet.add(new Person("maliu",12));
        treeSet.add(new Person("zhangsan",19));
        treeSet.add(new Person("zhangsan",12));
        System.out.println(treeSet);


    }

    @Override//重写外部比较器
    public int compare(Person o1, Person o2) {
        if(o1.getAge()>o2.getAge()){
            return -1;
        }else if(o1.getAge() < o2.getAge()){
            return 1;
        }else{
            return 0;
        }
    }
}

小节：
collection接口：
子接口：list,Set
常用的API:增删改查
迭代器:Iterator,Iterable
比较器：内部、外部
泛型：泛型类、泛型接口、方法
数据结构：
数组、链表、哈希表、红黑树