集合

Collection接口

Collection是所有单列集合的父接口，因此在Collection中定义了单列集合(List和Set)通用的一些方法，
这些方法可用于操作所有的单列集合。方法如下：
public boolean add(E e) ： 把给定的对象添加到当前集合中 。
public void clear() :清空集合中所有的元素。
public boolean remove(E e) : 把给定的对象在当前集合中删除。
public boolean contains(E e) : 判断当前集合中是否包含给定的对象。
public boolean isEmpty() : 判断当前集合是否为空。
public int size() : 返回集合中元素的个数。
public Object[] toArray() : 把集合中的元素，存储到数组中。

一 、list接口

java.util.List 接口继承自 Collection 接口，是单列集合的一个重要分支，习惯性地会将实现了
List 接口的对象称为List集合。在List集合中允许出现重复的元素，所有的元素是以一种线性方式进行
存储的，在程序中可以通过索引来访问集合中的指定元素。另外，List集合还有一个特点就是元素有
序，即元素的存入顺序和取出顺序一致。
看完API，我们总结一下：
List接口特点：
1. 它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就
是按照11、22、33的顺序完成的）。
2. 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道
理）。
3. 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。
tips:我们在基础班的时候已经学习过List接口的子类java.util.ArrayList类，该类中的方法都是来自
List中定义。

List作为Collection集合的子接口，不但继承了Collection接口中的全部方法，而且还增加了一些根据元
素索引来操作集合的特有方法，如下：
public void add(int index, E element) : 将指定的元素，添加到该集合中的指定位置上。
public E get(int index) :返回集合中指定位置的元素。
public E remove(int index) : 移除列表中指定位置的元素, 返回的是被移除的元素。
public E set(int index, E element) :用指定元素替换集合中指定位置的元素,返回值的更新
前的元素。

class  arrayList{
    public static void main(String[] args) {
        ArrayList<String> arra = new ArrayList<>();
        增删慢,查找快
        //添加元素
        arra.add("张三");
        arra.add("李四");
        arra.add("王二");
        arra.add("麻子");
        //输出
        System.out.println(arra);
        //访问元素
        System.out.println(arra.get(1));
        //修改元素
        arra.set(1,"凤姐");
        System.out.println(arra.get(1));
        //删除元素
        arra.remove(1);
        System.out.println(arra);
        //计算大小
        System.out.println(arra.size());
        //迭代数组列表
        for (String a:arra) {
            System.out.println(a);
        }

    }
}

Vector

//Vector :使用的是数组结构,对于增加删除慢,查找快
        Vector<Integer> date = new Vector<>();
        date.add(123);
        date.add(234);
        System.out.println(date.toString());

iterator与Listerator

ArrayList<Integer> data = new ArrayList<>();
        data.add(1);
        data.add(2);
        data.add(3);
        data.add(4);
        data.add(5);
        Iterator<Integer> iterator = data.iterator();

        /*
        //遍历
        while (iterator.hasNext()){
            Integer i = iterator.next();
            System.out.println(i);
        }*/
        //删除
        iterator.next();
        iterator.remove();
        System.out.println(data.size());
    }

//Iterator
        ArrayList<Integer> data = new ArrayList<>();
        data.add(1);
        data.add(2);
        data.add(3);
        data.add(4);
        data.add(5);
        ListIterator<Integer> iterator = data.listIterator();
        //添加
        iterator.add(100);
        //改变下标为1的值,先移动到下标1的位置
        iterator.next();
        iterator.next();
        iterator.set(200);
        System.out.println(data.size());

        //移动下标回0位置,因为添加一个元素,所以要多移动一个位置才能回0位置
        iterator.previous();
        iterator.previous();
        iterator.previous();
        //遍历
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

Tree 与 Compareble

TreeSet<Person> data = new TreeSet<>();
        Person p1 = new Person("张三", 18);
        Person p2 = new Person("李四",17);
        Person p3 = new Person("王二",19);
        Person p4 = new Person("麻子",16);
        data.add(p1);
        data.add(p2);
        data.add(p3);
        data.add(p4);
        for (Person a:data) {
            System.out.println(a);
        }
    }
    static class Person implements Comparable<Person>{
        private String name;
        private int age;

        @Override
        public int compareTo(Person o) {
            if (this.age>o.age){
                return 1;
            }else if (this.age==o.age){
                return 0;
            }
            return -1;
        }

        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", 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);
        }

        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;
        }



    }

 //TreeSet :有序,自动排序
    public static void main(String[] args) {
        TreeSet<String> data = new TreeSet<>();
        data.add("A");
        data.add("C");
        data.add("D");
        data.add("B");
        for (String i:data) {
            System.out.println(i);
        }

HashMap

HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。

HashMap 实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。

HashMap 是无序的，即不会记录插入的顺序。

HashMap 继承于AbstractMap，实现了 Map、Cloneable、java.io.Serializable 接口。

package com.kkb;

import java.util.HashMap;

public class hasmap {
    public static void main(String[] args) {
        //创建HaspMap对象
        HashMap<Integer,String> apm = new HashMap<>();
        //添加键值对
        apm.put(1,"一");
        apm.put(2,"二");
        apm.put(3,"三");
        apm.put(4,"四");
        apm.put(5,"五");
        //输出结果
        System.out.println(apm);
        //访问元素
        System.out.println(apm.get(1));
        //计算大小
        System.out.println(apm.size());
        //迭代元素
        for (Integer i:apm.keySet()) {
            System.out.println("key:"+i+"value:"+apm.get(i));
        }
        //清空所有元素
        apm.clear();
        System.out.println(apm);

        HashMap<Integer,String> amp1 = new HashMap<>();
        amp1.put(6,"六");
        amp1.put(7,"七");


        //添加所有
        apm.putAll(amp1);
        System.out.println(apm);
    }
}