java04_[常规内容]_Java数据类型介绍

Java数据类型介绍


在Java中，数据类型用于定义变量的类型，指定变量可以存储的数据范围和操作。Java的数据类型可以分为两大类：基本数据类型和引用数据类型。


基本数据类型


整数类型

用于表示整数值，包括byte、short、int和long。

  • byte：1字节，范围为-128到127。
  • short：2字节，范围为-32768到32767。
  • int：4字节，范围为-2147483648到2147483647。
  • long：8字节，范围为-9223372036854775808到9223372036854775807。

浮点类型

用于表示带有小数部分的数值，包括float和double。

  • float：4字节，范围为±3.40282347e+38F，具有约7位有效数字。
  • double：8字节，范围为±1.79769313486231570e+308，具有约15位有效数字。

字符类型

用于表示单个字符，使用char类型，占用2字节。


布尔类型

用于表示真或假，使用boolean类型，取值为true或false。


基本数据类型注意点


①：浮点类型的不准确性

​ 在计算机中，浮点数是使用二进制表示的，但大多数实数（如0.1和0.3）在二进制下是无限循环的。这就导致了一些小数无法准确表示，尤其是在进行算术运算时。

​ 例如，在Java中，以下代码将输出0.30000000000000004而不是期望的0.3：

double result = 0.1 + 0.2;
System.out.println(result);

​ 这是因为0.1和0.2都不能在二进制下精确表示。当它们相加时，得到的是一个近似值，而非精确的0.3。因此，在此示例中，相加后的结果包含了一些舍入误差。

​ 类似地，可以通过以下代码来检验1F/10F是否等于0.1：

double result = 1F/10F;
System.out.println(result);
if (result ==0.1) {
    System.out.println("Equal");
} else {
    System.out.println("Not equal");
}

​ 该代码会输出Not equal。在1F/10F产生了一些舍入误差结果为0.10000000149011612，因此计算结果不是精确的0.1。


​ 因此，在使用浮点数时，需要注意它们可能存在的不准确性。对于特定的应用程序，可以采用以下措施来降低误差：

  • 使用BigDecimal类：该类提供了精确的十进制数值计算，但效率可能较低。
  • 避免直接比较浮点数：由于舍入误差的存在，相等的两个浮点数可能无法直接比较相等。建议使用误差范围或epsilon值进行比较。
  • 理解算术运算和格式化行为：例如，舍入误差可能会导致某些小数舍入为0，而格式化时可能丢失这些信息。

总之，我们需要在编写Java程序时认识到浮点数的不准确性，并采取适当的措施来处理它们，以获得正确的计算结果。


②：布尔类型的字节大小

​ 在Java中，布尔类型（boolean）的大小是虚拟机实现相关的。根据Java虚拟机规范（Java Virtual Machine Specification），布尔类型并没有具体规定占用多少字节。

​ 然而，根据惯例和常见的实现方式，布尔类型通常被实现为占用1字节的存储空间。尽管布尔类型只有两个可能的值（true或false），但为了对齐内存，通常会将其存储为至少一个字节。

​ 布尔类型的确切大小可能因为特定的虚拟机实现或不同的编译器而有所不同。在Java中，最小可寻址的内存单元是字节（byte），所以布尔类型最小也会占用一个字节。

​ 在使用布尔类型时，我们应该关注其含义而不是具体的存储大小。布尔类型的值可以用于逻辑判断和条件控制，例如：

boolean isTrue = true;
boolean isFalse = false;

if (isTrue) {
    System.out.println("This statement is true.");
} else {
    System.out.println("This statement is false.");
}

​ 总结而言，在大多数情况下，布尔类型在Java中占用1字节的存储空间，但这并非是Java语言规范的要求。具体的实现取决于虚拟机和编译器的实现选择。


③：Unicode编码

​ Unicode是一种字符编码标准，用于在计算机中表示和处理文本。它旨在为世界上所有的字符（包括各种语言的字母、符号、标点符号等）提供一个统一的编码方案。

​ Unicode为每个字符定义了一个唯一的代码点（code point），使用十六进制表示，例如U+0041代表拉丁字母"A"。Unicode当前定义了超过137,000个字符，其中包括多种脚本（如拉丁字母、汉字、阿拉伯字母等），以及特殊符号和标点符号。

