Java基础知识总结（持续更新中）

Java基础知识（持续更新）

类型转化：数字、字符串、字符之间相互转化

1. 数字 <-> 字符串

// 数字转字符串
//  method1
      int number = 5;
      String str = String.valueOf(number);
      
//  method2
      int number = 5;
      Integer itr = number;  //int装箱为对象，再调用对象的toString方法
      String str = itr.toString(); //或者直接 String str = Integer.toString(number);
      
// method3
      int number = 5;
      String str = number + "";
  
// 字符串转数字
      String str = "123";
      int number = Integer.parseInt(str);

1. 字符串 <-> 字符

// 字符串转字符
// method 1  单个字符
       String str = "123";
       char ch = str.charAt(0); //charAt(index)方法，这里获取到的字符为1
       
// method 2 
       for (int i = 0; i < str.length(); i++) {
            System.out.println(str.substring(i, i + 1));
        }
        
// method 3  字符串转成字符数组
       String str = "123";
       char [] charArray = str.toCharArray();
       
// 单字符转字符串
// method 1
       char ch = '5';
       String str = String.valueOf(ch);

// method 2
       char ch = '5';
       String str = ch + "";
       
// method 3 字符数组转化成字符串 
       String newStr = new String(charArray, 0, charArray.length);
     

1. 字符 <-> 数字

// 字符转数字
// method 1
        char ch = '5';
        int a = ch - '0';
        
// method 2 （ 字符 -> 字符串 -> 数字 ）
                // 先把字符转为字符串，再转换为数字
                char ch = '5';
                String temp = String.valueOf(ch);
                int a = Integer.parseInt(temp);

// 数字转字符 （ 数字 -> 字符串 -> 字符 ）
       // 不能直接转换，因此需借助数字转字符串。
       // 首先将数字转为字符串，再获取字符
       int number = 5; //注意这里数字只能是个位数并且不能为负
       String s = Integer.toString(number);
       char ch = s.charAt(0);

1. 与数组之间的转化

// String -> char[]
String s = "3456789XJQKA2MF";
char [] charArray = s.toCharArray();

// char[] -> String
String s = new String(charArray, 0, charArray.length);

// 将 ch[i] 设为空 ch[i] = '\0'

// List -> Integer
List<Integer> nums
Integer[] arr = nums.toArray(new Integer[0]);

String类

1. 字符串相减/替换

使用 String 类的 replace() 方法来实现这个功能: replace(“target”,“replacement”)

如果你想将引号添加到字符串中，你可以使用转义字符 \" 来表示双引号。

String str1 = "abcdefg";
String str2 = "bcd";
String result = str1.replace(str2, "");
System.out.println(result);  // 输出: aefg

1. 字符串连接

使用 String 类的 concat() 方法来实现这个功能: contact(String s)

也可以用StringBuilder类来添加，空间效率更快

 String s = "菜鸟教程";
 s = s.concat("网址:").concat("www.runoob.com");
 System.out.println(s);    //输出 菜鸟教程网址:www.runoob.com

1. 比较子/字符串是否相同

• equals() 方法

String str1 = "abc";
String str2 = "123a";
str1.equals(str2);    //输出 false
"abc".equals(str2);    //输出 true

• equalsIgnoreCase() 方法 --不区分大小写

String str1 = "abc";
String str2 = "ABC";
System.out.println(str1.equalsIgnoreCase(str2));    // 输出 true

• compareTo() 方法

compareTo() 方法用于按字典顺序比较两个字符串的大小，该比较是基于字符串各个字符的 Unicode 值。

String str1 = "A";
String str2 = "a";
System.out.println(str1.compareTo(str2));    // a - A 输出 32
System.out.println(str2.compareTo(str1));    // A - a 输出 -32
System.out.println(str2.compareTo("a"));    // 相同输出 0

1. 字符串是否包含

contains() 方法

String str = "abcdef";
boolean statue = srt.contains("bc");    // statue = true;

1. 获取子字符串

• substring(int beginIndex)

  1. 这个版本的substring方法从指定的索引位置开始，提取字符串的一部分，一直到字符串的末尾。

