D-16 集合

1 数组封装：

        数组操作，比较复杂也不能进行添加和删除操作，需要添加或删除操作时候需要新建新数组，复制 或移位，太麻烦，所以 我们对添加和删除操作进行封装

public class Array {
	/**
	 * 封装的数组
	 */
	private Object[] elements;
	/**
	 * 数组中已有元素个数
	 */
	private int size = 0;

	public Array() {
		// 数组默认长度为 10
		elements = new Object[10];
	}

	/**
	 * 获取元素个数
	 * 
	 * @return
	 */
	public int size() {
		return size;
	}

	/**
	 * 根据索引获取数据
	 * 
	 * @param index
	 * @return
	 */
	public Object get(int index) {
		// 如果index >= size 说明 不存在
		if (index >= size) {
			throw new ArrayIndexOutOfBoundsException(index);
		}
		return elements[index];
	}

	/**
	 * 更改
	 * 
	 * @param index
	 * @param element
	 */
	public void set(int index, Object element) {
		// 如果index >= size 说明 不存在
		if (index >= size) {
			throw new ArrayIndexOutOfBoundsException(index);
		}
		elements[index] = element;
	}

	/**
	 * 向数组中添加元素
	 * 
	 * @param element
	 */
	public void add(Object element) {
		// 1 判断数组中是否满了
		if (size == elements.length) {
			// 1.2 满了 就扩容,复制数组,再放进去
			// 扩容为原来的二倍
			Object[] newArr = new Object[size << 1];
			// 数组复制
			System.arraycopy(elements, 0, newArr, 0, size);
			// 赋值
			elements = newArr;
		}
		// 添加进去,size++
		elements[size] = element;
		size++;
	}

	/**
	 * 删除指定元素
	 * 
	 * @param index
	 */
	public void remove(int index) {
		// 如果index >= size 说明 不存在
		if (index >= size) {
			throw new ArrayIndexOutOfBoundsException(index);
		}
		// 移位
		for (int i = index; i < size - 1; i++) {
			elements[index] = elements[index + 1];
		}
		// 最后一位赋值为null
		elements[size - 1] = null;
		// 个数-1
		size--;
	}

2 集合

          Java集合 是使程序能够存储和操作元素不固定的一组数据，所有java集合类 都位于java util包中

 Collection 是集合，俩个直接子接口是 List 和set

List 特性：  有序的，可重复的，并且能够保证数据的添加顺序和取出顺序一致

Set 特性  ： 无序的，不可重复的，不能保证数据的添加和取出顺序一致

  List 有三个子类：

                ArrayList ： 底层是数组，  查询和更改效率非常高

                LinkedList: 底层是双向链表，添加和删除效率高一些

                Vector ： 底层也是数组，  是线程安全， 已废弃 ，不推荐使用  被Arralist 替代

set 有 俩个子类：

        HashSet  ： 底层为    散列表

        TreeSet :    底层 为二叉树

使用方法

public static void main(String[] args){
		//创建一个ArrayList对象
		Collection collection = new ArrayList();
		//判断是否为空
		System.out.println(collection.isEmpty());
		// 已有元素个数
		System.out.println(collection.size());
		//添加，如果添加一个基本类型，则会进行自动装箱对应的包装类类型，然后在发生多态转型为Object类型
		collection.add(1);
		collection.add(2);
		collection.add(3);
		collection.add("张");
		System.out.println(collection.size());
		System.out.println(collection);
		
		//删除指定元素， 是根据数据删除！！！不是索引
		collection.remove("张");
		System.out.println(collection);
		
		//转为数组
		Object [] arr = collection.toArray();
		for(int i =0;i <arr.length;i++){
			System.out.println(arr[i]);
		}
		//清楚集合中的数据
		collection.clear();
		System.out.println(collection.size());
	}

3 Iterator 迭代器

         迭代器是一种模式，它可以使遍历和被遍历的对象相分离，我们就不会在关心 什么数据结构，如何进行存储得了，只要拿到了迭代器对象就能遍历

迭代器 中有三个方法： 

                boolean hasNext(); 判断游标下是否还有元素，默认指向顶端，并没有指向第一个元素

                E next（） ： 将迭代器游标向下移动一位，并取出该元素

                remove（） ； 删除当前执行的元素，会把集合中的也删除

而且迭代器一旦创建，集合不能删除 和添加 。如果要进行添加和删除，需要重新生成迭代器

迭代器简写方法   就是 增强for循环    forEach

 注意！！！！！！：

        contains(Object o) : 判断是否包含某个元素

        remove（Object o） :删除后指定元素 

       这俩个方法 底层都会取调用equals 方法进行比较

3.1 forEach 

        会把数组中每个元素赋值给变量element  不是下标

4 List

public static void main(String[] args){
		List list = new ArrayList();
		list.add(2);
		list.add(44);
		list.add(11);
		list.add(56);
		list.add(54);
		//对 list进行升序排序
		Collections.sort(list);
		System.out.println(list);
	}

public static void main(String[] args){
		List list = new ArrayList();
		//集合中只能保存引用数据类型，如果添加的是基本类型的话
		//会先进性自动装箱为对应的包装类，然后发生多态转型为Object类型
		//add(E e):尾部添加
		list.add(1);
		list.add(2);
		//add(int index,E e): 把元素插入到指定位置，非特殊情况，尽量不能，因为其他元素需要向后移位
		list.add(0, 3);
		//set(int index,E e): 更改指定索引的元素值
		list.set(1, 4);
		//get(int index): 获取对应索引的元素值
		System.out.println(list.get(0));
		//list 中 remove方法有重载
		//如果传入引用的是 int值，则是删除对应索引的元素，根据索引删除
		//如果传入引用类型的值，则是删除对应的类型，根据元素值删除
		//删除索引为0的元素
		list.remove(0);
		//删除 值为4 的元素
		list.remove(new Integer(4));
		System.out.println(list);
	}