​ 在实际存储和传输Unicode字符时，需要选择一种具体的编码方案进行表示。常见的编码方案包括UTF-8、UTF-16和UTF-32。这些编码方案根据不同需求和字符的范围来选择合适的编码方式。

  • UTF-8是一种变长编码方案，用1到4个字节表示一个字符，适用于在英文和一般文字之间平衡存储空间和编码效率的场景，并且保持向后兼容ASCII编码。
  • UTF-16是一种定长或双字节编码方案，用2个字节表示大部分字符，但对于一些罕见字符需要用4个字节表示，适用于较常见的非拉丁字符集，如汉字。
  • UTF-32是一种固定长度编码方案，将每个字符统一表示为4个字节，适用于需要一致处理每个字符的场景。

​ 在Java中，字符串按照UTF-16编码进行存储。Java的String类提供了许多用于操作Unicode字符的方法，比如charAt()、length()和substring()。

​ 我们可以使用Java的字符转义序列来表示Unicode字符，例如\u0041代表"A"。此外，在Java中也可以直接使用Unicode字符来表示字符串。

​ 例如，以下代码演示了Java中如何使用Unicode字符：

String str = "\u4F60\u597D"; // 使用Unicode字符表示中文 "你好"
System.out.println(str); // 输出："你好"

String emoji = "\uD83D\uDE0A"; // 使用Unicode字符表示笑脸表情 😀
System.out.println(emoji); // 输出：😀

​ 总结而言，Unicode是一种字符编码标准，用于表示和处理世界各种语言的字符。在Java中，字符串按照UTF-16编码存储，并提供了相应的方法用于操作和处理Unicode字符。


④：Unicode与UTF的关系

​ Unicode（统一码、万国码）是一种字符集，它为世界上几乎所有的字符都分配了一个唯一的标识符。每个字符都被赋予一个称为"码点"的数字值。

​ 而UTF（Unicode转换格式）是一种编码方案，用于在计算机系统中存储和传输Unicode字符。UTF定义了多种实现方式，包括UTF-8、UTF-16和UTF-32等。

​ Unicode和UTF的关系是这样的：

  1. Unicode字符集中定义了各种字符的标识符，即码点。

  2. UTF编码方案则定义了如何使用字节来表示这些字符。

  3. UTF-8是一种变长编码方案，可以使用1到4个字节来表示不同范围的Unicode字符。

  4. UTF-16是一种定长或变长编码方案，使用2或4个字节来表示Unicode字符。

  5. UTF-32是一种定长编码方案，始终使用4个字节来表示Unicode字符。

​ 因此，Unicode提供了字符的标识符，而UTF则提供了将这些字符表示为字节序列的方法。UTF-8、UTF-16和UTF-32是最常用的UTF编码方案，它们根据需要选择合适的字节长度来表示Unicode字符。其中，UTF-8是最常用的编码方案，因为它在表示ASCII字符时只需一个字节，并且可以向后兼容ASCII编码。

​ 总结而言，Unicode是一个字符集，为字符分配了唯一的标识符。UTF是一种编码方案，定义了如何使用字节来表示Unicode字符。UTF-8、UTF-16和UTF-32是常用的UTF编码方案。


引用数据类型


类类型（Class Type）

用于表示一个类的实例，如自定义类、库提供的类等。


接口类型（Interface Type）

用于表示一个接口的实现。

​ 在Java中，接口（Interface）是一种定义了一组抽象方法的类型。它可以被类实现（implements）或者其他接口继承（extends）。接口提供了一种机制，让类以统一的方式进行行为定义，从而实现了多态性和代码重用。

​ 接口的定义使用关键字 interface。下面是一个简单的接口示例：

public interface Shape {
    double getArea();
    double getPerimeter();
}

​ 上面的接口 Shape 定义了两个抽象方法 getArea() 和 getPerimeter()，但没有提供方法的具体实现。其他类可以实现该接口，并提供这两个方法的实际实现。例如：

public class Circle implements Shape {
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    public double getArea() {
        return Math.PI * radius * radius;
    }
    
    public double getPerimeter() {
        return 2 * Math.PI * radius;
    }
}

