break 和 continue
发表更新编程 / Java小白5 分钟读完 (大约725个字)

break 和 continue

在 Java 中，控制结构用来引导程序的执行流。break 和 continue 是两种常用的控制语句，主要用于循环和 switch 语句。下面我们将详细介绍这两个关键字的用法和区别。

1. break 语句

break 语句用于立即终止一个循环或 switch 语句，并跳出该语句的块。它常用于当特定条件满足时提前退出循环。

1.1 break 在循环中的用法

1
2
3
4
5
6
7
8
9
10
11
public class BreakExample {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            if (i == 5) {
                break;  // 当 i 为 5 时退出循环
            }
            System.out.println("i: " + i);
        }
        System.out.println("循环结束");
    }
}

输出：

1
2
3
4
5
6
i: 0
i: 1
i: 2
i: 3
i: 4
循环结束

在上面的例子中，当 i 等于 5 时，break 语句被执行，导致循环提前终止，因此输出结果只包含 0 到 4。

1.2 break 在 switch 语句中的用法

在 switch 语句中，break 用于阻止程序继续执行后续的 case 代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class SwitchBreakExample {
    public static void main(String[] args) {
        int day = 3;
        switch (day) {
            case 1:
                System.out.println("星期一");
                break;  // 结束 switch 的执行
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            default:
                System.out.println("未知的星期");
        }
        System.out.println("switch 结束");
    }
}

输出：

1
2
星期三
switch 结束

在本例中，day 等于 3，程序执行到 case 3 的代码块和 break 语句后，跳出 switch 语句。

2. continue 语句

continue 语句用于跳过当前循环的剩余部分，并立即开始下一次循环迭代。它 commonly 用于在满足特定条件时跳过某些代码。

2.1 continue 在循环中的用法

1
2
3
4
5
6
7
8
9
10
11
public class ContinueExample {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            if (i % 2 == 0) {
                continue;  // 如果 i 为偶数，则跳过当前循环
            }
            System.out.println("i: " + i);
        }
        System.out.println("循环结束");
    }
}

输出：

1
2
3
4
5
6
i: 1
i: 3
i: 5
i: 7
i: 9
循环结束

在此例中，当 i 为偶数时，continue 语句被执行，使该循环的剩余部分被跳过，结果只输出了 1、3、5、7 和 9。

2.2 continue 在嵌套循环中的用法

在嵌套循环中，continue 只影响它所在的循环。

1
2
3
4
5
6
7
8
9
10
11
12
public class NestedContinueExample {
    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (j == 1) {
                    continue;  // 跳过 j = 1 的情况
                }
                System.out.println("i: " + i + ", j: " + j);
            }
        }
    }
}

输出：

1
2
3
4
5
6
i: 0, j: 0
i: 0, j: 2
i: 1, j: 0
i: 1, j: 2
i: 2, j: 0
i: 2, j: 2

在这个例子中，continue 语句用于内层循环，当 j 等于 1 时，当前的迭代会被跳过。

结论

  • 使用 break 可以立即退出循环或 switch 语句。
  • 使用 continue 可以跳过循环中的某些代码，并立即进行下一轮循环。
  • 了解这两个控制词的使用，可以更灵活地编写循环语句，控制程序的执行流。

希望通过本节内容，您对 Java 中的 break 和 continue 有了更深入的认识和了解！

18 NIO与异步I/O操作
发表更新编程 / Java进阶6 分钟读完 (大约863个字)

18 NIO与异步I/O操作

在Java中，NIO（New Input/Output）是一个重要的特性，它提供了面向缓冲区的I/O操作和异步I/O能力。这意味着我们可以在更高效的模式下读取和写入数据，特别是在需要处理大量并发连接的应用程序中，NIO能够显著提高性能。

1. NIO概述

Java NIO主要提供了以下几个关键概念：

  • Channel: 代表可以执行读写操作的对象。Channel可以视作I/O通道，能够异步地与I/O设备（如文件、网络）进行交互。
  • Buffer: 数据的容器，所有的数据都通过Buffer进行传输。Buffer中有不同类型（如ByteBuffer, CharBuffer）来处理不同的数据类型。
  • Selector: 允许单线程处理多个Channel，使得我们可以在同一个线程内管理多个连接，以减少线程数量和上下文切换开销。

2. NIO基本使用

2.1 创建一个简单的NIO读取文件示例

使用NIO读取文件的基本步骤如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.io.FileInputStream;
import java.io.IOException;

public class NIOFileReadExample {

