常见的数据结构及特征

ArrayList：既然是一串连续的存储结构，所以方便查找。新增和删除操作的时候，是要有移动位置的操作。所以ArrayList适用于存储，查询操作比较频繁的数package Test;

package Test;

import java.util.ArrayList;

/*有序,可重复
		有指定下标,添加顺序和取出顺序一致
		ArrayList : 底层是个Object[] 数组,随机查询效率高,随机删除效率低,默认初始化时10,扩大之后是原来的1.5倍,并且是第一次添加数据的时候进行默认长度设置,只new的时候,不添加数据,则长度为0, 等于是 Object[]  elementData= {};  长度为0
		LinkedList : 底层是双向链表,随机查询效率低,随机删除效率高
		Vector : 已经过时,属于线程安全,而ArrayList是Vector的升级版 , 默认初始化是10,扩大之后是原来的2倍
 */
public class Collection_03_Arraylist {

	public static void main(String[] args) {
		ArrayList list = new ArrayList();
		// 尾部添加
		list.add(1);
		list.add(2);
		list.add(5);
		// 添加到指定位置
		list.add(0, 8);
		// 更改指定元素的值
		list.set(1, 11);
		// get : 根据索引 获取值
		System.out.println(list.get(1));
		// 个数
		System.out.println(list.size());
		// 是否包含(调用equals)
		System.out.println(list.contains(2));
		System.out.println(list);
		// 注意 : remove有方法重载,一个int (要删除的索引)  一个 object(要删除的数据)
		// 这个2 是删除的索引,并不是要删除2这个元素
		list.remove(1);
		// 这样才是删除2这个数据
		list.remove(new Integer(2));
		System.out.println(list);
	}

}

LinkedList：LinkedList底层使用的是双向循环链表数据结构,不适合存储需要大量查询操作的数据存储，插入就比ArrayList方便，不需要进行换位操作。

package Test;

import java.util.LinkedList;

/*队列 : 先到先得  , 栈 : 先进后出
 * 
 * 链表 : 链表中保存节点,而一个节点有三部分 1 添加的数据 2 上一个节点 3 下一个节点
 * 	链表是没有下标的,只能从头一个个找,所以查找慢
 * 	由于链表中 都是引用指向,所以删除快, 比如 3个元素 分别是 1,2,3  要删除 2  , 
 * 		只需要让 1 的下一个 = 1 的下一个的下一个 然后 3 的上一个 = 1的引用 
 * 
 * LinkedList是模拟的双向链表,就是  1 可以找到 2  , 2 也能找到 1
 * 
 * 添加指定位置 / 获取指定位置的值 : 可以传入索引,但是其实不是下标,而是LinkedList封装的方法,帮我们自动循环去找
 * 			本质 还是循环,因为链表是非连续的空间,只能从头一个一个找,
 * 			只不过LinkedList模拟了下标访问的方式,对我们使用起来,提供了便捷
 */
public class Collection_05LinkedList {

	public static void main(String[] args) {
		LinkedList linkedList = new LinkedList();
		// 尾部添加 true
		linkedList.add(1);
		// 尾部添加 void
		linkedList.addLast(2);
		// 插入指定位置
		linkedList.add(0,2);
		// 首部添加 void
		linkedList.addFirst(2);
		// 首部添加 void
		linkedList.push(3);
		// 尾部添加 true
		linkedList.offer(22);
		// 首部添加 true
		linkedList.offerFirst(1);
		// 尾部添加 true
		linkedList.offerLast(4);
		
		// 本质就是在调用两个方法 : linkLast 和 linkFirst
		// 根据下标获取
		System.out.println(linkedList.get(0));
		System.out.println(linkedList.get(0));
		// 获取首元素
		System.out.println(linkedList.getFirst());
		// 获取尾元素
		System.out.println(linkedList.getLast());
		// 删除第一个元素,并返回该元素
		linkedList.pop();
		// 删除最后一个元素,并返回该元素
		linkedList.poll();
		// remove重载  int是根据索引删除, Object 是根据内容删除
		linkedList.remove(1);
		linkedList.remove(  new Integer(22) );
	}

}

TreeSet：底层数据结构是二叉树有序的，并且没有重复元素。可以指定一个顺序

package Test_01;

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

