HashSet,LinkedHashedSet,TreeSet,HashMap,LinkedHashMap,Hashtable,Properties,TreeMap集合大总结！

第一节 Set接口

1.1 Set接口常用方法

方法名	描述
add(E e)	确保此 collection 包含指定的元素（可选操作）。
addAll(Collection<? extends E> c)	将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
clear()	移除此 collection 中的所有元素（可选操作）。
contains(Object o)	如果此 collection 包含指定的元素，则返回true。
containsAll(Collection<?> c)	如果此 collection 包含指定 collection 中的所有元素，则返回 true。
equals(Object o)	比较此 collection 与指定对象是否相等。
isEmpty()	如果此 collection 不包含元素，则返回true。
iterator()	返回在此 collection 的元素上进行迭代的迭代器。
remove(Object o)	从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
removeAll(Collection<?> c)	移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
retainAll(Collection<?> c)	仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。
size()	返回此 collection 中的元素数。
toArray()	返回包含此 collection 中所有元素的数组。

1.2 存储特点

相对无序存储，不可以存储相同的元素（排重），不能通过下标访问

package com.qf.day16;
​
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
​
/**
 * Set接口
 * 特点：无序，不可重复
 * @author wgy
 *
 */
public class Demo1 {
    public static void main(String[] args) {
        //创建对象
        Set<String> set=new HashSet<String>();
        //1添加
        set.add("菊花");
        set.add("枸杞");
        set.add("红枣");
        set.add("人参");
        set.add("灵芝");
        set.add("枸杞");
        System.out.println("元素个数:"+set.size());
        System.out.println(set);
        //2删除
        //2.1删除一个
//      set.remove("灵芝");
//      System.out.println("删除之后:"+set);
//      //2.2清空
//      set.clear();
        //3遍历
        //3.1foreach
        System.out.println("--------增强for----------");
        for (String string : set) {
            System.out.println(string);
        }
        //3.2使用迭代器
        System.out.println("---------迭代器-------");
        Iterator<String> it=set.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }
        //4判断
        System.out.println(set.contains("菊花"));
        System.out.println(set.contains("梅花"));
    }
}

 

1.3 Set实现类

1.3.1 HashSet

1.基于哈希表（jdk1.7之前：数组+链表。jdk1.8：数组+链表+红黑树，实际上是一个HashMap实例）实现。无序，无下标，元素不可重复。
2.它不保证set的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用null元素。
3.元素排重：hashCode()+equals()，每个对象的hashCode值是唯一的，所以hashCode值表示对象在内存中的位置

1）重写hashCode()

案例：设计一个Animal类，重写hashCode方法，向一个HashSet集合中添加Animal对象，
    检验是否排重（若所有属性都相同，视为相同元素）

代码实现：

