java阶段三-Queue集合、Set集合、Map集合、异常机制

布满荆棘的人生 2023-10-04 12:38 5阅读 0赞

### (1)Queue集合 (2)Set集合 (3)Map集合 (4)异常机制 ###

### 1.Queue集合(重点) ###

1.1 基本概念  
java.util.Queue集合是Collection集合的子集合，与List集合是平级关系。  
该集合的主要实现类是：**LinkedList类，因为该类在增删方面有一定的优势**。  
该集合用于描述具**有先进先出**特征的数据结构，叫做**队列**(first in first out)。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70]  
1.2队列的方法：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 1]  
1：offer

package StructTest;
    
    import java.util.LinkedList;
    import java.util.Queue;
    import java.util.concurrent.LinkedBlockingDeque;
    
    public class QueueTest {
        
        public static void main(String[] args) {
        
            // 1.声明Queue类型的引用指向实现类的对象
            Queue<Integer> q1=new LinkedList<Integer>();
            // 2.将数据11、22、33、44、55依次放入队列中
            for(int i=0;i<=5;i++){
        
                boolean b1=q1.offer(i*11);
                System.out.println("b1="+b1);
                System.out.println("队列中的元素有："+q1);
            }
            }

2：peek

// 3.获取队首元素并打印
            System.out.println("队首元素为："+q1.peek());
            System.out.println("------------------------");

3：poll

// 4.将队列中的所有元素依次删除并打印
            int len=q1.size();
            for (int i=0;i<=len;i++){
        
                System.out.println("出栈的元素是："+q1.poll());
            }
            System.out.println("--------------------");
            // 5.打印队列中最终的所有元素
            System.out.println("队列中的最终的元素有："+q1);

### 2.Set集合(重点) ###

2.1 基本概念  
java.util.Set集合是Collection集合的子集合，与List集合以及Queue集合平级关系  
该集合与List集合的主要区别在于：**元素没有先后次序并且不允许重复的元素。**  
该集合的主要实现类有：HashSet类 和 TreeSet类。  
其中HashSet类的底层采用哈希表进行数据管理的。  
**可迭代，iterator**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 3]  
其中TreeSet类的底层采用二叉树进行数据管理的。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 4]  
![在这里插入图片描述][20210507160005864.png]  
Ctrl+O：开始搜索

2.2 常用的方法  
参考Collection集合的方法即可[https://blog.csdn.net/qq\_45656077/article/details/116431318?spm=1001.2014.3001.5501][https_blog.csdn.net_qq_45656077_article_details_116431318_spm_1001.2014.3001.5501]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 5]

注意：  
当使用迭代器迭代集合中的所有元素时，若使用集合中的remove方法来删除元素，则会出现ConcurrentModificationException并发修改异常，以后的开发中应该使用迭代器的remove方法来删除元素。

Demo：

**1：add**

package StructTest;
    
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.Set;
    
    public class SetTest {
        
        public static void main(String[] args) {
        
            // 1.声明Set集合的引用指向实现类的对象
            Set<String> s1=new HashSet<String>();
            // 2.向集合中添加元素并打印出来
            boolean b1=s1.add("two");
            System.out.println("b1="+b1);//b1=true
            System.out.println("集合中添加元素有："+s1);//[two]
    
            b1=s1.add("one");
            System.out.println("b1="+b1);//b1=true
            // 没有先后放入次序
            b1=s1.add("three");
            System.out.println("b1="+b1);//b1=true
    
            b1=s1.add("three");
            System.out.println("b1="+b1);//b1=true
            // 该集合中的元素不允许重复
            // 自动调用toString方法，打印String类型的整体
            System.out.println("集合中添加元素有："+s1);//[one, two, three]
            
    
        }
    }

**2：迭代：next，hasnext**

// 3.使用迭代器来访问集合中的所有元素
            // 3.1 调用成员方法获取迭代器对象
            Iterator<String> it= s1.iterator();
            // 3.2 使用迭代器对象获取每个元素并打印
            // 判断该迭代器指向的集合中是否拥有可以迭代/遍历的元素
            System.out.println(it.hasNext());//true
            // 获取一个元素并指向下一个位置
            // 与toString方法相比取出的是单个元素，更加灵活
            while (it.hasNext()){
        
                System.out.println("取出的元素是："+it.next());
            }
            //练习：使用StringBuilder类和迭代器实现toString方法的效果
            // 4.1.构造StringBuilder类型的对象用于拼接
            StringBuilder str=new StringBuilder();
    //        方法-：
            // 4.2.使用迭代器取出集合中的每个元素并拼接到StringBuilder对象中
            str.append("集合中的元素有：[");
    //        重新获取迭代器
            it=s1.iterator();
            while (it.hasNext()){
        
                String ts=it.next();
                if (it.hasNext()) {
        
                    str.append(it.next()).append(",").append(" ");
                }else {
        
                    str.append(ts).append("]");
                }
            }
    //        最后多余的逗号和空格删除
    //        str.delete(str.length()-2,str.length()).append("]");
            System.out.println(str);
    
            System.out.println("-------------------");

**3:remove**

// 5.使用迭代器来获取集合中的所有元素，当元素值为"two"时则删除该元素
            // 5.1 重新获取迭代器对象
            it=s1.iterator();
            // 5.2 取出集合中的每个元素并进行判断，若是"two"则删除
            while (it.hasNext()){
        
                String ts=it.next();
                if ("two".equals(ts)){
        
                    it.remove();
                }
            }
            // 5.3 打印删除之后的结果
            System.out.println("执行删除操作后的集合元素有："+s1);

2.3 增强版的for循环(for each结构)  
(1)语法格式  
for(元素类型 变量名 : 数组名/集合名) \{  
循环体;  
\}

(2)执行流程  
不断地从数组或集合中取出一个元素并赋值给变量并执行循环体，直到处理完毕所有元素为止。

总结：  
遍历Set集合的方式有三种：  
1:toString()

int[] arr1={
        1,2,3,4};
     System.out.println(Arrays.toString(arr1));

输出一个整体：  
![在这里插入图片描述][20210510103011671.png]

2:for each结构

//        2:for each
            int[] arr1={
        1,12,3,1,3,8};
            for (int i: arr1){
        
                System.out.println(i);
            }
        }

