数 据 类 型

news2024/11/15 13:00:00

概述

Java 是强类型语言。

每一种数据都定义了明确的数据类型，在内存中分配了不同大小的内存空间（字节）。

Java 中一共有 8 种基本类型（primitive type），包括 4 种整型、2 种浮点型、1 种字符类型（用于表示 Unicode 编码的代码单元）和 1 种用于表示真值的 boolean 类型。

Java 的数据类型分为两大类：基本数据类型和引用数据类型。基本数据类型又分为四类八种。

暂时无法在飞书文档外展示此内容

在这里插入图片描述

int 类型最为常用，但是如果 int 类型的范围不够时，需要使用 long 类型。byte 和 short 主要用于特定的场合，比如底层的文件处理或者存储空间有限时的大数组。

Java 的各个数据类型有固定的范围和字段长度，不受具体的操作系统的影响，以保证程序的可移植性。

Java 中没有无符号数，即 Java 中的数都是有符号的。

整数和小数取值范围大小关系：double > float > long > int > short > byte。

可以把小空间赋给大空间。

C 和 C++ 程序会针对不同的处理器选择最高效的整型，这样一来，一个在 32 位处理器上运行得很好的 C 程序在 16 位系统上运行时可能会发生整数溢出。

可以在一行声明多个变量，但是不提倡这种写法，分别声明每一个变量可以提高程序的可读性。

public class test2 {
    public static void main(String[] args) {
        int a, b;  // 可以在一行声明多个变量
        int a1;    // 分别声明每一个变量可以提高程序的可读性
        int a2;
    }
}

声明一个变量之后，必须用赋值语句显式地初始化变量。千万不要使用未初始化的变量的值。

public class test2 {
    public static void main(String[] args) {
        int a;
        System.out.println(a);  // 报错：java: 可能尚未初始化变量 a
    }
}

public class test2 {
    public static void main(String[] args) {
        int a;                      // 声明
        a = 10;                     // 初始化
        System.out.println(a);      // 10
    }
}

也可以将变量的声明和初始化放在同一行中。Java 中可以将声明放在代码中的任何地方。在 Java 中，变量的声明要尽可能靠近第一次使用这个变量的地方，这是一种很好的编程风格。

在 Java 中，并不区分变量的声明和定义。

public class test2 {
    public static void main(String[] args) {
        int a = 10;                 // 声明和初始化放在同一行
        System.out.println(a);      // 10
    }
}

从 Java 10 开始，对于局部变量，如果可以从变量的初始值推断出它的类型，就不再需要声明类型，只需要使用关键字 var 而无须指定类型。

public class test2 {
    public static void main(String[] args) {
        var a = 10;                 // 使用关键字 var 而无须指定类型
        System.out.println(a);      // 10
        {
            var b = 100;            // 使用关键字 var 而无须指定类型
            System.out.println(b);  // 100
        }
    }
}

C 和 C++ 区分变量的声明和定义。例如：

int i = 10;            // 是一个定义
extern int i;          // 是一个声明

boolean 类型

boolean 类型的值，只有 true 和 false 两种。

Java 中，integer 与 boolean 两种类型并不相容，不可以用 0 或非 0 的整数代替 false 和 true。

例如，下面的代码是错误的，不能用整数作为测试条件：

int x = 1;
while(x)
{}

只能用 boolean 值作为测试条件。

例如，下面的代码是可行的：

boolean isOK = true;
while(isOK)
{}
// 或者
int x = 1;
while(x == 1)
{}

打印 boolean 字面量：

public class ValueDemo1 {
    public static void main(String[] args) {
        // 打印布尔型字面量
        System.out.println(true);
        System.out.println(false);
    }
}

执行结果：

true
false

char 类型

单个字符用 char，多个字符用 String。

char 类型原本用于表示单个字符。不过，现在情况已经有所变化。如今，有些 Unicode 字符可以用一个 char 值描述，另外一些 Unicode 字符则需要两个 char 值。

在 Java 中，char 的本质是一个整数，在输出时，输出的是 Unicode 码对应的字符。可以直接给 char 赋一个整数，然后输出时，会输出对应的 Unicode 字符。char 类型是可以进行运算的，相当于一个整数，因为它有对应的 Unicode 码。

