JavaSE探赜索隐之乾坤袋（集合）

集合的概念

说道集合就得先谈谈数组。数组是同一类元素的有序集合，但数组有其局限性，那就是定义之后长度固定，且里面只能存一种类型的元素。我们在开发中经常会使用到长度可变的数据集合，数组不能满足要求，我们就需要长度能动态变化的容器来保存数据。这容器就是集合。

集合API

集合类位于java.util包中。是java数据结构的实现，由许多接口、抽象类、实现类构成。

Collection接口

collection接口定义了存取一组对象的方法，其子接口List、Set分别定义了对象的存储方式。

Set中的数据对象没有顺序，不可以重复。

List中的数据对象有顺序，可以重复。

Colletion接口中定义的共有的方法：

返回值类型	方法名	功能
boolean	add（Object element）	添加元素
boolean	addAll（Collection c）	添加一个集合到调用集合后
boolean	remove（Object element）	删除元素
boolean	removeAll（Collection c）	删除集合中另一个集合的全部元素
void	clear（）	清空集合
int	size（）	集合的长度
boolean	isEmpty（）	集合是否为空
boolean	contains（Object element）	判断元素是否是集合的子集
boolean	containsAll（Collecton c）	判断真子集
boolean	retainAll（Collecton c）	求交集

public class CollectionDeno {public static void main(String[] args) {Collection c = new ArrayList();ArrayList list = new ArrayList();list.add("tb");list.add("wph");//System.out.println(c.add("pdd"));//1.给集合添加元素。返回值：boolean，始终是true。c.add("tb");c.add("tm");//c.remove("tb");//从集合删除元素。返回值：boolean，集合中有该元素返回true，否则返回false。//System.out.println(list.removeAll(c));/*条件删除语句c.removeIf(new Predicate() {//实现抽象接口要用匿名内部类.@Overridepublic boolean test(Object o) {return o.equals("tm");//返回判断条件.}});*/System.out.println(c);// c.contains("tb");//判断集合中是否包含元素。返回值：boolean//System.out.println(c.containsAll(list));//判断该集合是否包含另外一个集合.//System.out.println(Arrays.toString(c.toArray()));//将集合转化成数组.//System.out.println(Arrays.asList(c.toArray()));//将数组转化成集合.//System.out.println(c.size());//集合长度.System.out.println(c);}}

List接口、实现类

List接口继承了Collection接口，有三个实现类ArrayList、LinkedList、Vector。

ArrayList底层是数组存储。
实现长度可变数组，遍历元素效率比较高。

优点: 底层数据结构是数组,长度可变的，查询快，增删慢。
缺点: 线程不安全，效率高