​ 在上述代码中，Circle 类实现了 Shape 接口，并提供了 getArea() 和 getPerimeter() 方法的具体实现。

​ 接口还可以包含常量和默认方法。常量在接口中声明时，会被隐式地指定为 public static final 类型。默认方法是在接口中提供的具有默认实现的方法，可以被实现类继承或覆盖。

​ 以下是一个包含常量和默认方法的接口示例：

public interface Vehicle {
    int MAX_SPEED = 120; // 常量
    
    void start(); // 抽象方法
    
    default void stop() { // 默认方法
        System.out.println("Vehicle stopped.");
    }
}

​ 接口在Java中有很多应用场景，例如定义回调函数、实现多继承等。它们提供了规范和标准，使得代码更加灵活、可扩展和模块化。

​ 需要注意的是，接口本身不能被实例化，但可以通过引用变量指向实现了该接口的类的对象。例如：

Shape shape = new Circle(5.0);
double area = shape.getArea();

​ 上述代码中，shape 是一个 Shape 类型的引用变量，指向一个实现了 Shape 接口的 Circle 对象。通过这种方式，可以实现面向接口编程，提高代码的灵活性和可维护性。


数组类型（Array Type）

用于存储多个相同类型的数据元素，如int[]、String[]等。


字符串类型（String）

虽然它看起来像基本数据类型，但实际上是一个类。字符串类型用于表示一串字符。


自动装箱和拆箱类型（Autoboxing and Unboxing Types）

用于实现基本数据类型和对应包装类型之间的自动转换，如Integer与int之间的转换。


引用数据类型注意点


①：类的分类及特点


​ 在Java中，类可以根据其特性和用途进行分类。下面是一些常见的类的分类以及各自的示例：

  1. 基础类（Built-in Classes）：这些类是Java编程语言提供的内置类，用于支持基本的数据类型、输入输出、异常处理等。例如：

    • String：用于表示字符串。
    • Integer、Double等：用于表示整数、浮点数等基本数据类型的包装类。
    • System：提供了与系统相关的属性和方法。
    • Exception：用于异常处理的基类。

  2. 自定义类（Custom Classes）：这些类由开发者根据需求自定义的类。例如：

    • Person：表示一个人，可能包含姓名、年龄等属性和相关的方法。
    • Car：表示一辆汽车，可能包括品牌、型号等属性和相关的方法。
    • Student：表示一个学生，可能包括学号、课程成绩等属性和相关的方法。

  3. 抽象类（Abstract Classes）：这些类不能被实例化，只能作为其他类的父类或基类。它们可以包含抽象方法和具体方法。例如：

    • Animal：作为其他动物类的父类，可以定义共有的属性和方法，如eat()、sleep()等。
    • Shape：作为各种形状类的父类，可以定义共有的属性和方法，如calculateArea()、calculatePerimeter()等。

  4. 接口（Interfaces）：它在Java中是一种特殊的类，但它不是传统意义上的类。这些类定义了一组方法的规范，但没有实现。其他类可以实现这些接口，并提供方法对应的具体实现。例如：

    • Comparable：定义了对象之间可比较的规范，实现类可以进行比较操作。
    • Runnable：定义了线程执行的规范，实现类可以在多线程环境中执行。

  5. 泛型类（Generic Classes）：这些类具有类型参数，可以在类的定义中使用任意类型。例如：

    • List<T>：表示一个列表，可以存储各种类型的对象，并提供相关操作方法。
    • Map<K, V>：表示一个映射表，可以存储键-值对，并提供相关操作方法。

​ 这些是Java中常见的类的分类和示例。开发者可以根据需求自定义类，并按照类的特性进行分类。这样可以提高代码的组织性、可读性和可维护性。