public class Animal {
    private String name;
    private int age;
    @Override
    public String toString() {
        return "Animal [name=" + name + ", age=" + age + "]";
    }
    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 Animal() {
        super();
    }
    public Animal(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    /*重写hashCode()方法，单纯为了检查此方法是否可以实现排重效果，所以返回一个固定的值，使所有本类对象的hashCode值都是相同的*/
    public int hashCode() {
        return 1;
    }
}

向HashSet集合中添加多个Animal对象时，所有属性都相同时，并没有完成想要的排重效果；
所以只重写hashCode方法并不能实现我们想要的排重效果

2）重写equals()

equals()方法是Object类中的方法，表示比较两个对象是否相等，若不重写相当于比较对象的地址，
所以我们可以尝试重写equals方法，检查是否排重

案例：设计一个Animal类，重写equals方法，向一个HashSet集合中添加Animal对象，
	检验是否排重（若所有属性都相同，视为相同元素）

代码实现：

public class Animal {
	private String name;
	private int age;
	@Override
	public String toString() {
		return "Animal [name=" + name + ", age=" + age + "]";
	}
	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 Animal() {
		super();
	}
	public Animal(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
  	/*重写hashCode()方法，单纯为了检查此方法是否可以实现排重效果，所以返回true，使得所有本类对象使用equals方法比较时，都是相等的*/
	public boolean equals(Object obj) {
		return true;
	}
}

向HashSet集合中添加多个Animal对象时，所有属性都相同时，并没有完成想要的排重效果；

所以只重写equals方法，也不能完全实现我们想要的排重效果。

1.3.4 HashSet实现排重

HashSet的重复依据：hashCode和equals
需要同时重写hashCode和equals方法，实现排重。
案例：设计一个Student类，同时重写hashCode和equals方法，检查是否实现排重

代码实现：

public class Student {
	private String name;
	public Student(String name) {
		super();
		this.name = name;
	}
	public Student() {
		super();
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + "]";
	}
	@Override
  	//重写equals
	public boolean equals(Object obj) {
      	//先判断传入的参数对象是否是Student对象，若不是直接返回false
		if(obj instanceof Student) {
          	//若是，强转成Student对象，并比较属性的值
			Student s = (Student) obj;
			if(this.name.equals(s.name)) {
              	 //若属性的值相同，则返回true
				return true;
			}
		}
		return false;
	}
  	@Override
    public int hashCode(){
      	/*hashCode方法返回值是int类型，所以重写时需要找到int类型的数据返回，还要保证此方法的返回值与对象的所有属性都相关,所以返回姓名属性的字符串的长度*/
		return this.name.hashCode();
    }
}

同时重写hashCode和equals两个方法，可以实现元素的排重效果

1.3.5 LinkedHashSet

1.LinkedHashSet基于哈希表和链表实现。是HashSet的子类。在HashSet的基础上，保证了存取顺序一致（链表的迭代顺序就是插入顺序）。在迭代访问元素时，性能比HashSet好，但插入时比HashSet逊色一点。效率高，线程不安全。
2.元素排重：与HashSet集合排重方法一致。

1.3.6 TreeSet集合

TreeSet集合是可以给元素进行重新排序的一个Set接口的实现。使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的Comparator进行排序，具体取决于使用的构造方法。 
存储特点：
	无序存储，排重，通过红黑树实现的集合，可以给元素进行重新排序

 

1.3.8 TreeSet元素排序

1.自然排序 Comparable

1.元素所属的类需要实现java.lang.Comparable接口，并重写compareTo方法。
2.compareTo方法除了可以进行排序外，还有排重的功能，但是必须在compareTo方法中对类中所有的属性值都进行判断，否则不比较那个属性，排重就会忽略哪个属性

案例：设计一个Person类，实现将Person对象添加到TreeSet集合中时，对所有的元素进行排序

代码实现：

public class Person implements Comparable<Person> {
	private String name;
	private int age;
	public Person() {
		super();
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	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;
	}
	@Override
  	//重写compareTo方法，按照年龄升序，若年龄相同按照姓名降序排序
	public int compareTo(Person o) {
      	//Person中有两个属性，此方法中必须对name和age两个属性都进行比较，否则将无法正确排重
		if(this.age != o.age) {
			return this.age - o.age;
		}else {
			return o.name.compareTo(this.name);
		}
	}
}

2.定制排序 Comparator

1.元素需要通过java.util.Comparator接口（比较器）中的compare方法进行比较大小，并排序。
2.compare方法除了可以进行排序外，还有排重的功能，但是必须在compare方法中对类中所有的属性值都进行判断，否则不比较那个属性，排重就会忽略哪个属性
3.TreeSet集合中的无参数构造方法默认使用自然排序的方式对元素进行排序，使用TreeSet集合的定制排序时，创建集合对象不可以直接使用无参数构造方法，需要使用传入一个Comparator比较器的构造方法创建集合对象。
例：TreeSet<Animal> treeSet = new TreeSet<>(new Comparator());

代码实现：

public class Animal {
	private String name;
	private int age;
	@Override
	public String toString() {
		return "Animal [name=" + name + ", age=" + age + "]";
	}
	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 Animal(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public Animal() {
		super();
	}
}
public class AnimalDemo{
    public static void main(String[]args){
      	//创建一个TreeSet集合，使用Comparator接口的匿名内部类的匿名对象作为比较器
        TreeSet<Animal> treeSet = new TreeSet<>(new Comparator() {
          	@Override
            public int compare(Animal o1, Animal o2) {
                if(o1.age!=o2.age) {
                    return o2.age - o1.age;
                }else {
                    return o1.name.compareTo(o2.name);
                }
            }
        });
      	//添加元素
      	treeSet.add(new Animal("大黄", 1));
      	treeSet.add(new Animal("旺财", 2));
      	//遍历集合
      	Iterator<Animal> it = treeSet.iterator();
        while(it.hasNext()){
          	System.out.println(it.next());
        }
    }
}

 

1.4 SortedSet接口

TreeSet除了实现了Set接口外，还实现了SortedSet接口，SortedSet接口中常用的方法如下：

方法名	描述
first()	返回此 set 中当前第一个（最低）元素。
last()	返回此 set 中当前最后一个（最高）元素。
headSet(E toElement)	返回此 set 的部分视图，其元素严格小于toElement。
tailSet(E fromElement)	返回此 set 的部分视图，其元素大于等于fromElement。
subSet(E fromElement, E toElement)	返回此 set 的部分视图，其元素从 fromElement（包括）到 toElement（不包括）。

 

第二节 Map接口

2.1 概述

Map接口是将键映射到值的对象。一个映射不能包含重复的键，每个键最多只能映射到一个值，值可以重复。
cn--->中国
usa--->美国
uk--->英国
us--->美国
cn--->中华人民共和国

2.2 Map接口的常用方法

方法名	描述
clear()	从此映射中移除所有映射关系（可选操作）。
containsKey(Object key)	如果此映射包含指定键的映射关系，则返回 true。
containsValue(Object value)	如果此映射将一个或多个键映射到指定值，则返回 true。
entrySet()	返回此映射中包含的映射关系的 Set集合。
equals(Object o)	比较指定的对象与此映射是否相等。
get(Object key)	返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
hashCode()	返回此映射的哈希码值。
isEmpty()	如果此映射未包含键-值映射关系，则返回 true。
keySet()	返回此映射中包含的键的 Set 集合。
put(K key, V value)	将指定的值与此映射中的指定键关联（可选操作）。
putAll(Map<? extends K,? extends V> m)	从指定映射中将所有映射关系复制到此映射中（可选操作）。
remove(Object key)	如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
size()	返回此映射中的键-值映射关系数。

案例：

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

/**
 * Map集合的使用
 * 1 存储的键值对，键不能重复，一个键对应一个值，值可以重复。
 * 2 无序
 *
 */
public class Demo1 {
	public static void main(String[] args) {
		//创建集合
		Map<String, String> map=new HashMap<>();
		//1添加元素
		map.put("cn", "中国");
		map.put("usa", "美国");
		map.put("uk","英国");
		map.put("kor", "韩国");
		map.put("cn", "中华人民共和国");//会把原来的值覆盖掉
		//map.put("us", "美国");
		
		System.out.println("元素个数:"+map.size());
		System.out.println("打印："+map.toString());
		
		//2删除
		//map.remove("uk");
		//System.out.println("删除之后:"+map.toString());
		///map.clear();
		//3遍历
		//3.1使用keySet遍历
		System.out.println("---------keySet()----------");
		Set<String> keySet = map.keySet();
		for (String key : keySet) {
			System.out.println(key+"..........."+map.get(key));
		}
		//3.2使用entrySet();
		System.out.println("---------entrySet()---------");
		Set<Entry<String, String>> entrySet = map.entrySet();//Entry（映射对）
		for (Entry<String, String> entry : entrySet) {
			System.out.println(entry.getKey()+"...."+entry.getValue());
		}
		
		//4判断
		//4.1isEmpty
		System.out.println("判断isEmpty():"+map.isEmpty());
		
		//4.2判断是否包含指定的key
		System.out.println("cn:"+map.containsKey("cn"));
		//4.3判断是否包含指定的value
		System.out.println("韩国:"+map.containsValue("韩国"));
		
		
	}
}

2.3 Map实现类

2.3.1 HashMap

1.基于哈希表（数组+链表+红黑树）实现。无序，无下标，键值对无序存储，键不可以重复，值可以重复。jdk1.2，运行效率快，线程不安全，允许null作为key或者value
2.HashMap集合的排重，只需要重写键所属的类的hashCode和equals方法即可。

代码实现：

//Person作为键
public class Person {
	private String name;
	private int age;
	public Person() {
		super();
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	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;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	@Override
	public int hashCode() {
		return age + name.length();
	}
	@Override
	public boolean equals(Object obj) {
		if(obj instanceof Person) {
			Person p = (Person) obj;
			if(p.name.equals(name)&&p.age==age) {
				return true;
			}
		}
		return false;
	}
}
//Dog类作为值
public class Dog {
	private String name;
	public Dog(String name) {
		super();
		this.name = name;
	}
	public Dog() {
		super();
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		return "Dog [name=" + name + "]";
	}
}
//测试类
public class Demo {
	public static void main(String[] args) {
		HashMap<Person, Dog> map = new HashMap<>();
		map.put(new Person("zhangsan", 12), new Dog("大黄"));
		map.put(new Person("lisi", 12), new Dog("旺财"));
		map.put(new Person("zhangsan", 12), new Dog("二哈"));
      
	}
}

map集合中若向集合中添加相同键的键值对时，新的值会将旧的值覆盖。
上述代码中map集合中有两个键值对，分别为：张三-12---二哈，lisi-12---旺财

2.3.2 LinkedHashMap

1.基于哈希表和链接列表实现，映射有序存储，LinkedHashMap集合可以保证迭代顺序和存入顺序一样。
2.此实现与HashSet的不同之外在于，后者维护着一个运行于所有条目的双重链接列表。用法与HashSet类似。

2.3.3 Hashtable

1.基于哈希表实现，键值对无序存储，不允许key或value为null。jdk1.0，运行效率慢，线程安全 

2.3.4 HashMap与Hashtable的区别

1）Hashtable线程安全，而HashMap线程不安全
2）Hashtable中不允许存在null的键和null值，但是HashMap中允许null的键和null值

2.3.5 Properties集合

1.Properties是Hashtable的子类,通常用于配置文件的读取，元素也是以键值对的形式存在。
2.key和value都是String，没有泛型。

public class PropertiesDemo {
	public static void main(String[] args) {
		//1.实例化一个Properties的对象
		Properties pro = new Properties();
		System.out.println(pro);
		
		//2.把文件userlist.properties中的键值对同步到集合中
		//实质：读取
		/*
        void load(InputStream inStream); //从输入流中读取属性列表（键和元素对）。 
        */
		try {
			pro.load(new BufferedInputStream(new FileInputStream(new File("file/userlist.properties"))));
		} catch (Exception e) {
			e.printStackTrace();
		}	
		System.out.println(pro);
		
		//3.向集合中添加一对键值对
		/*
		 *  Object setProperty(String key, String value) 
          	调用 Hashtable 的方法 put。 
		 */
		pro.setProperty("address", "china");		
		System.out.println(pro);
		
		try {
			//4.store
			//实质：写入
			//comments:工作日志
			pro.store(new BufferedOutputStream(new FileOutputStream(new File("file/userlist.properties"))), "add a pair of key and value");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

 

2.3.6 TreeMap集合

1.基于自平衡红黑二叉树（红黑树）实现，可以对Key进行自动排序
2.排重依据：Comparable接口的compareTo()方法的返回值。如果返回0就认为是重复的元素。	 

案例1:

/**
 * TreeMap的使用
 * 存储结构：自平衡红黑二叉树
 * @author wgy
 *
 */
public class Demo5 {
	public static void main(String[] args) {
		//创建集合
		TreeMap<Person, String> treeMap=new TreeMap<>();
		Person p1=new Person("马云", 50);
		Person p2=new Person("李彦宏", 45);
		Person p3=new Person("马化腾", 40);
		Person p4=new Person("马云", 50);
		
		//1添加数据
		treeMap.put(p1, "杭州");
		treeMap.put(p2, "北京");
		treeMap.put(p3, "深圳");
		treeMap.put(p4, "shanghai");
		
		System.out.println("元素个数:"+treeMap.size());
		System.out.println(treeMap.toString());
		
		System.out.println("---------------------比较器--------------------");
		TreeMap<Person, String> treeMap2=new TreeMap<>(new Comparator<Person>() {

			@Override
			public int compare(Person o1, Person o2) {
				int n=o1.getAge()-o2.getAge();
				int n2=o1.getName().compareTo(o2.getName());
				return n==0?n2:n;
				
			}
		});
		treeMap2.put(p1, "杭州");
		treeMap2.put(p2, "北京");
		treeMap2.put(p3, "深圳");
		treeMap2.put(p4, "shanghai");
		
		System.out.println(treeMap2.toString());
		
	}
}

 

2.4 Map遍历

2.4.1 使用keySet方法与get方法结合

public class Demo {
    public static void main(String[] args){
      	HashMap<String, Integer> map = new HashMap<>();
      	map.put("aaa", 12);
      	map.put("bbb", 13);
      	map.put("ccc", 14);
      	//通过keySet获取map中所有键
      	Set<String> set = map.keySet();
      	//获取set的迭代器
      	Iterator<String> it = set.iterator();
        while(it.hasNext()){
          	String s = it.next();
          	//通过迭代的键，找到对应的值，一起输出
          	System.out.println(s+"---"+map.get(s));
        }
    }
}

2.4.2 使用Map.Entry方法：

调用Map集合的entrySet方法，相当于将Map集合转成一个Set集合，再通过Set集合的遍历方式遍历即可。

代码实现：

public class Demo {
	public static void main(String[] args) {
		HashMap<String, Integer> map = new HashMap<>();
		map.put("aaa", 111);
		map.put("bbb", 222);
		map.put("ccc", 333);
		//将map转成一个Set集合
		Set<Map.Entry<String, Integer>> set = map.entrySet();
		//遍历set
		Iterator<Map.Entry<String, Integer>> it = set.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}
}

 

2.5 HashMap实现原理源码分析

一.HashMap的实现原理：
	1.基于哈希表(数组+链表+二叉树(红黑树)) since JDK1.8
	2.默认加载因子为0.75，默认数组的大小是16
	3.把对象存储到哈希表中，如何存储？
	答：把key对象通过hash()方法计算hash值，然后用这个hash值对数组长度（默认16）取余数，来决定该key对象在数组	   中存储的位置，当这个位置有多个对象时，以链表结构存储，JDK1.8后，当链表长度大于8时，链表将转换为红黑树（二     叉树）结构存储，这样的目的是为了取值更快，存储的数据量越大，性能的表现越明显。
    4.扩充原理：
	当数组的容量超过了75%，那么表示该数组需要扩充，如何扩充？
	扩充的算法是：当前数组容量<<1(相当于乘以2)，扩大1倍，扩充次数过多，会影响性能，每次扩充表示哈希表
	重新散列（重新计算每个对象的存储位置），我们在开发中尽量要减少扩充次数带来的性能降低问题。
    5.线程不安全，适合在单线程中使用。

二.工作原理:
HashMap是基于hashing的原理，我们使用put(key, value)存储对象到HashMap中，使用get(key)从HashMap中获取对象。当我们给put()方法传递键和值时，我们先对键调用hashCode()方法，计算并返回的hashCode是用于找到Map数组的bucket位置来储存Node 对象。这里关键点在于指出，HashMap是在bucket中储存键对象和值对象，作为Map.Node

 

以下是具体的put过程（JDK1.8版）
1)、对Key求Hash值，然后再计算下标
2)、如果没有碰撞，直接放入桶中（碰撞的意思是计算得到的Hash值相同，需要放到同一个bucket中）
3)、如果碰撞了，以链表的方式链接到后面
4)、如果链表长度超过阀值( TREEIFY THRESHOLD==8)，就把链表转成红黑树，链表长度低于6，就把红黑树转回链表
5)、如果节点已经存在就替换旧值
6)、如果桶满了(容量16*加载因子0.75)，就需要 resize（扩容2倍后重排）
以下是具体get过程(考虑特殊情况如果两个键的hashcode相同，你如何获取值对象？)
当我们调用get()方法，HashMap会使用键对象的hashcode找到bucket位置，找到bucket位置之后，会调用keys.equals()方法去找到链表中正确的节点，最终找到要找的值对象。

 

第三节 Collections工具类

此类完全由在 Collection 上进行操作或返回 Collection 的静态方法组成。对集合进行操作时，可以使用这个类中的静态方法。

3.1 Collections中常用方法

1.排序 sort()

public class Demo {
	public static void main(String[] args) {
		HashMap<String, Integer> map = new HashMap<>();
		map.put("aaa", 111);
		map.put("bbb", 222);
		map.put("ccc", 333);
		//将map转成一个Set集合
		Set<Map.Entry<String, Integer>> set = map.entrySet();
		//遍历set
		Iterator<Map.Entry<String, Integer>> it = set.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}
}

2.将集合中的元素进行反转 reverse()

/*
		static void reverse(List<?> list) 
          反转指定列表中元素的顺序。 
		*/
		Collections.reverse();

3.将集合元素打乱 shuffle()

/*
		static void shuffle(List<?> list) 
          使用默认随机源对指定列表进行置换。 
		*/

4.获取集合中的最大值、最小值 max() min()

/*
		static T max(Collection coll) 
          根据元素的自然顺序，返回给定 collection 的最大元素。
		  
		  static <T extends Object & Comparable<? super T>> 
		T min(Collection<? extends T> coll) 
          根据元素的自然顺序 返回给定 collection 的最小元素。 
		*/
		int n1 = Collections.max(list);

5.替换 replace()

/*
		static <T> boolean 
 replaceAll(List<T> list, T oldVal, T newVal) 
          使用另一个值替换列表中出现的所有某一指定值 
		*/
		//原因：List集合是不排重的，使用新的元素将集合中出现的所有的旧的元素替换掉
		Collections.replaceAll(list,5,100);

6.统计指定元素在集合中出现的次数 frequency()

/*
		static int frequency(Collection<?> c, Object o) 
          返回指定 collection 中等于指定对象的元素数。 
		*/
		int num = Collections.frequency(list,5);

7.二分法查找 binarySearch()

/*
		static <T> int 
 binarySearch(List<? extends Comparable<? super T>> list, T key) 
          使用二分搜索法搜索指定列表，以获得指定对象。 
		*/
		//前提：必须是排好序的集合
		int index = Collections.binarySearch(list,-10);

