0
# File and IO Operations
1

2
Comprehensive file and I/O utilities through `FileUtil` and `IoUtil` classes, providing file operations, stream handling, and resource management.
3

4
## Import
5

6
```java
7
import cn.hutool.core.io.FileUtil;
8
import cn.hutool.core.io.IoUtil;
9
import cn.hutool.core.io.ResourceUtil;
10
import cn.hutool.core.io.NioUtil;
11
```
12

13
## File Operations
14

15
### File Reading
16

17
```java { .api }
18
// Read file content as string
19
public static String readUtf8String(File file);
20
public static String readString(File file, Charset charset);
21
public static String readString(String path);
22

23
// Read as bytes
24
public static byte[] readBytes(File file);
25
public static byte[] readBytes(String path);
26

27
// Read as lines
28
public static List<String> readUtf8Lines(File file);
29
public static List<String> readLines(File file, Charset charset);
30
```
31

32
### File Writing
33

34
```java { .api }
35
// Write string content
36
public static File writeUtf8String(String content, File file);
37
public static File writeString(String content, File file, Charset charset);
38
public static File writeString(String content, String path, Charset charset);
39

40
// Write bytes
41
public static File writeBytes(byte[] data, File file);
42
public static File writeBytes(byte[] data, String path);
43

44
// Append content
45
public static File appendUtf8String(String content, File file);
46
public static File appendString(String content, File file, Charset charset);
47
```
48

49
**Usage Examples:**
50

51
```java
52
// Read file content
53
String content = FileUtil.readUtf8String("config.txt");
54
byte[] data = FileUtil.readBytes("image.jpg");
55
List<String> lines = FileUtil.readUtf8Lines("data.csv");
56

57
// Write file content
58
FileUtil.writeUtf8String("Hello World", "greeting.txt");
59
FileUtil.writeBytes(imageData, "output.jpg");
60

61
// Append to file
62
FileUtil.appendUtf8String("\nNew line", "log.txt");
63
```
64

65
## File Management
66

67
### File Creation and Deletion
68

69
```java { .api }
70
// Create files and directories
71
public static File touch(File file);
72
public static File touch(String fullFilePath);
73
public static File mkdir(String dirPath);
74
public static File mkdir(File dir);
75

76
// Delete operations
77
public static boolean del(File file);
78
public static boolean del(String fullFileOrDirPath);
79
public static boolean clean(File directory);
80
```
81

82
### File Copying and Moving
83

84
```java { .api }
85
// Copy operations
86
public static File copy(File src, File dest, boolean isOverride);
87
public static File copy(String srcPath, String destPath, boolean isOverride);
88

89
// Move operations  
90
public static File move(File src, File dest, boolean isOverride);
91
public static File move(String srcPath, String destPath, boolean isOverride);
92

93
// Rename
94
public static File rename(File file, String newName, boolean isOverride);
95
```
96

97
**Usage Examples:**
98

99
```java
100
// Create file and directories
101
File newFile = FileUtil.touch("data/output.txt");  // Creates parent dirs if needed
102
File newDir = FileUtil.mkdir("reports/2023");
103

104
// Copy files
105
FileUtil.copy("source.txt", "backup/source.txt", true);
106
FileUtil.copy(new File("data.csv"), new File("archive/data.csv"), false);
107

108
// Move and rename
109
FileUtil.move("temp.txt", "final.txt", true);
110
FileUtil.rename(new File("old-name.txt"), "new-name.txt", false);
111
```
112

113
## File Information
114

115
### File Properties
116

117
```java { .api }
118
// File existence and type
119
public static boolean exist(File file);
120
public static boolean exist(String path);
121
public static boolean isDirectory(File file);
122
public static boolean isFile(File file);
123

124
// File size
125
public static long size(File file);
126
public static String readableFileSize(long size);
127

128
// File time
129
public static Date lastModifiedTime(File file);
130
public static File setLastModifiedTime(File file, Date time);
131
```
132

133
### File Name Operations
134

135
```java { .api }
136
// Get file name parts
137
public static String getName(File file);
138
public static String getName(String filePath);
139
public static String mainName(File file);  // without extension
140
public static String mainName(String fileName);
141
public static String extName(File file);   // extension only
142
public static String extName(String fileName);
143

144
// Path operations
145
public static String getParent(File file, int level);
146
public static String normalize(String path);
147
public static String getAbsolutePath(File file);
148
```
149

150
## Stream Operations
151

152
### Input/Output Stream Utilities
153

154
```java { .api }
155
// Copy streams
156
public static long copy(InputStream in, OutputStream out);
157
public static long copy(InputStream in, OutputStream out, int bufferSize);
158
public static long copy(Reader reader, Writer writer);
159

160
// Read from streams
161
public static String read(InputStream in, Charset charset);
162
public static String read(Reader reader);
163
public static byte[] readBytes(InputStream in);
164

165
// Write to streams
166
public static void write(OutputStream out, boolean isCloseOut, byte[] content);
167
public static void write(Writer writer, boolean isCloseWriter, String content);
168
```
169

170
### Stream Conversion
171