​ Java中的类具有以下特点：

  1. 封装性（Encapsulation）：类通过封装将数据和方法组合在一起，隐藏了内部实现细节，只暴露必要的接口。这提供了更好的安全性和可维护性，同时也避免了对外部代码的直接访问。

  2. 继承性（Inheritance）：类可以通过继承机制来派生出新的类，新类可以继承和复用父类的属性和方法。继承性促进了代码重用和层次化设计，提高了代码的可扩展性和可维护性。

  3. 多态性（Polymorphism）：Java中的多态性允许不同类型的对象针对相同的消息作出不同的响应。通过多态性，可以以通用的方式处理不同类型的对象，提高代码的灵活性和可扩展性。

  4. 抽象性（Abstraction）：类的抽象性允许定义具有共同属性和行为的对象的模板。抽象类和接口提供了定义抽象方法和常量的机制，用于约束和组织类的结构，使得代码更加模块化、可理解和可维护。

  5. 类和对象的关系：类是对象的模板，而对象是类的实例。通过创建对象，可以根据类的定义使用类的属性和方法。类定义了对象的行为和特征，对象是类的具体实现。

  6. 数据成员和成员方法：类由数据成员（属性）和成员方法（行为）组成。数据成员用于存储对象的状态和属性，成员方法定义了对象的行为和操作。

  7. 类的实例化和访问：通过使用new关键字可以创建类的实例（对象），然后通过对象访问该类的成员变量和方法。

​ 这些特点使得类成为Java面向对象编程的基础。通过类的封装、继承、多态和抽象性，可以构建具有高内聚性和低耦合性的模块化代码，提高代码的可读性、可复用性和可扩展性。


②：数组详解


​ 在Java中，数组是一种用于存储多个相同类型元素的数据结构。它是一个固定大小的、连续分配的内存块，可以通过索引访问和操作其中的元素。下面是关于Java数组的详细解释：

  1. 声明和创建数组：
    Java数组的声明包括指定元素类型和数组名。例如，int[] numbers;声明了一个整数类型的数组变量numbers，但并未创建数组对象。要创建数组对象，需要使用new关键字并指定数组的长度。例如，numbers = new int[5];将创建一个长度为5的整数数组。

  2. 初始化数组：
    数组的初始化是为数组元素赋予初始值的过程。在Java中，有以下几种初始化数组的方式：

    • 静态初始化：在声明数组时直接指定元素的初始值。

      int[] numbers = {1, 2, 3, 4, 5};

    • 动态初始化：先声明数组，然后逐个为元素赋值。

      int[] numbers = new int[5];
numbers[0] = 1;
numbers[1] = 2;
// ...

  3. 访问数组元素：
    数组的元素通过索引访问，索引从0开始，依次递增。使用数组名[索引]的方式可以获取或修改对应索引处的元素值。例如，int x = numbers[2];获取索引为2的元素值，并将其赋给变量x。

  4. 数组长度：
    数组的长度表示数组中元素的个数，可以通过数组名.length获得。例如，int len = numbers.length;将把数组numbers的长度赋给变量len。

  5. 遍历数组：
    通过循环结构和索引可以遍历数组，访问每个元素并进行相应的操作。常用的遍历方法有：

    • 使用for循环遍历数组：

      for (int i = 0; i < numbers.length; i++) {
    // 访问numbers[i]
}

    • 使用增强型for循环遍历数组：

      for (int number : numbers) {
    // 访问number
}

  6. 多维数组：
    在Java中，还可以创建多维数组，即数组中包含其他数组。例如，int[][] matrix = new int[3][3];创建一个3x3的二维整数数组。多维数组的访问和操作方式类似于一维数组，需要使用多个索引来定位元素。

  7. 数组的注意事项：

    • 数组长度是固定的，一旦确定不能更改。
    • 数组的索引范围是从0到数组长度减1，超出索引范围会导致ArrayIndexOutOfBoundsException异常。
    • 数组可以存储任何类型的数据，包括基本数据类型和对象引用类型。

​ 以上是关于Java数组的详细解释。使用数组可以方便地组织和处理一系列相同类型的数据，是编程中常用的数据结构之一。


③：字符串详解


​ 在Java中，字符串（String）是一种不可变的字符序列，它对应的类是java.lang.String。这意味着一旦创建了一个字符串对象，就不能修改其中的字符。下面是Java字符串的一些详细内容：

  1. 字符串的创建

​ 可以使用双引号（"）或者字符串常量创建字符串对象。例如：

String str1 = "Hello, World!"; // 使用双引号创建字符串
String str2 = new String("Hello, World!"); // 使用构造方法创建字符串
  1. 字符串的常用方法