  package day2;
/*ArrayList底层是数组实现的.*/import java.util.ArrayList;public class ArrayListDemo extends ArrayList {public static void main(String[] args) {ArrayList list = new ArrayList();//无参构造方法,默认10行.ArrayList list1 = new ArrayList(15);//有参构造方法,指定初始容量.ArrayList list2 = new ArrayList(list1);//有参构造方法,里面可以将集合直接传进去,但是只能传collection(单列)接口下的.list.add("a");list.add("s");list.add("s");list.add("d");list.add("f");//装满之后,扩容为原来的1.5倍.在调用add时,会判断原来的集合长度是否够用,不够的话调用group()复制原来的集合并添加新的元素.;list.add(0,"s");//给指定位置添加元素.//System.out.println(list.get(2));//获取指定索引的元素.//System.out.println(list.indexOf("b"));//获取指定元素的索引.//System.out.println(list.lastIndexOf("s"));//获取最后一次出现的指定元素索引.list.remove(2);list.set(1,"n");list.sort(new StringC());//排序,括号中传入比较器.(比较器类的构造方法.)}}

LinkedList底层是链表。插入、删除效率比较高。

优点: 底层数据结构是链表(双向链表)，查询慢，增删快。
缺点: 线程不安全，效率高

package day2;import java.util.LinkedList;
import java.util.List;public class LinkedListDemo {public static void main(String[] args) {LinkedList list =  new LinkedList<>();list.add("a");list.add("a");list.add("a");list.add("a");list.add("a");//调用Linkalst()list.addFirst("b");list.addLast("c");//调用Linklast()System.out.println(list);list.get(2);//获取指定(索引)序号的元素.list.getFirst();list.getLast();list.lastIndexOf("a");//获取最后一次出现该元素的索引.list.remove("a");//删除首个3出现的该元素.如果不填,默认为第一个元素.list.set(2,"s");//修改第二个元素为s.System.out.println(list);List list1 = list.subList(3,4);//将集合中部分元素截取出来组成新的集合.(List)System.out.println(list1);}
}

Vector底层是数组存储，添加同步锁，线程安全。

优点: 底层数据结构是数组，查询快，增删慢。
缺点: 添加同步锁, 线程安全，效率低

//Vector里面的方法用synchronized修饰,是线程安全的.
/*以add()方法为例演示Vector底层方法源码。
*/
public synchronized boolean add(E e) {modCount++;ensureCapacityHelper(elementCount + 1);elementData[elementCount++] = e;return true;}

集合的迭代。

 //方法一/*删除元素后集合长度发生变化。*//*for (int i = 0; i < list.size(); i++) {if(list.get(i).equals("a")){list.remove(i);i--;}}System.out.println(list);*///方法二/*不允许在循环时对集合中的元素进行操作。没有break会抛出异常ConcurrentModificationException.*/for (Object obj:list) {if(obj.equals("a")){list.remove(obj);//break;//允许删一次.将循环封装起来,不允许修改变量i.没有break会抛出异常ConcurrentModificationException.}//System.out.println(list);如果第一个元素为a,则后面全部跳过，所以该步骤无效。}System.out.println(list);//方法三/*Iterator     集合迭代器(内部类可以对外部的元素进行操作.)*/Iterator iterator = list.iterator();while (iterator.hasNext()){//检测集合中是否还有未迭代的元素.Object obj = iterator.next();System.out.println(obj);//iterator.remove();//只能使用迭代器中的删除方法.if (obj.equals("a")){iterator.remove();}}

Set接口实现类

（不允许有重复元素。）

hashSet
不是按照添加的元素进行排序的。
底层数据结构是hash表加链表。

向hashset中添加元素时如何判定是否是重复元素？
【效率】首先会获得添加内容的hash值，再经过hash（）计算出添加元素的hash值，判断原集合中是否存在。
【安全】当hash值相同时会调用equals（）比较内容是否相等。

public class Student implements Comparable<Student> {private int num;private String name;private int age;public int getNum() {return num;}public void setNum(int num) {this.num = num;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Student(int num, String name, int age) {this.num = num;this.name = name;this.age = age;}/*当hash值出现重复时,会调用eauals方法,进行内容判断效率第,安全*/@Overridepublic boolean equals(Object o) {if (this == o) return true;if (!(o instanceof Student)) return false;Student student = (Student) o;return num == student.num &&age == student.age &&Objects.equals(name, student.name);}/*重写Object类中的hashCode(),来自己操作对象中包含的内容计算hash值效率高,会出现重复*/@Overridepublic int hashCode() {return Objects.hash(num, name, age);}@Overridepublic String toString() {return "Student{" +"num=" + num +", name='" + name + '\'' +", age=" + age +'}';}//以学号排序@Overridepublic int compareTo(Student o) {return this.num-o.num;}}

public static void main(String[] args) {//HashSet无序  不按照输入顺序  有自己特定的方法//public native int hashCode();  会调用此方法HashSet<String> hs = new HashSet<>();hs.add("a");hs.add("a");hs.add("b");hs.add("呵呵");hs.add("嘻嘻");System.out.println(hs);HashSet<Student> h = new HashSet<>();Student s1 = new Student(101,"tom",2);Student s2 = new Student(101,"tom",26);Student s3 = new Student(102,"jim",23);Student s4 = new Student(103,"bom",14);h.add(s1);h.add(s2);h.add(s3);h.add(s4);System.out.println(h);}

TreeSet

TreeSet底层是二叉树。（红黑树是一种自平衡的二叉树。）
按照元素添加顺序进行排序。

不可存储重复元素。

向TreeSet中添加元素时底层会调用compareTo（）比较大小。因此存储的对象必须实现comparable接口。

public static void main(String [] args){TreeSet<String> t1 = new TreeSet();t1.add("l");t1.add("o");t1.add("v");t1.add("e");System.out.println(t1);TreeSet<Student> t2 = new TreeSer();Student s1 = new Student(001,"铁男",20);Student s2 = new Student(002,"陆伟",21);Student s3 = new Student(003."赵红兵",22);t2.add(s1);t2.add(s2);t2.add(s3);System.out.println(t2);}

Map接口

**双列存储，键值对。**键不能重复，值可以重复。如果键重复，后面的键会覆盖掉前面已经添加进去的键的值。

map中常用的方法：

V put(K key,V value)//添加键值对，返回value类型
V remove(Object key)//删除键值对
void clear()//删除所有键值对
boolean containsKey(Object key)//判断该集合中是否包含有此键的键值对。
boolean containsValue(Object value)
boolean isEmpty()
int size()
V get(Object key)//返回到指定键所映射的值，
Set<K> keySet()//返回此地图中包含的键的Set视图。
Collection<V> values()
Set<Map.Entry<K,V>> entrySet()

Map的实现类有三个：HashMap、TreeMap、HashTable。

Treemap是有序的HashMap、HashTable是无序的。

hashtable的方法时同步的，hashmap的方法是不同步的。因此前者线程安全，后者不安全。

hashmap效率更高，hashtable效率低。

hashtable不允许null值，hashmap允许null值。

public static void main(String []args){HashMap<Integer,String> map1 = new HashMap<Integer,String>();map.put(1,"Tom");map.put(2,"Bob");map.put(3,"Alan");System.out.println(map);HashMap<String,String> map2 = new HashMap<String,String>();map2.put("姓名：","五五开");map2.put("年龄：","26");map2.put("爱好：","给阿姨倒卡布奇诺。");System.out.println(map2);System.out.println(map2.remove("姓名"));//删除，返回布尔类型System.out.println(map2.get("年龄："));//获取信息，返回value类型System.out.println(map2.containsKey("姓名："));System.out.println(map2.contiansValue("26"));System.out.println(map2.size());System.out.println(map2.isEmpty());map2.clear();}

map集合的遍历
- 方式1：根据键找值
  获取所有键的集合
  遍历键的集合，获取到每一个键
  根据键找值
- 方式2：根据键值对对象找键和值
  获取所有键值对对象的集合
  遍历键值对对象的集合，获取到每一个键值对对象
  根据键值对对象找键和值