3:迭代器方式

Iterator<String> it= s1.iterator();
            // 3.2 使用迭代器对象获取每个元素并打印
            // 判断该迭代器指向的集合中是否拥有可以迭代/遍历的元素
            System.out.println(it.hasNext());//true
            // 获取一个元素并指向下一个位置
            // 与toString方法相比取出的是单个元素，更加灵活
            while (it.hasNext()){
        
                System.out.println("取出的元素是："+it.next());
            }

**遍历List集合的方式有四种：除了上述3种方式外，还有get方法。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 6]

for (String ts : s1){
        
                System.out.println(ts);
            }
            System.out.println("------------------------------");
            int[] arr={
        11,22,33,44,55};
            for (int i:arr){
        
                System.out.println(i);

### 3.Map集合(重点) ###

3.1 基本概念  
java.util.Map<K,V>集合中操作元素的基本单位是：**单对元素**，其中类型参数如下：  
K - 此映射所维护的键(key)的类型  
V - 映射值(value)的类型

该集合中**不允许出现重复的键**，**每个键最多只能映射到一个值。**  
该集合的主要实现类有：HashMap类 和 TreeMap类。  
其中HashMap类的底层是采用**哈希表**进行数据管理的。  
其中TreeMap类的底层是采用**二叉树**进行数据管理的。

3.2 常用的方法  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 7]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 8]  
**Demo：**  
1：put  
**注意：  
1：当put所传入的索引值已经存在时，之前的值会被后传入的值覆盖  
2：Java字符串，字符需要用双引号  
3：在下面的代码中，str1用来接收被修改的值，传给str1**

package StructTest.MapTest;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    public class maptest1 {
        
        public static void main(String[] args) {
        
            // 1.声明Map类型的引用指向实现类的对象
            Map<Integer,String> m1=new HashMap<Integer,String>();
            // 2.向集合中添加元素并打印
            String str1=m1.put(1,"one");
            System.out.println("str1="+ str1);//str1=null
    
            str1=m1.put(2,"two");
            System.out.println("str="+str1);
            // 自动调用toString方法，默认格式为：{
        key1=value1, key2=value2, ...}
            System.out.println(m1);//{
        1=one, 2=two}
            m1.put(3,"three");
            System.out.println(m1);//{
        1=one, 2=two, 3=three}
            // 实现了修改的功能
            str1 =m1.put(1,"shimmer");
            System.out.println("str1="+str1);//str1=one
            System.out.println(m1);//{
        1=shimmer, 2=two, 3=three}
    
          
        }
    
    }

2：get，  
**注意：get()传入的是键，取出的是他的value，传值判断不了一直返回null**

// 3.实现查找的功能,get ,根据key返回value
            String str2=m1.get(2);//two
            System.out.println(str2);
    
            str2=m1.get("one");//null
            System.out.println(str2);
    
            str2=m1.get(11);//null
            System.out.println(str2);

containsKey

System.out.println(m1.containsKey(1));//true
     System.out.println(m1.containsKey(11));//false

containsValue

System.out.println(m1.containsValue("one"));//false
     System.out.println(m1.containsValue("shimmer"));//true

3：remove  
删除也是传入键删除值