• substring(int beginIndex, int endIndex)

  • 这个版本的substring方法从指定的起始索引位置开始，提取字符串的一部分，直到结束索引之前的位置。

  • public class SubstringExample {
        public static void main(String[] args) {
            String s = "Hello, world!";
            // 第1个substring方法
            // 使用单个索引，提取从索引2开始到末尾的子字符串
            String substring1 = s.substring(2);
            System.out.println("Substring 1: " + substring1); // 输出：llo, world!
            
            // 第2个substring方法
            // 使用两个索引，提取从索引7到索引12之前的子字符串，即 7 - 11 
            String substring2 = s.substring(7, 12);
            System.out.println("Substring 2: " + substring2); // 输出：world
            
            // 提取索引4之前的子字符串（索引4不包括在内）
            String substring3 = s.substring(0, 4);
            System.out.println("Substring 3: " + substring3); // 输出：Hell
        }
    }
    

1. 查找 字符/串 位置

• int indexOf(String str)：

  1. 这个版本的 indexOf 方法用于查找指定子字符串在字符串中第一次出现的索引位置。

• int indexOf(String str,int fromIndex):

  • 返回从 fromIndex 位置开始查找指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

  • public class IndexOfExample {
        public static void main(String[] args) {
            String text = "Hello, world! This is a sample text.";
            // 第1个indexOf方法
            // 查找字符 ',' 第一次出现的索引
            int commaIndex = text.indexOf(',');
            System.out.println( commaIndex); // 输出： 5
    
            // 查找子字符串 "world" 第一次出现的索引
            int worldIndex = text.indexOf("world");
            System.out.println( worldIndex); // 输出： 7
    
            // 查找不存在的字符或子字符串
            int notFoundIndex = text.indexOf("123");
            System.out.println( notFoundIndex); // 输出：-1
            
            // 第二个indexOf方法
            String t = text.indexOf("o",6);
            System.out.println( t); // 输出： 8
        }
    }
    

1. 进制转化

十进制转化为其他进制

public static boolean check(int base, int num){ // 进制位， 转换数
        int t = num;
        int sum = 0;
        while (t != 0){
            sum += t % base;
            t /= base;
        }
        return num % sum == 0;
    }

System.out.println(n + "的三进制是:" + Integer.toString(n, 3));
System.out.println(n + "的二进制是:" + Integer.toBinaryString(n));
System.out.println(n + "的八进制是:" + Integer.toOctalString(n));
System.out.println(n + "的十六进制是:" + Integer.toHexString(n));

其他进制转为十进制

    public static void main(String[] args) {
        String a = "1001";
        int s = Integer.parseInt(a, 2);// 二进制转十进制
        System.out.println(s);
    }

1. 大小写变换

s = s.toLowerCase(); //转换成小写
s = s.toUpperCase(); //转换成大写

String 方法

下面是 String 类支持的方法，更多详细，参看 Java String API 文档:

StringBuilder/StringBuffer类

当对字符串进行修改的时候，使用 StringBuffer / StringBuilder 类更方便。和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。方法类似

public class RunoobTest{
    public static void main(String args[]){
        StringBuilder sb = new StringBuilder(10);// 创建对象并设置字符序列长度为 10，也可不设置
        // StringBuilder/StringBuff 常用方法
        // 追加字符 append(String s/ char c)
        sb.append("Runoob..");
        
        // 插入字符 insert(int offset, String s)
        sb.insert(7, "Java");
        
        // 删除字符 delete(int start, int end)
        sb.delete(4,7);
        
        // 替换字符 replace(int start, int end, String str)
        
        // 反转字符 reverse()
        sb.reverse();
        
        // 字符串形式表示 toString()
        sb.toString()
    }
}

StringBuffer 方法

以下是 StringBuffer 类支持的主要方法：

以下列表列出了 StringBuffer 类的其他常用方法：

Math类

1. 对数字开方

Math.sqrt(16) -> 4

1. 对数字取整数

向上取整：Math.ceil(double a) [n/x] = [(n+x-1)/x] 向下取整：Math.floor(double a) 四舍五入取整：Math.round(double a)

例：

Math.ceil（24.1）–> 25

Math.floor（24.8）–> 24

Math.round（24.1）–> 24

Math.round（24.8）–> 25

import java.text.DecimalFormat;
public class Main {
    public static void main(String[] args) {
        double number1 = 25.00000;
        double number2 = 5432.10;
        //"#.######"指定了保留六位有效数字,小数点后不足6位不补0
        DecimalFormat decimalFormat = new DecimalFormat("#.######");
        
        // 设置最小小数位数为0，不写也可以
        decimalFormat.setMinimumFractionDigits(0); 

        String formattedNumber1 = decimalFormat.format(number1);
        String formattedNumber2 = decimalFormat.format(number2);

        System.out.println(formattedNumber1); // 输出：25
        System.out.println(formattedNumber2); // 输出：5432.1
    }
}

