List集合
概念
是一个容器,作用为存放多个数据,通常用来替代数组
特点
-  只能存放引用类型 
-  所有集合都来自于java.util包 
List , Set , Map都是接口
List的存储特点
有序,有下标,元素可以重复
List的常用实现类
-  ArrayList (常用) -  JDK1.2 底层数组实现 查询快,增删慢 线程不安全,效率高 
 
-  
-  LinkedList -  JDK1.2 底层链表实现 查询慢,增删快 线程不安全,效率高 
 
-  
-  Vector -  JDK1.0 底层数组实现 都慢 线程安全,效率低 
 
-  
创建
-  建议使用多态 
List 集合名=new 实现类();
常用方法
-  集合名.方法名(实参列表)
-  boolean add(元素): 往集合末尾添加一个元素 
-  void add(下标, 元素): 将元素添加至指定下标位置 
-  boolean addAll(集合名):将指定集合元素添加至当前集合末尾 
-  boolean addAll(下标,集合名):将指定集合元素添加至当前集合指定下标位置 
-  int size():获取集合长度 
-  元素 get(下标):获取指定下标位置的元素 -  下标不可超出使用范围,否则报出下标越界异常 
 
-  
-  boolean contains(元素):判断是否包含指定元素 
-  boolean containsAll(集合名):判断当前集合中是否包含指定集合的所有元素 
-  下标 indexOf(元素):获取指定元素第一次出现的下标 
-  下标 lastIndexOf(元素):获取指定元素最后一次出现的下标 
-  boolean isEmpty():判断集合元素是否为空,不可判比null值 
-  被删除的元素 remove(下标):删除指定下标位置的元素 
-  boolean remove(元素):删除指定元素 -  如果集合元素为整数值,则会优先认定值为下标。所以删除整数值元素时只能通过下标删除 
 
-  
-  旧元素 set(下标,新元素):将指定下标位置的值替换为新元素值 
-  Object[] toArray():将集合转换为数组 
遍历
-  下标遍历 
for(int i=0;i<集合名.size();i++){//通过集合名.get(i)的方式获取当前元素
}List list = new ArrayList();list.add(10);list.add(20);list.add(30);list.add(40);list.add(50);//下标遍历for (int i = 0; i < list.size(); i++) {System.out.print(list.get(i)+" ");}System.out.println();迭代器遍历
-  获取集合的迭代器:集合名.iterator() 
-  操作迭代器: -  boolean hasNext():判断是否存在下一元素 
-  元素 next():使指针后移一位,获取下一元素 
 
-  
-  使用: -  迭代过程中不可增删元素 
-  一次迭代只能调用一次next方法,否则迭代与操作元素数量不一致 
 
