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

Posted Recently 祝祝

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java阶段三-Queue集合Set集合Map集合异常机制相关的知识,希望对你有一定的参考价值。

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

1.Queue集合(重点)

1.1 基本概念
java.util.Queue集合是Collection集合的子集合,与List集合是平级关系。
该集合的主要实现类是:LinkedList类,因为该类在增删方面有一定的优势
该集合用于描述具有先进先出特征的数据结构,叫做队列(first in first out)。
在这里插入图片描述
1.2队列的方法:
在这里插入图片描述
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.将数据1122334455依次放入队列中
        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
在这里插入图片描述
在这里插入图片描述
其中TreeSet类的底层采用二叉树进行数据管理的。
在这里插入图片描述
在这里插入图片描述
Ctrl+O:开始搜索

2.2 常用的方法
参考Collection集合的方法即可https://blog.csdn.net/qq_45656077/article/details/116431318?spm=1001.2014.3001.5501
在这里插入图片描述

注意:
当使用迭代器迭代集合中的所有元素时,若使用集合中的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));

输出一个整体:
在这里插入图片描述

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方法。
在这里插入图片描述

   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 常用的方法
在这里插入图片描述
在这里插入图片描述
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));
        }
    }

在这里插入图片描述

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 - 数字格式异常
在这里插入图片描述
注意:
当程序执行过程中发生异常但没有手动处理时,由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

以上是关于java阶段三-Queue集合Set集合Map集合异常机制的主要内容,如果未能解决你的问题,请参考以下文章

Java集合

java集合框架详解

java集合 Collection,Map

Java Collection集合中List,Set,Queue以及Map的使用

华为三面:说说ListMap和Set有什么区别?

java集合List,Map,Set,Queue使用