172
```java { .api }
173
// Convert between stream types
174
public static BufferedInputStream toBuffered(InputStream in);
175
public static BufferedOutputStream toBuffered(OutputStream out);
176
public static BufferedReader toBuffered(Reader reader);
177
public static BufferedWriter toBuffered(Writer writer);
178

179
// Stream to collections
180
public static List<String> readLines(InputStream in, Charset charset);
181
public static <T> List<T> readObj(InputStream in);
182
```
183

184
**Usage Examples:**
185

186
```java
187
// Copy streams with automatic resource management
188
try (FileInputStream fis = new FileInputStream("input.txt");
189
     FileOutputStream fos = new FileOutputStream("output.txt")) {
190
    long bytesCopied = IoUtil.copy(fis, fos);
191
    System.out.println("Copied " + bytesCopied + " bytes");
192
}
193

194
// Read from URL
195
try (InputStream in = new URL("https://example.com/data.json").openStream()) {
196
    String json = IoUtil.read(in, CharsetUtil.UTF_8);
197
    // Process JSON data
198
}
199
```
200

201
## Resource Management
202

203
### Classpath Resources
204

205
```java { .api }
206
// Get resource streams
207
public static InputStream getStream(String resource);
208
public static InputStream getStreamSafe(String resource);
209

210
// Read resource content
211
public static String readUtf8Str(String resource);
212
public static String readStr(String resource, Charset charset);
213
public static byte[] readBytes(String resource);
214

215
// Get resource URLs and files
216
public static URL getResource(String resource);
217
public static File getResourceObj(String resource);
218
```
219

220
### Resource Cleanup
221

222
```java { .api }
223
// Close resources safely
224
public static void close(Closeable closeable);
225
public static void closeQuietly(Closeable... closeables);
226

227
// Try-with-resources utilities
228
public static <T> T readThenClose(InputStream in, Function<InputStream, T> reader);
229
```
230

231
**Usage Examples:**
232

233
```java
234
// Read classpath resources
235
String config = ResourceUtil.readUtf8Str("application.properties");
236
byte[] templateData = ResourceUtil.readBytes("templates/email.html");
237

238
// Safe resource handling
239
InputStream inputStream = null;
240
try {
241
    inputStream = ResourceUtil.getStream("data.xml");
242
    // Process stream
243
} finally {
244
    IoUtil.closeQuietly(inputStream);
245
}
246

247
// Functional approach
248
String data = IoUtil.readThenClose(
249
    new FileInputStream("large-file.txt"),
250
    stream -> IoUtil.read(stream, CharsetUtil.UTF_8)
251
);
252
```
253

254
## NIO Operations
255

256
### NIO File Operations
257

258
```java { .api }
259
// NIO file operations
260
public static String readUtf8(Path path);
261
public static byte[] readBytes(Path path);
262
public static List<String> readAllLines(Path path, Charset charset);
263

264
// NIO write operations
265
public static Path writeUtf8(Path path, String content);
266
public static Path write(Path path, byte[] bytes);
267
public static Path write(Path path, Iterable<String> lines, Charset charset);
268
```
269

270
### Channel Operations
271

272
```java { .api }
273
// Channel copying
274
public static long copy(ReadableByteChannel src, WritableByteChannel dest);
275
public static long copy(FileChannel src, FileChannel dest);
276

277
// Direct memory operations
278
public static ByteBuffer read(FileChannel channel, long position, int size);
279
```
280

281
## File Watching
282

283
### File Monitor
284

285
```java { .api }
286
// Watch for file changes
287
public static WatchMonitor watchDir(File dir, WatchKind[] events, Watcher watcher);
288
public static WatchMonitor watchFile(File file, Watcher watcher);
289
```
290

291
## Utility Methods
292

293
### File Filtering and Finding
294

295
```java { .api }
296
// List files with filters
297
public static List<File> ls(String path);
298
public static File[] ls(File file);
299
public static List<File> listFileNames(File dir, String... suffixes);
300

301
// Find files
302
public static List<File> loopFiles(File file, FileFilter fileFilter);
303
public static List<File> loopFiles(String path, int maxDepth, FileFilter fileFilter);
304
```
305

306
### Path Utilities
307

308
```java { .api }
309
// Path joining and normalization
310
public static String join(String parent, String... paths);
311
public static File file(String path);
312
public static File file(File parent, String... paths);
313

314
// Check path types
315
public static boolean isAbsolutePath(String path);
316
public static boolean isWindows();
317
public static boolean isLinux();
318
```
319

320
**Usage Examples:**
321

322
```java
323
// List and filter files
324
List<File> javaFiles = FileUtil.loopFiles("src/main/java", 
325
    file -> file.getName().endsWith(".java"));
326

327
// Path operations
328
String fullPath = FileUtil.join("home", "user", "documents", "file.txt");
329
File configFile = FileUtil.file("conf", "application.yml");
330

331
// File monitoring
332
WatchMonitor monitor = FileUtil.watchDir(new File("./logs"), 
333
    new WatchKind[]{WatchKind.CREATE, WatchKind.MODIFY}, 
334
    new SimpleWatcher() {
335
        @Override
336
        public void onCreate(WatchEvent<?> event, Path currentPath) {
337
            System.out.println("New file created: " + currentPath);
338
        }
339
    });
340
monitor.start();
341
```
342

343
All file and I/O operations handle exceptions gracefully and provide both checked and unchecked variants. The utilities support cross-platform file operations and handle path separators, encodings, and resource cleanup automatically.