Java核心集合框架Collection及拓展

集合容器主要⽤于保存对象，主要分类有三种List 、Set、Map

List 有序、重复集合
   List接口主要有ArrayList、Vector、LinkedLis
Set无序、不可重复
    Set接口主要有HasSet、LinedHash、TreeSet
Map 键值对存储
    Map接口主要有HashMap、TreeSet
Collection接口有两个主要的子类分别是List和Set，但Map不是Collection的子类因为其本身就是一个顶层接口

框架List基础介绍

  List数据结构

	List是一个线性列表接口能够控制每个元素插入位置，能够通过索引，接口存储一组不唯一，有序（插入对象）的对象。

  常见实现类
   ArrayList基于数组实现，是⼀个动态的数组队列，但它和Java中的数组⼜不⼀样，它的容量可以
⾃动增⻓
   LinkedList基于的数据结构是链表，⼀个双向链表，链表数据结构的特点是每个元素分配的空间不
必连续

//创建对象,LinkedList和ArrayList api⼀样
List<String> list=new ArrayList<>();
//往容器⾥⾯添加对象
list.add("jack");
//根据索引获取元素
list.get(index);
//更新⼀个元素
list.set(index, “⼩滴课堂”);
//返回⼤⼩ 
list.size();
//根据索引删除⼀个元素
list.remove(index);
//根据对象删除元素
list.remove("jack");

框架Map基础介绍

  什么是Map数据结构
底层就是⼀个数组结构，数组中的每⼀项⼜是⼀个链表，即数组和链表的结合体
Table是数组，数组的元素是Entry
Entry元素是⼀个key-value键值对，它持有⼀个指向下⼀个 Entry元素的引⽤，table数组的
每个Entry元素同时也作为当前Entry链表的⾸节点，也指向了该链表的下⼀个Entry元素

    常⻅的实现类
  HashMap
⼀个散列桶（数组和链表），它存储的内容是键值对(key-value)映射
是基于hashing的原理，使⽤put(key, value)存储对象到HashMap中，使⽤get(key)从
HashMap中获取对象。当put()⽅法传递键和值时，会先对键调⽤hashCode()⽅法，计
算并返回的hashCode是⽤于找到Map数组的bucket位置来储存Entry对象的，是⾮线程
安全的，所以HashMap操作速度很快
  TreeMap
在数据的存储过程中，能够⾃动对数据进⾏排序，实现了SotredMap接⼝，它是有序的
集合
TreeMap使⽤的存储结构是平衡⼆叉树，也称为红⿊树
默认排序规则：按照key的字典顺序来排序（升序），也可以⾃定义排序规则，要实现
Comparator接⼝

Map<String,String> map = new HashMap<>();
//往map⾥⾯放key - value;
map.put("⼩明","⼴东⼴州");
map.put("⼩东","⼴东深圳");
//根据key获取value
map.get("⼩东");
//判断是否包含某个key
map.containsKey("⼩明");
//返回map的元素数量
map.size();
//清空容器
map.clear();
//获取所有value集合
map.values();
//返回所有key的集合
map.keySet()
//返回⼀个Set集合，集合的类型为Map.Entry , 是Map声明的⼀个内部接⼝，接⼝为泛型，定
义为Entry<K,V>，
//它表示Map中的⼀个实体(⼀个key-value对),主要有getKey(),getValue⽅法
Set<Map.Entry<String,String>> entrySet = map.entrySet();
//判断map是否为空
map.isEmpty();

框架Set基础介绍

       什么是Set数据结构
Set相对于List是简单的⼀种集合,具有和 Collection 完全⼀样的接⼝，只是实现上不同，Set
不保存重复的元素，存储⼀组唯⼀，⽆序的对象。
Set中的元素是不能重复的, 实现细节可以参考Map，因为这些Set的实现都是对应的Map的⼀种封装。⽐如HashSet是对HashMap的封装，TreeSet对应TreeMap
Set底层是⼀个HashMap，由于HashMap的put()⽅法是⼀个键值对，当新放⼊HashMap的
Entry中key 与集合中原有Entry的key相同（hashCode()返回值相等，通过equals⽐较也返回
true），新添加的Entry的value会将覆盖原来Entry的value，但key不会有任何改变。允许包含值为null的元素，但最多只能有⼀个null元素常⻅的实现类
    HashSet
HashSet类按照哈希算法来存取集合中的对象，存取速度⽐较快
对应的Map是HashMap，是基于Hash的快速元素插⼊，元素⽆顺序。
    TreeSet
