java学习（一）之集合

立Flag

身为一个已经在读研究生的程序员，自己无疑是不合格，要技术没技术，要学术没学术。所以，我，准备“痛改前非”，给自己定下一个每日学习记录打卡计划：每天学习一些知识点后来csdn以博客的形式进行记录。fighting!!!

今日学习内容

集合Collection [ java.util.Collection ]

Collection为单列集合

1. Collection的学习结构

2. Collection接口中的方法：
   1. 将指定元素添加到集合中：public boolean add(Elment e);
   2. 删除指定的元素（元素在集合中存在，返回true，否则返回false）：public boolean remove(Elment e);
   3. 判断集合是否包含指定元素：public bollean contains(Element e);
   4. 判断集合是否为空：public boolean isEmpty();
   5. 清空集合，但集合依然存在：public void clear();
   6. 将集合中的元素存储到Object数组中：public Object[] toArray();
3. 特点
   Collection>无索引，不能使用普通for循环
4. 遍历
   1. 迭代器(Iterator)
      Iterator是一个接口，通过Colection对象的iterator()方法获取迭代器实现类对象；Iterator<T>跟着集合的泛型走。

      Collection<T> coll = new ArrayList();//创建一个Collection对象
      Iterator<T> iterator = coll.iterator();//获取迭代器额实现类对象
      while(iterator.hasNext()){//判断集合中是否有下一个元素
      	iterator.next();//获取集合中的下一个元素
      }
      //使用fro进行迭代
      for(Iterator<T> it=coll.terator();it.hasNext();){
      	it.next();
      }
      

      
   2. 增强for循环
      Collection<T> extends Iteratable，所有的单列集合都可以使用增强for循环

      	for(T c : coll){
      		system.out.println(c);
      	}
      

列表List

1. 特点
   • 有序集合（存储和取出的顺序一致）
   • 有索引，可以使用普通for循环
   • 允许存储重复元素
2. 接口中的方法
   1. 在指定位置添加指定元素：public void add(int index,Elment e);
   2. 移除指定位置的元素，返回被删除移除的元素：public Elment remove(int index);
   3. 获取指定位置的元素：public Elment get(int index);
   4. 更新指定位置的元素，返回更新前的元素：public Elment set(int index,Elment e);
3. List集合遍历
   1. 迭代器遍历
   2. 增强for循环
   3. 普通for循环
4. 可能会出现的异常
   1. IndexOutOfBoundsException索引越界异常
   2. ArrayIndexOutOfBoundsException数组索引越界异常
   3. StringIndexOutOfBoundsException字符串索引越界异常

ArrayList实现类

1. 特点
   1. 多线程（实现不是同步的）
   2. 大小可变的数组
   3. 查询快，增删满（每新增一个元素，都要新创建数组，进行复制）
   4. 可以使用多态：List<T> arrayList = new ArrayList<>();

LinkedList实现类

1. 特点
   1. 多线程（此实现不是同步的）
   2. 底层是链表
   3. 查询慢，增删快
   4. 不能使用多态：LinkedList<T> lined = new LinkedList<T>();
2. 方法
   1. 在链表的首部/尾部添加元素：public void addFirst(Elment e);public void addLast(Elment e);
   2. 移除链表的第一个/最后一个元素：public Elment removeFirst();public Elment removeLast();
   3. 获取链表的第一个/最后一个元素：public Elment getFirst();public Elment getLast();
   4. 在链表首部添加元素（等同于addFirst()）：public void push(Elment e);
   5. 移除链表的第一个元素（等同于removeFirst()）：public Elment pop();
   6. 判断链表是否为空：isEmpty();

Vector

1. 可增长的对象数组
2. 单线程（同步实现）

集Set

