5.javaSE基础__集合(List+Set+Map实现类)

\1. 抽象类和接口的区别

1. 抽象类的需要abstract修饰,内部方法可以是抽象的也可以是不抽象的
2. 接口: 可以看成抽象类,但不是类,方法没有方法体(1.8之前),由实现类实现具体方法功能

\1. 什么是异常

程序运行时出现的错误

\1. 异常的分类

1. Error
2. Exception
   • RunTimeException: 除0,空指针,数字类型不匹配
   • 非RunTimeException: 找不到文件 FileNotExceptiojn

\1. 常见的异常有哪些

\1. try...catch...finally里每个模块分别做什么

• try : 监控代码,由jvm抛出异常
• catch: 接受异常
• finally: 善后处理,必须要走的一步

\1. throw和throws的区别

• tthrow: 抛出异常类型指向对象
• throws: 异常指向类

文章目录

• 一.集合
• • • 1.体系结构
• 二.List接口
• • • 1.ArrayList
    • 2.LinkedList
    • 3.Vector
    • 4.泛型generics
    • 5.迭代器Iterator
  • 三.LinkedList接口
  • • 1.定义:
    • 2.特点:
    • 2.常用方法
  • 四.Vetor类
  • 五.集合排序
  • • 1.Comparable
    • 2.使用Comparator匿名内部类
    • 3.使用List接口自带的sort()方法
  • 六.List的contains()方法去重
• 三.Set接口
• • • 1.特征:
    • 2.分类:
  • **++一).HashSet类++**.HashSet类**)
  • • 1.方法:
    • 2.HashSet去重
  • 二).TreeSet类.TreeSet类)
  • • 1.特点:
  • 三).LinkedHashSet类.LinkedHashSet类)
• 四.Map接口
• • 一).定义.定义)
  • • 1.Map集合的特点
    • 2.分类
    • 3.常用方法:
  • 二).HashMap实现类.HashMap实现类)
  • • 1.HashMap存储结构（扩展）----了解即可
    • • 1、**JDK1.8之前HashMap存在的问题？**
    • 2.底层结构---了解
  • 三).TreeMap实现类.TreeMap实现类)

一.集合

1.体系结构

Collection

1. List

   有序可重复,允许插入Boolean值,null值

   • ArrayList
   • LinkedList
   • Vertor

2. Set

   无序不可重复

3. Map

二.List接口

继承Collecting接口,允许出现重复元素,元素存入顺序和取出顺序一致

1.ArrayList

基于数组实现的类,动态增减数组的大小

//默认存储object对象,任何元素都可存放(null,boolean....)
ArrayList<Object>  arrayList = new ArrayList<>();

特点: 插入和删除慢,访问块,线程不安全,不适用多线程;

1. 常用方法:

   void add(int index, Object element):	在指定位置index上添加元素element
   boolean addAll(int index, Collection c):	将集合c的所有元素添加到指定位置index
   Object get(int index):	返回List中指定位置的元素
   int indexOf(Object o):	返回第一个出现元素o的位置，否则返回-1
   int lastIndexOf(Object o) ：	返回最后一个出现元素o的位置，否则返回-1
   Object remove(int index)	删除指定位置上的元素
   Object set(int index, Object element)	用元素element取代位置index上的元素，并且返回旧的元素

2. 扩容

   创建大的新数组,将原所有元素赋值进去

   • 当添加元素后，size 大小已经等于或超过了数组的容量 capacity 时，就会触发扩容操作。
   • 扩容的大小默认情况下为原数组大小的一半。比如原数组大小为 10，那么扩容后的数组大小为 15。(1.5倍扩容)
   • 如果扩容后的大小还是不够，那么就以添加元素的数量作为扩容大小，即新数组的大小为 oldCapacity + (oldCapacity >> 1) + 1。

2.LinkedList

基于链表实现的类

特点: 插入和删除快,访问慢,线程不安全,不适用多线程;

3.Vector

特点: 访问和插入快,支持同步操作,适用于多线程环境;效率比ArrayList低,不推荐单线程环境下使用

4.泛型generics