char 类型的字面量值要用单引号括起来。例如：‘A’ 是编码值为 65 的字符常量。它与 “A” 不同，“A” 是包含一个字符的字符串。char 类型的值可以表示为十六进制值，其范围从 \u0000 ~\uFFFFF。例如 \u2122 表示商标符号（ T M ^{TM} TM），\u03C0 表示希腊字母 π \pi π。

字符在计算机中的存储：在根据码表，找到这个字符的编码，再将编码转为二进制，在计算机中存储这个二进制。读取字符时，要由二进制根据编码转换为字符。

编码转换的网址

字面量

字符型字面量要用单引号括起来，内容有且只能有一个，即内容不能为空。字符串类型的字面量用双引号括起来，内容可以为空。比如：""。

转义字符

转义字符是字符型常量。
\t：制表符，在打印的时候，将前面的字符串的长度补齐到 8，或者 8 的倍数，最少补 1 个空格，最多补 8 个空格。
\n：换行符。
\r：回车。
\\：一个 \。
\\\\：两个 \，即 \\。
\"：一个 "。
\'：一个 '。

程序示例：

public class test3 {
    public static void main(String[] args) {
        System.out.println("************************");
        System.out.println("abc" + '\t' + "def");
        // System.out.println("abc" + "\t" + "def");    // \t 也可以用双引号括起来
        System.out.println("12345678" + "\t" + "abc");  // 输出: 12345678        abc, 因为最少要补 1 个空格,最多补 8 个空格
    }
}

执行结果：

************************
abc     def
12345678        abc

程序示例：

public class ChangeChar {
    public static void main(String[] args) {
        // \t：制表位
        System.out.println("天津\t上海\t北京");
        // \n：换行符
        System.out.println("天津\n上海\n北京");
        // \\：一个\
        System.out.println("Hello\\ok");
        System.out.println("C:\\Windows\\apppatch");
        // \ 会把后面那个字母当成是一个转义符的一个组合，
        // 如果组合起来之后是一个合法的转义符，就正常编译，否则报错:非法转义符
        // 反正就一定会当成是一个转义符，然后去判断是否是合法的转义符
        // 输出两个 \\：
        System.out.println("C:\\\\Windows\\\\apppatch");
        // \"：一个"
        System.out.println("他说:\"你好。\"");  // 输出：他说:"你好。"
        // \'：一个'
        // \r：一个回车
        System.out.println("好的可以\r你好");  // 输出：你好可以
        System.out.println("好的可以\r\n你好");
    }
}

执行结果：

天津        上海        北京
天津
上海
北京
Hello\ok
C:\Windows\apppatch
C:\\Windows\\apppatch
他说:"你好。"
你好
好的可以
你好

可以在加引号的字符字面量或字符串中使用这些转义序列。

例如，'\u2122' 或 "Hello\n"。转义序列 \u 还可以在加引号字符常量或字符串之外使用（而其他所有转义序列不可以）。例如：

public static void main(String\u005B\u005D args)

就是完全合法的，\u005B 和 \u005D 分别是 [ 和 ] 的编码。

Unicode 转义序列会在解析代码之前处理。

例如，“\u0022+\u0022” 当中，\u0022 会在解析之前转换为 "，这会得到 ""+""，也就是一个空串。

更隐秘地，一定要当心注释中的 \u。以下注释

// \u000A is a newline

会产生一个语法错误，因为读程序时 \u000A 会替换为一个换行符。

下面这个注释

// look inside c:\users

也会产生一个语法错误，因为 \u 后面并没有跟着 4 位十六进制数。

字符编码

ASCII 码表

用一个字节表示，一共 128 个字符。扩展的 ASCII 码表一共 256 个字符。

Unicode 码表

Unicode 编码表的编码大小固定，使用两个字节来表示字符，字母和汉字统一都是占用两个字节，这样浪费空间。Unicode 的好处是使用一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独一无二的编码，使用 Unicode 没有乱码的问题。

Unicode的缺点：一个英文字母和一个汉字都占用 2 个字节，这对于存储空间来说是浪费的。

2 的 16 次方是 65536，所以最多可以表示 65536 个字符。

编码 0-127 的字符与 ASCII 的编码一样。比如 ‘a’ 在 ASCII 码是 0x61，在 Unicode 码是 0x0061，都对应 97。因此 Unicode 码兼容 ASCII 码。

