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.体系结构

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
2

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

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
1
2
3
4
5
6
7

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对象
        }
1
2
3
4

三.LinkedList接口

1.定义:

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

2.特点:

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

2.常用方法

四.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();
    }
}
1
2
3
4
5
6
7
8

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());
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

• 倒序

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

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;
//            }
1
2
3
4
5
6
7
8
9

六.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);
            }
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

三.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);
    }
​
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

二).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.常用方法:

二).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());
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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());
}

1