编译时数据类型的安全检测机制,数据类型被指定为一个参数,数据类型要一致;

        TreeSet<Integer> treeSet = new TreeSet<>();//数据类型Integer,传递参数类型一致为Integer
        treeSet.add(1);
        treeSet.add(5);
        treeSet.add(2);
        treeSet.add(4);
        treeSet.add(5);
        treeSet.add("aa");//报错:ClassCastException

5.迭代器Iterator

一个对象,可遍历对象

Java中的Iterator功能比较简单，只能单向移动：

• 使用方法iterator()要求容器返回一个Iterator。
• 第一次调用Iterator的next()方法时，它返回序列的第一个元素。
• 使用next()获得序列中的下一个元素。
• ++使用hasNext()检查序列中是否还有元素。++
• ++使用remove()将迭代器所指向的集合删除元素。++

        Iterator<Employee> iterator = list.iterator();
        while (iterator.hasNext()) {//判断元素是否存在
            System.out.println(iterator.next());//存在则输出所有Employee对象
        }

三.LinkedList接口

1.定义:

双向链表结构,方便插入和删除元素,不支持快速访问

2.特点:

• LinkedList没有实现RandomAccess接口，因此LinkedList不支持随机访问
• LinkedList的任意位置插入和删除元素时效率比较高，时间复杂度为O(1)
• LinkedList比较适合任意位置插入的场景

2.常用方法

方法	说明
public void addFirst(E e)	将指定元素插入集合的开头
public void addLast(E e)	将指定元素插入集合的结尾
public E getFirst()	返回集合第一个元素
public E getLast()	返回集合最后一个元素
public E removeFirst()	移除并返回集合的第一个元素
public E removeLast()	移除并返回最后一个元素
public E pop()	从集合所表示的堆栈中弹出一个元素
public void push(E e)	将元素推入集合所表示的堆栈中
public boolean isEmpty()	判断集合是否为空

四.Vetor类

五.集合排序

1.Comparable

1. 实体类实现Comparable接口
2. 重写compareTo()方法
3. Collections.sort()排序//默认升序

//实体类Employee实现`Comparable`接口
public class Employee implements Comparable{
............
@Override
    public int compareTo(Employee o) {
        return this.getAge() - o.getAge();
    }
}

compareTo（）方法，该方法的返回值0代表相等，1表示大于，-1表示小于；

2.使用Comparator匿名内部类

public static void main(String[] args) {
        ArrayList<Employee> list = new ArrayList<>();
        list.add(new Employee("arran", 23,123));
        list.add(new Employee("arran", 22,3243));
        list.add(new Employee("arran", 22,3123));
        list.add(new Employee("arran", 26,435));
//        while (iterator.hasNext()) {
//            System.out.println(iterator.next());
//        }
//        });
  	//匿名内部类
        list.sort(new Comparator<Employee>() {
            @Override
            public int compare(Employee o1, Employee o2) {
                return o1.getAge()-o2.getAge();
            }
        });
  	//迭代器遍历对象
        Iterator<Employee> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

• 倒序

  //参数颠倒下位置    
  public int compare(Employee o1, Employee o2) {
                  return o2.getAge()-o1.getAge();
              }

3.使用List接口自带的sort()方法

//        Collections.sort(list, new Comparator<Employee>() {
//            @Override
//            public int compare(Employee o1, Employee o2) {
//                int result=o1.getAge()-o2.getAge();
//                if (result==0) {
//                    result=(int)(o1.getSalary()-o2.getSalary());
//                }
//                return result;
//            }

六.List的contains()方法去重

  public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<>();
        list.add(11);
        list.add(55);
        list.add(33);
        list.add(55);
        list.add(44);
//        System.out.println(list);
        ArrayList<Object> objects1 = new ArrayList<>(list);
        for (Object o : list) {//遍历对象数组list,如果不包含
            if (!objects1.contains(o)) {
                objects1.add(o);
            }
        }

三.Set接口

1.特征:

• 扩展Collection接口
• 不重复元素
• 无序
• 允许存储null元素，但是最多只能有一个(HashSet)

2.分类:

1. ++HashSet类++

   元素无序排列,允许有null,重复的元素背覆盖

2. ++TreeSet类++

   元素按顺序排列

3. LinkedHashSet类

++一).HashSet类++

1.方法:

类似List或ArrayList类

2.HashSet去重