1. 高精度计算(数大于long)

import java.math.BigDecimal;
public class HighPrecisionExample {
    public static void main(String[] args) {
        // 使用字符串构造BigDecimal以确保精度准确
        BigDecimal num1 = new BigDecimal("123.456");
        BigDecimal num2 = new BigDecimal("789.012");

        // 加法
        BigDecimal sum = num1.add(num2);

        // 减法
        BigDecimal difference = num1.subtract(num2);

        // 乘法
        BigDecimal product = num1.multiply(num2);

        // 除法，指定精度和舍入模式
        BigDecimal quotient = num1.divide(num2, 10, BigDecimal.ROUND_HALF_UP);
        // ROUND_HALF_UP 四舍五入 ROUND_UP（向上取 ROUND_DOWN 向下取
    }
}

Number & Math 类方法

下面的表中列出的是 Number & Math 类常用的一些方法：

Arrays类

1. 数组创建

//一维数组
    int [] a = new int [10];
// 二维数组
    String[][] s = new String[3][4];
    //或   列可以先不写，后面要创建
    String[][] s = new String[2][];
    s[0] = new String[2];
    s[1] = new String[3];
//定义包含 first 属性的类
class MyObject {
 int first;
 // 构造函数
 public MyObject(int first) {
    this.first = first;
    }
}

public class Main {
 public static void main(String[] args) {
     // 创建一个包含三个 MyObject 对象的数组
     MyObject[] myArray = new MyObject[2];

     // 初始化数组中的每个元素
     myArray[0] = new MyObject(10);
     myArray[1] = new MyObject(20);
     myArray[0].first = 12;

     // 访问数组中的第一个元素的 first 属性
     int value = myArray[0].first;
     System.out.println("Value of first in the first element: " + value);
     // Value of first in the first element: 12
 }
}

1. For-Each循环

JDK 1.5 引进了一种新的循环类型，被称为 For-Each 循环或者加强型循环，它能在不使用下标的情况下遍历数组。

for(type element: array)
{
    System.out.println(element);
}

double[] myList = {1.9, 2.9, 3.4, 3.5};
// 打印所有数组元素
for (double element: myList) {
     System.out.println(element);
}

1. 数组赋值

一维数组填充

int [] map = new int [5];
Arrays.fill(map,1); // 将 map数组 填充为 1

二维数组填充

int[][] map=new int[4][5];
Arrays.fill(map,-1); // 失败

int[][] map=new int[4][5];
int[] ten=new int[10];
Arrays.fill(ten, -1);
Arrays.fill(map,ten); // 成功
//特别注意：map 的每一项指向的都是同一个一维数组 ten。修改一个会影响其他地址的值 ，
//如：修改 map[0][1] = 100 ,则 map[1][1] ，map[2][1]等都是100.

1. 数组排序

// 升序
Arrays.sort(int[] a); // 从小到大,升序
Arrays.sort(int[] a, int fromIndex, int toIndex);//对数组部分排序，区间左闭右开

//多维数组
// 先f[0]升序，若f[0]相同，按f[1]降序
Arrays.sort(f, (o1, o2) -> o1[0] == o2[0] ? o2[1] - o1[1] : o1[0] - o2[0]);//排序

建议使用Collections.sort()方法，比Arrays.sort()效率高

public static void sort(int[] arr) {
        List<Integer> list = new ArrayList<>();
        for (int i : arr) {
            list.add(i);
        }
        Collections.sort(list);
        for (int i = 0; i < arr.length; i++) {
            arr[i] = list.get(i);
        }
    }
// 降序
//首先要注意的是不能用int这个类型了，要用Integer，不能使用基本类型（int,double, char）
//如果是int型需要改成Integer，float要改成Float
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
 
public class Main {
    public static void main(String[] args) {
        Integer[] arr2={1,4,3,6,7,9,11};
        Arrays.sort(arr2, Collections.reverseOrder());
        System.out.println(Arrays.toString(arr2));
    }
}

