自由学习记录（8）

字符集

.exe结尾的也算是文件吗

是的，.exe 文件是 Windows 操作系统中的可执行文件，属于文件的一种。它们可以直接运行，通常包含程序的机器代码。当你在++文件系统中检查一个包含 .exe 扩展名的文件时，它被视为普通文件。++

在 Java 中，你可以通过 File 类来检测它是否是文件。例如，使用 isFile() 方法可以判断一个文件对象是否是文件，包括 .exe 文件。

文件和文件夹，两个，

如何递归文件夹

要递归地遍历一个文件夹及其子文件夹中的所有文件和子文件夹，你可以使用 Java 的 File 类。以下是一个示例代码，展示了如何实现这一功能：

示例代码

复制代码

import java.io.File;

public class DirectoryTraversal

{

public static void main(String[] args)

{ // 指定要遍历的目录

File directory = new File("your_directory_path");

// 递归遍历目录

traverseDirectory(directory);

}

// 遍历方法

public static void traverseDirectory(File dir)

{ // 判断是否是目录

if (dir.isDirectory())

{

System.out.println("目录: " + dir.getAbsolutePath());

File[] files = dir.listFiles();

if (files != null)

{

for (File file : files)

{

if (file.isDirectory())

{ // 如果是子目录，递归调用

traverseDirectory(file); }

else

{ // 如果是文件，打印文件名

System.out.println("文件: " + file.getAbsolutePath());

} } }

}

else

{ System.out.println(dir.getAbsolutePath() + " 不是一个目录"); }

}

代码解析

指定目录 ：在 main 方法中，指定你想要遍历的目录路径。
递归方法 traverseDirectory(File dir)：
- 首先检查给定的 File 对象是否是一个目录。
- 如果是目录，打印目录的绝对路径。
- 使用 ++listFiles() 方法获取该目录下的所有文件和子目录++。
- 遍历获取到的文件和子目录：
  - 如果是++子目录，递归调用 traverseDirectory(file)++。
  - 如果是文件，打印文件的绝对路径。

注意事项

确保路径正确且存在。
对于++权限受限的目录，可能会抛出 SecurityException++。
如果++目录为空，listFiles() 会返回 null，需要进行空检查++。

Java的file

在 Java 中，File 类可以区分文件和文件夹。使用 File 类中的一些方法，你可以判断一个路径指向的是文件还是文件夹。

常用的方法有：

isFile() ：判断当前 File 对象是否是一个文件。
- 返回 true 表示它是一个文件。
isDirectory() ：判断当前 File 对象是否是一个文件夹（目录）。
- 返回 true 表示它是一个文件夹。

复制代码

import java.io.File;

public class FileExample

{

public static void main(String[] args)

{

File file = new File("example.txt");

File directory = new File("exampleDirectory"); // 判断是否是文件

if (file.isFile())

{ System.out.println(file.getName() + " 是一个文件"); }

// 判断是否是文件夹

if (directory.isDirectory())

{ System.out.println(directory.getName() + " 是一个文件夹"); } } }

在这个例子中：

如果 example.txt 是一个文件，file.isFile() 会返回 true。
如果 exampleDirectory 是一个文件夹，directory.isDirectory() 会返回 true。

不带后缀new的file就是文件夹？

在 Java 中，File 类的对象并不依赖于文件名是否带有后缀来判断其是文件还是文件夹。也就是说，不带后缀的 File 对象可以指向文件夹，带后缀的 File 对象也可以指向文件。

具体示例

如果你创建一个 File 对象指向一个文件夹，例如 new File("exampleDirectory")，你可以通过 isDirectory() 方法判断它是否是一个文件夹。
反之，如果你创建一个 File 对象指向一个文件，例如 new File("example.txt")，你可以通过 isFile() 方法判断它是否是一个文件。

示例代码

import java.io.File;

public class FileExample

{

public static void main(String[] args)

{

File folder = new File("exampleDirectory");

File file = new File("example.txt"); // 检查文件夹

if (folder.isDirectory())

{ System.out.println(folder.getName() + " 是一个文件夹"); }

else

{ System.out.println(folder.getName() + " 不是一个文件夹"); }

// 检查文件 if (file.isFile())

{ System.out.println(file.getName() + " 是一个文件"); }

else

{ System.out.println(file.getName() + " 不是一个文件"); }

}

总结

File 对象本身并不区分文件和文件夹的后缀。
使用 isFile() 和 isDirectory() 方法可以判断一个 File 对象代表的是文件还是文件夹。

栈和堆

1. 栈（Stack）

用途: 栈是用于管理短期、局部变量的存储。它的特点是后进先出（LIFO），当函数被调用时，局部变量（包括函数参数和返回地址）会被推入栈中，函数返回后，栈中的这些数据会被弹出。
生命周期: 栈中的变量会在函数执行完成后自动销毁，内存被回收。由于栈内存管理是由编译器自动处理的，存储的对象生命周期较短，通常在程序块或函数调用结束后就会销毁。
速度: 栈的内存分配非常高效，因为它是顺序分配的，且自动回收不需要显式管理。
典型用途 : 局部变量、函数调用、递归、短期数据存储等。它适合那些会频繁修改、快速销毁的数据。

2. 堆（Heap）

用途 : 堆用于存储较长生命周期的数据或需要动态分配的内存。堆内存不会自动回收，需要程序员手动管理分配和释放内存（在 C/C++ 中通过 malloc/free 或 new/delete，在 C#、Java 中则由垃圾回收机制自动管理）。
生命周期 : 堆中的内存可以在函数调用之外长期存在，直到手动释放或由垃圾回收器清理。
速度 : 堆的内存分配和释放相对较慢，因为需要管理内存碎片和动态分配。每次分配都可能涉及到操作系统级别的开销。
典型用途: 动态分配的对象、大型结构体、需要长期存储的对象、集合等。适合较大且生命周期较长的数据，比如在运行时动态创建的对象。

栈与堆的选择

栈适合存储那些会频繁被创建和销毁的临时数据，典型例子是局部变量和函数调用。
堆则更适合长时间存储数据或需要动态分配内存的场景，比如对象的生命周期跨越多个函数调用时，需要在堆中存储。

c++的库相关

C++ 没有一个像 C 的 stdlib.h 那样"覆盖所有库"的单一头文件，原因是 C++ 的标准库（STL, Standard Template Library）模块化程度更高。C++ 标准库提供了很多功能强大的库，涵盖了从容器、算法到输入输出等各个方面。与 C 的库不同，C++ 的标准库倾向于通过多个特定功能的头文件来组织，而不是一个巨大的头文件。

在 C++ 中，常见的库和头文件分布如下：

1. C++ 标准库头文件

C++ 提供了功能丰富的标准库头文件，这些头文件根据具体的功能进行划分：

输入/输出流： ++iostream（标准输入输出流，类似 C 的 stdio.h），fstream（文件流）++
字符串处理： ++string（C++ 字符串类），sstream（字符串流）++
容器： ++vector（动态数组），map（关联容器），set（集合），list（链表）++等
算法： algorithm（排序、查找、遍历等算法）
多线程： thread（多线程支持），mutex（互斥锁）
时间： chrono（时间处理）

这些头文件的模块化设计是为了让代码更具可维护性和清晰度。

2. C++ 支持的 C 标准库

C++ 继承了 C 的许多标准库，因此 C 的一些头文件在 C++ 中依然可以使用，但通常带有 c 前缀。例如：

cstdlib 对应 C 的 stdlib.h，包含动态内存管理、随机数生成、进程控制等功能。
cstdio 对应 C 的 stdio.h，用于标准输入输出功能。
cmath 对应 C 的 math.h，用于数学计算。
cstring 对应 C 的 string.h，用于 C 风格字符串处理。

3. C++ 常见的头文件

iostream : 用于输入输出流，取代了 C 的 stdio.h。
vector: C++ 动态数组容器。
map: 键值对关联容器，类似于字典。
string: C++ 字符串类，处理字符串更加简便。
algorithm: 提供了各种算法（如排序、搜索等）。

4. C++ 的 `stdlib.h`（`cstdlib`）

C++ 中的 cstdlib 是 C 的 stdlib.h 的改进版，提供了与 C 语言类似的功能，包括动态内存管理（malloc/free）、随机数生成、环境控制（exit、system）等。这与 C 的 stdlib.h 类似，只是命名上做了规范化。

例如，C++ 中可以这样使用 cstdlib：

复制代码

#include <cstdlib>

#include <iostream>

int main() {

int *ptr = (int*) std::malloc(10 * sizeof(int));

if (ptr == nullptr)

{

std::cerr << "Memory allocation failed" << std::endl;

return 1;

}

std::free(ptr);

return 0;

}

5. 综合性库

虽然 C++ 没有像 C 的 stdlib.h 那样一个包含所有功能的头文件，但你可以根据需求选择使用多个标准库头文件，这样也提高了模块化和性能。例如：

使用 iostream 进行输入输出操作。
使用 vector 存储动态数组。
使用 algorithm 进行常用算法操作。

总结

C++ 的标准库模块化设计更清晰，针对不同的功能有专门的头文件，而不是像 C 的 stdlib.h 一样包含所有基础库。对于动态内存、输入输出、容器等功能，C++ 标准库提供了更高层次的抽象和功能，可以通过多个头文件使用这些功能。

c++中有c#那样的泛型list和dictionary吗

C++ 和 C# 在泛型容器的使用上有一些区别，但 C++ 也提供了类似的功能，虽然它不像 C# 中的 List<T> 和 Dictionary<TKey, TValue> 那样直观。C++ 使用模板和 标准模板库（STL） 来实现类似的泛型容器。

1. `std::vector` 替代 `List<T>`

C++ 中最常用的动态数组容器是 std::vector，它可以像 C# 的 List<T> 一样动态调整大小并存储任意类型的元素。std::vector 类似于 C# 中的 List<T>。

#include <iostream>

#include <vector>

int main()

{

std::vector<int> myVector; // 向 vector 添加元素

myVector.push_back(1);

myVector.push_back(2);

myVector.push_back(3); // 访问元素

for (int i = 0; i < myVector.size(); ++i)

{ std::cout << myVector[i] << " "; } return 0; }

在这个例子中，std::vector 就像 C# 的 List<int>，可以动态扩展、访问、删除等。

2. `std::map` 替代 `Dictionary<TKey, TValue>`

C++ 中使用 std::map 或 std::unordered_map 来实现键值对的存储功能，类似于 C# 中的 Dictionary<TKey, TValue>。

std::map 是一种基于红黑树实现的有序键值对容器。
std::unordered_map 则是一种基于哈希表实现的无序键值对容器。

#include <iostream>

#include <map>

int main()

{ std::map<std::string, int> myMap;

// 插入键值对

myMap["apple"] = 3;

myMap["banana"] = 5;

// 访问键值对

std::cout << "apple: " << myMap["apple"] << std::endl;

std::cout << "banana: " << myMap["banana"] << std::endl;

return 0; }

在这个例子中，std::map 类似于 C# 的 Dictionary<string, int>。

3. 模板泛型

C++ 的模板功能可以让你像 C# 的泛型一样定义自己的泛型类或函数。虽然 STL 提供了很多现成的容器，但你可以根据需要定义自己的泛型逻辑。

#include <iostream>

// 定义一个简单的泛型函数

template <typename T> T add(T a, T b)

{ return a + b; }

int main()

{

std::cout << add(5, 10) << std::endl; // 整数相加

std::cout << add(3.5, 2.5) << std::endl; // 浮点数相加

return 0;

}

总结：

std::vector 是 C++ 中的动态数组，类似 C# 的 List<T>。
std::map 和 std::unordered_map 是 C++ 中的字典类型，类似 C# 的 Dictionary<TKey, TValue>。
C++ 的模板功能类似于 C# 的泛型。

C++ 的模板比 C# 的泛型更强大，但 C++ 的语法和使用方式相对复杂一些。

c++的输入输出

方法一：使用 `for` 循环和数组存储

cpp 复制代码