UTF-8 码表

UTF-8 是 Unicode 是一种改进，是在互联网上广泛使用的码表。UTF-8 是一种变长的编码方式，可以使用 1-6 个字节表示一个符号，根据不同的符号而变化字节长度，字母使用 1 个字节，汉字使用 3 个字节。

GBK 码表

可以表示汉字，而且范围广，字母使用 1 个字节，汉字 2 个字节。

GB2312 码表

可以表示汉字，GB2312 可以表示的汉字个数少于 GBK。

Big5 码表

可以表示繁体中文，多用于台湾、香港。

byte 类型


short 类型


int 类型

后缀

Java 程序中的整形常量都默认为 int 类型，如果要申明 long 类型必须加后缀 l 或 L。

程序示例：

public class test3 {
    public static void main(String[] aStrings) {
        long a = 10l;               // 加后缀 l
        long b = 10L;               // 加后缀 L
        // int c = 10L;             // 报错：java: 不兼容的类型: 从 long 转换到 int 可能会有损失
        System.out.println(a);      // 10
        System.out.println(b);      // 10
        // System.out.println(c);
    }
}

程序示例：

public class test3 {
    public static void main(String[] args) {
        long a = 999999999;         // 正常输出
        // long b = 9999999999;     // 报错：java: 整数太大
        long b = 9999999999L;       // 加了后缀 L 后才能正常输出
        System.out.println(a);
        System.out.println(b);
        long c = 10L;               // 就算一个整数在 int 范围内，也可以通过后缀 L 让它变成 long 类型
        System.out.println(c);
    }
}

整数的进制

  • 十进制整数不加前缀；
  • 二进制整数加前缀 0b 或 0B；
  • 八进制整数加前缀 0；
  • 十六进制整数加前缀 0x 或 0x。

程序示例：

public static void main(String[] args) {
    System.out.println(10);         // 10
    System.out.println(010);        // 8
    System.out.println(0b10);       // 2
    System.out.println(0x10);       // 16
}

long 类型


float 类型

6~7 位有效数字。

double 类型

15 位有效数字。

double 表示这种数值的精度是 float 类型的两倍，所以有人称之为双精度 double precision。

浮点数值不适用于无法接受舍入误差的金融计算。例如：

public class test2 {
    public static void main(String[] args) {
        System.out.println(2.0 - 1.1);      // 0.8999999999999999
    }
}

这种舍入误差的主要原因是浮点数值采用二进制表示，而在二进制系统中无法准确地表示分数 1/10。这就好像十进制无法精确地表示分数 1/3 一样。如果需要精确的数值计算，不允许有舍入误差，则应该使用 BigDecimal 类。

字面量

浮点数字面量有两种写法：

  1. 十进制，如 5.12，512.0f，.512（小数点不能省略）等。
  2. e 计数法，如 5.12e2，5.12E-2 等。
  3. p 计数法 ，这是是用十六进制表示浮点型字面量，用 p 表示指数，尾数采用十六进制，指数采用十进制，指数的基数是 2 而不是 10。

后缀

Java 的浮点数字面量默认为 double 类型，如果要将一个浮点型字面量视为 float 类型，必须加后缀 f 或 F。

程序示例：

public static void main(String[] aStrings) {
    double a = 11.1;
    // float b = 11.1;             // java: 不兼容的类型: 从 double 转换到 float 可能会有损失
    float c = 11.1F;
    System.out.println(a);          // 11.1
    // System.out.println(b);
    System.out.println(c);          // 11.1
}

在一个数值字面量后面加 d 或 D 可以将其视为 double 类型，一般都不需要这么做，但是不会报错。

程序示例：

public static void main(String[] args) {
    double d1 = 3.3d;           // 加后缀 d 将 float 类型数值变为 double 类型
    double d2 = 3D;             // 加后缀 D 将 int 类型数值变为 double 类型
    System.out.println(d1);     // 3.3
    System.out.println(d2);     // 3.0
}

浮点型常量不能赋值给整型，程序示例：

public static void main(String[] args) {
    int a = 1.1;  // 报错：java: 不兼容的类型: 从 double 转换到 int 可能会有损失
    System.out.println(a);
}

特殊的浮点值

所有的浮点数的计算都遵循 IEEE 754 规范。