// 冒泡排序：降序
public static void sort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - 1 - i; j++) {
            // 如果相邻元素逆序，则交换它们
            if (arr[j] < arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

1. 数组比较

Arrays.equals() 适用于一维数组的比较。
Arrays.deepEquals() 更适合用于多维数组，特别是当数组中包含其他数组时。

例子：
int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};
boolean judge = Arrays.equals(arr1, arr2)); // true

int[][] matrix1 = {{1, 2}, {3, 4}};
int[][] matrix2 = {{1, 2}, {3, 4}};
boolean judge =Arrays.deepEquals(matrix1, matrix2); // true
// 方法源代码
public static boolean equals(long[] a, long[] a2) {
    if (a.length != a2.length) return false;
    for (int i = 0; i < a.length; i++) {
        if (a[i] != a2[i])  return false;
    }
    return true;
}

1. 指定值第一次出现下标

public static int binarySearch(Object[] a, Object key)

用二分查找算法在数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好。如果查找值包含在数组中，则返回索引；否则返回 -1

Arrays.binarySearch(数组, 开始, 结束, 值)；

Arrays.binarySearch( arr , 0 , 10 , 5 );在下表为 0 - 9 中搜索

public static void main(String[] args) {
    int[] array = {5, 2, 9, 1, 5, 6};

    // 对数组进行排序
    Arrays.sort(array);
    // 要查找的值
    int targetValue = -9;

    // 使用binarySearch查找值的下标
    int index = Arrays.binarySearch(array, targetValue);
    System.out.println(index);
}

1. 数组转化为List

Arrays.asList()方法

String[] a = {"apple", "banana", "orange", "grape"};
List<String> list = new ArrayList<>(Arrays.asList(a));

// 不支持结构修改（add、remove 操作）
List<String> list = Arrays.asList(a);

Integer类

1. 校验数据是否为int、double、string类型的方法 instanceof

String sContentValue = "1234567";
boolean bCheckResult = true;
try
{
        Integer iCheckValue = Integer.parseInt(sContentValue);
                                
        if (iCheckValue instanceof Integer == false){
                bCheckResult = false;
        }
}
catch(NumberFormatException e)
{  
        bCheckResult = false;
}

Collection类

1. List 集合排序

只有List集合可以使用Collections.sort(List list)进行排序，若为其他类型集合转化为List集合

Collections.sort(List list)方法（升序排序）

Collections.sort(List list, Collections.reverseOrder());对有序集合降序排序（降序排序）

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(5);numbers.add(2);
        numbers.add(8);numbers.add(1);
        
        // 使用Collections.sort()方法升序排序
        Collections.sort(numbers);
        
        // 降序排序
            // 法1：推荐
            Collections.sort(numbers, Collections.reverseOrder());
            // 法2：Lambda 表达式的排序降序排序
            Collections.sort(b, (x,y)->y-x);
            //或
            list.sort((o1, o2) -> o2 - o1);

    }
}

1. 遍历集合

遍历ArrayList

import java.util.*;
 
public class Test{
 public static void main(String[] args) {
     List<String> list=new ArrayList<String>();
     list.add("Hello");list.add("World");list.add("HAHAHAHA");
     //第一种遍历方法使用 For-Each 遍历 List
     for (String str : list) {            //也可以改写 for(int i=0;i<list.size();i++) 这种形式
        System.out.println(str);
     }
 
     //第二种遍历，把链表变为数组相关的内容进行遍历
     String[] strArray=new String[list.size()];
     list.toArray(strArray);
     for(int i=0;i<strArray.length;i++) //这里也可以改写为  for(String str:strArray) 这种形式
     {
        System.out.println(strArray[i]);
     }
     
    //第三种遍历 使用迭代器进行相关遍历
     
     Iterator<String> ite=list.iterator();
     while(ite.hasNext())//判断下一个元素之后有值
     {
         System.out.println(ite.next());
     }
 }
}

遍历Map

import java.util.*;
 
public class Test{
     public static void main(String[] args) {
      Map<String, String> map = new HashMap<String, String>();
      map.put("1", "value1");map.put("2", "value2");map.put("3", "value3");
      
      //第一种：普遍使用，二次取值
      System.out.println("通过Map.keySet遍历key和value：");
      for (String key : map.keySet()) {
       System.out.println("key= "+ key + " and value= " + map.get(key));
      }
      
      //第二种
      System.out.println("通过Map.entrySet使用iterator遍历key和value：");
      Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
      while (it.hasNext()) {
       Map.Entry<String, String> entry = it.next();
       System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
      }
      
      //第三种：推荐，尤其是容量大时
      System.out.println("通过Map.entrySet遍历key和value");
      for (Map.Entry<String, String> entry : map.entrySet()) {
       System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
      }
    
      //第四种
      System.out.println("通过Map.values()遍历所有的value，但不能遍历key");
      for (String v : map.values()) {
       System.out.println("value= " + v);
      }
     }
}

