JavaDS预备知识

集合框架

Java 集合框架 Java Collection Framework ，又被称为容器 container ，是定义在 java.util 包下的一组接口 interfaces和其实现类 classes 。
其主要表现为将多个元素 element 置于一个单元中，对数据进行创建(Create)、读取(Retrieve)、更新(Update)和删除(Delete)的操作。即平时我们俗称的增删查改 CRUD 。

在这里插入图片描述

数据结构与算法的概念

数据结构(Data Structure)是计算机存储、组织数据的方式，指相互之间存在一种或多种特定关系的数据元素的
集合。

算法(Algorithm):就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。

时间复杂度和空间复杂度

算法效率分析分为两种：第一种是时间效率，第二种是空间效率。时间效率被称为时间复杂度，而空间效率被称作空间复杂度。 时间复杂度主要衡量的是一个算法的运行速度，而空间复杂度主要衡量一个算法所需要的额外空间，

由于计算机的飞速发展，计算机的存储容量得到大幅度提高，因此我们现在主要考虑时间复杂度。

时间复杂度

时间复杂度的定义：在计算机科学中，算法的时间复杂度是一个数学函数，它定量描述了该算法的运行时间。一个算法执行所耗费的时间，从理论上说，是不能算出来的，只有你把你的程序放在机器上跑起来，才能知道。但是我们需要每个算法都上机测试吗？是可以都上机测试，但是这很麻烦，所以才有了时间复杂度这个分析方式。一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。

因此我们使用计算机执行语句的次数来表示时间复杂度，但是在实际中我们计算时间复杂度时，我们其实并不一定要计算精确的执行次数，而只需要大概执行次数，那么这里我们使用大O的渐进表示法。

大O渐进法使用规则：
1、用常数1取代运行时间中的所有加法常数。
2、在修改后的运行次数函数中，只保留最高阶项。
3、如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。

一个算法面对不同的问题时，执行语句的次数也会由此不一样，例如我们在一个数组里查找一个数据，如果这个数据就是第一个，那执行次数就是1次，如果是最后一个，那执行次数就是整个数组的长度，也就是算法的执行情况，有三种，最好的情况，平均情况，最坏情况。时间复杂度取算法的最坏情况，因为最坏情况下都能接受，那这个算法就是一个好的算法。

例题：

//求func2的时间复杂度
    void func2(int N){
        int count = 0;

        for (int i = 0; i < 2 * N; i++) {
            count++;
        }
        
        int m = 10;
        while(m-- > 0){
            count++;
        }
    }

首先for循环语句一共执行2N次，while语句执行10次，一共执行2N+10 次，使用大O渐进法表示，保留最高阶，剩下2*N，去除2，剩下N，所以时间复杂度为O（N）

    void func3(int N,int M){
        int count = 0;
        for (int i = 0; i < N; i++) {
            count++;
        }

        for (int i = 0; i < M; i++) {
            count++;
        }
    }

一共执行次数为N+M，即时间复杂度为O（N+M）

    void func4(){
        int count = 0;
        for (int i = 0; i < 100; i++) {
            count++;
        }
    }

语句执行次数为100，是常数化为1，则时间复杂度为O（1）

    void bubbleSort(int[] array){
        boolean flag = true;
        for (int i = 0; flag && i < array.length - 1; i++) {
            flag = false;
            for (int j = i; j < array.length - i - 1; j++) {
                if(array[j] > array[j+1]){
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    flag = true;
                }
            }
        }
    }

上面这个是冒泡排序算法，时间复杂度取最坏的情况，假设数组的长度为N，第一轮冒泡排序的执行次数为N-1，第二困轮冒泡排序的执行次数为N-2，以此类推，这个是一个等差数列，使用等差数列的求和公式为N(N-1)/2，使用大O渐进法表示O（N^2）

    int binarySearch(int[] array, int value) {
        int begin = 0;
        int end = array.length - 1;
        while(begin < end){
            int mid = (begin + end) / 2;
            if(array[mid] > value){
                end = mid - 1;
            }else if(array[mid] < value){
                begin = mid + 1;
            }else{
                return mid;
            }
        }
        
        return -1;
    }

