Java中集合框架包括Collection接口、Set接口、List接口、Map接口，已经常用的它们的实现类，简单的JDK源码分析底层实现
集合框架：
Java语言的设计者对常用的数据结构和算法做了一些规范（接口）和实现（实现接口的类）。所有抽象出来的数据结构和操作（算法）统称为集合框架。
程序员在具体应用的时候，不必考虑数据结构和算法实现细节，只需要用这些类创建一些对象，然后直接应用就可以了，这样就大大提高了编程效率。
集合框架常用的内容有：
集合框架接口：
Collection：集合的根结点，元素是Object，没有实现类。存储的对象可以重复，但是没有顺序！
常用方法：
add(E e) ：向集合中添加一个元素，返回值类型为：boolean contains(Object o)：判断集合中是否包含某个元素，返回值类型为：boolean remove(Object o)： 移除某一个元素 ，返回值类型为：boolean size() ：返回集合中的有效元素个数，返回值类型为：int
List接口：
元素有顺序有下标，内容可以重复。
常用方法：
void add(int index, E element)：向指定位置处添加元素，无返回值类型 get(int index):根据下标获取对应的元素，返回值类型为：Object indexOf(Object o) ：返回指定元素对应的第一次出现下标，若没有返回-1，返回值类型为：int E remove(int index) ：移除指定下标处对应的元素 E set(int index, E element)：向指定位置处添加元素并且覆盖原来的元素,更改
List接口的三个常用实现类：
ArrayList 数组实现，查询快，增删慢 jdk 1.2 线程不安全的，轻量级实现，运行效率高 LinkedList 链表实现，查询慢，增删快 Vector 数组实现，查询快，增删慢 jdk1.0 线程安全的，重量级实现，运行效率低
下面看一下ArrayList的增删改查操作：
package test; import java.util.ArrayList; public class testArrayList { /** * 集合框架 * 集合：一个对象，用来储存其他多个对象 * ArrayList 能更好的代替数组 * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub ArrayList<String> list = new ArrayList<String>(); //新增 list.add("今天周日"); list.add("明天周一"); list.add(0, "昨天周六"); //修改 list.set(1, "今天周日不上晚自习"); System.out.println(list); //查找 System.out.println(list.get(1)); //删除 System.out.println(list.remove(2)); //遍历 for (String string : list) { System.out.println(string); } } }
linkedList和Vector的增删改查都是一样的
Set接口：
无序无下标，元素不可以重复
set接口的方法都是从Collection接口中继承而来，
add(E e) ：向集合中添加一个元素，返回值类型为：boolean contains(Object o)：判断集合中是否包含某个元素，返回值类型为：boolean remove(Object o)： 移除某一个元素 ，返回值类型为：boolean size() ：返回集合中的有效元素个数，返回值类型为：int
HashSet实现类的简单增删改查以及常用方法：
package test; import java.util.HashSet; import java.util.Iterator; import java.util.LinkedHashSet; import java.util.Set; public class test { /** * Set 元素无顺序 内容不可重复 * 方法全部继承自Collection接口 * 遍历：迭代遍历或者for-each遍历 */ public static void main(String[] args) { //set中判断元素不重复值的是元素内容不重复 //Set<String> set = new HashSet<>(); Set<String> set = new LinkedHashSet<>(); String s1 = new String("aaa"); String s2 = new String("bbb"); String s3 = new String("ccc"); String s4 = new String("aaa"); set.add(s1); set.add(s2); set.add(s3); set.add(s4); //forEach遍历 for (String string : set) { System.out.print(string+"\t"); } System.out.println(); //删除操作 set.remove(s3); //看set中是否包含一个对象 System.out.println(set.contains(s4)); //再次添加 System.out.println(set.add("aaa")); //迭代遍历 Iterator<String> it = set.iterator(); while(it.hasNext()){ System.out.print(it.next()+"\t"); /*Object o = it.next(); System.out.println(o);*/ } } }
TreeSet：
对Set集合进行按照一定顺序进行从小到大排列：
比如说下面的程序，Set中放一个Worker对象，要想使他进行排列必须得先指定他按照什么顺序排列，先先给他一个排序规则这样JVM才知道要怎么做。也就是Worker类要实现 Comparable接口
package test; import java.util.Set; import java.util.TreeSet; public class TestTreeMap2 { public static void main(String[] args) { Set<Worker> set = new TreeSet<Worker>(); //对元素进行升序排列 set.add(new Worker("hansf",38,10.0)); set.add(new Worker("awang",48,20.0)); set.add(new Worker("kangkang",36,30.0)); set.add(new Worker("make",58,40.0)); set.add(new Worker("songtf",58,50.0)); //遍历 for(Worker worker:set){ System.out.println(worker); } } } //要实现Comparable接口才可以进行按照规则排序！！！！！ public class Worker implements Comparable<Worker>{ private String name; private int age; private double salary; public Worker(String name, int age, double salary) { super(); this.name = name; this.age = age; this.salary = salary; } public Worker() { super(); } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public double getSalary() { return salary; } public void setSalary(double salary) { this.salary = salary; } public void work(){ System.out.println(name+"work"); } @Override public String toString() { return "Worker [name=" + name + ", age=" + age + ", salary=" + salary + "]"; } return false; } else if (!name.equals(other.name)) return false; if (Double.doubleToLongBits(salary) != Double .doubleToLongBits(other.salary)) return false; return true; } @Override public int compareTo(Worker o) { // 比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。 //以年龄为例 if(this.age<o.getAge()){ return -1; }else if(this.age==o.getAge()){ if(this.salary<o.getSalary()){ return -1; }else if(this.salary==o.getSalary()){ return 0; }else{ return 1; } }else{ return 1; } } }
Map集合
Map集合的一个元素是由一个键(key)和一个值(value)组成的
key不允许重复，value允许重复
Map集合常用方法：
V put(K key, V value) ：向集合中添加一个元素， 若集合中包含这个key，使用v覆盖掉，并且返回原来key所对应的value V remove(Object key)：根据key删除集合中元素，并且返回删除的value size()：获取集合中有效的键值对个数 boolean containsKey(Object key) ：如果此集合包含指定键所对应的键值对，则返回 true。 boolean containsValue(Object value) ： 如果集合中包含对应的value 则返回true
遍历方式
①键遍历 能够获取到键和值
1.键遍历
获取所有的key对应的set集合 Set keySet()
Set<Integer> set = map.keySet();
循环遍历set集合 获取key 还可以根据key获取对应的value
for(Integer key:set){ String value = map.get(key); //根据键获取值 System.out.println(key+"----"+value); //获取所有的key }
2值遍历 只能够获取到值（value）
获取所有的value 存放在集合中
Collection<String> values = map.values();
遍历集合
for(String value:values){ System.out.println(value); }
键值对遍历 能够获取到键和值
将key和value 封装成一个对象Map.Entry<Integer,String>，把封装的对象存放在集合里面
entrySet() :能够获取 键值对对象 存放的集合
Set<Map.Entry<Integer, String>> set = map.entrySet();
遍历集合 获取对应键和值
for(Map.Entry<Integer, String> entry:set){ Integer key = entry.getKey(); String value = entry.getValue(); System.out.println(key+"---"+value); }
Map的常用方法示例：
package test; import java.util.Collection; import java.util.HashMap; import java.util.Map; import java.util.Map.Entry; import java.util.Set; public class testMap { public static void main(String[] args) { // TODO Auto-generated method stub Map<String, Integer> map = new HashMap<String, Integer>(); //增 map.put("a", 1); map.put("b", 2); map.put("c", 3); map.put("d", 4); map.put("e", 5); //查 System.out.println(map.get("c")); //改 map.put("c", 33); System.out.println(map.get("c")); //删 map.remove("d"); //遍历 System.out.println(map); //查找map中是否包含指定的key System.out.println(map.containsKey("e")); //查找map中是否包含指定的value map.containsValue("5"); //长度 System.out.println(map.size()); System.out.println(); //遍历key System.out.println("遍历key"); Set<String> set = map.keySet(); for (String string : set) { Integer val = map.get(string); System.out.print(string+"\t"+val+"\n"); } System.out.println(); //遍历value System.out.println("遍历value："); Collection<Integer> values = map.values(); for (Integer integer : values) { System.out.print(integer+"\t"); } System.out.println(); System.out.println("遍历键值对："); Set<Entry<String,Integer>> set2 = map.entrySet(); for (Entry<String, Integer> entry : set2) { System.out.println(entry); } } }
Map实现类 之间的区别、
HashMap JDk1.2 线程不安全 轻量级实现 运行效率高 允许key和value为null值
自定义的类型作为key时，必须重写hashCode和equals方法
LinkedHashMap JDK1.2
自定义的类型作为key时，必须重写hashCode和equals方法
保证遍历的顺序跟添加的顺序一致
TreeMap JDK1.2
保证遍历的顺序为key升序排列后的结果
自定义的类型作为key时，需要实现Comparable接口，以及实现compareTo方法
Propertis jdK 1.0
键和值都必须是String类型，通过用来读取配置文件时
HashTable jdK 1.0 线程安全 重量级实现 运行效率低 不允许key和value为null