ArrayList集合–元素可重复有序

import java.util.ArrayList; // 引入 ArrayList 类
ArrayList<E> objectName =new ArrayList<>();　 // 初始化
//例如
ArrayList<String> sites = new ArrayList<String>();

• E: 泛型数据类型，泛型String Integer Character Boolean等引用数据类型
• objectName: 对象名。

1. 排序

List<Integer> numbers = new ArrayList<>();
numbers.add(5);numbers.add(2);
numbers.add(8);numbers.add(1);

// 使用Collections.sort()方法升序排序
Collections.sort(numbers);

// 降序排序
    // 法1：推荐
    Collections.sort(numbers, Collections.reverseOrder());
    // 法2：Lambda 表达式的排序降序排序
    list.sort((o1, o2) -> o2 - o1);

1. 删除元素

• remove(int index)：删除指定索引处的元素。

List<Integer> numbers = new ArrayList<>();
numbers.remove(3); // 删除下标为3的元素

• remove(Object o)：删除第一次出现的指定元素。

List<Integer> numbers = new ArrayList<>();
Integer a = 3；
numbers.remove(a);// 删除第一次出现的3

List<String> list = new ArrayList<>();
list.remove("abc");// 删除字符串abc

• boolean removeAll(Collection<?> c)：是否删除另一个集合所有元素

public class RemoveAllExample {
    public static void main(String[] args) {
        // 创建一个ArrayList
        ArrayList<String> list1 = new ArrayList<>(Arrays.asList("apple", "banana", "orange", "grape"));

        // 创建另一个ArrayList，包含要移除的元素
        List<String> elementsToRemove = Arrays.asList("banana", "grape");

        // 使用removeAll移除包含在elementsToRemove中的元素
        boolean result = list1.removeAll(elementsToRemove);

        if (result) {
            System.out.println("移除成功，剩余的元素：" + list1);
        } else {
            System.out.println("列表未发生改变，没有移除任何元素。");
        }
    }
}

常用方法

ArrayList 常用方法
添加元素：
add(E element): 在列表末尾添加一个元素。
add(int index, E element): 在指定索引位置插入一个元素。

获取元素：
get(int index): 获取指定索引位置的元素。

修改元素：
set(int index, E element): 修改指定索引位置的元素。

删除元素：
remove(int index): 删除指定索引位置的元素。
remove(Object obj): 删除第一个出现的指定元素。
// 如 remove(Integer.valueOf(30);// 
clear(): 清空列表中的所有元素。

查找元素：
indexOf(Object obj): 返回指定元素第一次出现的索引，如果不存在则返回 -1。
lastIndexOf(Object obj): 返回指定元素最后一次出现的索引，如果不存在则返回 -1。
contains(Object obj): 判断列表是否包含指定元素。

获得集合大小：
size(): 返回列表中元素的数量。

获得子列表：
subList(int fromIndex, int toIndex): 返回从 fromIndex 到 toIndex 之间的子列表。

isEmpty(): 判断列表是否为空。

数组转换：
toArray(): 将列表转换为数组。
//例如
String[] arr = new String[sites.size()];
sites.toArray(arr);

toString()：将Arraylist对象转换为字符串。

HashSet集合–元素不可重复乱序

import java.util.HashSet; // 引入 HashSet 类
//下面两种形式都可以
HashSet<E> sites = new HashSet<E>();
Set<E> set = new HashSet<>();
// 例如：
HashSet<String> sites = new HashSet<String>();
Set<Character> set = new HashSet<>();
获取HashSet元素
// 通过迭代器获取元素
    Iterator<String> iterator = linkedHashSet.iterator();
    while (iterator.hasNext()) {
        String element = iterator.next();
        System.out.println(element);
    }

// 或者将 LinkedHashSet 转换为数组
    String[] array = linkedHashSet.toArray(new String[0]);
    for (String element : array) {
        System.out.println(element);
    }

HashSet 常用方法同 ArrayList 一样，无get()方法

详细参考–菜鸟教程Java HashSet，如下

https://www.runoob.com/java/java-hashset.html