二分查找，每次查找，待查询数据都会减少一半，直到数据只剩下一个，假设查找的次数为x，数据总数为N，
（1/2）^ x * N = 1 ; x = logN (以2为底数的对数)

    long factorial(int N) {
        return N < 2 ? N : factorial(N-1) * N;
    }

上面是一个求阶乘的递归算法，递归算法的执行次数等于 递归调用次数*每次递归执行的语句次数，所以这个算法的执行总次数 N-2（N>2时）或者 1 （N == 1 || N == 2），时间复杂度为O（N）

    int fibonacci(int N) {
        return N < 2? N : fibonacci(N - 1)+fibonacci(N-2);
    }

我们画个图：假设求第八个斐波那契数
在这里插入图片描述
一般情况下，每求一个数都会进行两次递归才能求出，以此类推，时间复杂度为O（N^2）

空间复杂度

空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度 。空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。空间复杂度计算规则基本跟时间复杂度类似，也使用大O渐进表示法。

例题：

    void bubbleSort(int[] array){
        boolean flag = true;
        for (int i = 0; flag && i < array.length - 1; i++) {
            flag = false;
            for (int j = i; j < array.length - i - 1; j++) {
                if(array[j] > array[j+1]){
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    flag = true;
                }
            }
        }
    }

冒泡排序使用了一个数组的空间和几个变量的空间，这是常数，所以空间复杂度为O（1）

// 计算fibonacci的空间复杂度？
int[] fibonacci(int n) {
    long[] fibArray = new long[n + 1];
    fibArray[0] = 0;
    fibArray[1] = 1;
    for (int i = 2; i <= n ; i++) {
    fibArray[i] = fibArray[i - 1] + fibArray [i - 2];
   }
 
    return fibArray;
}

新建了一个数组，大小为N+1，则空间复杂度为O（N）

// 计算阶乘递归Factorial的空间复杂度？
long factorial(int N) {
 return N < 2 ? N : factorial(N-1)*N;
}

空间复杂度为O（N）

    int fibonacci(int N) {
        return N < 2? N : fibonacci(N - 1)+fibonacci(N-2);
    }

要注意递归开辟的空间是可以重复利用的，所以如果一个递归要用到之前递归就开辟好的空间，是可以直接拿过来使用的，不用额外开辟新的空间，所以时间复杂度为O（N）

包装类

在Java中，由于基本类型不是继承自Object，为了在泛型代码中可以支持基本类型，Java给每个基本类型都对应了一个包装类型。

基本数据类型包装类
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
charCharater
booleanBoolean

这里要注意两个包装类，Integer 和 Charater ,除了它们两个之外，其他的包装类都是大写开头即可。

自动装箱（显示装箱）和自动拆箱（显示拆箱）

装箱是指把基本数据类型变为包装类类型的过程。

    public static void main(String[] args) {
        int a = 10;
        Integer b = Integer.valueOf(a);//显示装箱
        Integer c = 10;//自动装箱
    }

显示装箱是我们自己调用了 valueOf 的方法，自动装箱是底层帮我们自动调用 valueOf 方法

拆箱是指把包装类类型变为基本数据类型的过程

    public static void main(String[] args) {
        Integer a = 10;
        int b = a;//自动拆箱
        int c = a.intValue();//显示拆箱
        double d = a.doubleValue();//显示拆箱

        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
    }

在这里插入图片描述
自动拆箱是底层帮我们自动调用Value，显示拆箱就是我们自己调用这个方法，我们可以使用不同的拆箱方法来将数据转化成你想要的基本数据类型，所以Integer这个包装类可以转化成不同的基本数据类型。

面试题

说出下面代码的输出结果：

    public static void main(String[] args) {
        Integer a = 127;
        Integer b = 127;

        Integer c = 128;
        Integer d = 128;

        System.out.println(a == b);
        System.out.println(c == d);
    }

