1、Set集合的特点：
（1）无序（存储和读取的顺序有肯不一样）；
（2）不允许重复（要求元素唯一）；
（3）没有索引
2、HashSet有三种遍历集合对象的方式：
（1）转换成数组；
（2）迭代器；
（3）增强for
例：
package com.itheima;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class HashSetDemo {
public static void main(String[] args) {
//创建集合对象
//HashSet<String> hs=new HashSet<String>();
Set<String> set=new HashSet<String>();//父接口引用指向指向子类对象
//添加元素对象
set.add("hello");
set.add("world");
set.add("java");
//遍历集合对象
//method(set);
//method1(set);
for(String s:set) {
System.out.println(s);
}
}
public static void method1(Set<String> set) {
//迭代器
Iterator<String> it=set.iterator();
while(it.hasNext()) {
String s=it.next();
System.out.println(s);
}
}
public static void method(Set<String> set) {
//转换成数组
Object[] obj=set.toArray();
for(int i =0;i<obj.length;i++) {
System.out.println(obj[i]);
}
}
}
3、HashSet的add()方法的去重功能：
（1）当前集合中的每一个元素和新添加的元素进行hash值比较；
（2）如果hash值不一样，则直接添加新元素；如果hash值一样，则比较地址值或者使用equals方法进行比较；
（3）如果比较的结果一样，则认为是重复不添加；如果比较的结果不一样，则添加
以Person类为例：
@Override
public String toString() {
return "Person [name=" + name + ", age="+ age + "]";
}
@Override
public int hashCode() {
return age+name.hashCode();
}
@Override
public boolean equals(Object obj) {
System.out.println("---------");
//提高效率
if(this==obj) {
return true;
}
if(this.getClass()!=obj.getClass()) {
return false;
}
//向下转型
Person p=(Person)obj;
if(!this.name.equals(p.name)) {
return false;
}
if(this.age!=p.age) {
return false;
}
return true;
}
注意：
去重中提高程序效率的方法：
让成员变量不同的对象，他们的返回值也不同，即让HashCode()方法的返回值和对象的成员变量有关，可以让HashCode()方法返回所有成员变量之和（基本数
据类型直接相加；引用数据类型获取HashCode()方法返回值后再相加（boolean不可以参与运算））
4、Collection和Collections的区别：
（1）Collection是集合体系的最顶层，包含了集合体系的共性；
（2）Collections是一个工具类，方法都是用于操作Collection
Collections中的一些基本操作：
（1）static void swap(List list,int i,int j):将指定列表中的两个索引进行位置互换；
（2）static void sort(List<T> list):按照列表中元素的自然顺序进行排序；
（3）static void shuffle(List list):随机置换；
（4）static void reverse(List list):反转；
（5）static void fill(List list,Object obj):使用指定的对象填充指定列表的所有元素；
（6）static void copy(List dest,List src):把源列表中的数据覆盖到目标列表中；
（7）static void binarySearch(List list,Object key):使用二分查找法查找指定元素在指定列表的索引位置
5、Map:专门用于存储对应关系的集合
Map和Collection的区别：
（1） Map：是一个双列集合，常用于处理有对应关系的数据，其中key是不能重复的；
（2）Collection：是单列集合，有不同的子体系，有的允许重复索引，有序；有的不允许重复索引，无序
注意：
Map是将键映射到值的对象。一个映射不能包含重复的键，每个键最多只能映射到一个值（一对一关系）
Map的常用功能：
（1）V put(K key,V value):将key映射到value,如果key存在，则覆盖value,并将原来的value返回；
（2）void clear():清空所有的对应关系；
（3）V remove(Object key):根据指定的key删除对应关系，并返回key所对应的值，如果没有删除成功，则返回null；
（4）boolean containsKey(Object key):判断指定key是否存在；
（5）boolean containsValue(Object value):判断指定value是否存在；
（6）boolean isEmpty():判断是否有对应关系；
（7）int size():返回对应关系的个数；
（8）V get(Object key):根据指定的key返回对应的value；
（9）Collection<V> values():以collection的形式返回所有的value；
（10）Set<K> keySet():以set的形式返回所有的key
遍历Map的两种方式：
例：
（1）遍历Map对象(第一种方式)
Set<String> keys=map.keySet();
for(String key:keys) {
String value=map.get(key);
System.out.println("编号:"+key+"姓名:"+value);
（2）遍历Map对象(第二种方式)
Set<Map.Entry<String, String>> entrys=map.entrySet();
for(Map.Entry<String, String> entry:entrys) {
String key=entry.getKey();
String value=entry.getValue();
System.out.println("编号:"+key+"姓名:"+value);
注：HashMap的遍历和Map一样，并且可以实现去重，相同编号的后面会覆盖前面的
6、异常的体系结构：
（1）Throwable（最顶层）；
（2）Error:出现不能够处理的严重问题；
（3）Exception:可以处理的问题
异常是在写代码时出现编译或者运行错误，包含了错误的类型，原因以及位置
7、异常的处理方式：
捕获处理
try----catch语句
try{
可能出现问题的代码；
}catch(异常对象){
处理异常；
}
注意：jvm处理异常的方式：
如果出现异常我们没有处理，jvm会帮我们进行处理，他会把异常的类型，原因已经位置显示在命令行，并且终止程序，异常后面的代码将不再执行
8、处理多个异常：
（1）使用多个try---catch语句；
（2）使用一个try和多个catch
注意：多个catch之间的顺序：
（1）多个catch之间可以有子父类；
（2）同级之间没有顺序关系；
（3）如果有子父类，父类异常必须在后面
9、Throwable的常用方法：
（1）String getMessage():原因；
（2）String toString():类型和原因；
（3）void printStackTrace():类型、原因和位置
10、finally:组合try---catch使用，用于释放资源等收尾工作，无论try---catch语句如何执行，finally的代码一定会执行
格式：
try{
可能出现问题的代码；
}catch(异常对象){
处理异常；
}finally{
释放资源；
清理垃圾；
}
11、异常的分类：
（1）运行时期异常：RuntimeException的子类，在编译时期可以自由选择处理或者不处理；
（2）编译时期异常：Exception的子类，不是RuntimeException的子类，在编译时期必须处理（抛出或捕获）
12、throws和throw的区别：
（1）throws：处理异常的一种方式，把异常抛出，由调用者来处理；
（2）throw：制造异常的方式，并且结束方法
注意：如果抛出(throw)的是编译时期的异常，必须在方法声明处抛出（throws)
定义异常类的方法：写一个类去继承 RuntimeException或 Exception，然后实现多个构造
13、递归：在方法本身不断的调用方法自己
注意：
（1）递归一定要由出口，否则会内存溢出；
（2）递归次数不宜过多，否则会内存溢出