​ Java字符串提供了丰富的方法来操作字符串，包括：

  • length()：获取字符串长度。
  • charAt(index)：获取指定索引处的字符。
  • substring(startIndex, endIndex)：截取子字符串。
  • indexOf(str)：获取子字符串在原字符串中的位置。
  • lastIndexOf(str)：获取子字符串在原字符串中最后出现的位置。
  • equals(str)：比较两个字符串是否相等。
  • equalsIgnoreCase(str)：忽略大小写比较两个字符串是否相等。
  • toLowerCase()：将字符串转换为小写。
  • toUpperCase()：将字符串转换为大写。
  • trim()：去除字符串两端的空格。
  • replace(oldStr, newStr)：替换字符串中的某个子串为另一个子串。

​ 示例代码：

String str = "Hello,World!";
System.out.println(str.length()); // 输出 12
System.out.println(str.charAt(0)); // 输出 H
System.out.println(str.substring(2, 7)); // 输出 "llo,W "
System.out.println(str.indexOf("World")); // 输出 6
System.out.println(str.equalsIgnoreCase("hello,world!")); // 输出 true
System.out.println(str.replace("World", "Java")); // 输出 "Hello, Java!"
  1. 字符串的拼接和格式化

​ Java字符串可以使用+或concat()方法进行拼接。例如：

String str1 = "Hello";
String str2 = "World";
String str3 = str1 + ", " + str2; // 使用"+"
String str4 = str1.concat(", ").concat(str2); // 使用"concat()"

​ 此外，Java还提供了String.format()方法来格式化字符串，支持类似于C语言中的printf的格式化方式。例如：

String name = "Tom";
int age = 18;
String info = String.format("%s is %d years old.", name, age);
System.out.println(info); // 输出 "Tom is 18 years old."
  1. 字符串的比较

​ Java字符串可以使用equals()、compareTo()等方法进行比较。其中，equals()方法用于比较两个字符串是否相等，compareTo()方法用于比较字符串的大小关系。例如：

String str1 = "Hello";
String str2 = "Hello";
String str3 = "World";
System.out.println(str1.equals(str2)); // 输出 true
System.out.println(str1.compareTo(str2)); // 输出 0
System.out.println(str1.equals(str3)); // 输出 false
System.out.println(str1.compareTo(str3)); // 输出 -15，表示str1小于str3

​ 总之，Java字符串是一种不可变的字符序列，提供了丰富的方法来操作字符串，包括字符串的创建、常用方法、拼接和格式化、比较等等。


④：字符串的存储方式


​ 在Java中，String字符串对象的存储方式有两种：基于字面量（Literal）的存储和基于堆（Heap）的存储。

  1. 基于字面量的存储：
    当使用字面量创建字符串对象时，Java会首先在字符串常量池（String Pool）中查找是否存在相同值的字符串对象。如果存在，则直接返回已经存在的对象的引用；如果不存在，则在字符串常量池中创建一个新的字符串对象，然后返回其引用。由于字符串常量池的特性，相同值的字符串对象在内存中只会存在一份，以节省内存并提高性能。

    字符串常量池是位于Java堆内存之外的一块特殊内存区域，它保存着程序中所有的字符串字面量。当使用字面量创建字符串时，编译器会先检查字符串常量池中是否已存在相同内容的字符串，如果存在则直接返回该字符串的引用，如果不存在则在常量池中创建一个新的字符串对象，并返回其引用。

    例如：

    String str1 = "Hello"; // 字符串常量池中创建一个新的字符串对象
String str2 = "Hello"; // 直接使用已存在的字符串对象

    ​ 在上述代码中，str1和str2都指向字符串常量池中的同一个对象，因为它们的值相同。

  2. 基于堆的存储：
    当使用new关键字显式创建字符串对象时，无论字符串常量池中是否存在相同值的字符串对象，都会在堆中创建一个新的字符串对象。

    基于堆的存储方式会创建一个新的String对象，即使字符串常量池中已经存在相同内容的字符串。这是因为使用new关键字创建字符串时，会在堆内存中分配一块新的空间来存储字符串对象。

    例如：

    String str3 = new String("Hello"); // 在堆中创建一个新的字符串对象

    在上述代码中，str3指向堆中的一个新的String对象，其值与常量池中的字符串"Hello"相同，但它们是不同的对象。