在这里插入图片描述

思路：要想知道结果为什么，我们就要知道装箱的源码：

在这里插入图片描述

当 i 大于等于IntegerCache.low && i 小于等于 IntegerCache.high 时，就会返回数组的某一个数值，否则就会创建一个新对象，如果是返回数组的某一个数值时，那么拆箱比较之后的结果就是相等的，如果创建的是新对象，那进行 == 的比较就是对引用数据类型进行比较时，两个对象不同时那结果自然不用。

在这里插入图片描述

我们翻开IntederCache 数组时，我们可以发现low = -128，high = 127，所以装箱127的时候，就是直接取数组的值，如果装箱128的时候，就会创建新对象，所以结果就是true false

泛型

一般的类和方法，只能使用具体的类型: 要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。
泛型是在JDK1.5引入的新的语法，通俗讲，泛型：就是适用于许多类型。从代码上讲，就是对类型实现了参数化。

实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值？

class MyArray {
    public Object[] array = new Object[10];

    public void setArray(int pos, Object value) {
        array[pos] = value;
    }

    public Object getArray(int pos) {
        return array[pos];
    }
}

public class Test2 {
    public static void main(String[] args) {
        MyArray arr = new MyArray();
        arr.setArray(0,10);
        arr.setArray(1,"String");
        arr.setArray(2,3.14);

        int a = (int)arr.getArray(0);
        String str = (String)arr.getArray(1);
        double b = (double)arr.getArray(2);

        System.out.println(a);
        System.out.println(str);
        System.out.println(b);
    }
}

我们会创建一个Object[]的数组，因为Object是所有类的父类，所以这种数组可以接受不同的数据类型，当我们拿取数组的数组的时候，由于是Object类，就需要强制类型转化。

虽然在这种情况下，当前数组任何数据都可以存放，但是，更多情况下，我们还是希望他只能够持有一种数据类型。而不是同时持有这么多类型。

语法

泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译器去做检查。此时，就需要把类型作为参数传递。需要什么类型，就传入什么类型

创建

class 泛型类名称<类型形参列表> {
    // 这里可以使用类型参数
}

类型形参一般使用一个大写字母表示，常用的名称有：
E 表示 Element
K 表示 Key
V 表示 Value
N 表示 Number
T 表示 Type
S, U, V 等等，第二、第三、第四个类型

使用

泛型类<类型实参> 变量名; // 定义一个泛型类引用
new 泛型类<类型实参>(构造方法实参); // 实例化一个泛型类对象

实例：

MyArray<Integer> list = new MyArray<Integer>();

要注意：类型形参我们在使用的时候，我们需要使用的是引用数据类型，不能使用基本数据类，所以我们要使用整型的时候，我们应该使用包装类Integer，但是不能使用int。

类型推导(Type Inference)

当编译器可以根据上下文推导出类型实参时，可以省略类型实参的填写

MyArray<Integer> list = new MyArray<>(); // 可以推导出实例化需要的类型实参为 Integer

我们把上面的包含Object数组的类改写成泛型类：

class MyArray<E>{
    public Object[] array = new Object[10];

    public void setArray(int pos, E value){
        array[pos] = value;
    }

    public E getAaary(int pos){
        return (E)array[pos];
    }
}

由于是泛型，这里使用E，但是我们还是使用Object数组接收不同类型的数据，数据的类型是Object，返回值是E，所以在返回数据的时候我们需要强制类型转化

裸类型(Raw Type)

裸类型是一个泛型类但没有带着类型实参

MyArray arr = new MyArray();

注意： 我们不要自己去使用裸类型，裸类型是为了兼容老版本的 API 保留的机制

我们将上面的代码来实践一下使用：

    public static void main(String[] args) {
        MyArray<String> arr1 = new MyArray<String>();
        MyArray<Integer> arr2 = new MyArray<>();//类型推导，省略后面的类型
        MyArray arr3 = new MyArray();//裸类型不推荐使用，没有编译器检查，是为了兼容老版本
    }