public class Main {
​
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        list.add(11);
        list.add(22);
        list.add(33);
        list.add(11);
        Set<Integer> hashSet = new HashSet<Integer>(list);
        list = new ArrayList<Integer>(hashSet);
        System.out.println(list);
    }
​
}

二).TreeSet类

1.特点:

• 结构红黑树算法(树结构实现);
• 元素按顺序排列
• 方法类似LIst...,contains()

三).LinkedHashSet类

LinkedHashSet正好介于HashSet和TreeSet之间，它也是一个hash表，但它同时维护了一个双链表来记录插入的顺序

四.Map接口

一).定义

Map是将键"key"映射到值"value"的对象

Map 接口提供三种collection 视图:

1. 键集: keySet()
2. 值集: values()
3. 键-值集: entrySet()

1.Map集合的特点

• 双列集合,包含key和value;
• Map集合中的元素，key和value的数据类型可以相同，也可以不同
• key不允许重复,value可以重复;
• key和value是一一对应的。

2.分类

1. HashMap类：
2. TreeMap类：
3. LinkedHashMap类：

3.常用方法:

方法	说明
Object put(Object key, Object value)	将互相关联的一组键/值对放入该映像
Object remove(Object key)	从映像中删除与key相关的映射
void putAll(Map t)	将来自特定映像的所有元素添加给该映像
void clear()	从映像中删除所有映射
Object get(Object key)	获得与关键字key相关的值
boolean containsKey(Object key)	判断映像中是否存在关键字key
boolean containsValue(Object value)	判断映像中是否存在值value
int size()	返回当前映像中映射的数量
boolean isEmpty()	判断映像是否为空
Set keySet()	返回映像中所有关键字的视图集
Collection values()	返回映像中所有值的视图集
Set entrySet()	返回Map.Entry对象的视图集，即映像中的关键字/值对

二).HashMap实现类

使用类似ArrayList类

1.HashMap存储结构（扩展）----了解即可

HashMap底是哈希表，查询速度非常快（jdk1.8之前是数组+单向链表，1.8之后是数组+单向链表/红黑树 ，链表长度超过8时，换成红黑树），可参考：

1. 数组优点：通过数组下标可以快速实现对数组元素的访问，效率极高；
2. 链表优点：插入或删除数据不需要移动元素，只需修改节点引用，效率极高。

1、JDK1.8之前HashMap存在的问题？

HashMap通过hash方法计算key的哈希码，然后通过(n-1)&hash公式（n为数组长度）得到key在数组中存放的下标。当两个key在数组中存放的下标一致时，数据将以链表的方式存储（哈希冲突，哈希碰撞）。在链表中查找数据必须从第一个元素开始一层一层往下找，直到找到为止，时间复杂度为O(N)，所以当链表长度越来越长时，HashMap的效率越来越低。

2.底层结构---了解

HashMap内部使用数组存储数据，数组中的每个元素类型为Node<K,V>：

Node包含了四个字段：hash、key、value、next，其中next表示链表的下一个节点。

三).TreeMap实现类

       TreeMap<Object, Object> treeMap = new TreeMap<>();
        treeMap.put("111","wefweg");
        treeMap.put("333","fwef");//key不能为空null,输出NullPointerException
        treeMap.put("444",null);//ClassCastException, key不允许重复
        treeMap.put("222","wefweg");
        treeMap.put("5555","wefweg");//参
        System.out.println(treeMap);
        //迭代方式1: 通过key获取value
        Set<Object> keySet = treeMap.keySet();
        for (Object o : keySet) {
            System.out.println(o+":"+treeMap.get(o));
        }
        System.out.println("........................");
        //迭代方式2: entrySet()获得key
        Set<Map.Entry<Object, Object>> entries = treeMap.entrySet();
        for (Map.Entry<Object, Object> entry : entries) {
            System.out.println(entry.getKey()+":"+entry.getValue());
        }

ect o : keySet) {

System.out.println(o+":"+treeMap.get(o));

}

System.out.println("...");

//迭代方式2: entrySet()获得key

Set<Map.Entry<Object, Object>> entries = treeMap.entrySet();

for (Map.Entry<Object, Object> entry : entries) {

System.out.println(entry.getKey()+":"+entry.getValue());

}