韩老师Java第14章课程笔记

水深无声 2024-03-30 17:26 34阅读 0赞

#### 文章目录 ####

*  0.带你学英语
 *  1、集合框架体系图
 *   *  1.1 集合的来源起因
     *  1.2 集合的好处
     *  1.3 框架体系图
 *  2、Collection接口 特点 方法
 *   *  2.1 Collection接口和常用方法
     *  2.2 Collection接口遍历元素方式--使用Itereator(迭代器)
     *  2.3 增强for循环
     *  2.4 List接口基本介绍
 *  3、Collection接口的子接口：List实现类：ArrayList、LinkedList、Vector
 *   *  3.1 ArrayList注意事项
     *  3.2 Vector底层结构和源码剖析
     *  3.3 Vector与ArrayList比较
     *  3.4 LinkedList
     *  3.5 ArrayList与LinkedList比较
 *  4、Collection接口的子接口;set实现类;HashSet,LinkedHashSet
 *   *  4.1 Set接口常用方法
     *  4.2 Set接口遍历方式
     *  4.3 HashSet底层机制说明
     *  4.4 LinkedHashSet全面说明
 *  5、Map接口特点方法遍历方式
 *   *  5.1 Map接口实现类的特点
     *  5.2 Map结构特点
     *  5.3 Map接口常用方法
 *  6、Map接口实现类：HashMap、Hashtable等
 *   *  6.1 HashMap小结
     *  6.2 HashMap底层机制及源码剖析
     *  6.3 Hashtable与HashMap的对比
     *  6.4 Properties基本介绍类
     *  6.5 开发中集合实现类总结
 *  7、Collections工具类的使用（）

## 0.带你学英语 ##

*  structure 结构
 *  threhold 门槛
 *  dictionary 字典

## 1、集合框架体系图 ##

### 1.1 集合的来源起因 ###

数组

*  长度开始时必须指定，而且一旦指定，不能修改
 *  保存的必须为同一类型的元素
 *  使用数组进行增加元素的示意代码

### 1.2 集合的好处 ###

*  可以动态保存任意多个对象，使用比较方便
 *  提供了一系列1方便的操作对象方法
 *  使用集合添加、删除新元素的示意代码

### 1.3 框架体系图 ###

![在这里插入图片描述][b230c1698cf347a9aa51534416aa2a4b.png]  
![在这里插入图片描述][474b3f5c31d4443eb9dd758289e8c66d.png]

## 2、Collection接口 特点 方法 ##

### 2.1 Collection接口和常用方法 ###

1.  collection实现子类可以存放多个元素，每个元素可以是Object
2.  有些Collection的实现类，可以存放重复元素，有些不可以
3.  有些Collection的实现类，有些是有序的List，有些不是有序的Set
4.  Collection接口没有直接的实现子类，是通过它的子接口set和List来实现的。