1. 特点
   1. 不允许存储重复元素
      原理：
      1. 当添加一个新元素时，首先调用``hashCode()```计算新元素的哈希值
      2. 将此哈希值与集合中数组结构中已有的哈希值进行比较
         1. 若数组结构中有相同哈希值，即产生哈希冲突，则调用equals()进行比较
            1. 若相等，则不进行添加；
            2. 否则，将添加的元素连接到相应的哈希值对应的链表中
         2. 否则，添加新元素：在数组结构中填入哈希值，且连接元素
   2. 无索引，不能使用普通for循环

哈希集HashSet

1. 特点
   1. 多线程
   2. 底层结构是哈希表—查询速度很快
   3. 无序集合
   4. 使用多态：Set<T> hashSet = new HashSet<>();
2. 哈希值
   1. 一个十进制整数，由系统随机给出（对象的地址，逻辑地址）
      Object的hashCode()可获得对象的哈希值（toString()使用了此函数获取哈希值）
      public native int hashCode();中的native代表调用本地操作系统的方法获取哈希值
      String类重写了hashCode()，使得相同字符串的哈希值一致
   2. 哈希冲突：哈希值相同
3. 哈希表
   1. jdk1.8以前：数组+链表
   2. jdk1.8以后：数组+红黑树
      
4. 自定义类型元素<T>
   为保证元素唯一：必须重写hashCode()和equals()方法保证equals()相等的hashCode()计算获得的哈希值一定相等

LinkedHashSet

1. 结构
   哈希表+链表（用来记录元素存储顺序）
2. 特点
   1. 有序集合
   2. 不允许存储重复元素

树集TreeSet

…后续补充

集合工具类Collections

1. 往集合中添加多个元素：public static <T> addAll(Collection<T> coll, T.. e);
2. 打乱集合中元素的顺序：public static void shuffle(List<?> list);
3. 按照默认顺序（升序）排序：public static <T> sort(List<T> list);
   自定义类型T：必须实现Comparable<T>接口，重写compareTo(T e)；可自定义比较规则（this和e的比较）
   排序规则：
   1. 升序：自己(this)-参数e
   2. 降序：参数e-自己(this)
4. 按照指定规则排序：public static <T> sort(ist<T> list, Comparator<? super T>);

   List<Integer> list = new ArrayList<>();
   //往集合中添加数据[省略]
   Collections.sort(list,new Comparator<Integer>(){
   	@Override
   	public int compare(Integer o1, Integer o2){
   		//return 0;//默认
   		return o1 - o2;//升序
   		//return o2 - o1;降序
   	}
   })
   

5. Comparable和Comparator的区别
   1. Comparable：比较自己与参数
   2. Comparator：找一个第三方进行比，比较参数

可变参数

1. 前提
   当方法的参数类型已经确定，但参数个数不确定的时候
2. 格式
   修饰符 返回值类型 方法名(参数类型…变量名){
   方法体
   }
3. 原理
   底层是一个数组，根据传递参数的个数(0,1,2,…,n)，创建对应长度的数组
4. 注意事项
   1. 一个方法的参数列表中只能有一个可变参数
   2. 参数列表中的可变参数只能放在参数列表的额末尾
5. 终极写法
   修饰符 返回值类型 方法名(Object变量名);可以传递任意类型的参数

泛型

1. 创建集合对象时，使用泛型
   1. 优点
      1. 避免类型转换的麻烦
      2. 将运行期异常提升为编译期异常
   2. 缺点
      泛型是什么类型，就只能存储什么类型
2. 创建集合对象时，不使用泛型
   1. 优点
      默认类型为Object类型，可存储任意类型的数据
   2. 缺点
      不安全，会抛出异常（涉及到类型转换）
3. 含自定义泛型的类
   1. 格式

      修饰符 class 类名<泛型>{
      	修饰符 泛型 成员变量名;
      	修饰符 泛型 成员方法(泛型 参数名){...}
      	//do something
      }
      

   2. 注意
      创建对象时，对象是什么类型，泛型就是什么类型
4. 含自定义泛型的方法
   1. 格式

      修饰符 (static) <泛型> 返回值类型 方法名(参数列表（使用泛型）){
      }
      

   2. 注意
      调用方法时，传递什么类型的参数，泛型就是什么类型
5. 含自定义泛型的接口
   1. 格式

      修饰符 interface 接口名<泛型>{
      	public abstract void method(<泛型> v);
      }
      

   2. 注意
      1. 定义接口的实现类，指定接口的泛型，实现接口

         public class mpl implements 接口名<String>{
         	@Override
         	public void method(String s){
         	}
         }
         

      2. 接口使用什么泛型，实现类就用什么反泛型，类跟着接口走

         public class impl<T> implements 接口名<T>{
         }
         

6. 泛型通配符?
   1. 注意
      不能创建对象使用，只能作为方法的参数使用
7. 泛型的上下限
   1. 上限（只能是T的子类/本身）：<? extends T>
   2. 下限（只能是T的父类/本身）：<? super T>

写在最后

失败+10086，几乎是翻着整理的笔记写完的，压根没记住学的东西。丧！