Collection集合、Collections工具类
集合框架概述
1.集合、数组都是对多个数据进行存储操作的结构，简称java容器
此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt,.jpg数据库中）
2.数组在存储多个数据方面
(1)特点:一旦初始化后，长度确定；元素数据类型确定，只能操作指定类型的数据；如：String[ ]、Object[ ] arr2
(2)缺点：
a.一旦初始化，长度不可修改；
b.数组提供的方法有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高；
c.获取数组中实际元素个数的需求，数组没有现成的属性和方法；
d.数组有序、可重复，对于无序、不可重复需求，不能满足
java集合分为Collection和Map两种体系
Collection接口：单列数据，定义存取一个一个对象的方法集合
1. List接口:有序，可重复（动态数组）
|--------------------ArrayList：作为List的主要实现类，线程不安全，效率高；底层使用Object[ ]存储、
|--------------------LinkedList：对于频繁的插入、删除操作，其比ArrayList高；底层使用“双向链表”存储
|--------------------Vector：作为List接口的古老实现类，线程安全，效率低；底层使用Object[ ]存储
2.Set接口:无序，不可重复（数学中的“集合”），操作过滤问题，即相同数据过滤掉
|--------------------HashSet：作为Set接口的主要实现类；线程不安全；可以存储null值
|-------------------------------LinkedHashSet：在HashSet基础上添加了Link，是HashSet的子类，使其在遍历内部数据时，可以按照添加的顺序遍历（不同于有序）
|--------------------TreeSet：可以按照添加对象的指定属性进行排序
Collection接口
Map:双列数据，保存具有映射关系”key-value对“的集合（数学中函数y=f(x)）
|------HashMap：Map的主要实现类，线程不安全，效率高；可以存储null（jdk7之前，底层数组+链表；jdk8，数组+链表+红黑树）
|--------------------LinkedHashMap:保证在遍历map元素时，可以按照添加的顺序实现遍历。原因：在原有HashMap的底层结构基础上，添加了一堆指针，指向前一个和后一个元素，对于频繁的遍历操作，执行效率高于HashMap
|------TreeMap：按照添加的key-value对进行排序，实现排序遍历。其中key的排序为自然排序或定制排序；底层使用的红黑树
|------Hashtable：古老的实现类，线程安全，效率低；不能存储null
|--------------------Properties：常用来处理配置文件，其中key和value都是String
Map接口
Collection接口中声明方法的测试
向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals()
Collection c1 = new ArrayList();
c1.add(new Person("xiaohong",12));
c1.add(new Person("xiaohong",12));
//false,未重写equals方法时:即Object的equals方法相当于==，基本数据类型，比较值；引用数据，比较地址
// System.out.println(c1.contains(new Person("xiaohong", 12)));
System.out.println(c1.contains(new Person("xiaohong", 12)));//true,重写equals方法时，即比较值
Collection c2 = Arrays.asList(12);
System.out.println(c1.containsAll(c2));
下列方法操作的对象:
Collection c1 = new ArrayList();
c1.add(12);//表示数字
c1.add("12");//表示字符串
c1.add(new Person("xiaohong",12));
c1.add(new Person("xiaohong",12));
Collection c2 = Arrays.asList(12,13);
(1)retainAll(Colection coll):交集
System.out.println(c1.retainAll(c2));//true,两个集合的交集
System.out.println(c1);//[12] 交集后输出c1
(2)removeAll(Collection coll):差集
System.out.println(c1.removeAll(c2));//true,移除c1中存在的c2，即差集
System.out.println(c1);//[12, com.vv.string.Person@0, com.vv.string.Person@0]
(3)hashCode():哈希值
//返回当前对象的哈希值
System.out.println(c1.hashCode());
(4)toArray():集合--》数组
//1.集合---->数组
Object[] objects = c1.toArray();
for (int i = 0; i < objects.length; i++) {
System.out.print(objects[i] + "\t");
}
System.out.println();
//2.数组----->集合
List<Object> objects1 = Arrays.asList(objects);
System.out.println(objects1);//[12, 12, com.vv.string.Person@0, false]
//a.基本数据类型数组--->集合 将数组整体存入
List<int[]> ints = Arrays.asList(new int[]{123, 145});
System.out.println(ints);//[[I@5d6f64b1] int型的一维数组
System.out.println(ints.size());//1
//b.包装类的数组--->集合
List<Integer> integers = Arrays.asList(new Integer[]{12, 45});
System.out.println(integers);//[12, 45]
System.out.println(integers.size());//2
(5)Iterator(迭代器)
1.主要用于遍历Collection集合中的元素；
2.Collection接口继承了java.lang.Iterable接口，该接口有一个iterator方法，因此所有实现了Collection接口的集合都有一个iterator方法，用来返回一个实现了iterator接口的对象
3.Iterator仅用于遍历集合，其本身并不提供承装对象的能力；但若需要创建Iterator对象，则必须有一个被迭代的集合
4.每次调用iterator方法都会得到一个全新的迭代器对象
迭代器执行原理
两种错误的迭代方式：
// 错误方式一：结果跳着输出且NoSuchElementException
Iterator iterator = c1.iterator();
while(iterator.next() != null){
System.out.println(iterator.next());//
}
//每次c1.iterator().hasNext()都会创建新的迭代器对象
//错误方式二：一直输出第一个位置的值
while (c1.iterator().hasNext()){
System.out.println(c1.iterator().next());
}
(6)remove(Object obj)
Iterator iterator = c1.iterator();
while (iterator.hasNext()){
if("13".equals(iterator.next())){//????数字如何和迭代器元素比较
iterator.remove();
}
// System.out.print(iterator.next()+"\t");//出错，NoSuchElementException，原因是迭代器中元素改变了
}
Iterator iterator1 = c1.iterator();
while (iterator1.hasNext()){
System.out.print(iterator1.next()+"\t");//12 Person{name='xiaohong', age=14} false
}
length、length()、size()区别
length——数组的属性；
length()——String的方法；
size()——集合的方法；
JDK5.0：ForEach遍历集合和数组
//for(集合元素类型 局部变量：集合对象)
for(Object obj:coll)
Iterator iterator1 = c1.iterator();
for(Object c : c1){//内部仍然调用了迭代器
System.out.print(iterator1.next()+"\t");
}
例题
int[] arr = new int[]{112,3,4};
//方式一赋值
for (int i = 0; i < arr.length; i++) {
arr[i] = 4;//对本身的数组元素进行修改
}
//方式二赋值
// for(int a : arr){
// a = 4;//取出来，重新对s赋值。在常量池中
// }
for(int a : arr){
System.out.print(a + "\t");//方式一：4 4 4 方式二：112 3 4
}
List接口
ArrayList、LinkedList、Vector三者异同
ArrayList
jdk7.0中的ArrayList对象的创建类似于单例的饿汉式，底层创建了长度为10的Object[ ]；而jdk8.0中的ArrayList对象的创建类似于单例的懒汉式，底层的Object[ ]初始化为{ },延迟了数组创建，节省内存
扩容2倍
LinkedList
内部没有声明数组，而是定义了Node类型的first和last，用于记录首末元素。其中Node用于保存数据，其prev和next两个变量分别记录前一个和后一个元素
扩容1.5倍
List接口中常用方法
List中:remove(int index)
ArrayList list = new ArrayList();
list.add(12);
list.add("xiaohong");
list.add(new Person("hh",10));
list.add(false);
System.out.println(list.remove(2));//Person{name='hh', age=10}
区别Colection中:remove(Object o)
c1.add("20");//表示字符串
c1.add(new Person("xiaohong",12));
System.out.println(c1.remove("20"));//true
System.out.println(c1);//[Person{name='xiaohong', age=12}]
subList(begin end)类似于String中的subString(begin end)都是左开右闭
List中主要方法
增/插add删remove改set查get长度size()遍历（1）Iterator（2）forEach（3）普通循环
例题：remove考察
@Test
public void test1(){
List list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
updateList(list);
System.out.println(list);
}
void updateList(List list){
// list.remove(2);//[1 ,2] 删除索引位置的值
list.remove(new Integer(2));//[1,3] 删除该对象
}
Set接口中的方法
Set接口中没有额外定义的新方法，使用的都是Collection中声明过的方法（无序即代表没有索引）
List接口中有额外定义的新方法，因为List中有索引（有顺序即代表有索引）
HashSet论证Set的无序性，并不是代表随机性
HashSet存储数据时，底层数组并非按照数组索引的顺序添加，而是根据数组的哈希值确定
不可重复性：保证添加的元素按照equals()判断时，不能返回true，即相同的元素只能添加一个
@Test
public void test(){
Set set = new HashSet();
set.add(12);
set.add("hh");
set.add(new Person("zhangsan",10));
set.add(new Person("zhangsan",10));
System.out.println(set);
}
添加元素：以HashSet（其底层是数组+链表）为例：
向HashSet中添加元素a，先调用hashCode，计算其哈希值，然后哈希值接着通过某种计算方法计算出在HashSet底层数组中的存放位置（即为：索引位置），判断数组此位置上是否已经有元素：若没有，则a添加成功；若有元素b，首先比较a，b的哈希值，若哈希值不相同，则a添加成功；若相同，进而需要调用元素a所在类的equals方法，equals返回true，a添加失败。返回false，a添加成功
对于a添加时其位置有元素而言，a和已经存在于指定索引位置上的数据之间以链表方式存储（jdk7，a放到数组中，指向原来的元素；jdk8，原来的元素在数组中，指向元素a）
HashSet底层结构
Set set = new HashSet();
set.add(12);
set.add("hh");
set.add(new Person("zhangsan",10));
set.add(new Person("zhangsan",10));
// //当未重写equals和hasCode时
// System.out.println(set);//[hh, Person{name='zhangsan', age=10}, 12, Person{name='zhangsan', age=10}]
// //当只重写equals时
// System.out.println(set);//[hh, Person{name='zhangsan', age=10}, 12, Person{name='zhangsan', age=10}]
//当只重写hasCode时
System.out.println(set);//[hh, Person{name='zhangsan', age=10}, 12, Person{name='zhangsan', age=10}]
// //当重写equals和hasCode时
// System.out.println(set);//[hh, Person{name='zhangsan', age=10}, 12]
向Set中添加的数据，其所在的类必须进行hashCode和equals重写，重写的hashCode和equals尽可能保持一致性，相等的对象必须具有相等的散列码（hashCode）
LinkedHashSet底层结构
LinkedHashSet
作为HashSet的子类，在添加数据时，每个数组还维护了两个引用，记录此数据的前后数据，其对于“频繁的遍历操作”，LinkedHashSet频率高于HashSet
LinkedHashSet
TreeSet
1.向TreeSet添加数据，必须是相同的对象;
2.排序方式自然排序、定制排序
自然排序：
两对象进行比较时，为CompareTo方法，不再是equals方法
Set set = new TreeSet();
/*
TreeSet中存放不同对象出错java.lang.Integer cannot be cast to java.lang.String
set.add(12);
set.add("hh");
set.add(new Person("xiao",15));
System.out.println(set);
*/
/*
//1.基本数据类型存储，默认从小到大排序
set.add(12);
set.add(32);
set.add(2);
System.out.println(set);//[2, 12, 32]
*/
//2.对象存储，
/*
未对对象实现Comparable,重写CompareTo方法，即并未告知TreeSet以对象的哪种属性进行排序
com.vv.string.Person cannot be cast to java.lang.Comparable
*/
set.add(new Person("hong",15));
set.add(new Person("wang",5));
set.add(new Person("zhang",35));
set.add(new Person("zhang",25));
/*在Person中实现Comparable接口时，对属性进行按照指定大小进行排序*/
// //当仅对name属性进行比较时
// System.out.println(set);//[Person{name='hong', age=15}, Person{name='wang', age=5}, Person{name='zhang', age=35}]
//当对name和age属性进行比较时
System.out.println(set);//[Person{name='hong', age=15}, Person{name='wang', age=5}, Person{name='zhang', age=25}, Person{name='zhang', age=35}]
定制排序:Comparator
Set set = new TreeSet(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if(o1 instanceof Person && o2 instanceof Person){
return -Integer.compare(((Person) o1).age,((Person) o2).age);
//[Person{name='zhang', age=35}, Person{name='zhang', age=25}, Person{name='hong', age=15}, Person{name='wang', age=5}]
}else{
throw new RuntimeException("对象类型不一致");
}
}
});
例题：
1.属性排序
//生日排序
@Test
public void test(){
Employee e1 = new Employee("xiaohong",12,new MyDate(1926,2,6));
Employee e2 = new Employee("zhangsan",82,new MyDate(1823,3,7));
Employee e3 = new Employee("lisi",62,new MyDate(1926,5,6));
Employee e4 = new Employee("zhaoliu",12,new MyDate(1753,2,9));
Employee e5 = new Employee("dawei",18,new MyDate(1926,5,3));
//使用Comparator對生日進行排序
TreeSet set = new TreeSet(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof Employee && o2 instanceof Employee) {
Employee e1 = (Employee) o1;
Employee e2 = (Employee) o2;
MyDate m1 = e1.getBirthday();
MyDate m2 = e2.getBirthday();
/*//方式一:直接在该方法中比较
int year = m1.getYear() - m2.getYear();
//比较年
if (year != 0) {
return Integer.compare(m1.getYear(), m2.getYear());
}
int month = m1.getMonth() - m2.getMonth();
//比较月
if (month != 0) {
return Integer.compare(m1.getMonth(), m2.getMonth());
}
//比较日
return Integer.compare(m1.getDay(), m2.getDay());*/
//方式二：在MyDate中实现Comparable接口
return m1.compareTo(m2);
}
throw new RuntimeException("對象不一致");
}
});
// TreeSet set = new TreeSet();
set.add(e1);
set.add(e2);
set.add(e3);
set.add(e4);
set.add(e5);
// Iterator iterator = set.iterator();
for(Object o : set ){
System.out.println(o);
}
}
//name排序的同时，按照生日排序
//在Person类中比较
@Override
public int compareTo(Object o) {
if(o instanceof Employee){
Employee e = (Employee) o;
int i =this.name.compareTo(e.getName());
if(i == 0){
return this.getBirthday().compareTo(e.getBirthday());
}else{
return i;
}
}
throw new RuntimeException("对象类型不一致");
}
2.在List内去除重复元素
public static void main(String[] args) {
List list = new ArrayList();
list.add(new Integer(2));
list.add(new Integer(2));
list.add(new Integer(1));
List list1 = updateSet(list);
for(Object o : list1){
System.out.print(o + "\t");
}
// for (int i = 0; i < list.size(); i++) {
// System.out.println(list.get(i));
// }
}
public static List updateSet(List list){
HashSet set = new HashSet();
//若list中添加的是自定义对象，则需要进行hashCode重写；Integer的equals方法已经重写了
set.addAll(list);
return new ArrayList(set);
}
3.set***********太坑了
HashSet set = new HashSet();
Person p1 = new Person("AA",11);
Person p2 = new Person("BB",22);
set.add(p1);
set.add(p2);
p1.setName("CC");
set.remove(p1);
// 首先算出此时name为CC和age为11的哈希值，再与name为AA和age为11的哈希值比较，结果不等；
// 因此，此时删除的位置其实为空，故存储结果为[Person{name='BB', age=22}, Person{name='CC', age=11}]，
System.out.println(set);
set.add(new Person("CC",11));
//name为CC和age为11的位置存储添加的数据，其中结果的值，一个为AA所在位置的值替换，另一个为新的位置
// [Person{name='BB', age=22}, Person{name='CC', age=11}, Person{name='CC', age=11}]
System.out.println(set);
//虽然AA的位置仍在，但通过equals比较时发现，两者对象不一样，因此使用链表重新指向
//[Person{name='BB', age=22}, Person{name='CC', age=11}, Person{name='CC', age=11}, Person{name='AA', age=11}]
set.add(new Person("AA",11));
System.out.println(set);
Map接口
Map中的key：无序、不可重复，使用Set存储所有的key--》key所在类要重写equals和hashCode方法（例如：containsKey需要重写equals和hashCode）
Map中的value：无序、可重复，使用Collection存储所有的value--》value所在类要重写equals方法（例如：containsValue需要重写equals方法）
一个键值对：key-value构成了一个Entry对象。
Map中的entry：无序、不可重复，使用Set存储所有的entry
jdk7的HashMap底层原理
jdk8的HashMap底层原理
map元试图操作方法：
Map map = new HashMap();
map.put(1,2);
map.put(null,3);
map.put("AA",9);
//遍历key
Set set = map.keySet();
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println();
//遍历value
Collection values = map.values();
Iterator iterator1 = values.iterator();
while (iterator1.hasNext()){
System.out.println(iterator1.next());
}
//遍历key-value
//方式一：
Set entrySet = map.entrySet();
Iterator iterator2 = entrySet.iterator();
while (iterator2.hasNext()){
Object obj = iterator2.next();
Map.Entry entry = (Map.Entry) obj;
System.out.println(entry.getKey()+"......"+entry.getValue());
}
//方式二：
Set set1 = map.keySet();
Iterator iterator3 = set1.iterator();
while (iterator3.hasNext()){
Object obj = iterator3.next();
Object value = map.get(obj);
System.out.println(obj+"......"+value);
}
TreeMap的key必须是同一个类创建的对象,因此要按照key排序：自然排序或者定制排序
Map map = new TreeMap();
map.put(new User("zhangsan",16),"shanxi");
map.put(new User("lisan",16),"xian");
map.put(new User("lisan",15),"dali");
Set set = map.entrySet();
Iterator iterator = set.iterator();
while(iterator.hasNext()){
Object obj = iterator.next();
Map.Entry entry = (Map.Entry) obj;
System.out.println(entry.getKey()+"..........."+entry.getValue());
}
Collections是一个操作Collection（Set、List）和Map等集合的工具类
注意：copy方法
List list = new ArrayList();
list.add(12);
list.add(34);
list.add(34);
list.add(85);
// //错误写法一：Source does not fit in dest，看源码后：list.size() > list1.size()
// List list1 = new ArrayList();
// Collections.copy(list1,list);
//错误写法二：list1.size()为0，size()表示add后的数组长度
// List list1 = new ArrayList(list.size());//表示的是数组的长度
// Collections.copy(list1,list);
//eg:
List l = new ArrayList(9);//创建长度为9的数组
System.out.println(l.size());//0
List dest = Arrays.asList(new Object[list.size()]);
Collections.copy(dest,list);
System.out.println(dest);//[12, 34, 34, 85]
Collections中的synchronizedXxx()方法，可使指定集合包装成线程同步的集合，从而解决多线程并发问题
