集合

1、集合

2、集合的特点

• (1) Collection 接口存储一组不唯一，无序的对象
  (2) List 接口存储一组不唯一，有序（插入顺序）的对象
  (3) Set 接口存储一组唯一，无序的对象
  (4) Map接口存储一组键值对象，提供key到value的映射

3、Collection接口下的两大集合分类：

• List : 表示不唯一，且有序的集合
  ArrayList ：相当于一个可变长度的数组
  get(int i) : 根据下标获取集合中的元素
  add(int i,Object o) : 在执行的下标位置添加元素
  remove(int i) : 删除指定下标的元素
  set(int i,Object o) : 替换指定下标的元素
  indexOf(Object p) /lastIndexOf():查询指定元素的起始位置
  sort(Comparator c)：根据排序规则，实现集合的排序

4、ArrayList集合的使用（ArrayList集合相当于是一个可变长度的数组）

• size() ： 获取集合的长度
  isEmpty() : 判断集合是否为空（集合内是否存储了元素），空就是长度为0
  contains(Object o) : 判断集合是否包含指定元素，返回boolean，判断规则大部分的实现类是通过equals方法判断
  iterator() : 获取集合的迭代器，用于遍历集合
  Object toArray() : 把集合转换为数组
  add() ：添加一个集合元素
  addAll(Collection c)：添加一个Collection集合
  remove(Object o) : 删除指定的对象
  removeAll(Collection c) : 删除指定集合内匹配的元素
  clear() : 清空集合内的元素

//创建了一个可以存储任意类型的list集合
		ArrayList list = new ArrayList();
		//底层使用Object类型的数组存储所有数据
		list.add("a");
		//初始化时默认创建一个空数组，每次添加时会自动扩容
		list.add("a");
		//可以存储重复的数据add方法默认是新增到数组的末尾
		list.add("a");
		//可以通过add方法指定下标新增，新增的内容插入到指定下标中，之前小标的内容后移
		list.add(2,"b");
		ArrayList list1 = new ArrayList();
		list1.add(1);
		list1.add(true);
		list1.add("hello");
		//可以将其他的Collection类型的集合添加到当前集合内
		list.addAll(list1);
		System.out.println(list);
		//获取集合的元素，可以通过下标
		Object obj = list.get(5);//如果超出了下标，报错？
		//System.out.println(obj);
		//可以通过for循环遍历集合
		//size()用于获取集合的长度，集合数组存储的数据的长度
		/*for(int i=0;i<list.size();i++) {
			System.out.println(list.get(i));
		}*/
		//使用foreach遍历
		/*for(Object o : list) {
			System.out.println(o);
		}*/
		
		
		//删除集合里的数据
		Object removeobj = list.remove(4);
		System.out.println("删除的数据为："+removeobj);
		//删除指定的对象，删除第一个符合的元素
		boolean flag = list.remove("a");
		System.out.println(flag);
		list1.add("world");
		list1.add("nihao ");
		//removeAll可以删除指定结合中所有包含的元素
		flag = list.removeAll(list1);
		System.out.println(flag);
		//用于修改指定下标的元素，返回修改之前的数据
		Object setobj = list.set(2, "你好");
		System.out.println("setobj:"+setobj);
		
		//判断集合中是否包含某个元素
		boolean iscontains = list.contains("c");
		System.out.println("是否包含a:"+iscontains);
		//使用迭代器遍历 ，迭代器的意义在于统一所有集合遍历的方式
		//先将数据放到迭代器中
		Iterator it = list.iterator();
		//从迭代器中取出一个数据，那么迭代器中就少一个，直到取完为止
		while(it.hasNext()) {
			Object o = it.next();//得到取出的数据
			System.out.println(o);
		}

5、LinkedList ： 是一个链表结构的集合
由于都实现了List接口，所以它与ArrayList的方法基本上一致，只不过LinkedList多了几个方法，多了的方法都是针对头尾的操作

自定义LinkedList

package day26;