小结：
1.泛型是将数据类型参数化，进行传递
2.例如：使用 < T > 表示当前类是一个泛型类。
3.泛型目前为止的优点：数据类型参数化，编译时自动进行类型检查和转换

擦除机制

泛型的引入是JDK5开始引入的，在JDK5之前是没有泛型的，所以裸类型是为了兼容JDK5之前的版本，从JDK5版本后泛型使用的是擦除机制。

在编译的过程当中，将所有的T替换为Object这种机制，我们称为：擦除机制。

由于Java会进行静态类型检查，所以如果你使用Integer的泛型，就不能使用String,double等数据进行赋值。

泛型的上界

在定义泛型类时，有时需要对传入的类型变量做一定的约束，可以通过类型边界来约束。

class 泛型类名称<类型形参 extends 类型边界> {
   //...
}

举个例子：

public class MyArray<E extends Number> {
   //...
}

这时候我们传入的类型形参就必须是Number或者是Number的子类

    public static void main(String[] args) {
        Array<Integer> arr1 = new Array<>();
        Array<Double> arr2 = new Array<>();
        Array<String> arr3 = new Array<String>();//编译错误 err
    }

Integer和Double 都是Number 的子类，String 不是Number 的子类，所以使用String 会发生编译报错。

public class MyArray<E extends Comparable<E>> {
   ...
}

这时候E就必须实现Comparable接口

泛型方法

方法限定符 <类型形参列表> 返回值类型 方法名称(形参列表) { ... }

举个例子：

    public<E extends Comparable<E>> E find(E[] arr){
        //...
    }
    
    public static <E extends Comparable<E>> void find(){
        //...
    }

方法的泛型类型形参写在 public 等访问权限修饰符 和 static 后面，并且类型形参要保持一致，就是如果使用E就必须统一使用E，不能混用别的类型形参（T等等）

使用：
调用泛型方法时，我们可以在方法前面加上类型参数或者不使用类型参数，和上面一样也有类型推导的机制。

    public static void main(String[] args) {
        Integer[] a = {1,2,3,4,5,6};
        MyArray.find(a);
        MyArray.<Integer>find(a);
    }

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【Vue报错】v-bind动态绑定src无效

【Vue报错】v-bind动态绑定src无效

今天遇到v-bind动态绑定video的src&#xff0c;出现无效的问题 但是翻看以前的项目都是没问题的 之前的项目 现在的项目 发现并不能呈现视频效果 进行了改进&#xff0c;成功展示
阅读更多...
go语言Gin框架的学习路线(六)

go语言Gin框架的学习路线(六)

gin的路由器 Gin 是一个用 Go (Golang) 编写的 Web 框架&#xff0c;以其高性能和快速路由能力而闻名。在 Gin 中&#xff0c;路由器是框架的核心组件之一&#xff0c;负责处理 HTTP 请求并将其映射到相应的处理函数上。 以下是 Gin 路由器的一些关键特性和工作原理的简要解释…
阅读更多...
【前端项目笔记】9 数据报表

【前端项目笔记】9 数据报表

数据报表 效果展示&#xff1a; 在开发代码之前新建分支 git checkout -b report 新建分支report git branch 查看分支 git push -u origin report 将本地report分支推送到云端origin并命名为report 通过路由的形式将数据报表加载到页面中 渲染数据报表基本布局 面包屑导航…
阅读更多...
[TensorFlow-Lite][深度学习]【快速简介-1】

[TensorFlow-Lite][深度学习]【快速简介-1】

前言&#xff1a; 很多场景下面我们需要需要把我们的深度学习模型部署到Android,IOS 手机上面. Google 通过TensorFlow Lite 提供了对应的解决方案. 目录&#xff1a; 端侧部署优点 硬件支持 性能 应用案例 一 端侧部署优点 1; 很多场景下面&#xff1a; 无网络,数据无法…
阅读更多...
昇思第10天