// 4.实现删除的功能
            String str3 =m1.remove(5);
            System.out.println(str3);//null
            str3=m1.remove(1);
    
            System.out.println("集合中的元素还有："+m1);//{
        2=two, 3=three}

4：map集合中遍历方式一

// 遍历方式一：调用toString方法，String类型的整体
    System.out.println("集合中的元素有："+m1);//集合中的元素有：{
        2=two, 3=three}

5：map集合中遍历方式二

// 遍历方式二：调用entrySet方法，以键值对为基本单位进行转换  灵活
            // 使用for each结构遍历Set集合中的所有元素
            Set<Map.Entry<Integer,String>> s1=m1.entrySet();
            for (Map.Entry<Integer,String> me :s1){
        
                System.out.println(me);
    //            2=two
    //            3=three
            }

6：map集合中遍历方式三

Set<Integer> s2=m1.keySet();
            for (Integer in :s2){
        
                System.out.println(in+"="+m1.get(in));
            }
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 9]

### 4.异常机制(重点、简单) ###

4.1 基本概念  
异常就是\*\*"不正常"**的含义，在Java语言中用于**表示运行阶段发生的错误\*\*。  
java.lang.Throwable类是Java语言中**所有错误(Error)和异常(Exception)的超类**。  
其中Error类主要用于描述**比较严重**无法编码解决的问题，如：JVM挂了。  
其中Exception类主要用于描述**比较轻微**可以编码解决的问题，如：0作为除数。

4.2 基本分类  
java.lang.Exception类是所有异常类的超类，主要分为以下两大类：  
RuntimeException - 运行时异常，也叫作**非检测性异常**

Thread.sleep(1000);

IOException和其它异常 - 其它异常，也叫作**检测性异常**
             - 所谓检测性异常就是在编译阶段能够被编译器检测出来的异常

其中RuntimeException类的主要子类：  
ArithmeticException - 算术异常  
ArrayIndexOutOfBoundsException - 数组下标越界异常  
NullPointerException - 空指针异常  
ClassCastException - 类型转换异常  
NumberFormatException - 数字格式异常  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 10]  
**注意：  
当程序执行过程中发生异常但没有手动处理时，由Java虚拟机采用默认方式处理，而默认处理方式就是：打印异常名称、异常原因、异常发生的位置等并终止程序。**

4.3 异常的避免  
在以后的开发中尽量使用if条件判断来避免异常的发生。

package cn.learn.day14;
    
    import java.io.IOException;
    
    public class ExceptionPreventTest {
        
    
    	public static void main(String[] args) {
        
    		
    		int ia = 10;
    		int ib = 0;
    		if(0 != ib) {
        
    			System.out.println(ia / ib);
    		}
    		
    		int[] arr = new int[5];
    		int pos = 5;
    		if(pos >= 0 && pos < arr.length) {
        
    			System.out.println(arr[pos]);
    		}
    		
    		String str1 = null;
    		if(null != str1) {
        
    			System.out.println(str1.length());
    		}
    		
    		Exception ex = new Exception();
    		if(ex instanceof IOException) {
        
    			IOException ie = (IOException)ex;
    		}
    		
    		String str2 = "123a";
    		if(str2.matches("\\d+")) {
        
    			System.out.println(Integer.parseInt(str2));
    		}
    		
    		System.out.println("程序总算结束了！");
    	}
    
    }

作业：  
1.复习和总结集合的所有内容，重点掌握Queue集合Set集合的代码。  
2.准备一个HashSet集合，实现生成10个1~20之间不重复的随机数放入集合并打印。  
3.声明一个List集合放入11、22、33、44、55，分别使用4种方式遍历。  
4.准备一个HashMap集合，统计字符串"123,456,789,123,456"中每个数字字符串出现 的次数并打印出来。  
**作业解析：**[https://shimo.im/docs/cTgQPCxvkccDTyp8][https_shimo.im_docs_cTgQPCxvkccDTyp8]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210507153548409.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210507153601340.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210507155528986.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20210507155625419.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20210507155945339.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3,size_16,color_FFFFFF,t_70
[20210507160005864.png]: https://img-blog.csdnimg.cn/20210507160005864.png
[https_blog.csdn.net_qq_45656077_article_details_116431318_spm_1001.2014.3001.5501]: https://blog.csdn.net/qq_45656077/article/details/116431318?spm=1001.2014.3001.5501
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20210507160043413.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3,size_16,color_FFFFFF,t_70
[20210510103011671.png]: https://img-blog.csdnimg.cn/20210510103011671.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20210510102043733.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20210510103443464.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20210510103519675.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20210510172333759.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/20210510173224592.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3,size_16,color_FFFFFF,t_70
[https_shimo.im_docs_cTgQPCxvkccDTyp8]: https://shimo.im/docs/cTgQPCxvkccDTyp8