import day26.MyLinkedList.Node;

/**
 * 自定义的LinkedList
 * @author jun
 */
public class MyLinkedList {

	
	 // 链表的头部
	Node first;
	// 链表的尾部
	Node last;
	//标记元素个数
	int size;
	
	public void add(Object t) {
		//新建一个node对象
		Node node = new Node(null, t, null);
		//判断集合中没有元素
		if(last == null) {
			//集合为空，我们新增的元素要设置为第一项
			first = node;
			last = node;
		}else {
			//集合有值，那么我们新增的元素可以添加到末尾处
			last.next = node;  //将尾部节点的下一个指向新增的元素
			node.prev = last; //将新增的元素的上一个指向last
			last = node;  //将链表的尾部指向新增的元素
		}
		size++;
	}
	
	/**
	 * 指定下标插入
	 * @param index
	 * @param obj
	 */
	public void add(int index ,Object obj) {
		 //新增的下标超过了集合的长度，当成是新增到尾部
		if(index>=size) {
			add(obj);
			return ;
		}
		Node temp = first;
		for(int j=0;j<index;j++){
			temp = temp.next;
		}
		//插入的时候要判断是否是首位或最后一位
		//temp就是要插入的位置  temp位置得后移一位，让新的元素插入
		//链表结构得后移就是断开与之前元素得关系
		//先得到之前得元素 
		Node a = temp.prev; 
		Node c = new Node(a,obj,temp); 
		if(a!= null) {
			a.next = c;
		}else {
			first = c;
		}
		temp.prev = c;
	}
	
	public void remove(int index) {
		//当下标超过长度时，默认删除最后一位
		if(index >= size) {
			Node prev = last.prev;
			prev.next = null;
			last = prev;
			return;
		}
		
		Node temp = first;
		for(int j=0;j<index;j++){
			temp = temp.next;
		}
		/*	if(temp.prev == null) {
				
			}*/
		if(index <= 0) {
			Node next = temp.next;
			next.prev = null;
			first = next;
		}else {
			Node prev = temp.prev;
			Node next = temp.next;
			prev.next  = next;
			next.prev = prev;
		}
		
	}
	
	/**
	 * 根据下标获取
	 * @param i
	 * @return
	 */
	public Object get(int i) {
		Node temp = first;
		for(int j=0;j<i;j++){
			temp = temp.next;
		}
		return temp.value;
	}
	
	
	//linkedlist底层使用的链表结构
	//链表元素类
	public class Node{
		Object value; //存储的数据
		Node prev;   //前一个
		Node next;  //后一个
		
		public Node(Node prev,Object value,Node next) {
			this.prev = prev;
			this.value= value;
			this.next = next;
		}
	}
}

6、Set : 存储无序且唯一的数据

• HashSet ：使用Map集合来存储数据
  ① 通过hashcode()方法与equals（）方法来确定数据的唯一性
  ② 存储重复的数据会覆盖

1、TreeSet（二叉树实现的）

• 有序唯一，要求存储的元素必须实现Comparable接口
  该集合是通过compareTo方法来确定数据的唯一性，返回0表示数据重复

2、HashMap集合常用的方法

• V put(K,V) : 将数据存入集合中 ，会返回Value
  V get（K）:根据键获取值
  Set keySet():获取所有的键
  Collection values():获取所有的值
  Set entrySet():获取键值对集合
  remove(Object key):根据key删除数据
  replace(Object key,Object value):根据key替换值
  containsKey（Object key） : 判断键是否存在
  containsValue ： 判断值是否存在

3、集合里使用的数据结构

• (1) 所有的程序就是数据结构和算法的集合
  (2) 数据结构有哪些？
  ① 栈 ：先进后出
  ② 队列 ： 先进先出
  ③ 数组 ： 有序，可通过下标操作，遍历效率高，新增和删除效率低
  ④ 链表 ： 有序，新增和删除数据效率高，遍历效率慢
  ⑤ 树 ：二叉树、平衡树、红黑树