6.15集合1 和 泛型

news2024/12/28 4:06:29

举例 1:中药店,每个抽屉外面贴着标签请添加图片描述

举例 2:超市购物架上很多瓶子,每个瓶子装的是什么,有标签请添加图片描述

举例 3:家庭厨房中请添加图片描述

集合

我们接下来要学习的内容是Java基础中一个很重要的部分:集合

1 Collection接口
1.1 集合前言
Java语言的java.util包中提供了一些集合类,这些集合类又称之为容器
提到容器不难想到数组,集合类与数组最主要的不同之处是,数组的长度是固定的,集合的长度是可变的,而数组的访问方式比较单一,插入/删除等操作比较繁琐,而集合的访问方式比较灵活

在这里插入图片描述

常用的集合类有List集合,Set集合,Map集合,其中List集合与Set集合继承了Collection接口,各个接口还提供了不同的实现类.

在这里插入图片描述

1.2 集合概念

集合的英文名称是Collection,是用来存放对象的数据结构,而且长度可变,可以存放不同类型的对象,并且还提供了一组操作成批对象的方法.Collection接口层次结构 中的根接口,接口不能直接使用,但是该接口提供了添加元素/删除元素/管理元素的父接口公共方法.
由于List接口与Set接口都继承了Collection接口,因此这些方法对于List集合和Set集合是通用的.

1.3 集合的继承结构

Collection接口
List 接口【数据有下标,有序,可重复】
ArrayList子类
LinkedList子类
Set 接口【数据无下标,无序,不可重复】
HashSet子类
Map 接口【键值对的方式存数据】
HashMap子类

1.4 Collection方法速查表

在这里插入图片描述

1.5 练习:Collection接口测试

创建包: cn.tedu.collection
创建类: TestCollection.java

package cn.tedu.collection;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;

/**本类用于测试Collection接口*/
public class TestCollection {
    public static void main(String[] args) {
        //1.创建Collection相关的对象
        //Collection c = new Collection();//报错,因为Collection是接口
        //<Integer>是泛型,用来约束集合中的数据类型,不能是基本类型,必须是引用类型
        Collection<Integer> c = new ArrayList<>();

        //2.1测试集合中的常用方法--单个集合间的操作
        c.add(100);//向集合中添加元素 Ctrl+D快速向下复制
        c.add(200);//向集合中添加元素
        c.add(300);//向集合中添加元素
        c.add(400);//向集合中添加元素
        c.add(500);//向集合中添加元素
        System.out.println(c);//直接打印集合,查看集合中的元素

//        c.clear();//清空当前集合中的所有元素
//        System.out.println(c);

        System.out.println(c.hashCode());//获取集合对象的哈希码值
        System.out.println(c.toString());//打印集合的具体元素
        System.out.println(c.equals(200));//false,集合对象c与值200是否相等

        System.out.println(c.contains(200));//true,c集合中是否包含指定元素200
        System.out.println(c.isEmpty());//false,判断集合是否为空
        System.out.println(c.remove(100));//true,移除集合中的指定元素,成功返回true
        System.out.println(c);//[200, 300, 400, 500]
        System.out.println(c.size());//4,返回集合的元素个数

        Object[] array = c.toArray();//将指定的集合转为数组Object[]
        System.out.println(Arrays.toString(array));//[200, 300, 400, 500]

        //2.2测试多个集合间的操作
        Collection<Integer>  c2 = new ArrayList<>();//创建第2个集合
        c2.add(2);//向c2集合添加元素
        c2.add(4);//向c2集合添加元素
        c2.add(5);//向c2集合添加元素
        System.out.println(c2);//查看c2集合中的元素

        c.addAll(c2);//把c2集合的所有元素添加到c集合当中
        System.out.println(c);//c2集合的所有元素追加到了c集合末尾
        System.out.println(c2);//c2集合本身没有任何改变

        //当前集合c是否包含指定集合c2中的所有元素
        System.out.println(c.containsAll(c2));
        System.out.println(c.contains(200));//c是否包含单个指定元素200

        System.out.println(c.removeAll(c2));//删除c集合中属于c2集合的所有元素
        System.out.println(c);

        System.out.println(c.add(5));
        System.out.println(c);
        System.out.println(c.retainAll(c2));//取c集合与c2集合的交集(公共元素)
        System.out.println(c);//[5]

        //3.迭代集合/遍历集合
        /**迭代步骤:
         * 1.获取集合的迭代器 c.iterator();
         * 2.判断集合中是否有下一个可迭代的元素 it.hasNext()
         * 3.获取当前迭代到的元素 it.next()*/
        Iterator<Integer> it = c.iterator();
        while(it.hasNext()){
            Integer num = it.next();
            System.out.println(num);
        }
    }
}