		//注意：Collections工具类中的方法只操作Collection接口，主要操作的是List接口	

8.集合和数组的转换

//1 数组转成集合
	package com.qf.day16;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Demo2 {
	public static void main(String[] args) {
		//arrayToList();
		//listToArray();
		 arrayToList2();
	}
	//1数组转成集合，集合不能做添加、删除操作
	public static void arrayToList() {
		String[] names= {"张三","李四","王五"};
		List<String> list=Arrays.asList(names);
		
		System.out.println("list："+list);
		//添加
		//list.add("赵六");
		//删除
		//list.remove(0);
		//System.out.println("添加或删除之后list："+list);
		list.set(0, "本伟");
		System.out.println("替换之后:"+list);
		
	}
	//2 集合转成数组
	public static void listToArray() {
		ArrayList<String> arrayList=new ArrayList<>();
		arrayList.add("苹果");
		arrayList.add("小米");
		arrayList.add("华为");
		arrayList.add("三星");
		
		//数组
		String[] arr=arrayList.toArray(new String[0]);
		System.out.println("--------遍历数组-------");
		for (String string : arr) {
			System.out.println(string);
		}
	}
	
	//3特殊
	public static void arrayToList2() {
		Integer[] nums= {10,20,5,8,9};
		List<Integer> arraylist=Arrays.asList(nums);
		for (Integer integer : arraylist) {
			System.out.println(integer);
		}
		
	}
	
}

 

总结

Collection 父接口
    |_____List （特点：有序的，可以重复）
           |___ArrayList  （存储结构:数组，适合遍历查找）
           |___LinkedList （链表，适合添加和删除）
           |___Vector      数组 
           |___Stack       数组（栈）先进后出，Vector子类
           |___Queue       队列
           |___Deque       双端队列
    |_____Set（特点:无序的，不能重复）
           |_____HashSet  哈希表(数组+链表+二叉树)  
                 重复依据：1 执行hashCode()来计算存储的位置 2 执行equals比较结果
           |_____LinkedHashSet 哈希表 可以保证顺序 
           |_____TreeSet  自平衡红黑二叉树 
            1 元素要实现Comparable接口 2 定制比较器 Comparator  
                 重复依据：Comparable接口的compareTo方法的返回值0，或比较器的返回为0
Map(特点：1存储键值对，一个键对应一个值，键不能重复，值可以重复 2 无序)  
  |______ HashMap  哈希表 1 执行hashCode()来计算存储的位置 ，2 执行equals比较结果
  |______ Hashtable 哈希表  不能存储null键和null值，线程安全的  jdk1.0
           --Properties
  |_______LinkedHashMap  哈希表  可以保证顺序
  |_______TreeMap  自平衡红黑二叉树  1 key 要实现Comparable接口 ，2 定制比较器 Comparator
 
 Collections工具类的使用。
 

面试题

1.简述HashSet和LinkedHashSet之间的区别?
    LinkedHashSet在HashSet的基础上，用链表保证了存取顺序一致（迭代顺序就是插入顺序）。在迭代访问元素时，性能比HashSet好，但插入时比HashSet逊色一点。
    
2.HashSet怎么保证元素不重复?
    基于hashCode()实现，该方法返回的是哈希码。1.哈希码不同，则存入元素。2.哈希码相同，则调用equals方法进一步比较两个元素，如结果为true，则拒绝后者存入。
    
3.TreeSet怎么实现元素不重复？
    基于排列顺序实现元素不重复，集合元素的所对应的类必须实现Comparable接口，指定排序规则，通过CompareTo方法确定是否为重复元素。
    
4.LinkedHashSet和HashSet的区别？
    1）HashSet:基于哈希表实现，无序无下标，元素不重复，效率高，线程不安全。基于hashCode和equals排重。
    2）LinkedHashSet:基于哈希表和链表实现。是HashSet的子类。在HashSet的基础上，保证了存取顺序一致（链表的迭代顺序就是插入顺序）。在迭代访问元素时，性能比HashSet好，但插入时比HashSet逊色一点。效率高，线程不安全。
​