-  
//获取迭代器Iterator it = list.iterator();//利用循环操作迭代器while(it.hasNext()){Object o = it.next();if (o != null) {System.out.print(o+"  ");}}System.out.println();外遍历forEach
for(数据类型 元素名:集合名){//元素名就代表正在被遍历的元素
}for (Object o : list) {System.out.print(o+"  ");}System.out.println();1. - 遍历过程中无法增删元素- JDK5.02. 自遍历forEach- JDK8.0- 集合名.forEach(Consumer接口实现类对象)list.forEach(new Consumer() {@Overridepublic void accept(Object o) {//参数o就表示当前元素System.out.print(o+"  ");}});System.out.println();//自遍历forEach-lambdalist.forEach(o -> System.out.print(o + "  "));## 泛型- 用于集合: 约束集合可存放的数据类型## 泛型- 用于集合: 约束集合可存放的数据类型~~~java
List<泛型类型> 集合名=new 实现类名<泛型类型>();
~~~### 使用1. 存放类型为基本类型时,需要将泛型类型声明为对应包装类型2. 前后泛型声明必须一致3. 前边泛型不可省略4. 后边泛型<>内容可省~~~javaList<泛型类型> 集合名=new 实现类名<>();~~~~~~java
package com.by.test;import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.function.Consumer;public class Test4 {public static void main(String[] args) {List<Integer> list = new ArrayList<>();list.add(10);list.add(20);list.add(30);list.add(40);list.add(50);/* list.add(5.5);list.add("abc");*///四种遍历方式//下标遍历for (int i = 0; i < list.size(); i++) {//接收当前元素Integer n = list.get(i);System.out.print(n+"  ");}System.out.println();//迭代器遍历Iterator<Integer> it = list.iterator();while (it.hasNext()) {Integer n = it.next();System.out.print(n+"  ");}System.out.println();//外遍历for (Integer i : list) {System.out.print(i+"  ");}System.out.println();//自遍历list.forEach(new Consumer<Integer>() {@Overridepublic void accept(Integer i) {System.out.print(i+"  ");}});System.out.println();//lambdalist.forEach(i-> System.out.print(i+"  "));}
}
~~~Set集合
Collection
-  是List和Set的父接口 
-  所有集合都是由Collection或者Map派生 
特点
-  内部存放List和Set的共性方法 
-  没有直接实现类 
Set的存储特点
无序,无下标,元素不可重复
Set的常用实现类
-  HashSet -  JDK1.2 底层哈希表(数组+链表)实现 线程不安全,效率高 
 
-  
-  LinkedHashSet -  JDK1.2 使HashSet的子类,底层哈希表实现 线程不安全,效率高 
 
-  
-  TreeSet -  JDK1.2 底层红黑树实现,是SortedSet的实现类 线程不安全,效率高 
 红黑树:树状结构存放数据,使用的是二分查找法,特点为查询效率快 
-  
创建
-  建议使用多态 
Set<泛型> 集合名=new 实现类名<>();
常用方法
-  所有方法都继承自Collection,无独有方法 
遍历
-  迭代器遍历 
-  外遍历forEach 
-  自遍历forEach 
哈希表的去重原理
-  先调用元素的hashCode方法获取哈希码值 
-  通过哈希码值%数组长度(16)得到存放下标 
-  如果下标位置未存有元素,则直接存放 
-  如果下标位置存有元素, 则调用当前元素的equals方法与下标位置元素进行值的比较 
-  都不相同, 在下标位置上继续链表存放 
-  有相同,则舍弃添加当前元素 
使用
-  HashSet和LinkedHashSet如果存放的是自定义类型,则必须重写hashCode和equals方法才能实现去重 
-  LinkedHashSet可以保证元素存入与取出的顺序一致 
-  TreeSet可以实现对元素进行默认的升序排序 -  如果TreeSet中存放的是自定义类型,则必须自定义排序规则 
-  排序方式: -  实现Comparable接口,重写CompareTo方法 -  思路:让当前对象this和参数对象o进行比较 
-  实现:对谁排序,就让谁实现 
-  规则: -  从小到大: this的值>o的值,返回正数 this的值<o的值,返回负数 
-  从大到小: this的值>o的值,返回负数 this的值<o的值,返回正数 相等返回0 
 
-  
 
-  
 
-  
 
-  
package com.by.entity;public class Student implements Comparable<Student>{private String name;private int age;private double score;//省略getter、setter、构造@Overridepublic int compareTo(Student o) {//根据学生成绩从高到底排序if (this.score > o.score) {return -1;} else if (this.score < o.score) {return 1;}return 0;}
}实现Comparator接口,重写compare方法- 思路: 让参数o1和o2进行比较
- 实现:在集合创建处的小括号内传入实现类对象Set<Student> set = new TreeSet<>((o1,o2)->{//根据学生成绩从低到高if (o1.getScore() > o2.getScore()) {return 1;} else if (o1.getScore() < o2.getScore()) {return -1;}return 0;});1. - > 1. 默认识别Comparable,但是Comparator优先级更高> 2. Comparator更能保护类的单一职责,有利于后期代码的维护, 集合排序扩展性更高,更推荐该方式2. TreeSet去重规则:当compareTo或compare方 法返回值为0时去重Map集合
存储特点
-  以键值对的形式存储数据 
-  键(key): 无序,无下标,元素不可重复 
-  值(value): 无序,无下标,元素可以重复 
常用实现类
-  HashMap -  JDK1.2 底层哈希表实现 线程不安全,效率高 
 
-  
-  LinkedHashMap -  JDK1.2 是HashMap的子类,底层哈希表实现 线程不安全,效率高 
 
-  
-  TreeMap -  JDK1.2 是SortedMap的实现类,底层红黑树实现 线程不安全,效率高 
 
-  
-  Hashtable -  JDK1.0 底层哈希表实现 线程安全,效率低 
 
-  
-  Properties -  JDK1.0 是Hashtable的子类,底层哈希表实现 线程安全,效率低 
 
-  
创建
-  建议使用多态 
Map<键的泛型,值的泛型> 集合名=new 实现类名<>();
常用方法
K: 键
V: 值
-  V put(K,V):向集合中添加一个键值对 -  如果键已经存在,则进行值的覆盖 
 
-  
-  int size(): 获取集合长度 
-  boolean containsKey(K): 判断集合是否包含指定键 
-  boolean containsValue(V): 判断集合是否包含指定值 
-  V get(K): 根据键获取值 
## 遍历1. 键遍历- Set<K的泛型> keySet(): 获取集合所有的键放入Set集合返回~~~java
//先获取所有的键Set<String> set1 = map.keySet();//遍历键set1.forEach(k -> System.out.println(k + "  " + map.get(k)));
~~~2. 值遍历- Collection<V的泛型> values(): 获取集合所有的值放入Collection集合返回~~~java
//获取所有的值Collection<String> coll = map.values();//遍历值for (String s : coll) {System.out.println(s);}
~~~3. 键值对遍历- Set<  Map.Entry<K的泛型,V的泛型> >  entrySet(): 将所有的键值对对象放入Set集合返回- entry对象.getKey(): 获取entry对象中的键- entry对象.getValue():获取entry对象中的值~~~java
//获取到所有的entry对象Set<Map.Entry<String, String>> set2 = map.entrySet();//遍历entry对象set2.forEach(entry-> System.out.println(entry.getKey()+","+entry.getValue()));
~~~4. 自遍历forEach- 集合名.forEach(BiConsumer接口实现类对象)~~~java
System.out.println("自遍历-->匿名内部类:");map.forEach(new BiConsumer<String, String>() {@Overridepublic void accept(String k, String v) {System.out.println(k+"  ,  "+v);}});System.out.println("自遍历-->lambda:");map.forEach((k,v)->System.out.println(k+"  ,  "+v));
~~~使用
-  除去TreeMap之外, 如果键为自定义类型,则必须重写hashCode和equals方法才能实现去重 
-  HashMap可以存放null值,键只能有一个null,值可以存在多个null 
-  LinkedHashMap在HashMap的基础上可以保证元素存入和取出的顺序一致 
-  TreeMap可以根据键进行默认的升序排序 -  如果键为自定义类型,则需要自定义排序规则,方式与TreeSet一致 
-  键不可为null,否则排序会导致空指针 
-  仍然在compareTo或者compare方法返回值为0时去重 
 
-  
-  Hashtable无法存放null值 
-  Properties只能存放String类型的数据 -  不推荐使用多态 
-  无法使用泛型 
-  setProperty(String,String): 向集合中添加一个键值对 
-  String getProperty(String): 根据键获取值 
-  load(输入流): 通过输入流将配置文件的内容读取到集合中 
 
-