为了更好的理解集合,我们需要首先引入一个概念:泛型

集合类在设计阶段/声明阶段不能确定这个集合到底实际存的是什么类型的对象或者数据,那么这个时候就需要使用泛型;
泛型即为“参数类型”,这个类型参数在
声明它的类、接口或方法中,代表未知的某种通用类型
请添加图片描述

泛型的格式

泛型长什么样

在这里插入图片描述
其实就是< ? >的部分,它就是泛型
泛型是(Generics)JDK1.5 的一个新特性,通常用来和集合对象一起使用
泛型概念非常重要,它是程序的增强器,它是目前主流的开发方式

集合中没有使用泛型时:

请添加图片描述

作用

那泛型有什么作用呢?
本质上就是编译器为了提供更好的可读性而提供的一种小手段,小技巧,虚拟机层面是不存在所谓“泛型”的概念的。是不有点神奇,不知所云,别着急等我讲完你就清楚了。

Java 泛型可以保证如果程序在编译时没有发出警告,运行时就不会产
生异常。即把不安全的因素在编译期间就排除了,而不是运行期;
既然通过了编译,那么类型一定是符合要求的,就避免了类型转换。
同时,代码更加简洁、健壮。

2.3 泛型示例

示例 1 : 我们创建一个ArrayList,看到eclipse发出黄线警告,这是为什么呢?
原因:ArrayList定义时使用了泛型,在声明时需要指定具体的类型请添加图片描述

arraylist的源码
请添加图片描述
我们把这个”<>”的方式称之为泛型,那么泛型有什么样的作用呢?就是在编译阶段检查传入的参数是否正确,保证程序在编译时没有发出警告;

请添加图片描述
有了泛型,我们可以看到要求存放的是String类型,而测试时存放的是int类型的100,所以编译器报错:
类型List的add方法要求添加的类型为String类型,int类型不匹配,不能正确存入

在这里插入图片描述

在方法的返回值前声明了一个,表示后面出现的E是泛型,而不是普通的java变量

T :表示一种特定的类型
E :也是一种类型的意思,只不过通常代表集合中的元素,表示的就是泛型的意思
? :这是一种无限的符号,代表任何类型都可以
K : key(键)
V :value(值)
N :Number(数值类型)

2.6 练习:泛型测试

创建包: cn.tedu. generic
创建类: TestGeneric1.java

package cn.tedu.generic;

import java.util.ArrayList;
import java.util.List;

/**本类用于测试泛型的优点*/
public class TestGeneric1 {
	public static void main(String[] args) {
		/**1.泛型是怎么来的?--想要模拟数组的数据类型检查*/
		String[] a = new String[5];//创建一个用来存放String类型数据的数组,长度为5
		a[2] = "泡泡";
		a[4] = "涛涛";
		//数组的好处:在编译时期检查数据的类型,如果不是要求的类型会在编译器就报错
		//a[0] = 1;
		//a[1] = 8.8;
		//a[3] = 'c';
		
		/**2.泛型通常会结合着集合一起使用*/
		List list = new ArrayList();//注意导包:java.util...
		//没有泛型,数据类型根本没有约束 -- 太自由!!!
		list.add("江江");
		list.add(1);
		list.add(8.8);
		list.add('a');
		System.out.println(list);//通过打印查看集合中的元素
		
		/**3.引入泛型--主要目的是想通过泛型来约束集合中元素的类型<?>*/
		/**4.泛型的好处:可以把报错的时机提前,在编译期就报错,而不是运行后抛出异常
		 * 在向集合中添加元素时,会先检查元素的数据类型,不是要求的类型就编译失败
		 * */
		List<String> list2 = new ArrayList<String>();//注意导包:java.util...
		list2.add("雷神");//约束了类型以后,只可以传String参数
		//list2.add(1);
		//list2.add(8.8);
		//list2.add('d');
		
		/**5.<type>--type的值应该如何写?
		 * 需要查看要存放的数据类型是什么,根据类型进行定义
		 * 但是type必须是引用类型,不是基本类型
		 */
		//List<int> list3 = new ArrayList<int>();//注意导包:java.util...
		List<Integer> list3 = new ArrayList<Integer>();//注意导包:java.util...
		list3.add(100);
		list3.add(200);
		System.out.println(list3);
	}
}