    int m;
    cout << "请输入一个整数 m: ";
    cin >> m;
    
    // 创建一个数组存储 m 个整数
    int arr[m];  // C++11 支持变长数组，但通常建议使用vector

    // 输入 m 个整数
    for (int i = 0; i < m; i++) {
        cout << "请输入第 " << i + 1 << " 个整数: ";
        cin >> arr[i];
    }

方法二：使用 `for` 循环和 `vector` 动态数组

相比普通数组，vector 更加灵活，不需要提前知道数组大小，而且更适合现代 C++ 编程。

cpp 复制代码

  // 输入 m 个整数
    for (int i = 0; i < m; i++) {
        int temp;
        cout << "请输入第 " << i + 1 << " 个整数: ";
        cin >> temp;
        numbers.push_back(temp);
    }

C++11 支持变长数组，但通常建议使用vector

尽管 C++11 支持变长数组，但这是一个非标准的特性。标准 C++ 其实不鼓励使用变长数组，主要是因为以下几个原因：

跨平台兼容性：变长数组是由部分编译器支持的扩展功能，可能在不同平台或编译器上无法正常工作。因此，代码的可移植性变差。
不安全性 ：如果在运行时指定的数组大小过大，可能导致栈溢出（stack overflow） 。因为变长数组是分配在栈上的，栈的空间是有限的。
标准化支持 ：C++ 标准库提供了更安全、灵活且标准化的容器，例如 std::vector。vector 是动态分配的，可以在运行时安全地调整大小，并且它自动管理内存，不容易导致栈溢出。

c++中的string（2）

在使用**std::string（C++）和 string（C#）** 时，虽然它们都提供了丰富的字符串操作功能，但在修改内容和查找单个字符的过程中，它们的设计理念和具体实现略有不同。下面我们从几种常见操作的角度，来看看两者在使用上的区别。

1. 访问单个字符

C++ 的 std::string ：你可以像数组一样通过下标访问字符串中的字符，std::string 的字符访问是可读可写的，可以修改字符串中的某个字符。
复制代码
std::string str = "hello";
char ch = str[1]; ``// 访问第2个字符 ``'e'
str[1] = 'a'; // 修改第2个字符为 'a'
C# 的 string ：你也可以通过下标访问字符串中的字符，但**C# 中的 string 是不可变的**，因此访问字符是只读的，无法直接修改字符串中的某个字符。如果要改变字符串，必须创建一个新的字符串。
复制代码
string str = "hello";
char ch = str[1]; // 访问第2个字符 'e'
// str[1] = 'a'; // 这是不合法的，因为 string 是不可变的

要修改字符串中的某个字符，可以通过类似**StringBuilder 或其他方式**实现：
复制代码
string str = "hello";
StringBuilder sb = new StringBuilder(str);
sb[1] = 'a'; // 修改第2个字符为 'a'
string newStr = sb.ToString(); // 将结果转换为 string

2. 修改字符串内容

C++ 的 std::string ： std::string 是可变的，可以通过各种函数直接修改内容，比如 append、insert、erase 等。
复制代码
std::string str = "hello";
str.append(" world"); // 结果: "hello world"
str.insert(5, ","); // 结果: "hello, world"
str.erase(5, 1); // 删除第5个字符，结果: "hello world"
C# 的 string ：因为 string 是不可变的，所以每次你修改字符串，都会创建一个新的字符串。

string str = "hello";
str = str + " world"; // 结果: "hello world"
str = str.Insert(5, ","); // 结果: "hello, world"
str = str.Remove(5, 1); // 删除第5个字符，结果: "hello world"

如果你需要频繁修改字符串，建议使用 StringBuilder 来避免创建过多临时对象。

StringBuilder sb = new StringBuilder("hello");
sb.Append(" world"); // 结果: "hello world"
sb.Insert(5, ","); // 结果: "hello, world"
sb.Remove(5, 1); // 结果: "hello world"

3. 查找子串或字符

C++ 的 std::string ： std::string 提供了 find 函数，可以查找子串或字符的第一次出现位置。查找失败时返回 std::string::npos。

std::string str = "hello world";
size_t pos = str.find('o'); // 返回 4，第一个 'o' 的位置
size_t pos2 = str.find("world"); // 返回 6，子串 "world" 的位置
C# 的 string ： C# 的 string 也有类似的 IndexOf 方法，用来查找子串或字符。查找失败时返回 -1。

string str = "hello world";
int pos = str.IndexOf('o'); // 返回 4，第一个 'o' 的位置
int pos2 = str.IndexOf("world"); // 返回 6，子串 "world" 的位置

4. 字符串长度

C++ 的 std::string ：你可以使用 length() 或 size() 方法获取字符串的长度。

std::string str = "hello";
size_t len = str.length(); // 返回 5
C# 的 string ： C# 中的 string 有一个 Length 属性，用来获取字符串的长度。

string str = "hello";
int len = str.Length; // 返回 5

5. 字符串拼接

C++ 的 std::string ： std::string 提供了 + 运算符和 append() 函数来拼接字符串。

std::string str1 = "hello";
std::string str2 = " world";
std::string result = str1 + str2; // 使用 '+' 运算符
str1.append(str2); // 使用 append() 方法
C# 的 string ： C# 中 + 运算符可以用于拼接字符串，也可以使用 String.Concat() 或 StringBuilder。

string str1 = "hello";
string str2 = " world";
string result = str1 + str2; // 使用 '+' 运算符
string result2 = String.Concat(str1, str2); ``// 使用 Concat()
对于频繁的字符串拼接操作，StringBuilder 更加高效。

总结：

在 C++ 中，std::string 是可变的，修改和访问字符都相对直接，适合处理动态变化的字符串。
在 C# 中，string 是不可变的，每次修改都创建一个新的对象。如果你需要频繁修改字符串，建议使用 StringBuilder 来提高性能。
这个地方str，底层上是创建了一个与"world"拼接之后的新字符串常量，然后这个str变量改为引用这个拼接后的字符串常量

两者在操作接口上都非常相似，但背后的设计思想不同：C++ 倾向于手动控制和优化内存使用，而 C# 则依赖垃圾回收和不可变性来提供更简单的内存管理和线程安全。

C++的string

C++ 中的 string 和 C# 中的 string 有很多相似点，但也有一些显著差异：

1. 实现和类型定义：

C++ 中的 string ：std::string 是 C++ 标准库中的类，不是结构体 。它是基于 std::basic_string 模板类 实现的，用来处理可变长度的字符序列。在底层，std::string 通过动态内存分配管理字符串。
C# 中的 string ：string 是引用类型，但它是一个 不可变 （immutable）的类。这意味着在 C# 中，每次对 string 进行修改时，实际上创建了一个新的字符串对象。

2. 内存管理：

C++ ：std::string 可以动态地增长和缩减内存，它使用了堆内存。如果你删除 string 对象，必须手动确保内存的释放（尽管 std::string 本身有析构函数会自动处理），但其内部的内存管理更多依赖于开发者对生命周期的控制。
C# ：C# 中的 string 对象在堆上分配，并且由垃圾回收器（GC）自动管理内存，因此开发者不需要手动释放内存。

3. 可变性：

C++ 的 std::string ：是 可变的 。你可以通过成员函数（例如 append()、erase() 等）修改字符串的内容，而不需要创建新的对象。
C# 的 string ：是 不可变的 。每次你修改一个 string，都会返回一个新的字符串对象，而原有的字符串不会被改变。

4. 性能考虑：

C++ ：由于 C++ 没有垃圾回收，std::string 的性能在很多场景下比 C# 的 string 更高效，特别是在处理大量字符串拼接或频繁修改时。C++ 中还有 std::string_view，用于不复制的字符串操作，进一步优化性能。
C# ：由于字符串的不可变性，如果你需要频繁拼接字符串，建议使用 StringBuilder，因为它在这类操作上比 string 更高效。

5. 字符串字面量的处理：

C++ ：字符串字面量默认是 const char[]，可以通过 std::string 构造函数进行转换。例如：
复制代码
std::string str = "hello";
这里会从 const char[] 创建一个 std::string 对象。
C# ：字符串字面量就是 string 类型，不需要显式转换。
复制代码
string str = "hello";

6. 字符串比较：

C++ ：std::string 提供了 == 运算符 ，可以直接比较字符串的值。而在 C 风格字符串中，你需要使用 strcmp 来进行比较。
C# ：string 也重载了 == 运算符，可以直接比较两个字符串的内容。

总结：

C++ 的 std::string 是一个可变的、动态分配的字符串类，更类似于 C# 中的 StringBuilder。
C# 中的 string 是不可变的，用于表示不变的字符串数据。

File文件

在 Java 中，File 类用于处理文件和目录的路径名。它提供了创建、删除、检查文件和目录是否存在，以及查询文件的属性（如文件的大小、读写权限等）等常用操作。

常用方法

1. 创建 `File` 对象

创建 File 对象并不会直接在文件系统中创建文件或目录，而是创建了一个与文件路径关联的对象。

File file = new File("path/to/file.txt");

2. 判断文件或目录是否存在

exists()：判断文件或目录是否存在。

if (file.exists())

{ System.out.println("File exists."); }

else { System.out.println("File does not exist."); }

3. 创建文件

createNewFile()：创建一个新文件，如果文件已存在则返回 false。

try { if (file.createNewFile()) { System.out.println("File created."); }

else { System.out.println("File already exists."); } }

catch (IOException e) { e.printStackTrace(); }

4. 创建目录

mkdir()：创建一个目录（只能创建单级目录）。
mkdirs()：创建多级目录。

File dir = new File("path/to/directory");

if (dir.mkdir()) { System.out.println("Directory created."); }

else { System.out.println("Directory not created."); }

5. 删除文件或目录

delete()：删除文件或空目录。不能删除非空目录。

if (file.delete()) { System.out.println("File deleted."); }

else { System.out.println("Failed to delete file."); }

6. 获取文件名和路径

getName()：返回文件名。
getPath()：返回文件的路径。
getAbsolutePath()：返回文件的绝对路径。

System.out.println("File name: " + file.getName());

System.out.println("File path: " + file.getPath());

System.out.println("Absolute path: " + file.getAbsolutePath());

7. 检查文件是否可读、可写或可执行

canRead()：判断文件是否可读。
canWrite()：判断文件是否可写。
canExecute()：判断文件是否可执行。

if (file.canRead()) { System.out.println("File is readable."); }

if (file.canWrite()) { System.out.println("File is writable."); }

if (file.canExecute()) { System.out.println("File is executable."); }

8. 获取文件大小

length()：返回文件的字节数。

System.out.println("File size: " + file.length() + " bytes");

9. 列出目录中的文件

list()：返回目录中的文件和子目录的字符串数组。
listFiles()：返回目录中的文件和子目录的**File 对象数组**。

File directory = new File("path/to/directory");

String[] files = directory.list();

for (String fileName : files) { System.out.println(fileName); }

10. 重命名文件

renameTo(File dest)：将文件或目录重命名为指定的文件或目录。

File newFile = new File("path/to/newFile.txt");

if (file.renameTo(newFile)) { System.out.println("File renamed."); }

else { System.out.println("Rename failed."); }

示例代码

java 复制代码

import java.io.File;
import java.io.IOException;

public class FileExample {
    public static void main(String[] args) {
        // 创建文件对象
        File file = new File("example.txt");
        
        // 判断文件是否存在
        if (file.exists()) {
            System.out.println("File exists.");
        } else {
            try {
                // 创建文件
                if (file.createNewFile()) {
                    System.out.println("File created.");
                } else {
                    System.out.println("File creation failed.");
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
        // 获取文件信息
        System.out.println("File name: " + file.getName());
        System.out.println("File path: " + file.getPath());
        System.out.println("Absolute path: " + file.getAbsolutePath());
        System.out.println("File size: " + file.length() + " bytes");
        
        // 删除文件
        if (file.delete()) {
            System.out.println("File deleted.");
        } else {
            System.out.println("Failed to delete file.");
        }
    }
}

对示例代码的解释和总结

创建文件对象不等于创建文件

当你使用 new File("example.txt") 创建一个文件对象时，这并不会立即生成一个物理文件。它只是创建了一个与该文件路径相关联的对象，用来操作或查询文件的状态。只有在调用诸如 createNewFile() 或 mkdir() 这类操作方法时，才会真正创建文件或文件夹。
file.exists() 可以查路径是否存在
file.exists() 是用来检查与 File 对象相关联的路径是否存在。如果你没有传入绝对路径，它会以项目的当前工作目录（通常是运行程序的目录）为基础，查找相对路径是否存在 。也就是说，只要这个 File 对象与某路径相关，它就能检查路径是否存在，而不需要你显式传入路径。
createNewFile() 真正创建文件

调用**createNewFile() 会尝试在指定路径下创建文件。如果文件已经存在，它会返回 false；** 如果文件不存在，并且路径有效，它会创建文件并返回 true。这是创建物理文件的操作。
catch (IOException e) 的作用

当在处理文件操作时（例如创建文件、读取文件等），可能会出现诸如文件路径无效、磁盘空间不足等异常情况 。IOException 是专门用于处理这类输入输出错误的异常 。e.printStackTrace() 是打印错误的堆栈跟踪信息 ，方便开发者定位和调试问题。如果不进行异常处理，程序遇到问题可能会直接崩溃。通过 try-catch 块，程序即便遇到异常，也可以正常执行后续逻辑。
获取文件信息依赖物理文件的存在

如果你只是创建了 File 对象，但没有调用 createNewFile() 或文件本身并不存在，你是不能获取到文件的某些信息（如大小、是否可读等） 。这些操作依赖于文件的实际存在，而 File 对象本身只是一个抽象路径的封装。

File 类是 Java 中用于处理文件和目录路径的基础类。通过它可以进行文件创建、删除、读取等常用操作，不过它并不直接操作文件内容。对于读写文件内容，通常会结合 FileInputStream、FileOutputStream、BufferedReader 等类使用。

Java变长参数

自由学习记录（8）

字符集

.exe结尾的也算是文件吗

如何递归文件夹

示例代码

代码解析

注意事项

Java的file

不带后缀new的file就是文件夹？

具体示例

示例代码

总结

栈和堆

1. 栈（Stack）

2. 堆（Heap）

栈与堆的选择

c++的库相关

1. C++ 标准库头文件

2. C++ 支持的 C 标准库

3. C++ 常见的头文件

4. C++ 的 stdlib.h（cstdlib）

5. 综合性库

总结

c++中有c#那样的泛型list和dictionary吗

1. std::vector 替代 List<T>

2. std::map 替代 Dictionary<TKey, TValue>

3. 模板泛型

总结：

c++的输入输出

方法一：使用 for 循环和数组存储

方法二：使用 for 循环和 vector 动态数组

C++11 支持变长数组，但通常建议使用vector

c++中的string（2）

1. 访问单个字符

2. 修改字符串内容

3. 查找子串或字符

4. 字符串长度

5. 字符串拼接

总结：

C++的string

1. 实现和类型定义：

2. 内存管理：

3. 可变性：

4. 性能考虑：

5. 字符串字面量的处理：

6. 字符串比较：

总结：

File文件

常用方法

1. 创建 File 对象

2. 判断文件或目录是否存在

3. 创建文件

4. 创建目录

5. 删除文件或目录

6. 获取文件名和路径

7. 检查文件是否可读、可写或可执行

8. 获取文件大小

9. 列出目录中的文件

10. 重命名文件

示例代码

对示例代码的解释和总结

4. C++ 的 `stdlib.h`（`cstdlib`）

1. `std::vector` 替代 `List<T>`

2. `std::map` 替代 `Dictionary<TKey, TValue>`

方法一：使用 `for` 循环和数组存储

方法二：使用 `for` 循环和 `vector` 动态数组

1. 创建 `File` 对象