/**16
 * 1 要添加的原始 实现 java.lang.Comparable接口 并实现compareTo方法
 * 2 写一个比较器类,实现java.util.Comparator比较器接口
 * 
 * 很多常用的类中都实现了Comparable接口 并实现compareTo方法
 * 	比如 Integer , String , Date等
 * 
 * 所以我们自定义类型的时候,一定要弄比较器类 
 */
public class TreeSet_02 {

	public static void main(String[] args) {
		Set set=new TreeSet();
		set.add(new User(19,"saf"));
		//重复就不会添加
		set.add(new User(29,"saf"));
		set.add(new User(19,"saff"));
		set.add(new User(14,"sf"));
		System.out.println(set);
	}
}

class User implements Comparable {
	int age;
	String name;

	public User(int age, String name) {
		super();
		this.age = age;
		this.name = name;
	}
	@Override
	public String toString() {
		return "User [age=" + age + ", name=" + name + "]";
	}

	@Override
	public int compareTo(Object o) {
		//this是要添加的元素
		//o是集合中的每一个元素
		//返回值是0说明重复，不添加
		//返回值大于0的值，说明要添加的这个元素比集合中的元素大，往后放
		//返回小于0的值，说明要添加的元素比集合中的元素小，往后放
		if(o instanceof User){
			User user=(User)o;
			int result=age-user.age;
			if(result==0){
				if(name.equals(user.name)){
					return 0;
				}else{
					return 1;
				}
			}
			return result;
		}
		return 0;
	}
}

HashSet：链表和红黑树,元素没有顺序(底层用的是HashMap，HashMap本身中的元素度没有顺序)、元素不能重复。

HashMap：链表和红黑树,Null可以做主键，但只能有一个，可以有多个Value为Null。适用于在Map中插入、删除和定位元素。

package Test_01;

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class Map_02 {
	/**
	 * 17 map和集合虽然没有关系,但是操作几乎是一样的
	 * 
	 * 添加 : Object put(Object key , Object value); void clear() : 清空map int
	 * size() boolean isEmpty()
	 * 
	 * 
	 * Object get(Object key) : 根据key 获取value Collection values() :
	 * 获取所有的value,返回集合 boolean containsKey(Object key) : 判断是否包含某个key boolean
	 * containsVallue(Object value) : 判断是否包含某个value Set keySet() :
	 * 把map中所有的key取出,返回set Set entrySet() : 把键值对保存entry中,以set形式返回 V
	 * remove(Object key) : 根据key删除映射,返回value值
	 * 
	 * map不能直接遍历
	 * 
	 */
	public static void main(String[] args) {
		Map<String,Integer> map=new HashMap<String,Integer>();
		map.put("a", 1);
		map.put("b", 2);
		map.put("c", 7);
		map.put("d", 4);
		map.put("e", 5);
		System.out.println(map);
		//keySet
		Set<String> keys=map.keySet();
		for(String key:keys){
			Integer value=map.get(key);
			System.out.println(key+":"+value);
		}
		
		//entrySet
		Set<Entry<String,Integer>>entrys=map.entrySet();
		for(Entry<String,Integer>entry:entrys){
			String key=entry.getKey();
			Integer value=entry.getValue();
			System.out.println(key+":"+value);
		}
	}
}

TreeMap：有序的，适用于按自然顺序或自定义顺序遍历键（key）。

LinkedHashMap：有序、Key和Value都允许空、Key重复会覆盖、Value允许重复

Vector：Vector是线程安全的，可以由多个线程访问一个Vector对象。但当一个线程访问的话，保证线程安全会消耗一定的资源。一个线程访问就无需考虑是否线程安全的问题，使用ArrayLis.

Map转list 并以value排序

package Test_01;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

	public class MapToList {
		public static void main(String[] args) {
			Map<String, Integer> map = new HashMap<String, Integer>();
			map.put("aa", 3);
			map.put("bb", 2);
			map.put("dd", 1);
			map.put("cc", 12);
			
			// 转换为set
			Set<Entry<String, Integer>> set = map.entrySet();
			//转换为list
			List <Entry<String, Integer>> list = new ArrayList<Map.Entry<String,Integer>>(set);
			//排序
			Collections.sort(list,new Comparator<Entry<String, Integer>>() {

				@Override
				public int compare(Entry<String, Integer> o1,
						Entry<String, Integer> o2) {
					return o1.getValue() - o2.getValue();
				}
			});
			// 遍历
			for (Entry<String, Integer> entry : list) {
				System.out.println(entry);
			}
		}
	}