有 3 个特殊的浮点数值表示溢出和出错情况：

  • 正无穷大
  • 负无穷大
  • NaN（不是一个数）

一个正整数除以 0 的结果为正无穷大。计算 0/0 或者负数的平方根结果为 NaN。

public class test {
    public static void main(String[] args) {
        System.out.println(Double.POSITIVE_INFINITY);  // Infinity
        System.out.println(Double.NEGATIVE_INFINITY);  // -Infinity
        System.out.println(Double.NaN);                // NaN
        System.out.println(Float.POSITIVE_INFINITY);   // Infinity
        System.out.println(Float.NEGATIVE_INFINITY);   // -Infinity
        System.out.println(Float.NaN);                 // NaN
        // System.out.println(10 / 0);  // 报错：Exception in thread "main" java.lang.ArithmeticException: / by zero
    }
}

不能如下检测一个特定结果是否等于 Double.NaN：

if (x == Double.NaN)    // is never true

所有 NaN 的值都认为是不相同的。不过，可以使用 Double.isNaN 方法来判断：

if (Double.isNaN(x))    // check whether x is "not a number"

类型转换

自动类型转换

自动类型转换是把精度小的类型自动转换为精度大的数据类型。

自动类型转换也叫隐式转换、自动类型提升。

总的原则：当 Java 程序在进行赋值或者算术运算时，精度小的类型自动转换为精度大的数据类型。

数据类型按精度（即容量）大小排序为：
char → \rightarrow → int → \rightarrow → long → \rightarrow → float → \rightarrow → double
byte → \rightarrow → short → \rightarrow → int → \rightarrow → long → \rightarrow → float → \rightarrow → double

暂时无法在飞书文档外展示此内容

图中有 6 个实线箭头，表示无信息丢失的转换；另外有 3 个虚线箭头，表示可能有精度损失的转换。例如，123456789 是一个大整数，它包含的位数多于 float 类型所能表示的位数。将这个整数转换为 float 类型时，数量级是正确的，但是会损失一些精度。

程序示例：

public class ConvertDemo {
    public static void main(String[] args) {
        int n = 123456789;
        float f = n;
        System.out.println(f);  // 1.23456792E8
    }
}

其他细化的规则：

有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。

当把精度（即容量）大的数据类型赋值给精度（即容量）小的数据类型时，就会报错，反之就会进行自动类型转换。

(byte, short) 和 char 之间不会相互自动转换。

byte，short，char 它们三者可以计算，在计算时首先转换为 int 类型（不论是否有 int 参与）。

boolean 不参与自动转换。

当用一个二元运算符连接两个值时，先要将两个操作数转换为同一种类型，然后再进行计算。

如果两个操作数中有一个是 double 类型，另一个操作数就会转换为 double 类型；

否则，如果其中一个操作数是 float 类型，另一个操作数将会转换为 float类型；

否则，如果其中一个操作数是 long 类型，另一个操作数将会转换为 long 类型；

否则，两个操作数都将被转换为 int 类型。

程序示例：

int n1 = 10;
// 有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
// float f1 = n1 + 1.1; // Type mismatch: cannot convert from double to float
float f1 = n1 + 1.1F;
System.out.println(f1); // 11.1

程序示例：

// 当把精度（即容量）大的数据类型赋值给精度（即容量）小的数据类型时，就会报错，反之就会进行自动类型转换。
// int a = 1.1; // Type mismatch: cannot convert from double to int
// System.out.println(a);
// 把一个常数（必须是整数类型）赋值给 byte 时，先看这个常数是否在 byte 范围内（-128~127），
// 如果在范围内，则可以赋值
byte b1 = 10;
System.out.println(b1); // 10
// byte b3 = 1.1;
// System.out.println(b3); // Type mismatch: cannot convert from double to byte
// 把一个变量赋值给 byte 时，要求变量必须也是 byte 类型
// int a1 = 10;
// byte b2 = a1; // Type mismatch: cannot convert from int to byte
// System.out.println(b2);

程序示例：

// byte，short，char 他们三者可以计算，在计算时首先转换为 int 类型（不论是否有 int 参与）。
byte b6 = 10;
char c1 = 2;
// byte b7 = b6 + c1; // Type mismatch: cannot convert from int to byte
// System.out.println(b7);
int n2 = b6 + c1;
System.out.println(n2); // 12