2.7 练习:泛型测试2

创建包: cn.tedu. generic
创建类: TestGeneric2.java

package cn.tedu.generic;
/**本类用来测试泛型的优点2*/
public class TestGeneric2 {
	public static void main(String[] args) {
		//需求:打印指定数组中的所有元素
		Integer[] a = {1,2,3,4,5,6,7,8,9,10};
		print(a);
		
		String[] b = {"大哥","二哥","三哥","四哥","五哥","六哥","小弟"};
		print(b);
		
		Double[] c = {6.0,6.6,6.66,6.666,6.6666};
		print(c);
	}
	/**1.泛型可以实现通用代码的编写,使用E表示元素的类型是Element类型 -- 可以理解成神似多态*/
	/**2.泛型的语法要求:如果在方法上使用泛型,必须两处同时出现,一个是传入参数的类型,一个是返回值前的泛型类型,表示这是一个泛型*/
	private static <E> void print(E[] e) {
		for(E d :e) {
			System.out.println(d);
		}
	}

//	public static void print(Double[] c) {
//		for(Double d : c) {
//			System.out.println(d);
//		}
//	}
//
//	public static void print(String[] b) {
//		for(String s : b) {
//			System.out.println(s);
//		}
//	}
//
//	public static void print(Integer[] a) {
//		//使用普通循环遍历数组比较复杂,引入高效for循环
//		//普通循环的好处是可以控制循环的步长(怎么变化)
//		for (int i = 0; i < a.length; i=i+2) {
//			System.out.println(a[i]);
//		}
//		/**
//		 * 高效for/foreach循环--如果只是单纯的从头到尾的遍历,使用增强for循环
//		 * 好处:比普通的for循环写法简便,而且效率高
//		 * 坏处:没有办法按照下标来操作值,只能从头到尾依次遍历
//		 * 语法:for(1 2 : 3){代码块} 3是要遍历的数据  1是遍历后得到的数据的类型 2是遍历起的数据名
//		 */
//		for(Integer i : a) {
//			System.out.print(i);
//		}
//	}
}

3 List接口

3.1 概述

有序的colletion(也称为序列).此接口的用户可以对列表中的每个元素的插入位置进行精确的控制,用户可以根据元素的整数索引(在列表中的位置)来访问元素,并搜索列表中的元素.

3.2 特点

元素都有下标
数据是有序的
允许存放重复的元素

3.3 List方法速查表

在这里插入图片描述

3.4 练习:List接口测试

创建包: cn.tedu.collection
创建类: TestList.java