昇思第10天

RNN实现情感分类 二分类问题&#xff1a;Positive和Negative两类 步骤&#xff1a; 1.加载IMDB数据集 2.加载预训练词向量:预训练词向量是对输入单词的数值化表示&#xff0c;通过nn.Embedding层&#xff0c;采用查表的方式&#xff0c;输入单词对应词表中的index&#xff0c;…
阅读更多...
CTF入门知识点

CTF入门知识点

CTF知识点 md5函数 <?php$a 123;echo md5($a,true); ?> 括号中true显示输出二进制 替换成false显示输出十六进制绕过 ffifdyop 这个字符串被 md5 哈希了之后会变成 276f722736c95d99e921722cf9ed621c&#xff0c;这个字符串前几位刚好是 or 6 而 Mysql 刚好又会把 …
阅读更多...
模型优化调参利器贝叶斯优化bayesian-optimization实践

模型优化调参利器贝叶斯优化bayesian-optimization实践

早在之前很多项目尤其是预测类型的项目中&#xff0c;就已经比较广泛地在实用贝叶斯优化库了&#xff0c;这是一个非常出色的纯python实现的项目&#xff0c;地址在这里&#xff0c;如下所示&#xff1a; 写这篇文章主要有两个目的&#xff0c;一方面是觉得这个工具库挺不错的值…
阅读更多...
BeikeShop多国语言多货币商城系统源码基于Laravel框架

BeikeShop多国语言多货币商城系统源码基于Laravel框架

BeikeShop是基于 Laravel 开发的一款开源商城系统&#xff0c;支持多语言商城 多货币商城 100%全开源 ChatGPT OpenAI B2C商城系统 H5商城 PHP商城系统 商城源码 PC商城 跨境电商系统 跨境商城系统 电商商城系统 Laravel 10 框架开发系统&#xff0c;支持插件市场。 Event 机制…
阅读更多...
Qt 加载图片的几种方式 以及加载 loading

Qt 加载图片的几种方式 以及加载 loading

项目中经常使用加载图片&#xff1a; 常用有两种方式&#xff1a; 1.使用 QWidget 加载图片&#xff1a; 效果&#xff1a; 样例源码&#xff1a; int pict_H ui->widgetImage->height();int pict_W ui->widgetImage->width();ui->widgetImage->setFixe…
阅读更多...
C++ 智能指针使用不当导致内存泄漏问题

C++ 智能指针使用不当导致内存泄漏问题

shared_ptr相互嵌套导致循环引用 代码示例 #include <iostream> #include <memory> using namespace std;class B;class A { public:std::shared_ptr<B> b_ptr;~A() { std::cout << "A destroyed\n"; } };class B { public:std::shared_pt…
阅读更多...
百日筑基第十二天-入门Elasticsearch

百日筑基第十二天-入门Elasticsearch

百日筑基第十二天-入门Elasticsearch Elasticsearch 是什么 Elasticsearch 是一个分布式、RESTful 风格的搜索和数据分析引擎。 安装 Elasticsearch 下载&#xff1a;https://www.elastic.co/cn/downloads/elasticsearch Elasticsearch 是免安装的&#xff0c;只需要把 zip…
阅读更多...
实在智能对话钉钉：宜搭+实在Agent，AI时代的工作方式

实在智能对话钉钉：宜搭+实在Agent，AI时代的工作方式

比起一个需求需要等产品、技术排期&#xff0c;越来越多的人开始追求把自己武装成「全能战士」&#xff0c;通过低代码工具一搭&#xff0c;一个高效的工作平台便产生了。 宜搭是钉钉自研的低代码应用构建平台&#xff0c;无论是专业开发者还是没有代码基础的业务人员&#xf…
阅读更多...
Nuxt3 的生命周期和钩子函数（十一）

Nuxt3 的生命周期和钩子函数（十一）