程序示例：

// byte，short，char 他们三者可以计算，在计算时首先转换为int类型（不论是否有 int 参与）。
byte b8 = 10;
byte b9 = 10;
byte b10 = b8 + b9; // Type mismatch: cannot convert from int to byte

隐式类型转换就是在补码前面加零：

public static void main(String[] args) {
    byte a = 10;    // 0000 1010
    int b = a;      // 0000 0000 0000 0000 0000 0000 0000 1010
    System.out.println(b);
}

整型字面量在范围内时可以降级赋值，用后缀 L 或 l 指定的常量除外。但是用变量赋值时即便值在范围内也不可以降级赋值。浮点型不论是字面量还是变量都不允许降级赋值。

程序示例：

public static void main(String[] args) {
    short a = 100;  // 没问题，是字面量降级赋值，int → short，在范围内
    System.out.println(a);
}

程序示例：

public static void main(String[] args) {
    int a = 100L;  // 报错：java: 不兼容的类型: 从 long 转换到 int 可能会有损失
    System.out.println(a);
}

程序示例：

public static void main(String[] args) {
    float a = 100;               // 没问题，可以将 int  赋值给 float，同样，也可以将 int 赋值给 double
    System.out.println(a);       // 100.0
}

程序示例：

public static void main(String[] args) {
    float a = 100.;               // 加了一点，变成了 double 类型，报错：java: 不兼容的类型: 从 double 转换到 float 可能会有损失
    System.out.println(a);        // 100.0
}

强制类型转换

强制类型转换是自动类型转换的逆过程，是将精度大的类型转换为精度小的数据类型。

使用强制类型转换时要加上强制转换符 ()，但可能造成精度降低或溢出，因此要格外要注意。

程序示例：

public static void main(String[] args) {
    int i1 = (int) 1.9;
    System.out.println(i1); // 打印 1，非四舍五入，直接丢弃小数点后的内容，造成精度损失
    // byte b1 = (byte) 2000;
    // System.out.println(b1); // b1 cannot be resolved to a variable
    int n1 = 2000;
    byte b2 = (byte) n1;
    System.out.println(b2); // -48，数据溢出
}

当需要精度高的数据类型转换为精度低的数据类型时，就要用到强制类型转换。

强制类型转换只针对最近的操作数有效，可以使用小括号修改优先级。

byte，char 和 short 可以接收处于范围内的 int 类型的整数，但是不能接收 int 类型的变量，如果需要，则需要进行强制类型转换。

程序示例：

// 强制类型转换只针对最近的操作数有效，可以使用小括号修改优先级。
public class Test {
    public static void main(String[] args) {
        // int x = (int) 10 * 3.5 + 6 * 1.5; // Type mismatch: cannot convert from double to int
        // System.out.println(x);
        int y = (int) (10 * 3.5 + 6 * 1.5);
        System.out.println(y);       // 44
    }
}

程序示例：

public class Test {
    public static void main(String[] args) {
        byte b1 = 1, b2 = 2;
        byte b3 = b1 + b2;           // 报错：java: 不兼容的类型: 从 int 转换到 byte 可能会有损失
        byte b3 = (byte) (b1 + b2);  // 正确
    }
}

程序示例：

public class Test {
    public static void main(String[] args) {
        int a = 97;
        char c = (char) a;
        char b = 97;
        System.out.println(c);   // a
        System.out.println(b);   // a，加不加强制类型转换都是一样的，因为 97 在 0-65535 之间，可以接收
        char d = a;              // 报错，用变量赋值需要强转
    }
}

强制类型转换就是删除补码前面多出来的位：

public static void main(String[] args) {
    int a = 300;            // 0000 0000 0000 0000 0000 0001 0010 1100
    byte b = (byte) a;      // 0010 1100
    System.out.println(b);  // 44
}

public static void main(String[] args) {
    int a = 200;            // 0000 0000 0000 0000 0000 0000 1100 1000
    byte b = (byte) a;      // 1100 1000
    System.out.println(b);  // -56
}

不要在 boolean 类型与任何数值类型之间进行强制类型转换，这样可以防止发生一些常见的错误，只有极少数的情况下需要将一个 boolean 值转换为一个数，此时可以使用条件表达式 b ? 1 : 0。

数字字面量加下划线