package cn.tedu.collection;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**本类用于测试List接口*/
public class TestList {
    public static void main(String[] args) {
       //1.创建List的多态对象,注意List是接口,不可实例化
       List<String> list = new ArrayList<String>();

       //2.测试继承自Collection中的方法
       list.add("大力娃");//向list集合中存入数据
       list.add("千顺娃");
       list.add("头铁娃");
       list.add("喷火娃");
       list.add("喷水娃");
       list.add("隐身娃");
       list.add("小紫娃");
       System.out.println(list);//查看集合中的元素

//       list.clear();//清空集合
//       System.out.println(list);
       System.out.println(list.contains("喷火娃"));//true,判断集合是否包含指定元素
       System.out.println(list.equals("喷水娃"));//false,集合对象与String数据不等
       System.out.println(list.isEmpty());//false,判断集合是否为空
       System.out.println(list.remove("小紫娃"));//移除集合中指定的元素
       System.out.println(list.size());//6,获取集合中元素的个数
       System.out.println(Arrays.toString(list.toArray()));//将集合转成数组

       //3.测试List接口自己的方法--List有序,可以根据索引来操作集合中的元素
       list.add("小蝴蝶");//追加在最后
       list.add(1,"蛇精");//在指定的索引处添加元素
       list.add(3,"小蝴蝶");//在指定的索引处添加元素
       System.out.println(list);

       System.out.println(list.indexOf("小蝴蝶"));//3,获取指定元素第一次出现的索引
       System.out.println(list.lastIndexOf("小蝴蝶"));//8,获取指定元素最后一次出现的索引

       System.out.println(list);
       //根据索引删除元素,并将被删除的元素返回
       System.out.println(list.remove(5));
       System.out.println(list);
       System.out.println(list.get(3));//获取指定索引处的元素
       System.out.println(list.set(7,"蝎子精"));//修改指定索引处元素的值为蝎子精
       System.out.println(list);

       //4.测试集合间的操作
       List<String> list2 = new ArrayList<>();//创建第2个集合
       list2.add("1");//向集合2中添加元素
       list2.add("2");
       list2.add("3");
       list2.add("4");
       System.out.println(list2);//查看集合中的元素
       //将2集合的所有元素添加到list集合中
       System.out.println(list.addAll(list2));
       //将2集合的所有元素添加到list集合的指定位置
       System.out.println(list.addAll(1,list2));
       System.out.println(list);
       //判断list集合中是否包含list2集合中的所有元素
       System.out.println(list.containsAll(list2));
       //移除list集合中属于list2集合中的所有元素
       System.out.println(list.removeAll(list2));
       System.out.println(list);
    }
}

3.5 练习:List接口测试2

创建包: cn.tedu.collection
创建类: TestList2.java



package cn.tedu.collection;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/**本类用于进一步测试List接口*/
public class TestList2 {
    public static void main(String[] args) {
        //1.创建List接口的多态对象
        List<String> list = new ArrayList<>();
        //2.向创建好list集合添加元素
        list.add("喜羊羊");
        list.add("美羊羊");
        list.add("懒羊羊");
        list.add("沸羊羊");
        list.add("小肥羊");
        list.add("肥羊卷");
        System.out.println(list);

        //3.测试集合的迭代
        /**集合的迭代方式:
         * 1.for循环
         * 2.高效for循环
         * 3.iterator
         * 4.listIterator
         * */
        //方式一:因为List集合是有序的,元素有下标的,所以可以根据下标进行遍历
        //从哪开始:0  到哪结束:list.size()-1  如何变化++
        for(int i = 0;i<list.size();i++){
            //根据本轮循环遍历到的索引值获取对应的集合元素
            System.out.println(list.get(i));
        }
        System.out.println("************方式一*************");

        //方式二:因为普通for循环遍历效率低,语法复杂,所以使用高效for来遍历
        //格式for(本轮遍历到的元素类型 元素名 :要遍历的内容名){循环体}
        for( String s : list){
            System.out.println(s);
        }
        System.out.println("************方式二*************");

        //方式三:从父接口中继承过来的迭代器iterator
        //1.获取对应的迭代器对象
        Iterator<String> it = list.iterator();
        //2.通过刚刚获取到的迭代器循环迭代集合中的所有元素
        while(it.hasNext()){//判断是否仍有下一个元素可以迭代
            System.out.println(it.next());//打印当前获取到的元素
        }
        System.out.println("************方式三*************");
        /**方式四:listIterator属于List接口特有的迭代器
         * Iterator<E>--父接口--hasNext() next()
         * ListIterator<E>--子接口--除了父接口的功能以外
         * 还有自己的特有功能,比如逆序遍历,添加元素等等,但是不常用
         * public interface ListIterator<E>extends Iterator<E>
         * */
        ListIterator<String> it2 = list.listIterator();
        while(it2.hasNext()){
            System.out.println(it2.next());
        }
        System.out.println(list);
        System.out.println("listIterator的逆序遍历:");
        ListIterator<String> it3 = list.listIterator();
        while(it3.hasNext()){//判断是否有下一个元素可迭代
            System.out.println(it3.next());//打印当前迭代到的元素
            if(!it3.hasNext()){//直到迭代器没有下一个元素可迭代--到最后了
                System.out.println("开始逆序迭代:");
                while (it3.hasPrevious()){//判断是否有上一个元素可迭代
                    System.out.println(it3.previous());//打印获取到的上一个元素
                }
               break;//终止循环,不然会一直从头到尾,再从尾到头迭代
            }
        }
    }
}



