Java 输入方法数组 String类

目录

一、输入方法
- 1. 常用方法
- 2. Scanner的使用
- 3. BufferedReader的使用
- 二、数组
- - 1. 数组的定义
  - - 静态初始化数组
    - 动态初始化数组
    - 多维数组
    - 2. 数组赋值机制
    - 3. 数组拷贝
    - - 使用循环逐元素拷贝
      - 使用 System.arraycopy() 方法
      - 使用 Arrays.copyOf() 方法
      - 4. 数组排序
      - 5. 数组合并
      - 6. 数组翻转
      - 7. 基于范围的 for 循环
      - 8. 二分查找
      - 三、String类
      - 创建字符串
        获取字符串长度
        获取字符或子字符串
        字符串连接
        字符串查找和比较
        字符串转换
        
        一、输入方法
        
        1. 常用方法
        
        在Java中，可以使用多种方法来获取用户的输入。以下是几种常用的输入方法：
        
        使用 Scanner 类：Scanner 类是Java标准库中提供的用于读取用户输入的类。它可以从标准输入（键盘）或其他输入流中读取数据。
        使用 BufferedReader 类：BufferedReader 类是Java标准库中提供的用于高效读取字符流的类。可以使用它来读取用户的输入。
        2. Scanner的使用
        
        首先从 java.util 包中导入 Scanner 类
        
        next()：读取并返回输入中的下一个以空白字符分隔的字符串。
        
        "空白字符分隔的字符串"指的是以空格、制表符或换行符等空白字符作为分隔符的字符串。当调用 next() 方法时，Scanner 会从输入中读取字符，直到遇到空白字符为止，然后返回读取到的字符串。
        
        import java.util.Scanner; ... Scanner scanner = new Scanner(System.in); System.out.print("请输入一个字符串："); String input = scanner.next(); System.out.println("您输入的字符串是：" + input);
        
        nextInt()：读取并返回输入中的下一个整数。
        
        import java.util.Scanner; ... Scanner scanner = new Scanner(System.in); System.out.print("请输入一个整数："); int number = scanner.nextInt(); System.out.println("您输入的整数是：" + number);
        
        nextDouble()：读取并返回输入中的下一个浮点数。
        
        import java.util.Scanner; ... Scanner scanner = new Scanner(System.in); System.out.print("请输入一个浮点数："); double number = scanner.nextDouble(); System.out.println("您输入的浮点数是：" + number);
        
        nextLine()：读取并返回输入中的下一行字符串。
        
        nextLine() 方法会读取包括空格在内的整行文本。它会一直读取输入，直到遇到换行符（\n）为止，并将整行文本作为字符串返回。
        
        import java.util.Scanner; ... Scanner scanner = new Scanner(System.in); System.out.print("请输入一行字符串："); String line = scanner.nextLine(); System.out.println("您输入的字符串是：" + line);
        
        hasNextXxx()：检查输入中是否还有下一个指定类型的数据。
        
        import java.util.Scanner; ... Scanner scanner = new Scanner(System.in); System.out.print("请输入一个整数："); if (scanner.hasNextInt()) { int number = scanner.nextInt(); System.out.println("您输入的整数是：" + number); } else { System.out.println("无效的输入！"); }
        
        3. BufferedReader的使用
        
        配合 try-catch 使用
        
        使用 BufferedReader 从文件中逐行读取文本
        import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; public class Main { public static void main(String[] args) { String fileName = "example.txt"; // 假设要读取的文件名为 example.txt try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) { String line; while ((line = reader.readLine()) != null) { System.out.println(line); // 逐行输出文本内容 } } catch (IOException e) { e.printStackTrace(); } } }
        
        使用 BufferedReader 从 System.in（标准输入流）读取输入
        import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class Main { public static void main(String[] args) { try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) { String line; while ((line = reader.readLine()) != null) { System.out.println("You entered: " + line); // 输出读入的内容 } } catch (IOException e) { e.printStackTrace(); } } }
        
        二、数组
        
        1. 数组的定义
        
        静态初始化数组
        
        在声明数组的同时，为数组元素指定初始值。可以使用花括号 {} 来包含初始值，并用逗号分隔各个元素。示例如下：
        
        // 声明并初始化一个整数数组 int[] numbers = {1, 2, 3, 4, 5}; // 声明并初始化一个字符串数组 String[] names = {"Alice", "Bob", "Charlie"};
        
        在静态初始化数组时，编译器会根据提供的初始值自动确定数组的长度。
        
        动态初始化数组
        
        在声明数组时，先指定数组的类型和长度，然后使用 new 关键字创建数组对象。示例如下：
        
        // 声明一个整数数组，并指定长度为 5 int[] numbers = new int[5]; // 声明一个字符串数组，并指定长度为 3 String[] names = new String[3]; //先声明数组，再 new 分配空间 double scores[] ; //声明数组，这时 scores 是 null scores = new double[5]; // 分配内存空间，可以存放数据
        
        动态初始化数组时，所有元素都会被自动初始化为默认值（例如，整数数组的元素默认为 0，字符串数组的元素默认为 null）。
        
        多维数组
        
        Java 中还支持多维数组，即数组的元素也可以是数组。可以使用多组方括号 [] 来表示多维数组的维度。示例如下：
        
        // 声明并初始化一个二维整数数组 int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; // 声明一个三维字符串数组，并指定长度 String[][][] cube = new String[3][4][2];
        
        多维数组的初始化方式与一维数组类似，可以使用静态初始化或动态初始化。
        
        需要注意的是，数组的索引从 0 开始，因此可以通过索引访问数组中的元素。例如，numbers[0] 表示整数数组 numbers 的第一个元素。
        
        此外，Java 还提供了一些数组相关的方法和属性，例如 length 属性用于获取数组的长度。可以使用点运算符 . 来访问数组的属性和调用方法。
        
        int[] numbers = {1, 2, 3, 4, 5}; int length = numbers.length; // 获取数组的长度，结果为 5
        
        2. 数组赋值机制
        
        基本数据类型赋值，这个值就是具体的数据，而且相互不影响。
        
        int n1 = 2; int n2 = n1;
        
        数组在默认情况下是引用传递，赋的值是地址。
        
        //代码 ArrayAssign.java int[] arr1 = {1,2,3}; int[] arr2 = arr1;
        
        3. 数组拷贝
        
        使用循环逐元素拷贝
        
        可以使用循环遍历源数组的每个元素，并逐个将其复制到目标数组中。示例代码如下：
        
        int[] sourceArray = {1, 2, 3, 4, 5}; int[] targetArray = new int[sourceArray.length]; for (int i = 0; i < sourceArray.length; i++) { targetArray[i] = sourceArray[i]; }
        
        通过循环逐个复制元素，实现了源数组到目标数组的拷贝。
        
        使用 System.arraycopy() 方法
        
        Java 提供了 System.arraycopy() 方法，可以方便地进行数组拷贝。该方法接受源数组、源数组的起始位置、目标数组、目标数组的起始位置以及要拷贝的元素数量作为参数。示例代码如下：
        
        int[] sourceArray = {1, 2, 3, 4, 5}; int[] targetArray = new int[sourceArray.length]; System.arraycopy(sourceArray, 0, targetArray, 0, sourceArray.length);
        
        通过调用 System.arraycopy() 方法，将源数组的元素拷贝到目标数组中。
        
        使用 Arrays.copyOf() 方法
        
        import java.util.Arrays;
        
        Arrays 类提供了 copyOf() 方法，可以用于拷贝数组。该方法接受源数组和目标数组的长度作为参数，并返回一个新的目标数组，其中包含源数组的元素。示例代码如下：
        
        import java.util.Arrays; ... int[] sourceArray = {1, 2, 3, 4, 5}; int[] targetArray = Arrays.copyOf(sourceArray, sourceArray.length);
        
        通过调用 Arrays.copyOf() 方法，将源数组的元素拷贝到目标数组中。
        
        4. 数组排序
        
        使用Arrays类中的 sort() 方法来对数组进行排序
        
        import java.util.Arrays; public class Main { public static void main(String[] args) { int[] numbers = {5, 2, 8, 4, 1}; // 对数组进行排序 Arrays.sort(numbers); // 打印排序后的数组 for (int number : numbers) { System.out.print(number + " "); } } }
        
        使用lambda表达式来调整 sort() 方法的比较规则
        
        import java.util.Arrays; public class test1 { public static void main(String[] args) { int[] arr = {3, 1, 4, 1, 5, 9, 2, 6, 5}; System.out.println("Original array: " + Arrays.toString(arr)); Arrays.sort(arr, (a, b) -> b - a); System.out.println("Sorted array: " + Arrays.toString(arr)); } } // Original array: [3, 1, 4, 1, 5, 9, 2, 6, 5] // Sorted array: [9, 6, 5, 5, 4, 3, 2, 1, 1]
        
        public class test1 { public static void main(String[] args) { int[] arr = {3, 1, 4, 1, 5, 9, 2, 6, 5}; System.out.println("Original array: " + Arrays.toString(arr)); Arrays.sort(arr, (a, b) -> { return a - b; }); System.out.println("Sorted array: " + Arrays.toString(arr)); } } // Original array: [3, 1, 4, 1, 5, 9, 2, 6, 5] // Sorted array: [1, 1, 2, 3, 4, 5, 5, 6, 9]
        
        5. 数组合并
        
        import java.util.Arrays; public class test1 { public static void main(String[] args) { int[] arr1 = {3, 2, 1}; int[] arr2 = {6, 5, 4}; int length = arr1.length + arr2.length; int[] res = new int[length]; System.arraycopy(arr1, 0, res, 0, arr1.length); System.arraycopy(arr2, 0, res, arr1.length, arr2.length); Arrays.sort(res); int[] arr = Arrays.copyOf(res, length); for (int i = 0; i < arr.length; ++i) { System.out.print(arr[i] + " "); } } }
        
        6. 数组翻转
        
        import java.util.Arrays; public class Main { public static void main(String[] args) { int[] arr = {1, 2, 3, 4, 5}; System.out.println("Original array: " + Arrays.toString(arr)); // Reverse the array Arrays.reverse(arr); System.out.println("Reversed array: " + Arrays.toString(arr)); } } // Original array: [1, 2, 3, 4, 5] // Reversed array: [5, 4, 3, 2, 1]
        
        7. 基于范围的 for 循环
        
        从 Java 5 开始，引入了基于范围的 for 循环（也称为增强型 for 循环或 foreach 循环），用于遍历数组、集合等可迭代对象。基于范围的 for 循环可以更简洁地遍历集合或数组中的元素，无需显式地使用索引。
        
        for (elementType element : collection) { // 在此处处理每个元素 }
        
        elementType 是集合中元素的类型。
        collection 是要遍历的集合或数组。
        element 是一个变量，用于迭代遍历集合中的每个元素。
        例如，遍历一个整数数组：
        
        int[] numbers = {1, 2, 3, 4, 5}; for (int number : numbers) { System.out.println(number); }
        
        8. 二分查找
        
        import java.util.Arrays; public class BinarySearchExample { public static void main(String[] args) { int[] arr = {2, 5, 8, 12, 16, 23, 38, 56, 72, 91}; int target = 23; // 对数组进行排序（二分查找要求数组已排序） Arrays.sort(arr); // 使用binarySearch方法查找目标值在数组中的位置 int index = Arrays.binarySearch(arr, target); if (index >= 0) { System.out.println("目标值 " + target + " 在数组中的位置为：" + index); } else { System.out.println("目标值 " + target + " 不在数组中。"); } } }
        
        三、String类
        
        创建字符串
        
        String str = "Hello";：通过直接赋值创建字符串对象。
        String str = new String("Hello");：使用构造函数创建字符串对象。
        String str = new String(charArray);：使用字符数组创建字符串对象。
        String str = String.valueOf(value);：将其他类型的数据转换为字符串。
        获取字符串长度
        
        int length = str.length();：获取字符串的长度。
        
        获取字符或子字符串
        
        char ch = str.charAt(index);：获取指定索引处的字符。
        String substring = str.substring(startIndex);：从startIndex开始获取子字符串。
        String substring = str.substring(startIndex, endIndex);：从startIndex开始到endIndex-1的子字符串。
        字符串连接
        
        String concatStr = str1.concat(str2);：将两个字符串连接成一个新字符串。
        String concatStr = str1 + str2;：使用"+"操作符连接字符串。
        字符串查找和比较
        
        int indexOf = str.indexOf(subStr);：查找子字符串在原字符串中的索引。
        int lastIndexOf = str.lastIndexOf(subStr);：查找子字符串在原字符串中最后出现的索引。
        boolean startsWith = str.startsWith(prefix);：检查字符串是否以指定前缀开头。
        boolean endsWith = str.endsWith(suffix);：检查字符串是否以指定后缀结尾。
        boolean equals = str1.equals(str2);：比较两个字符串是否相等。
        boolean equalsIgnoreCase = str1.equalsIgnoreCase(str2);：忽略大小写比较两个字符串是否相等。
        字符串转换
        
        char[] charArray = str.toCharArray();：将字符串转换为字符数组。
        byte[] byteArray = str.getBytes();：将字符串转换为字节数组。

数组 字符串

相关推荐