title: Nuxt3 的生命周期和钩子函数&#xff08;十一&#xff09; date: 2024/7/5 updated: 2024/7/5 author: cmdragon excerpt: 摘要&#xff1a;本文详细介绍了Nuxt3中几个关键的生命周期钩子和它们的使用方法&#xff0c;包括webpack:done用于Webpack编译完成后执行操作…
阅读更多...
Linux运维：MySQL备份，物理冷备份,热备,完备+二进制日志

Linux运维：MySQL备份，物理冷备份,热备,完备+二进制日志

备份类型 完全备份、增量备份、差异备份 完全备份&#xff1a;整个数据集都备份 增量备份&#xff1a;仅备份最近一次完全备份或增量备份&#xff08;如果存在增量&#xff09;以来变化的数据&#xff0c;备份较快&#xff0c;还原复杂。 差异备份&#xff1a;对比前一次备…
阅读更多...
2024 年第十四届亚太数学建模竞赛（中文赛项）浅析

2024 年第十四届亚太数学建模竞赛（中文赛项）浅析

需要完整B题资料&#xff0c;请关注&#xff1a;“小何数模”&#xff01; 本次亚太(中文赛)数学建模的赛题已正式出炉&#xff0c;无论是赛题难度还是认可度&#xff0c;该比赛都是仅次于数模国赛的独一档&#xff0c;可以用于国赛前的练手训练。考虑到大家解题实属不易&…
阅读更多...
离线安装arm架构Firefox

离线安装arm架构Firefox

离线安装Firefox浏览器及其插件在ARM架构的设备上&#xff08;如树莓派、部分Android设备或其他采用ARM处理器的Linux系统&#xff09;可能需要一些特殊步骤&#xff0c;因为默认情况下&#xff0c;大多数浏览器和插件都是为x86架构设计的。对于ARM架构&#xff0c;你需要找到特…
阅读更多...
深圳航空顶象验证码逆向，和百度验证码训练思路

深圳航空顶象验证码逆向，和百度验证码训练思路

声明(lianxi a15018601872) 本文章中所有内容仅供学习交流使用&#xff0c;不用于其他任何目的&#xff0c;抓包内容、敏感网址、数据接口等均已做脱敏处理&#xff0c;严禁用于商业用途和非法用途&#xff0c;否则由此产生的一切后果均与作者无关&#xff01; 前言(lianxi a…
阅读更多...
Java项目：基于SSM框架实现的校园快递代取管理系统【ssm+B/S架构+源码+数据库+毕业论文】

Java项目：基于SSM框架实现的校园快递代取管理系统【ssm+B/S架构+源码+数据库+毕业论文】

一、项目简介 本项目是一套基于SSM框架实现的校园快递代取管理系统 包含&#xff1a;项目源码、数据库脚本等&#xff0c;该项目附带全部源码可作为毕设使用。 项目都经过严格调试&#xff0c;eclipse或者idea 确保可以运行&#xff01; 该系统功能完善、界面美观、操作简单、…
阅读更多...
Windows系统下载安装ngnix

Windows系统下载安装ngnix

一 nginx下载安装 nginx是HTTP服务器和反向代理服务器&#xff0c;功能非常丰富&#xff0c;在nginx官网首页&#xff0c;点击download 在download页面下&#xff0c;可以选择Stable version稳定版本&#xff0c;点击下载 将下载完成的zip解压即可&#xff0c;然乎在nginx所在…
阅读更多...
Spring Boot 中的监视器是什么？有什么作用？

Spring Boot 中的监视器是什么？有什么作用？

前言&#xff1a; 监听器相信熟悉 Spring、Spring Boot 的都知道&#xff0c;但是监视器又是什么&#xff1f;估计很多人一脸懵的状态&#xff0c;本篇分享一下 Spring Boot 的监视器。 Spring Boot 系列文章传送门 Spring Boot 启动流程源码分析&#xff08;2&#xff09; …
阅读更多...
最新文章

Copyright @ 2022~2023