4 ArrayList

4.1 概述
存在java.util包中
内部是用数组结构存放数据,封装数组的操作,每个对象都有下标
内部数组默认的初始容量是10,如果不够会以1.5倍的容量增长
查询快,增删数据效率会低

在这里插入图片描述
在这里插入图片描述

4.2 创建对象

在这里插入图片描述

4.3 练习:ArrayList测试

创建包: cn.tedu.collection
创建类: TestArrayList.java

package cn.tedu.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

/**本类用于ArrayList相关测试*/
public class TestArrayList {
    public static void main(String[] args) {
        //1.创建对应的集合对象
        /**底层会自动帮我们创建数组来存放对象,并且数组的初始容量是10*/
        ArrayList<Integer> list = new ArrayList();

        //2.向集合中添加元素,用于测试
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(400);
        list.add(400);
        list.add(300);
        System.out.println(list);

        //3.测试常用方法
        //list.clear();//清空集合
        //System.out.println(list);//[]

        //false,是否包含指定元素“100”,这是String不是Integer,不包含
        System.out.println(list.contains("100"));
        System.out.println(list.get(0));//100,根据下标获取元素
        System.out.println(list.indexOf(400));//3,判断指定元素第一次出现的位置
        System.out.println(list.lastIndexOf(400));//4,判断指定元素最后一次出现的位置
        
        System.out.println(list.remove(1));//200,移除指定位置处的元素
        //System.out.println(list.remove(300));
        /**上面的代码会报错:数组下标越界:index:300 size:5
         * 主要是因为List中有两个重载的remove(),如果传入的是300
         * 会认为是int类型的index索引,所以如果想指定元素删除数据
         * 需要把int类型的300手动装箱成Integer类型*/
        System.out.println(list.remove(Integer.valueOf(300)));
        
        System.out.println(list.set(2,777));//修改指定索引处的元素的值为777
        System.out.println(list.size());//获取列表中元素的个数

        //4.进行集合的迭代
        //方式1:for循环
        System.out.println("方式一:for循环迭代");
        for(int i = 0;i <= list.size()-1 ; i++){
            System.out.println(list.get(i));
        }
        //方式2:高效for循环
        System.out.println("方式二:高效for循环迭代");
        //for(本轮遍历到元素的类型 元素名 : 要遍历的集合名){循环体}
        for(Integer t : list){
            System.out.println(t);
        }
        //方式3:iterator迭代器
        System.out.println("方式三:iterator迭代器:");
        //获取迭代器对象
        Iterator<Integer> it = list.iterator();
        //循环迭代集合中的所有元素
        while(it.hasNext()){//判断是否有下一个元素可迭代,如果有,继续循环
            System.out.println(it.next());//打印本轮迭代到的元素
        }
        //方式4:listIterator
        System.out.println("方式四:list独有的迭代器listIterator");
        //获取迭代器对象
        ListIterator<Integer> it2 = list.listIterator();
        //循环迭代集合中的所有元素
        while(it2.hasNext()){//判断是否有下个元素可迭代
            System.out.println(it2.next());//打印本轮迭代到的元素
        }
    }
}

5 LinkedList

5.1 概述
链表,两端效率高,底层就是链表实现的

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

5.2 创建对象
LinkedList() 构造一个空列表

5.3 常用方法

void addFirst(E e) 添加首元素
void addLast(E e) 添加尾元素
E getFirst() 获取首元素
E getLast() 获取尾元素
E element() 获取首元素
E removeFirst() 删除首元素
E removeLast() 删除尾元素

