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.将数据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
其中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集合异常机制的主要内容，如果未能解决你的问题，请参考以下文章