可以为数字字面量加下划线，这样可以提高可读性，编译器会去除这些下划线。以多少个数字为一组进行分割是随意的。

程序示例：

public class Underscore {
    public static void main(String[] args) {
        long a = 1_000_000_000_000_000L;
        int b = 0B1111_0000_1111_0000;
        System.out.println(a);      // 1000000000000000
        System.out.println(b);      // 61680
    }
}

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

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

相关文章

【C语言】07.函数

【C语言】07.函数

一、概念 C语言的函数，有些翻译为：子程序，子程序这种翻译更加准确⼀些。 C语言中的函数就是⼀个完成某项特定的任务的⼀小段代码。这段代码是有特殊的写法和调用方法的。 C语言的程序其实是由无数个小的函数组合而成的，也可以说&…
阅读更多...
什么是SIEM

什么是SIEM

SIEM 解决方案是一种企业级应用程序，可集中和自动化与网络安全相关的操作，该工具通过收集、分析和关联从组织 IT 基础设施中的各种实体聚合的网络事件来帮助应对网络威胁。 与帮助监控和评估组织物理空间中的危险的监视控制台相比，SIEM解决方…
阅读更多...
【百万字详解Redis】主从复制

【百万字详解Redis】主从复制

文章目录 一、主从复制概述1.1、单机问题1.1.1、机器宕机1.1.2、容器瓶颈1.1.3、QPS瓶颈 1.2、什么是主从复制1.3、主从复制形式1.3.1、一主一从1.3.2、一主多从 1.4、主从复制作用 二、单机主从2.1、复制redis.conf2.2、配置主机2.3、配置从机2.4、启动服务2.5、读写分离 三、…
阅读更多...
[工具探索]富士mini90拍立得使用指南

[工具探索]富士mini90拍立得使用指南

文章目录 1. 基本功能介绍1.1 相机外观1.2 电池与胶片 2. 设置相机2.1 装入电池2.2 装入胶片 3. 拍摄模式3.1 标准模式3.2 儿童模式3.3 远景模式3.4 双重曝光模式3.5 Bulb（B）模式3.6 **派对模式**3.7 微距模式3.8 **亮度模式**3.9 **定时拍摄模式**3.10 …
阅读更多...
php探针代码怎么写

php探针代码怎么写

创建php文件并输入代码，访问文件查看php版本、环境和系统配置信息，可使用ini_set()函数定制输出，但注意在生产环境中使用时要注重安全，因为它会泄露敏感信息。 PHP探针代码撰写指南 PHP探针代码是一种脚本，可提供关于…
阅读更多...
基于Java Mq的数据交换平台实现_设计消息的格式和内容

基于Java Mq的数据交换平台实现_设计消息的格式和内容

基于Java Mq的数据交换平台实现 目录概述需求： 设计思路实现思路分析 参考资料和推荐阅读 Survive by day and develop by night. talk for import biz , show your perfect code,full busy，skip hardness,make a better result,wait for change,challen…
阅读更多...
FileZilla：不安全的服务器，不支持 FTP over TLS 原因与解决方法

FileZilla：不安全的服务器，不支持 FTP over TLS 原因与解决方法

今天在用FileZilla Client连接某个主机的FTP的时候，主机地址、账号、密码、端口确定百分之百正确的情况下，结果报错如下： 状态: 正在解析 x.x.x 的地址 状态: 正在连接 x.x.x.x:21... 状态: 连接建立，等待欢迎消息... 状态: 不安全…
阅读更多...
6.6SSH的运用

6.6SSH的运用

ssh远程管理 ssh是一种安全通道协议，用来实现字符界面的远程登录。远程复制，远程文本传输。 ssh对通信双方的数据进行了加密 用户名和密码登录 密钥对认证方式（可以实现免密登录） ssh 22 网络层 传输层 数据传输的过程中是加密的 …
阅读更多...
Java Web学习笔记19——Ajax介绍

Java Web学习笔记19——Ajax介绍

Ajax: 概念：Asynchronous JavaScript And XML 异步的JavaScript和XML。 作用： 1）数据交换：通过Ajax可以给服务器发送请求，并获得服务器的响应数据。 2）异步交互：可以在不重新加载页面的情况…
阅读更多...
【NetTopologySuite类库】生成凸包