boolean offer(E e) 添加尾元素
boolean offerFirst(E e) 添加首元素
boolean offerLast(E e) 添加尾元素
E peek() 获取首元素
E peekFirst() 获取首元素
E peekLast() 获取尾元素
E poll() 返回并移除头元素
E pollFirst() 返回并移除头元素
E pollLast() 返回并移除尾元素

5.4练习:LinkedList测试

创建包: cn.tedu.collection
创建类: TestLinkedList.java

package cn.tedu.colletion;

import java.util.LinkedList;

/**本类用于测试LinkedList的相关测试*/
public class TestLinkedList {
	public static void main(String[] args) {
		//1.创建对象
		LinkedList<String> list = new LinkedList();
		//2.添加数据
		list.add("孙悟空");
		list.add("猪八戒");
		list.add("唐三藏");
		list.add("沙师弟");
		list.add("白龙马");
		System.out.println(list);
		
		//3.1自行测试从collection继承过来的共性方法测试
		
		//3.2 LinkedList特有方法测试
		list.addFirst("蜘蛛精");//添加首元素
		list.addLast("玉兔精");//添加尾元素
		System.out.println(list);
		
		System.out.println(list.getFirst());//获取首元素
		System.out.println(list.getLast());//获取尾元素
		
		System.out.println(list.removeFirst());//移除首元素,成功移除会返回移除的数据
		System.out.println(list);
		System.out.println(list.removeLast());//移除尾元素,成功移除会返回移除的数据
		System.out.println(list);
		
		//4.其他测试
		//4.1创建对象
		LinkedList<String> list2 = new LinkedList();
		//4.2添加数据
		list2.add("水浒传");
		list2.add("三国演义");
		list2.add("西游记");
		list2.add("红楼梦");
		System.out.println(list2);
		System.out.println(list2.element());//获取但不移除此列表的首元素(第一个元素)
		/**别名:查询系列*/
		System.out.println(list2.peek());//获取但不移除此列表的首元素(第一个元素)
		System.out.println(list2.peekFirst());//获取但不移除此列表的首元素(第一个元素)
		System.out.println(list2.peekLast());//获取但不移除此列表的尾元素(最后一个元素)
		
		/**别名:新增系列*/
		System.out.println(list2.offer("遮天"));//将指定元素添加到列表末尾
		System.out.println(list2.offerFirst("斗罗大陆"));//将指定元素插入列表开头
		System.out.println(list2.offerLast("斗破苍穹"));//将指定元素插入列表末尾
		System.out.println(list2);
		
		/**别名:移除系列*/
		System.out.println(list2.poll());//获取并且移除此列表的首元素(第一个元素),成功移除,返回移除元素
		System.out.println(list2.pollFirst());//获取并且移除此列表的首元素(第一个元素),成功移除,返回移除元素,如果此列表为空,则返回null
		System.out.println(list2.pollLast());//获取并且移除此列表的尾元素(最后一个元素),成功移除,返回移除元素,如果此列表为空,则返回null
		System.out.println(list2);
	}
}

6 扩展: ArrayList扩容

ArrayList相当于在没指定initialCapacity时就是会使用延迟分配对象数组空间,当第一次插入元素时才分配10(默认)个对象空间。假如有20个数据需要添加,那么会分别在第一次的时候,将ArrayList的容量变为10;之后扩容会按照1.5倍增长。也就是当添加第11个数据的时候,Arraylist继续扩容变为10*1.5=15;当添加第16个数据时,继续扩容变为15 * 1.5 =22个
ArrayList没有对外暴露其容量个数,查看源码我们可以知道,实际其值存放在elementData对象数组中,那我们只需拿到这个数组的长度,观察其值变化了几次就知道其扩容了多少次。怎么获取呢?只能用反射技术了。

在这里插入图片描述

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/663566.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

【服务器数据恢复】AIX下raid故障导致pool无法加载的数据恢复案例

服务器数据恢复环境&#xff1a; IBM P740小型机AIX操作系统Sybase数据库V7000存储。V7000存储配置了12块SAS机械硬盘&#xff08;其中一块为热备盘&#xff09;组建一组raid5磁盘阵列。存储设备一共创建了2组Mdisk&#xff0c;加到一个pool中。 服务器故障&#xff1a; IBM V…