HashSet 按插入顺序排列

用HashSet存储元素，HashSet不保证元素的顺序，它是基于哈希表实现的，元素的存储顺序与它们的哈希码有关，而哈希码与元素的插入顺序无关。

如果你希望输出的元素按照插入的顺序进行排列，你可以考虑使用LinkedHashSet。LinkedHashSet是HashSet的一个子类，它保留了元素的插入顺序。只需稍微修改你的代码，将HashSet替换为LinkedHashSet

如： Set set = new LinkedHashSet<>();

Map类

// 引入 HashMap 类      
import java.util.HashMap;
public class RunoobTest {
    public static void main(String[] args) {
        // 创建 HashMap 对象 Sites
        HashMap<Integer, String> Sites = new HashMap<Integer, String>();
        // 添加键值对
        Sites.put(1, "Google");
        Sites.put(2, "Runoob");
        Sites.put(3, "Taobao");
        Sites.put(4, "Zhihu");
        System.out.println(Sites);
    }
}

HashMap 常用方法：

队列

PriorityQueue 是 Java 中的一个优先队列实现，通过默认情况下是一个小顶堆（元素按升序排列）来实现。如果你希望使用大顶堆（元素按降序排列），你可以通过提供一个 Collections.reverseOrder() 的比较器来实现。以下是用中文描述的代码：

import java.util.Collections;
import java.util.PriorityQueue;

public class Main {
    public static void main(String[] args) {
        // 创建一个大顶堆优先队列
        PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());

        // 添加元素到优先队列
        pq.add(3);
        pq.add(1);
        pq.add(4);
        pq.add(1);
        pq.add(5);

        // 弹出并打印堆顶元素
        while (!pq.isEmpty()) {
            System.out.println(pq.poll());
        }
    }
}

IO流

BufferedReader的使用方法

import java.io.*;
public class Main {
    public static void main(String[] args) throws IOException {
        //创建BufferedReader对象，从键盘读入
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));       
        String str = br.readLine();  //读取一行字符串，br.readLine()读取的为字符串类型
        int n = br.read(); // 读取一个字符，返回对应 ASCII 的值
        int a = Integer.parseInt(str);  //将字符转化为整型
        br.ready();// 判断是否还有下一个，返回类型 boolean
        String[] temp=br.readLine().split(" ");//读取一行数据并用空格分隔，存入字符串数组
    }
}

        // 或
        String str1 = null ;        // 接收输入内容
        try{
            str1 = br.readLine() ;        // 只能读取一行数据
        }catch(IOException e){
            e.printStackTrace() ;        // 输出信息
        }
import java.io.*;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s = br.readLine();
        // 使用空格作为分隔符创建StringTokenizer对象
        StringTokenizer st = new StringTokenizer(s);
        
        // 获得字符串数量
        int n = st.countTokens();
        System.out.println(n);
        
        // 遍历并打印每个标记
        while (st.hasMoreTokens()) {
            String token = st.nextToken();
            System.out.println(token);
        }
    }
}

Scanner的使用方法

import java.util.Scanner;
public class Main {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);//创建Scanner类对象，从键盘读入数据
        int temp3 = sc.nextInt();
        double temp4 = sc.nextDouble();
        boolean temp5 = sc.nextBoolean();// true / false
        String temp2 = sc.next();//读取字符直到判断输入结束
        String temp1 = sc.nextLine();//读取下一行数据
        long temp = sc.hasNextLong();
        boolean temp = sc.hasNext(String str);//输入的字符与str比较，返回true/false
        sc.hasNext();// 判断是否还有下一个，返回类型 boolean
        sc.hasNextLine();// 判断是否还有下一行是，返回类型 boolean
        String [] s = sc.nextLine().split(" ");
        sc.useDelimiter(" ");//若以空格分隔字符串，需要读取空格才能继续读取
        //或者使用一个空的sc.nextLine()跳过空格 PS：此方法可以设置其他分隔符
        
    }
}

基础知识

1. ASCII码

1. 位运算符

• 按位与（&）：对应位上的两个二进制数都为1时，结果为1，否则为0。

result = a & b;

• 按位或（|）：对应位上的两个二进制数只要有一个为1时，结果为1，否则为0。

result = a | b;

• 按位异或（^）：对应位上的两个二进制数不相同时，结果为1，相同时结果为0。

result = a ^ b;