【NetTopologySuite类库】生成凸包

介绍 计算几何体的凸包。凸包是最小的凸几何体，包含输入几何体中的所有点。使用Graham Scan算法。 API地址： https://nettopologysuite.github.io/NetTopologySuite/api/NetTopologySuite.Algorithm.ConvexHull.html 示意图 示例代码 需在NuGet中安装…
阅读更多...
nomachine使用记录以及录包

nomachine使用记录以及录包

录包命令： rosbag record 话题名字（可以是原相机话题和执行程序的话题）rosbag play 包名（可以离线播放包的数据） rqt_image_view 话题可视化
阅读更多...
新买的移动硬盘无法识别

新买的移动硬盘无法识别

文章目录 背景解决方案 背景 同事新买的移动硬盘，插在电脑上识别不出来盘符，检查了一下，硬盘没问题应该，是ssk的硬盘盒M.2的SSD，硬盘驱动也是正常的，插拔了几次，都不识别，换了太电脑…
阅读更多...
未见过类型题每周总结（个人向）

未见过类型题每周总结（个人向）

1.DP40 小红取数 题目 解析 一道01背包的衍生问题，我们可以按照它的思路定义数组dp[i][j],表示前i个数中%k为j的最大和。为什么设置未%k的最大和呢？是因为当两个数分别%k，如a%kx，b%ky。那么（ab）%k&#…
阅读更多...
FENDI CLUB精酿啤酒品鉴体验

FENDI CLUB精酿啤酒品鉴体验

当提及“品质卓越，口感非凡”的啤酒时，FENDI CLUB精酿啤酒无疑是一个值得一试的选择。这款啤酒以其独特的酿造工艺和优质的原料，为消费者带来了与众不同的味觉享受。 一、独特的酿造工艺 FENDI CLUB精酿啤酒在酿造过程中，严格遵循…
阅读更多...
关于 spring boot 的 目录详解 和 配置文件 以及 日志

关于 spring boot 的 目录详解 和 配置文件 以及 日志

目录 配置文件 spring boot 的配置文件有两种格式，分别是 properties 和 yml（yaml）。这两种格式的配置文件是可以同时存在的，此时会以 properties 的文件为主，但一般都是使用同一种格式的。 格式 properties 语法格…
阅读更多...
使用 Django 创建 App

使用 Django 创建 App

文章目录 步骤 1：创建 Django 项目步骤 2：创建 App步骤 3：配置 App步骤 4：编写代码步骤 5：运行服务器 在 Django 中，App 是组织代码的基本单元，它可以包含模型、视图、模板等组件，帮…
阅读更多...
Hadoop的Windows环境准备

Hadoop的Windows环境准备

一、将Hadoop传输到Windows中 1、备份副本 cp -r /opt/softs/hadoop3.1.3/ /opt/softs/hadoop3.1.3_temp 2、删除备份的share目录 cd /opt/softs/hadoop3.1.3_temp rm -rf share/ 3、下载到Windows中 重命名去掉_temp 4、删除备份文件 rm -rf /opt/softs/hadoop3.1.3_t…
阅读更多...
Redis到底支不支持事务？

Redis到底支不支持事务？

文章目录 一、概述二、使用1、正常执行：2、主动放弃事务3、全部回滚:4、部分支持事务:5、WATCH: 三、事务三阶段四、小结 redis是支持事务的，但是它与传统的关系型数据库中的事务是有所不同的 一、概述 概念: 可以一次执行多个命令，本质是一…
阅读更多...
如何提高网站排名？

如何提高网站排名？

提高网站排名是一个复杂的过程，涉及到多个方面的优化，包括但不限于内容质量、网站结构、用户体验、外部链接建设等，GSR这个系统，它是一种快速提升关键词排名的方案，不过它有个前提，就是你的站点在目标关键词…
阅读更多...
自制植物大战僵尸：HTML5与JavaScript实现的简单游戏

自制植物大战僵尸：HTML5与JavaScript实现的简单游戏

引言 在本文中，我们将一起探索如何使用HTML5和JavaScript来创建一个简单的植物大战僵尸游戏。这不仅是一项有趣的编程挑战，也是学习游戏开发基础的绝佳机会。 什么是植物大战僵尸？ 植物大战僵尸是一款流行的策略塔防游戏，玩家需…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023