网络管理与维护(三)网络安全

网络安全 网络安全威胁 非授权访问 信息泄漏 破坏数据完整性 拒绝服务攻击 利用网络传播病毒 安全服务和安全机制 总结 1.通常可以把网络信息安全的问题划分为物理层、网络层、数据层和内容层四个层面。 2.网络存在的威胁主要表现&#xff1a; 非授权访问、信息泄漏、破坏数…

基于Django+Vue开发的社区疫情管理系统(附源码)

基于Django、Django Rest framework、Vue的前后端分离的社区疫情管理系统。 一、系统功能 用户管理&#xff08;只有管理员有权限&#xff09; 用户注册用户登录修改用户信息删除用户修改密码权限管理 首页数据展示 国内疫情数据展示国内疫情新闻近30日的感染人数&#xff08;…

【论文阅读】Adap-t: Adaptively Modulating Embedding Magnitude for Recommendation

【论文阅读】Adap-&#x1d70f;: Adaptively Modulating Embedding Magnitude for Recommendation 文章目录 【论文阅读】Adap-&#x1d70f;: Adaptively Modulating Embedding Magnitude for Recommendation1. 来源2. 介绍3. 模型解读3.1 准备工作3.1.1 任务说明3.1.2 基于嵌…

Linux:http服务(Apache 2.4.57)源码编译——配置网站 || 入门到入土

目录 1.下载源码包 2.配置httpd运行环境 3.编译源码包安装apache软件 4.优化执行路径 5.添加httpd系统服务 正文 1.httpd服务器的基本配置 2.本章持续更新 我的服务器为centos7系统 1.下载源码包 访问官方网站↓↓↓ Welcome! - The Apache HTTP Server Project ↑↑…

ONLYOFFICE Docs 7.4 版本大大增强了图形编辑功能!

ONLYOFFICE Docs 7.4 版本大大增强了图形编辑功能&#xff01; 书接上文&#xff1a; 北冰洋汽水我的最爱https://mp.weixin.qq.com/s?__bizMzI2MjUyNzkyNw&mid2247493734&idx1&sn416c4ee5756ea59883591d3c2c4a6ae4&chksmea4b66bedd3cefa89050e25b661e0be16…

malloc 背后的虚拟内存 和 malloc实现原理

面试的时候经常会被问到 malloc 的实现。从操作系统层面来说&#xff0c;malloc 确实是考察面试者对操作系统底层的存储管理理解的一个很好的方式&#xff0c;涉及到虚拟内存、分页/分段等。下面逐个细说。 1. 虚拟内存 首先需要知道的是程序运行起来的话需要被加载的物理内存…

spark 和 flink 的对比

一、设计理念 Spark 的数据模型是 弹性分布式数据集 RDD(Resilient Distributed Dattsets)&#xff0c;这个内存数据结构使得spark可以通过固定内存做大批量计算。初期的 Spark Streaming 是通过将数据流转成批 (micro-batches)&#xff0c;即收集一段时间(time-window)内到达的…

【计算机组成原理】——知识点复习(期末不挂科版)

课本&#xff1a; 考试题型&#xff1a; 题型一、计算题&#xff08;30分&#xff09; 1、定点数表示&#xff1a;用原码、反码、补码、移码表示十进制数&#xff08;5分&#xff09; 2、浮点数表示&#xff1a;十进制数↔单精度浮点数&#xff08;5分&#xff09; 3、加减运…

行业报告 | AI+制造业赋能,机器视觉开启掘金新大陆(上)

原创 | 文 BFT机器人 01 核心要点 Al制造业赋能&#xff0c;META 发布 SAM 助力机器视觉迎来 GPT 时刻。 机器视觉技术使得工业设备能够“看到”它正在进行的操作并进行快速决策&#xff0c;完整机器视觉系统由硬件软件组成,分别进行成像和图像处理工作。 目前&#xff0c;以“…

全网超全,接口自动化测试实战总结详全,这几个阶段你知道吗?