public static void main(String[] args) {
        
            List l = new ArrayList();
            //add:添加单个元素
            l.add("john");
            l.add(10);
            l.add(true);
            System.out.println(l);
            //remove 删除指定元素
            l.remove(true);//指定删除某个元素
            System.out.println(l);
            //contains 查找元素是否存在
            System.out.println(l.contains("jack"));
            //size:获取元素个数
            System.out.println(l.size());
            //isEmpty:判断是否为空
            System.out.println(l.isEmpty());
            //clear 清空
            l.clear();
            System.out.println(l.isEmpty());
            //addAll:添加多个元素
            ArrayList l2 = new ArrayList();
            l2.add("红楼梦");
            l2.add("三国演义");
            l2.addAll(l2);
            System.out.println(l);
            //containsall:查找多个元素是否都存在
            System.out.println(l.containsAll(l2));
            //removeAll:删除多个元素
            l.add("聊斋");
            l.removeAll(l2);
            System.out.println("list" + l);

### 2.2 Collection接口遍历元素方式–使用Itereator(迭代器) ###

*  Iterator对象称为迭代器，主要用于遍历collection集合中的元素
 *  所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了iterator接口的对象，即可以返回一个迭代器.
 *  Iterator的结构
 *  iterator仅用于遍历集合，Iterator本身并不存放对象

public static void main(String[] args) {
        
            Collection col = new ArrayList();
            col.add(new Book("三国演义",10.1));
            col.add(new Book("小李飞刀",100.1));
            col.add(new Book("三国演义",100.1));
            col.add(new Book("三国演义",101.1));
            Iterator iterator = col.iterator();
            while (iterator.hasNext()) {
        
                Object next =  iterator.next();
                System.out.println("obj=" + next);
            }
    
            //3.当退出while循环后，这时iterator迭代器指向最后一个元素
            iterator = col.iterator();
            System.out.println("===第二次遍历===");
            while (iterator.hasNext()) {
        
                Object next =  iterator.next();
                System.out.println("obj=" + next);
            }

### 2.3 增强for循环 ###

增强for循环，可以代替iterator迭代器，特点:增强for就是简化版的iterator，本质一样，只能用于遍历集合或数组

List l = new ArrayList();
            l.add(new Dog("小黑",3));
            l.add(new Dog("大黑",4));
            l.add(new Dog("小黄",5));
            l.add(new Dog("老黄",6));
    
            for (Object o :l) {
        
                System.out.println(o);
            }

### 2.4 List接口基本介绍 ###

List接口是Collection接口的子接口

*  List集合类中元素有序
 *  list集合中的每个元素都有其对应的顺序索引，即支持索引
 *  List容器中的元素都对应一个整数型的序号记载其在1容器中的位置，可以根据序号存取容器中的元素
 *  JDK API中list接口的实现类有：

<table> 
 <thead> 
  <tr> 
   <th>函数名</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>void add(int index,Object ele)</td> 
   <td>在index位置插入ele元素</td> 
  </tr> 
  <tr> 
   <td>boolean addAll(int index,Collection eles)</td> 
   <td>从index位置开始将eles中的所有元素添加进来</td> 
  </tr> 
  <tr> 
   <td>Object get(int index)</td> 
   <td>获取指定index位置的元素</td> 
  </tr> 
  <tr> 
   <td>init indexOf(Object obj)</td> 
   <td>返回obj在集合中首次出现的位置</td> 
  </tr> 
  <tr> 
   <td>int lastIndexOf(Object obj)</td> 
   <td>返回obj当前集合中末次出现的位置</td> 
  </tr> 
  <tr> 
   <td>Object remove(int index)</td> 
   <td>移除指定index位置的元素，并返回此元素</td> 
  </tr> 
  <tr> 
   <td>Object set(int index,object ele)</td> 
   <td>设置指定index位置的元素为ele，相当于是替换</td> 
  </tr> 
  <tr> 
   <td>List subList(int fromIndex,int toIndex)</td> 
   <td>返回从fromIndex到toIndex位置的子集合</td> 
  </tr> 
 </tbody> 
</table>

List l = new ArrayList();
            l.add("张三丰");
            l.add("张无忌");
            l.add(1,"张三");
            System.out.println(l);
            List l2 = new ArrayList();
            l2 = l;
            l.addAll(1,l2);
            System.out.println(l);
            //indexOf 返回obj在集合中首次出现的位置
            System.out.println(l.indexOf("tom"));
            //lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
            l.add("韩顺平");
            System.out.println("list=" + l);
            System.out.println(l.lastIndexOf("韩顺平"));
            //object remove（int index）:移除指定index位置的元素
            l.remove(0);
            System.out.println(l);
            //设置指定元素
            l.set(1,"码力");
            System.out.println(l);
            //subList(int fromIndex,int toindex)返回从制定范围的集合
            List l3 = l.subList(0, 2);
            System.out.println(l3);

## 3、Collection接口的子接口：List实现类：ArrayList、LinkedList、Vector ##

### 3.1 ArrayList注意事项 ###

*  ArrayList是数组实现数据存储的
 *  arraylist基本等同于vector除了ArrayList是线程不安全的，多线程安全不要ArrayList
 *  ArrayList中维护了一个object类型的数组elementdata
 *  当创建了ArrayList对象时，如果使用的是无参构造器，则初始elementData容量为0，第一次添加则扩容elementData为10，如需再次扩容，则扩容elementData为1.5倍
 *  如果使用的是指定大小的构造器，则初始elementData容量为指定大小，如果需要扩容，则直接扩容elementData为1.5倍

### 3.2 Vector底层结构和源码剖析 ###

1.  Vector类的定义说明
2.  vector底层也是一个对象数组
3.  vector是线程同步的，即线程安全啊
4.  在开发中，需要线程同步安全时，考虑使用vector

### 3.3 Vector与ArrayList比较 ###

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>底层结构</th> 
   <th>版本</th> 
   <th>线程安全</th> 
   <th>扩容倍数</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ArrayList</td> 
   <td>可变数组</td> 
   <td>jdk1.2</td> 
   <td>不安全，效率高</td> 
   <td>如果有参构造1.5倍,如果是无参，第一次10，第二次开始按照1.5扩</td> 
  </tr> 
  <tr> 
   <td>Vector</td> 
   <td>可变数组object[]</td> 
   <td>jdk1.0</td> 
   <td>安全，效率不高</td> 
   <td>如果是无参，默认10，满后，就按2倍扩容，如果指定大小，则每次直接按2倍扩</td> 
  </tr> 
 </tbody> 
</table>

### 3.4 LinkedList ###

*  LinkedList实现了双向链表和双向队列特点
 *  可以添加任意元素(元素可以重复)，包括null
 *  线程不安全，没有实现同步

### 3.5 ArrayList与LinkedList比较 ###

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>底层结构</th> 
   <th>增删效率</th> 
   <th>改查效率</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ArrayList</td> 
   <td>可变数组</td> 
   <td>较低数组扩容</td> 
   <td>较高</td> 
  </tr> 
  <tr> 
   <td>LinkedList</td> 
   <td>双向链表</td> 
   <td>较高，通过链表追加</td> 
   <td>较低</td> 
  </tr> 
 </tbody> 
</table>

*  如果我们改查的操作多，选择ArrayList
 *  如果我们增删操作多，选择LinkedList
 *  一般来说，大部分情况用ArrayList
 *  在一个项目中，根据业务灵活选择

## 4、Collection接口的子接口;set实现类;HashSet,LinkedHashSet ##

1.  HashSet实现了Set接口
2.  Hashset实际上是hashmap
3.  可以存放null值，但是只能有一个null
4.  HashSet不保证元素是有序的，取决于hash后，在确定索引的结果
5.  不能有重复元素/对象

### 4.1 Set接口常用方法 ###

和List接口一样，set接口也是Collection的子接口，因此，常用方法和Collection接口一样

### 4.2 Set接口遍历方式 ###

同Collection的遍历方式一样，因为Set接口是Collection接口的子接口。

1.  可以使用迭代器
2.  增强for
3.  不能使用索引方式实现

### 4.3 HashSet底层机制说明 ###

1.  HashSet底层是HashMap
2.  添加一个元素时，先得到hash值，会转成->索引值
3.  找到存储数据表table，看这个索引位置是否已经存放的有元素
4.  如果没有，直接加入
5.  如果有，调用equals比较，如果夏娜沟通，就放弃添加，如果不相同，则添加到最后
6.  如果数组size大于等于64，并且链表长大于等于8
7.  HashSet底层是HashMap,第一次添加时，table数组扩容到16，临界值(threshold)是16\*加载因子,(loadFactor)是0.75 = 12
8.  如果table数组使用到了临界值12，就会扩容到16*2 = 32,新的临界值就是32*0.75=24
9.  在Java8中，如果一条链表的元素个数到达TREEIFY\_THRESHOLD（默认是8），并且是table的大小>=MIN\_TREEIFY\_CAPACITY(默认64)就会进行树化，否则采用数组扩容机制

### 4.4 LinkedHashSet全面说明 ###

*  LinkedHashSet是HashSet的子类
 *  LinkedHashSet底层是一个LinkedHashMap,底层维护一个数组+sdfsdf双向链表
 *  LinkedHashSet根据元素的HashCode值来决定元素的存储位置，同时使用链表维护元素的次序，这使得元素看起来是以插入顺序保存的。
 *  LinkedHashSet不允许重复元素
 *  在LinkedHashSet中维护了一个hash表和双向链表(LinkedHashSet有head和tail)
 *  每一个节点有before和aftere属性，这样可以形成双向链表
 *  在添加一个元素时，先求hash值，在求索引，确定该元素在table的位置，然后将添加的元素加入到双向链表

tail.next = newElement;
    newElement.pre = tail
    tail = newEelment;

*  这样的话，我们遍历LinkedHashSet也能确保插入顺序和遍历顺序一致

## 5、Map接口特点方法遍历方式 ##

### 5.1 Map接口实现类的特点 ###

*  Map与Collection并列存在，用于保存具有映射关系的数据Key-value
 *  Map中的key和value可以是任何引用类型的数据，会封装到HashMap$Node对象中
 *  Map中的key不允许重复，原因和HashSet一样
 *  Map中的value可以重复
 *  Map中的key可以为null，value可以为null，注意key和null只能有一个，value为null可以多个
 *  常用String类作为Map中的key
 *  key和value之间存在单向一对一关系，即通过指定的key总能找到对应的value

### 5.2 Map结构特点 ###

Map存放key-value示意图，一对k-v是放在一个hashMap$Node中的，有因为Node实现了Entry接口，有些书上也说一对k-v就是一个Entry如图

### 5.3 Map接口常用方法 ###

*  put：添加
 *  remove；根据建删除映射关系
 *  get:根据键获取值
 *  size:获取元素个数
 *  isEmpty:判断个数是否为0
 *  clear:清除
 *  contaiinsKey:查找键是否存在

## 6、Map接口实现类：HashMap、Hashtable等 ##

### 6.1 HashMap小结 ###

*  Map接口常用实现类：HashMap,Hashtable和Properties
 *  HashMap是map接口使用频率最高实现类
 *  Hashap是以key-val对的方式来存储数据
 *  key不能重复，但是最值可以重复，允许使用null键和null值
 *  与HashSet一样，不保证映射的顺序，因为底层是以hash表方式来存储的
 *  hashMap没有实现同步，因此是线程不安全的
 *

### 6.2 HashMap底层机制及源码剖析 ###

*  HashMap底层维护了Node类型的数组table，默认为null
 *  当创建对象时，将加载因子为0.75
 *  当添加key-val时，通过key的哈希值得到在table的索引，然后判断该索引处是否有元素，如果没有元素直接添加，如果该索引处有元素，继续判断该元素的key和准备加入的key相是否相等，如果相等，则直接替换val；如果不相等需要判断是树结构还是会链表结构，作出相应处理，如果添加发现容量不够，则需要扩容。
 *  第1次添加，则需要扩容table容量为16，临界值为12(16\*0.75)
 *  以后再扩容，则需要扩容table容量为原来的2倍(32),临界值为原来的2倍，即24，以此类推
 *  在Java8中，如果一条链表的元素个数超过TREEIFY\_THRESHOLD（默认是8），并且table的大小>=MIN\_TREEIFY\_CAPACITY(默认64)，就会进行树化

### 6.3 Hashtable与HashMap的对比 ###

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>版本</th> 
   <th>线程安全</th> 
   <th>效率</th> 
   <th>允许null键null值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Hashmap</td> 
   <td>1.2</td> 
   <td>不安全</td> 
   <td>高</td> 
   <td>可以</td> 
  </tr> 
  <tr> 
   <td>Hashtable</td> 
   <td>1.0</td> 
   <td>安全</td> 
   <td>较低</td> 
   <td>不可以</td> 
  </tr> 
 </tbody> 
</table>

### 6.4 Properties基本介绍类 ###

1.  Properties类继承自hashtable类并且实现了map接口，也是使用一种键值对的形式保存数据
2.  他的使用特点和Hashtable类似
3.  Properties还可以用于从xxx.properties文件中国，加载数据到properties类对象，并进行读取和修改
4.  说明:工作后xxx.properties文件通常作为配置文件

### 6.5 开发中集合实现类总结 ###

![在这里插入图片描述][3b2e815ef9194a53afab8ece9912e4b5.png]

## 7、Collections工具类的使用（） ##

import java.lang.reflect.Array;
    import java.util.*;
    
    public class _21_collection {
        
        public static void main(String[] args) {
        
            List l = new ArrayList();
            l.add("tom");
            l.add("smith");
            l.add("king");
            l.add("milan");
            //reeverse 反转List中元素的顺序
            Collections.reverse(l);
            System.out.println(l);
            //shuffle(List):对List集合元素进行随机排序
            Collections.shuffle(l);
            System.out.println(l);
            //sort(list):根据元素的自然顺序
            Collections.sort(l);
            System.out.println(l);
            //sort(list,comparator) 根据指定的Comparator产生指定
            Collections.sort(l, new Comparator() {
        
                @Override
                public int compare(Object o1,Object o2){
        
                    return ((String)o1).length() - ((String)o2).length();
                }
            });
            System.out.println(l);
            //swap(list，int,int )将制定list集合中的i处元素进行交换
            Collections.swap(l,0,2);
            System.out.println(l);
            //Object max(Collection)
            System.out.println("自然顺序最大元素" + Collections.max(l));
            //Object max(Collection Comparator)根据Comparator指定的顺序，返回给定集合中最大元素
            Object maxObject = Collections.max(l, new Comparator() {
        
                @Override
                public int compare(Object o1,Object o2){
        
                    return ((String)o1).length() - ((String)o2).length();
                }
            });
            System.out.println(maxObject);
            //Object min(Collection)
            //Object min(Collection Comparator)
            //上面两个方法，参考max即可
    
            //int frequency(Collection object):返回指定集合中指定元素的出现次数
            System.out.println("tom出现次数" + Collections.frequency(l,"tom"));
            //void copy(List l,List src);将src内容复制到dest
            ArrayList dest = new ArrayList();
    
            for(int i = 0;i<l.size();i++){
        
                dest.add("");
            }
            Collections.copy(dest,l);
            System.out.println(dest);
    
            Collections.replaceAll(l,"tom","汤姆");
            System.out.println(l);
            //boolean replace(List l,Object o,Object n);
        }
    }

[b230c1698cf347a9aa51534416aa2a4b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/35f75daae55d430e8d0cb8d1015dc323.png
[474b3f5c31d4443eb9dd758289e8c66d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/63abfb62d4c847a9b83dcea0857802c1.png
[3b2e815ef9194a53afab8ece9912e4b5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/491fb1f42a334bc783b50b65e12c02c5.png