存储过程与函数：封装数据库逻辑的艺术（七）

文章目录

• 一.集合
• • • 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类**
  • • 1.方法:
    • 2.HashSet去重
  • 二).TreeSet类
  • • 1.特点:
  • 三).LinkedHashSet类
• 四.Map接口
• • 一).定义
  • • 1.Map集合的特点
    • 2.分类
    • 3.常用方法:
  • 二).HashMap实现类
  • • 1.HashMap存储结构（扩展）----了解即可
    • • 1、**JDK1.8之前HashMap存在的问题？**
    • 2.底层结构---了解
  • 三).TreeMap实现类

一.集合

1.体系结构

二.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. 扩容

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

2.LinkedList

基于链表实现的类

3.Vector

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

一个对象,可遍历对象

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

三.LinkedList接口

1.定义:

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

2.特点:

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

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类

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"的对象

1.Map集合的特点

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

2.分类

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

3.常用方法:

二).HashMap实现类

使用类似ArrayList类

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

2.底层结构—了解

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