Java类集框架----动态数组

Collection-----针对对象处理
Map-----针对键值对对象处理（key value）
1. Collection接口

add()：向集合中添加元素
iterator()：取得集合的迭代器（遍历集合的工具）

例：

package www.java.test;

import java.io.*;
import java.util.ArrayList;
import java.util.List;

class Person implements Serializable {
    private int age;
    private String name;
    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }
    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
    public boolean equals(Object obj){
        if(this == obj){
            return true;
        }
        if(obj == null){
            return false;
        }
        if(!(obj instanceof Person)){
            return false;
        }
        //先发生向下转型
        Person per = (Person) obj;
        return this.age == per.age && this.name.equals(per.name);
    }
}

public class Test{
    public static void main(String[] args) throws Exception{
        List<Person> list = new ArrayList<>();
       Person per1 = new Person(19,"李雷");
       Person per2 = new Person(10,"韩梅梅");
       Person per3 = new Person(30,"王五");
       list.add(per1);
       list.add(per2);
       list.add(per3);
        System.out.println(list);
    }
}

Collection接口有两个使用频率很高的子接口List（允许重复元素）、set（不允许重复元素）
1.1 List接口（90%）-----允许元素重复
List接口中重要的扩展方法：

public E get(int index)：根据索引取得数据
public E set(int index, E element)：根据指定索引改变相应元素

例 ：

package www.java.test;

import java.io.*;
import java.util.ArrayList;
import java.util.List;

class Person implements Serializable {
    private int age;
    private String name;
    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }
    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
    public boolean equals(Object obj){
        if(this == obj){
            return true;
        }
        if(obj == null){
            return false;
        }
        if(!(obj instanceof Person)){
            return false;
        }
        //先发生向下转型
        Person per = (Person) obj;
        return this.age == per.age && this.name.equals(per.name);
    }
}

public class Test{
    public static void main(String[] args) throws Exception{
        List<Person> list = new ArrayList<>();
       Person per1 = new Person(19,"李雷");
       Person per2 = new Person(10,"韩梅梅");
       Person per3 = new Person(30,"王五");
       list.add(per1);
       list.add(per2);
       list.add(per3);
       System.out.println(list.get(1));
    }
}

package www.java.test;

import java.io.*;
import java.util.ArrayList;
import java.util.List;

class Person implements Serializable {
    private int age;
    private String name;
    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }
    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
    public boolean equals(Object obj){
        if(this == obj){
            return true;
        }
        if(obj == null){
            return false;
        }
        if(!(obj instanceof Person)){
            return false;
        }
        //先发生向下转型
        Person per = (Person) obj;
        return this.age == per.age && this.name.equals(per.name);
    }
}

public class Test{
    public static void main(String[] args) throws Exception{
        List<Person> list = new ArrayList<>();
       Person per1 = new Person(19,"李雷");
       Person per2 = new Person(10,"韩梅梅");
       Person per3 = new Person(30,"王五");
       list.add(per1);
       list.add(per2);
       list.add(per3);
       System.out.println(list);
       System.out.println(list.set(1,new Person(30,"张三")));
       System.out.println(list);
    }
}

1.1.1 ArrayList（优先考虑）
接口中要保存自定义类对象、自定义类必须覆写equals()方法。
类集contains()、remove()等方法需要调用equals()来判断元素是否相等。

底层实现是一个对象数组，声明一个ArrayList对象时，长度为0；对集合的增删改查都是异步处理（无锁），性能较高，线程不安全；当数组长度不够时，扩容策略为变为原来数组的1.5倍。
1.1.2 Vector
底层实现是一个对象数组，声明一个Vector对象时，初始化对象数组长度为10；对集合的修改都采用同步处理（直接在方法上使用内建锁），性能较低，线程安全；当数组长度不够用时，扩容策略变为原来数组的2倍。
1.1.3 LinkedList
基于链表实现的动态数组

1.2 Set接口----不允许重复元素
Set接口中的方法与Collection完全一致，常用2个子类HashSet、TreeSet。

1.2.1 HashSet----无序存储-----底层基于哈希表
不允许元素重复，并且无序存储（根据hash码来保存元素），允许存放null

package www.java.test;

import java.util.HashSet;
import java.util.Set;

public class Test{
    public static void main(String[] args){
        Set<String> set = new HashSet<>();
        set.add("hello");
        set.add("world");
        //重复元素
        set.add("hello");
        set.add(null);
        set.add("java");
        System.out.println(set);
    }
}

1.2.2 TreeSet----有序存储—底层基于红黑树
不允许元素重复，并且按照升序排序，不允许存放null

package www.java.test;

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

public class Test{
    public static void main(String[] args){
        Set<String> set = new TreeSet<>();
        set.add("A");
        set.add("C");
        //重复元素
        set.add("A");
        set.add("B");
        System.out.println(set);
    }
}