by java集合group java集合queue

(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集合的方法即可

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