    public static void main(String[] args) {
        String filePath = "example.txt";

        try (FileInputStream fis = new FileInputStream(filePath);
             FileChannel fileChannel = fis.getChannel()) {

            ByteBuffer buffer = ByteBuffer.allocate(1024);
            int bytesRead = fileChannel.read(buffer);

            // 处理读取的数据
            while (bytesRead != -1) {
                buffer.flip(); // 切换到读模式
                while (buffer.hasRemaining()) {
                    System.out.print((char) buffer.get());
                }
                buffer.clear(); // 清空缓冲区，准备下一次读取
                bytesRead = fileChannel.read(buffer);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.2 NIO写文件示例

同样，NIO写文件的基本步骤如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.io.FileOutputStream;
import java.io.IOException;

public class NIOFileWriteExample {

    public static void main(String[] args) {
        String filePath = "output.txt";
        String content = "Hello NIO!";

        try (FileOutputStream fos = new FileOutputStream(filePath);
             FileChannel fileChannel = fos.getChannel()) {

            ByteBuffer buffer = ByteBuffer.allocate(1024);
            buffer.clear();
            buffer.put(content.getBytes());
            buffer.flip(); // 切换到读模式

            while (buffer.hasRemaining()) {
                fileChannel.write(buffer);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3. Selector和非阻塞I/O

Selector允许我们在单线程中处理多个Channel。使用Selector的步骤如下：

3.1 创建一个Selector并注册Channel

以下是使用Selector处理多个客户端连接的简单示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.channels.SelectionKey;
import java.util.Iterator;

public class NIOServer {

    public static void main(String[] args) throws IOException {
        Selector selector = Selector.open();
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.bind(new InetSocketAddress(9999));
        serverSocketChannel.configureBlocking(false);
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        while (true) {
            // 等待事件发生
            selector.select();

            Iterator<SelectionKey> keys = selector.selectedKeys().iterator();
            while (keys.hasNext()) {
                SelectionKey key = keys.next();

                if (key.isAcceptable()) {
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    socketChannel.configureBlocking(false);
                    socketChannel.register(selector, SelectionKey.OP_READ);
                    System.out.println("New connection accepted: " + socketChannel.getRemoteAddress());
                } else if (key.isReadable()) {
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    int bytesRead = socketChannel.read(buffer);

                    if (bytesRead > 0) {
                        buffer.flip();
                        socketChannel.write(buffer); // Echo back the received data
                    } else {
                        socketChannel.close(); // Client has disconnected
                    }
                }
                keys.remove(); // 处理完当前的key，移除
            }
        }
    }
}

4. 总结

  • NIO提供了更高效的I/O操作，适合处理大量连接的应用。
  • Channel和Buffer是NIO的核心概念，提供了异步读写能力。
  • Selector使得在单个线程中处理多个连接成为可能，有效降低了系统开销。

学习NIO是Java进阶的重要一步，它能够帮助开发者构建高效、可扩展的应用程序，尤其在网络编程及高并发场景中具有很大优势。

方法的定义与调用
发表更新编程 / Java小白5 分钟读完 (大约730个字)

方法的定义与调用

在学习 Java 的过程中，理解方法的定义与调用是一个重要的基础。方法是执行特定操作的一组语句的集合，可以提高代码的复用性和可读性。在本节中，我们将详细介绍方法的定义与调用。

1. 方法的定义

在 Java 中，定义一个方法的基本语法如下：

1
2
3
4
5
返回类型 方法名(参数类型 参数名1, 参数类型 参数名2, ...) {
    // 方法体
    // 执行代码
    return 返回值; // 可选
}

1.1 组成部分

  • 返回类型：表示方法返回的值的类型。如果方法没有返回值，使用 void 关键字。
  • 方法名：用于标识方法的名称，遵循 Java 的命名规则（首字母小写，多个单词使用驼峰命名）。
  • 参数列表：括号内可以定义零个或多个参数，每个参数都有其类型和名称。参数用于传递数据给方法。
  • 方法体：用花括号 {} 包裹，包含了执行的代码。如果定义了返回值，必须使用 return 语句返回数据。

2. 方法的调用

定义好方法后，需要在代码中调用它。方法调用的语法如下：

1
方法名(参数值1, 参数值2, ...);

2.1 调用示例

假设我们定义一个方法用来计算两数的和：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Calculator {
    // 方法定义
    public int add(int a, int b) {
        return a + b; // 返回两数之和
    }

    public static void main(String[] args) {
        // 创建 Calculator 对象
        Calculator calculator = new Calculator();
        
        // 方法调用
        int sum = calculator.add(5, 10); // 调用 add 方法
        System.out.println("结果是: " + sum); // 输出结果
    }
}

在上面的代码中：

  • add 方法定义了两个整型参数 a 和 b，返回它们的和。
  • 在 main 方法中，我们实例化了 Calculator 类，并调用了 add 方法，将 5 和 10 作为参数传递给它，最终输出结果。

3. 注意事项

  • 方法重载：可以在同一类中定义多个同名但参数不同的方法。这称为方法重载。
1
2
3
4
5
6
7
8
9
public class OverloadExample {
    public int add(int a, int b) {
        return a + b;
    }

    public double add(double a, double b) {
        return a + b;
    }
}

在上面的例子中，add 方法被重载了。一个接受两个整数，一个接受两个双精度数。

  • 方法调用时的参数：实际参数的类型必须与方法定义的形参类型匹配。

4. 总结

在这一节中，我们学习了如何定义和调用方法。方法的定义包含返回类型、方法名和参数列表，而调用方法需要传递相应的参数。掌握方法的使用是 Java 编程的重要基础，能够帮助我们构建更复杂和模块化的程序。

链接

分类

最新文章

标签

AI必备微积分24
AI概率论25
AI线性代数28
Apache2网站部署24
C++77
CDN加速18
CSS31
C语言92
Django开发35
Flask开发30
GAN29
GenerativeAI33
HTML25
Hexo网站开发30
Java76
Javascript30
LangChain28
Markdown30
Matplotlib18
Node.js30
NumPy22
Pandas21
PyQt533
PyTorch31
Python78
React40
TensorFlow30
Vue39
数据分析18
数据挖掘20
机器学习24
深度学习24
神经网络后门攻击26
统计学24
计算机网络24
计算机视觉32
×