​ 总结来说，基于字面量的存储方式会重用字符串常量池中已存在的相同值的字符串对象，以节省内存并提高性能。而基于堆的存储方式则会在堆中创建一个新的字符串对象。对于字符串常量的操作，推荐使用基于字面量的存储方式来提高性能和节省内存。


⑤：包装类


​ 在Java中，包装类（Wrapper Class）是一种用于将基本数据类型封装成对象的类。Java提供了对应于每种基本数据类型的包装类，它们位于java.lang包中。下面是Java中常见的包装类及其对应的基本数据类型：

包装类 基本数据类型
Boolean boolean
Byte byte
Short short
Integer int
Long long
Float float
Double double
Character char

​ 包装类提供了一系列方法来操作和获取封装的基本数据类型的值。以下是一些常用的包装类操作：

  1. 装箱和拆箱：

    • 装箱：通过调用包装类的构造方法或静态方法，将基本数据类型转换为对应的包装类对象。例如，Integer num = Integer.valueOf(10); 将整数值10装箱为Integer对象。
    • 拆箱：通过调用包装类的实例方法或静态方法，将包装类对象转换为基本数据类型。例如，int value = num.intValue(); 将Integer对象num拆箱为整数值。

  2. 自动装箱和拆箱：

    ​ 自动装箱和拆箱使得在包装类和基本数据类型之间进行转换更加便捷。例如，可以直接将一个整数赋值给Integer对象，而不需要显式调用valueOf方法。

    javaCopy Codeint x = 10;
Integer num = x; // 自动装箱

    ​ 反之，也可以直接将一个Integer对象赋值给基本数据类型，系统会自动拆箱：

    javaCopy CodeInteger num = Integer.valueOf(20);
int y = num; // 自动拆箱

  3. 常量和特殊值：

    • 每个包装类都有对应的常量，表示最大值、最小值等特殊值。例如，Integer.MAX_VALUE 表示int类型的最大值。
    • 包装类还提供了一些特殊值的常量，如NaN（非数字）和POSITIVE_INFINITY（正无穷大）。

  4. 字符串转换：

    • 包装类提供了静态方法 valueOf，可以将字符串转换为对应类型的包装类对象。例如，Integer num = Integer.valueOf("10"); 将字符串"10"转换为Integer对象。
    • 包装类还提供了实例方法 toString，用于将包装类对象转换为字符串。例如，String str = num.toString(); 将Integer对象num转换为字符串。

​ 通过使用包装类，可以在需要操作对象的场景中使用基本数据类型，并且可以利用包装类提供的方法进行更灵活的操作。此外，包装类还经常用于集合类和泛型中，因为它们只接受对象作为元素。需要注意的是，自动装箱和拆箱机制使得在包装类和基本数据类型之间进行转换更加方便。例如，在需要整数的地方可以直接使用Integer对象，不需要手动进行装箱和拆箱操作。

​ 总而言之，包装类是Java中用于封装基本数据类型的类，提供了一系列方法和常量来操作和获取封装的值。使用包装类可以在需要使用对象的场景中使用基本数据类型，并且方便地进行类型转换和操作。

Java是强类型语言

在Java中，每个变量在使用之前都必须先声明其数据类型。

这是强类型语言的特性之一，它要求程序员在编写代码时显式地指定变量的类型。

​ 在Java中，每个变量都必须先声明其数据类型，然后才能使用。例如：

int age = 25; // 声明一个整数类型的变量age，并赋值为25
double salary = 5000.50; // 声明一个浮点类型的变量salary，并赋值为5000.50
char gender = 'M'; // 声明一个字符类型的变量gender，并赋值为'M'
boolean isStudent = true; // 声明一个布尔类型的变量isStudent，并赋值为true

String name = "John"; // 声明一个字符串类型的变量name，并赋值为"John"
Integer number = 10; // 声明一个整数类型的包装类变量number，并赋值为10

​ 了解和正确使用不同的数据类型对于编写有效的Java程序非常重要。合理选择数据类型可以提高程序性能、减少内存使用，并确保数据的正确处理。






posted @ 2021-02-25 00:12  猪无名  阅读(33)  评论(0)  编辑  收藏  举报