集合

一、注解

类的克隆和序列化要实现接口，这两个接口中没有方法

浅拷贝：拷贝类，不拷贝类的属性，

深拷贝：拷贝类的同时，拷贝类的属性

在java中，我们常认为相同的类用友相同的hashcode

泛型

二、集合

集合分为两大类：单列数据 collection 双列数据 map<key，value>

collection：

​ 有序的数据，可以重复的 list

​ 无序的收据，不可以重复的 set

接口是一种标准

Collection:单列的值

​ List:有序不唯一，底层使用的时动态数组来保存数据的，List集合中的元素是存在下标的，是有固定的顺序，元素可以重复。

​ ArrayList:底层是一个Object类型的数组

​ 创建的时候，空的数组

​ 第一次添加元素的时候，初始化一个长度为10的数组

​ 增长是原来的1.5倍。循环遍历元素的效率高

​ LinkedList:底层是双向链表，插入和删除元素的效率高

​ Vector:底层是一个Object类型的数组，创建的时候。初始化一个长度为10的数组，

​ 增长是原来的两倍

​ Map:底层使用的时key-value这种格式来保存数据，并且是无序的，key是不允许重复的。

​ HsahMap:常用的一个实现类,线程不安全的，效率高

​ LinkedHashMap:有序的，按照存储的顺序取值

​ TreeMap：按照key进行排序的 不能存放null的key

​ HashTable：线程安全类，效率很低，不适用。不能存放null的key和value

三、List集合操作的API

3.1、List集合的创建

List list1 = new ArrayList();
List list2 = new Vector();
List list3 = new LinkedList();

3.2、List集合API操作

给List集合添加元素（add,addAll）

list1.add("admin");
list1.add(10);
list1.add('a');
list1.add(true);
list1.add(2,"guest");

List smallList = new ArrayList();
smallList.add(100);
smallList.add(1000);
list1.addAll(smallList);
list1.addAll(4,smallList);

修改指定元素、获取元素（set、get）

//修改指定元素
list.set(1,"x");
//通过下标获取元素
Object obj = list1.get(1);

List容器中的包含与搜索(contains、containsAll、indexOf、lastIndexOf)

//检查是否包含某个元素
boolean is = list1.contains(100);
//检查是否包含某个指定的集合
is = list1.containsAll(smallList);
//搜索指定的元素，返回下标（没有则返回-1）;
int index = list1.indexOd("x");
//反向搜索
index = list1.lastIndexOf('a');

容器迭代器的使用(iterator、listiterator)

所谓迭代器，就是获取容器中元素的一种方式而已：它存在自己比较固定的操作模式

//使用迭代器来获取元素
Iterator it = list1.iterator();
while(it.hasNext()){
    Object value = it.next();
}
//List容器有自己的专属迭代器----这个迭代器的操作方法比较灵活
ListIterator listIt = list1.listIterator();
//listIt.hasNext()  判断是否存在数据(下一行)
//listIt.hasPrevious()  判断是否存在数据(上一行)
while(listIt.hasPrevious()){
    //获取下一行数据
    Object obj = listIt.next();
    //向上进行数据获取
    //listIt.previous()
}

List容器中元素的移除(remove、removeAll)

// 通过指定的元素进行移除
/*
* boolean is = list1.remove("b"); System.out.println(is);
* System.out.println(list);
*/
/*boolean is = list1.remove(new Integer("1")); //复合引用类型的Integer
代表的是移除指定的元素，而不是下标，下标是一个int类型的值；
System.out.println(is);
System.out.println(list);*/
//移除指定的容器
boolean is = list.removeAll(smallList);
System.out.println(is);
System.out.println(list);

如何在List容器中删除自定义的对象元素

package com.it.www.beans;
public class Person {
private String name;
private Integer age;
public Person() {
super();
}
public Person(String name, Integer age) {
    super();
    this.name = name;
    this.age = age;
}
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
public Integer getAge() {
	return age;
}
public void setAge(Integer age) {
	this.age = age;
}
//实现的是对象中的属性的值的比较
@Override
    public boolean equals(Object obj) {
        if(obj instanceof Person){
            Person person = (Person)obj;
            if(this.name.equals(person.name)&&this.age==person.age){
                return true;
            }
        }
    return false;
    }
}
public class Demo3 {
    private static List list = new ArrayList();
    private static List smallList = new ArrayList();
    private static Person p1 = new Person("admin",30);
    private static Person p2 = new Person("guest",40);
    static {
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        smallList.add(1);
        smallList.add(2);
        smallList.add(3);
        list.addAll(smallList);
        list.add(p1);
        list.add(p2);
	}
//针对我们自定义的对象的移除
	public static void test2(){
		System.out.println(list);
		//如何来移除p1这个元素呢？
		//list.remove(p1);
		//在移除对象类型的元素时，内部使用的是equals方法来实现的；
		Person px = new Person("admin",30);
		//当我们重写了Person类中的equals方法（实现的是内容信息的比较）后，通过px可以正常的删除p1这个对象了。
		//结论：说明在List集合中删除指定的自定义对象元素的时候，确实内部是通过equals方法来处理的；
		list.remove(px);
		System.out.println(list);
	}
}

List容器中保留指定容器元素（retainAll）
List容器中的元素截取为另一个List容器
	List list2=list.subList(1, 4); ---[1 4) 下标范围。
List容器转化为Object[ ]
	Object[ ] os=list.toArray();
判断List容器是否为空
	list . isEmpty ();
清空List容器中的所有元素
	list .clear();
List容器中元素的个数
	list .size();

3.3、重点掌握的方法

1、如何创建List容器；
2、如何向容器中添加元素；
3、如何遍历元素 、查找 、 修改元素 、 删除元素 ；
4、List容器的转换----to数组，截取----subList ；
5、作为集合容器的常规操作（清除元素 、 判断是否为空 、 长度大小等）；

3.4、链表结构

链表结构的特性：
1、可以很好的保证一个固定的顺序；
2、链表结构保存的数据便于高效的插入元素和删除元素；
3、链表结构保存的数据遍历的效率是相对较低的；

3.5、LinkedList实现类

LinkedList的特性：
1、保证了固定的位置；
2、实现频繁的插入和删除的时候，效率较高；
3、进行遍历的时候，效率较低；

3.6、Vector实现类

Vector实现类的底层也是使用的数组结构，存在下标和ArrayList的特性是一样的，卫笃不同的是基于线程同步的，适用于多线程的环境中，是可以保证数据的安全

public static void main(String[] args) {
        Vector list = new Vector();
        list.addElement("a");
        list.addElement("b");
        list.addElement("c");
        list.addElement("d");
        System.out.println(list);
        Object value = list.elementAt(1);
        System.out.println(value);
            //返回的是一个枚举对象
        Enumeration en = list.elements();
        //有没有更多的元素
        while(en.hasMoreElements()){
            Object obj = en.nextElement();
            System.out.println(obj);
        }
}

3.7、List接口实现类之间的区别

ArrayList：底层采用的数据结构是数组结构。
特点：查询速度快，增删速度稍慢,线程不同步(适用于单线程的环境中)。容量的增长比例为自身的50%。

Vector：底层采用的数据结构是数组结构。
特点：早期版本中使用的一个容器，基于线程同步（适用于多线程的环境中）。容量的增长比例为自身的
100%。现被ArrayList替代。

LinkedList：底层采用的数据结构是链表结构。
特点：增删速度快，查询速度慢。线程不同步（适用于单线程的环境中）。

四、Set集合