TreeSet类实现了SortedSet接⼝，能够对集合中的对象进⾏排序

//创建对象,HashSet和TreeSet api⼀样
Set<Integer> set = new HashSet<>();
//往容器⾥⾯添加对象
set.add("jack");
//清空元素
set.clear();
//返回⼤⼩ 
set.size();
//根据对象删除元素
set.remove("jack");
//是否为空
set.isEmpty();

迭代器（Iterator）

     循环遍历集合
          普通for循环
          增强for循环
     
     三个核心方法
   boolean hashNext()
⽤于判断iterator内是否有下个元素，如果有则返回true，没有则false
   Obejct next()
返回iterator的下⼀个元素，同时指针也会向后移动1位
   void remove()
删除指针的上⼀个元素（容易出问题，删除元素不建议使⽤容器⾃⼰的⽅法）

public static void testSet(){
 Set<String> set = new HashSet<>();
 set.add("jack");
 set.add("tom");
 set.add("marry");
 set.add("tony");
 set.add("jack");
 Iterator<String> iterator = set.iterator();
 while (iterator.hasNext()){
 String str = iterator.next();
 System.out.println(str);
 }
 }
 public static void testList(){
 List<String> list = new ArrayList<>();
 list.add("jack");
 list.add("tom");
 list.add("mary");

 list.add("tim");
 list.add("tony");
 list.add("eric");
 list.add("jack");
 Iterator<String> iterator = list.iterator();
 while (iterator.hasNext()){
 String str = iterator.next();
 System.out.println(str);
 }
 }

Collections工具类

常用方法

按⾃然排序的升序排序

List<String> list =new ArrayList<>()
list.add("aaaa");
 list.add("zzz");
 list.add("gggg");
 Collections.sort(list)
 System.out.println(list)

sort(List list, Comparator c) ⾃定义排序规则，由Comparator控制排序逻辑

List<String> list =new ArrayList<>();
list.add("aaaa");
 list.add("zzz");
 list.add("gggg");
 Collections.sort(list,Comparator.naturalOrder())//升序
  Collections.sort(list,Comparator.reverseOrder())//降序

获取最大值和最小值

获取最⼤元素 max(Collection coll) 默认⽐较，不适合对象⽐较
获取最⼤元素 max(Collection coll, Comparator comparator)

List<Student> list = new ArrayList<>();
 list.add(new Student("jack", 26));
 list.add(new Student("tom", 29));
 list.add(new Student("mary", 32));
 list.add(new Student("tony", 19));
 list.add(new Student("smith", 41));

Collections.max(list,new Comparator<String>){
 @Override
 public int compare(Student o1,Student o2){
	return o1.getAge()-o2.getAge();
}
}



class Student {
 public Student(String name, int age) {
 this.name = name;
 this.age = age;
 }
 private int age;
 private String name;
 public void setAge(int age) {
 this.age = age;
 }
 public int getAge() {
 return age;
 }
 public void setName(String name) {
 this.name = name;
 }
 public String getName() {
 return name;
 }
 @Override
 public String toString() {
 return "Student{" +
 "age=" + age +
 ", name='" + name + '\'' +
 '}';
 }

Comparable

是⼀个接⼝，定制排序规则
对实现它的每个类的对象进⾏整体排序，⾥⾯ compareTo ⽅法是实现排序的具体⽅

public class TestCom {
 public static void main(String [] args) {
 Set<Student> studentSet = new TreeSet<>();
 studentSet.add(new Student("jack",32));
 studentSet.add(new Student("tom",22));
 studentSet.add(new Student("mary",35));
 studentSet.add(new Student("tim",11));
 studentSet.add(new Student("tony",49));
 studentSet.add(new Student("dd",30));
 System.out.println(studentSet);
 }
}
 class Student implements Comparable{
 private int age;
 private String name;
 public void setAge(int age) {
 this.age = age;
 }
 public int getAge() {
 return age;
 }
 public void setName(String name) {
 this.name = name;
 }
 public String getName() {
 return name;
 }
 public Student(String name,int age){
 this.name = name;
 this.age = age;
 }
 @Override
 public String toString() {
 return "Student{" +
 "age=" + age +
 ", name='" + name + '\'' +
 '}';
 }
@Override
public int compareTo(Object o) {
 if(o instanceof Student){ //判断是不是属于这个接口
 Student student = (Student)o; 
 return this.age - student.age;
 }
 //返回的数是0代表两个对象相同
 return 0;
 }
}