目录&#xff1a;导读 前言一、Python编程入门到精通二、接口自动化项目实战三、Web自动化项目实战四、App自动化项目实战五、一线大厂简历六、测试开发DevOps体系七、常用自动化测试工具八、JMeter性能测试九、总结&#xff08;尾部小惊喜&#xff09; 前言 接口自动化根本目…

【深入浅出 Spring Security(十)】权限管理的概述和使用详情

权限管理 一、授权的核心概念二、权限管理策略权限表达式&#xff08;SpEL Spring EL&#xff09;1. 基于 URL 的权限管理&#xff08;过滤器&#xff09;基本用法 2. 基于 方法 的权限管理&#xff08;AOP&#xff09;EnableGlobalMethodSecurity基本用法 三、权限管理之版本问…

游戏中用脚开飞机实现方案

看看这个图片&#xff0c;有人用脚开飞机&#xff0c;用几个踏板去控制&#xff0c;在游戏中&#xff0c;开飞机的操作比较简单&#xff0c;上升&#xff0c;下降&#xff0c;加减油门&#xff0c;方向左&#xff0c;方向右。 android设备中&#xff0c;使用模拟点击就可以实现…

好用的电容笔有哪些推荐?apple pencil的平替笔测评

随着平板电脑在校园、办公室中的应用越来越广泛&#xff0c;需要一种具有良好性能的电容笔。苹果品牌原装的这支电容笔&#xff0c;虽然功能很强&#xff0c;但因为其的价格实在是太贵了&#xff0c;所以只是用来学习记笔记&#xff0c;实在是太浪费了。所以&#xff0c;哪个电…

python接口自动化(一)--什么是接口、接口优势、类型(详解)

简介 经常听别人说接口测试&#xff0c;接口测试自动化&#xff0c;但是你对接口&#xff0c;有多少了解和认识&#xff0c;知道什么是接口吗&#xff1f;它是用来做什么的&#xff0c;测试时候要注意什么&#xff1f;坦白的说&#xff0c;笔者之前也不是很清楚。接下来先看一下…

计算机网络——自顶向下方法(第一章学习记录)

什么是Internet? 可以从两个不同的方面来理解Internet。&#xff08;它的构成。它的服务&#xff09; 1.因特网的主要构成 处在因特网的边缘部分就是在因特网上的所有主机&#xff0c;这些主机又称为端系统&#xff08;end system&#xff09;&#xff0c;端系统通过因特网服…

openEuler+Linaro合作成果展示|2023开放原子全球开源峰会

2023年6月11&#xff5e;13日&#xff0c;2023年开放原子全球开源峰会&#xff08;OpenAtom&#xff09;在北京经济开发区北人亦创国际会展中心召开&#xff0c;本届峰会旨在搭建全球开源生态发展合作交流平台&#xff0c;聚焦开源生态建设发展&#xff0c;并组织了openEuler、…

STL容器——unordered_set的用法

0、概述 unordered_set容器&#xff0c;可直译为无序 set 容器。即 unordered_set容器和 set 容器很像&#xff0c;唯一的区别就在于 set容器会自行对存储的数据进行排序&#xff0c;而 unordered_set 容器不会。下面是set、multiset和unordered_set之间的差别。 注意这三种集…

计算机网络管理 SNMP协议实用工具MIB Browser的安装和使用

⬜⬜⬜ &#x1f430;&#x1f7e7;&#x1f7e8;&#x1f7e9;&#x1f7e6;&#x1f7ea;(*^▽^*)欢迎光临 &#x1f7e7;&#x1f7e8;&#x1f7e9;&#x1f7e6;&#x1f7ea;&#x1f430;⬜⬜⬜ ✏️write in front✏️ &#x1f4dd;个人主页&#xff1a;陈丹宇jmu &am…

qt常用基本类

文章目录 点直线时间相关的类 qt里面打印log或者打印东西&#xff0c;自带打印函数qDebug 里面<<插入操作符可以写任意类型 qDebug()<<"im ssss"<<520; //默认给你带换行//也能加endl&#xff0c;那就多换一行并不是说printf或者cout就不能用了…