• 按位取反（~）：对二进制数的每一位取反，0变为1，1变为0。

result = ~a;

• 左移（<<）：将二进制数向左移动指定的位数，右侧用0填充。

result = a << n;

• 右移（>>）：将二进制数向右移动指定的位数，左侧用符号位填充（对于有符号整数）。

result = a >> n;

1. 数据类型及范围

获取某类型最大值 MAX_VALUE，例如：int a = Integer.MAX_VALUE

• 整数类型：

  • byte: 8位，1字节，范围为 -128 到 127 = 2^7-1

  • short: 16位，2字节，范围为 -32768 到 32767 = 2^15-1

  • int: 32位，4字节，范围为 -2147483648 到 2147483647 = 2^31-1 = 2*10^10

  • long: 64位，16字节，范围为 -9223372036854775808

    到9223372036854775807 = 2^63-1 = 9 *10^19

    超过int范围，后面＋L 如：long b = 10000000000L

• 浮点数类型：

  • float: 32位，4字节，范围为约 ±3.4E38
  • double: 64位，64字节，范围为约 ±1.7E308

• 字符类型：

  • char: 16位，2字节范围为 0 到 65535。表示Unicode字符。

• 布尔类型：

  • boolean:一般认为1字节 只有两个可能值，true 或 false。

1. 单位换算

• bit(比特) < byte(字节) < kb < mb < gb < tb < pb

  1 byte = 8 bit 1 kb = 1024 byte 1mb =1024 kb

  1 gb = 1024 mb 1 tb = 1024 gb 1 pb = 1024 tb

• 1s = 1000 ms

1. 输出格式：对齐方式和宽度控制

// 每个数字占5个位置，右对齐（从最右边输出，在前面补空格）
System.out.printf("%5d",i);   

// 每个数字占5个位置，左对齐（从最左边输出，后面补齐空格）
System.out.printf("%-5d",i);

// 输出小数控制
// 说明：%f默认保留6位，.后面的表示的是小数四舍五入保留的位数
System.out.printf("%.2f",3.1415926);   //小数点后保留2位，即 3.14

// 输出类型 printf 
 short -- %hd
 long  -- %ld
 long long -- %lld
 boolean -- %b

// 输出 %
System.out.printf("%.2f%%",81.82);   //将%输在小数后面，即 81.82% 

// 例子
//六位整数+一位小数点+三位小数=_314315.142（右对齐，左边补一个空格）
System.out.printf("%11.3f\n",314315.1415926);  
System.out.printf("%10.3f\n",314315.1415926);  //6+1+3=10 正好=314315.142
System.out.printf("%11.4f\n",314315.1415926);  //6+1+4=11 正好=314315.1426
System.out.printf("%8.3f\n",314315.1415926);   //6+1+3>8 正常输出=314315.142
System.out.printf("%14.3f\n",314315.1415926);  //6+1+3=14-4 补四个空格=_ _ _ _314315.142

double p = 0.235987565146
// 四舍五入保留4位小数，后面又0省略 如 p = 230.1 -> 230.1
DecimalFormat form=new DecimalFormat("0.####");
System.out.println(form.format(p));//(0.2360后面的0省略)  0.236 

其他零碎知识点

1. 正则表达式

str.replaceAll(“6{10,}”, “27”).replaceAll(“6{4,}”, “9”)

// 6出现10次及以上替换为27，出现四次及以上替换为9

1. 转义字符

        // 换行
        System.out.println("Hello\nWorld");  
//Hello
//World

        // 制表符
        System.out.println("Hello\tWorld");
//Hello        World

        // 退格
        System.out.println("Hello\bWorld");
//HelloWorld

        // 回车
        System.out.println("Hello\rWorld");
        //Hello
//World

        // 单引号和双引号
        System.out.println("She said: \"Hello, World!\"");
        System.out.println("It's a sunny day.");
//She said: "Hello, World!"
//It's a sunny day.

        // 反斜杠自身
        System.out.println("This is a backslash: \\");
 //This is a backslash: \
 
 // 在正则表达式中，需要使用两个反斜杠来转义一些特殊字符。
 // 例如，正则表达式中的 \( 表示 (   而 \\( 表示 \(
 // replaceAll 方法使用正则表达式来替换字符串中的匹配项
        String commend = "(al)G(al)()()G";
        String s = command.replaceAll("\\(\\)","o").replaceAll("\\(al\\)","al");
        System.out.println(s);