C++到Java学习总结（基础篇）

一、java与C++的一些区别

Java没有直接对应C++的指针、结构体等概念。

1. 数据结构：Java的ArrayList相当于C++的vector，HashMap和HashSet相当于C++的unordered_map和unordered_set。

2. 运算符：大多数基本运算符保持一致，比如+、-、*、/等，但位操作符如>>和<<仍与C++相同。

3. 字符串处理：Java中的String是不可变的对象，而不是C++中的char*或std::string。

4. 指针：Java不支持指针，所有对象都通过引用传递，类似于C++中的引用传递，但不需要手动管理内存（由垃圾回收机制管理）。

5. 内存管理：Java不需要手动调用delete，因为Java有垃圾回收机制，自动处理不再使用的对象。

6. 输入输出：Java使用Scanner进行输入，System.out.println进行输出。

7. java中的变量和函数都得写在类里面，因此调用其他类的变量和函数也必须通过类名调用。

8. 输入输出都是需要使用类中的方法。

9. java没有结构体。

10. java没有全局变量只能通过静态变量来模拟。

11. java中的常数是通过final来修饰的。

12. java中没有指针，只有引用，数组是一个容器对象，String也是一个类，因此数组和String变量都是一个对象，数组名和String名都不能说是指针，因为都是引用类型的变量。

13. Java 中的基本数据类型按值传递。

二、java的main函数入口介绍

public class Main {//文件名为Main.java
    public static void main(String[] args) {
        System.out.println("This is a Java program!");
    }
}

• 在可运行的Java程序中，至少需要有一个类包含public static void main(String[] args)方法作为程序的入口点，这是Java程序的标准入口。虚拟机（JVM）启动时会从这个方法开始执行程序。
• 一个.java源文件，最多只能有一个public的类，并且此时该类必须和文件名相同。程序入口点main方法，可以放到任何名字的类中。
• 程序入口点，必须声明为public static，即外部可直接访问的静态方法。、
• java的类不需要在最后添加;。

class Yorelee {//文件名可以不是Yorelee.java//该类默认访问控制——在包中可见 和 private不同
    public static void main(String[] args) {
        System.out.println("This is a Java program!");
    }
}

三、java中的基本数据类型和运算符

public class Main{
	// 定义常量
    static final int LIMITS = (int) 1e9;  // Java中使用`static final`来定义常量
    static int lobal = 2;  // 本包全局变量
    //private static int lobal = 3;表示本类的全局变量
	public static void main(String[] args){
		int a = 1;
		char b = '0', c = (char) lobal;
        int e = LIMITS;
		boolean flag = true;
		double d;float f;long ll;
		e = e + c;
        e = e >> 1;
        e++;
        e += 1;
        e = e | c;
        e = e & c;
        e = e ^ c;
        e = e >> 1;
        if(e == 1 || e == 2) e = 3;
        //或者
        e = (int) Math.sqrt(e);  // sqrt 和 pow 在Java中使用 Math 类的方法
        e = (int) Math.pow(e, 2); f = e;
        d = Math.sqrt(e);
        e = Math.max(e, c);
	}
}

• java中的全局变量和常量，都是类变量。用final修饰表示不能更改，用static修饰表示全类可以使用。默认为包可访问的，但其他类想访问必须使用Main.lobal。
• sqrt、pow(返回值为double)、max都是类Math中的方法（自动导入的java.lang.Math）。因此要访问这个方法就必须使用Math.。
• java中的类型转换也分为隐式类型转换和显示类型转换。不过高精度转低精度的时候必须显示类型转换（如double ->int）。低精度转高精度直接可以隐式类型转换：
  • byte → short → int → long → float → double||char → int

public class Main{
    static int lobal = 2;  // 本包全局变量
    //private static int lobal = 3;表示本类的全局变量
	public static void main(String[] args){	
	}
	static void func(){

	}
}
//java不能再类外定义变量，因此全局变量都得在类中定义，在这个类中定义的，其他类就必须用类名引用了
class Yorelee{
	public void func(){
		int x = Main.lobal;//使用Main中的静态变量，实际上就是全局变量
		Main.func();
	}
}

四、java中的普通数组 和 字符串

（1） java中的字符串使用String类对象来表示，注意这个类的字符串是不可变的。变化则产生新对象。（或者也可以使用char[]，但不常用，因为String类有很多内置方法）
（2）java中new出来的对象，不能delete。Java有自动的垃圾回收机制（Garbage Collection, GC）。可以手动调用System.gc(); // 建议Java虚拟机（JVM）尽快进行垃圾回收。
（3）在Java中，数组是对象，它有一个属性叫做length，可以用来获取数组的大小。但是String使用的是.length()方法。
（4）数组是一个容器对象，String是字符串类。它们的差别很大。

import java.util.Arrays;
public class Main{
	public static void main(String[] args){
		int x = 2;
		int[] a;//声明时并不指定长度
		a = new int[10];//定义时指定长度且不可变更，默认值是0
		a = new int[x];//更新引用
		int[] b = new int[2];//声明并定义
		int[] c = {1, 2, 3, 4};//声明并定义
		c[0] = 2;
		int len = a.length;//获取数组的大小
		
		char[] st = {'h','e','l','l','o'};
 		String str = "Hello ";//不可变字符串，相当于c++的char *;
		String[] s, t = {"b","a"};
		s = new String[3];
		s[0] = "yr";
		int strlen = s[0].length();

		Arrays.sort(b);
	}
}

• 使用java.util.Arrays类，使用其中的.sort()方法，可以对数组进行排序：Arrays.sort(numbers); numbers是任何类型的数组。

五、java中的String

不能直接在 String 或数组类型上使用 == 或 > 等运算符来比较它们的内容。这些运算符在比较对象时，实际上比较的是引用（内存地址），而不是对象的实际内容。因此，如果你想比较字符串或数组的内容，需要使用适当的方法。

String类是Java中用于表示和操作字符串的类。它提供了许多内置方法，用于处理字符串的各种操作。由于String在Java中是不可变对象，这些操作不会修改原始字符串，而是返回一个新的字符串。

以下是Java中常用的String对象的操作方法及其详细介绍：

1. 获取字符串长度

   • int length()：返回字符串的长度（字符数）。

   String str = "Hello, World!";
   int len = str.length();  // len = 13
   

2. 获取特定位置的字符

   • char charAt(int index)：返回字符串中指定索引处的字符，索引从0开始。

   String str = "Hello";
   char ch = str.charAt(1);  // ch = 'e'
   

3. 字符串拼接

   • String concat(String str)：将指定字符串拼接到当前字符串的末尾。
   • + 运算符：Java支持通过+运算符来拼接字符串。

   String str1 = "Hello";
   String str2 = " World";
   String result = str1.concat(str2);  // result = "Hello World"
   
   // 使用+号拼接
   String result2 = str1 + str2;  // result2 = "Hello World"
   

4. 比较字符串

   • boolean equals(Object another)：比较两个字符串是否相等（区分大小写）。
   • boolean equalsIgnoreCase(String another)：比较两个字符串是否相等（忽略大小写）。

   String str1 = "hello";
   String str2 = "Hello";
   boolean isEqual = str1.equals(str2);  // false
   boolean isEqualIgnoreCase = str1.equalsIgnoreCase(str2);  // true
   

5. 字符串替换

   • String replace(char oldChar, char newChar)：将字符串中所有的oldChar替换为newChar。
   • String replace(CharSequence target, CharSequence replacement)：将所有的子字符串target替换为replacement。
   • String replaceAll(String regex, String replacement)：使用正则表达式将所有匹配的子字符串替换为replacement。
   • String replaceFirst(String regex, String replacement)：使用正则表达式将第一次匹配的子字符串替换为replacement。

   String str = "Hello, World!";
   String replaced = str.replace('o', 'a');  // "Hella, Warld!"
   String replacedStr = str.replace("World", "Java");  // "Hello, Java!"
   

6. 字符串大小写转换

   • String toLowerCase()：将字符串转换为小写。
   • String toUpperCase()：将字符串转换为大写。

   String str = "Hello, World!";
   String lower = str.toLowerCase();  // "hello, world!"
   String upper = str.toUpperCase();  // "HELLO, WORLD!"
   

7. 字符串修剪

   • String trim()：去除字符串开头和结尾的空白字符（如空格、制表符等）。

   String str = "  Hello, World!  ";
   String trimmed = str.trim();  // "Hello, World!"
   

8. 字符串截取

• String substring(int beginIndex)：返回从指定索引开始的子字符串。
• String substring(int beginIndex, int endIndex)：返回从beginIndex开始到endIndex结束的子字符串（不包括endIndex处的字符）。

String str = "Hello, World!";
String subStr = str.substring(7);  // "World!"
String subStr2 = str.substring(0, 5);  // "Hello"

11. 字符串的格式化

• String format(String format, Object... args)：使用指定的格式字符串和参数生成新的字符串，类似于C语言中的printf。

String formatted = String.format("My name is %s and I am %d years old", "Alice", 25);
System.out.println(formatted);  // 输出：My name is Alice and I am 25 years old

12. 字符串比较

• int compareTo(String anotherString)：按字典顺序比较两个字符串。
• int compareToIgnoreCase(String str)：忽略大小写按字典顺序比较两个字符串。

String str1 = "apple";
String str2 = "banana";
int result = str1.compareTo(str2);  // 返回负数，表示str1小于str2

13. 检查字符串是否为空

• boolean isEmpty()：检查字符串是否为空（长度为0）。
• boolean isBlank()（Java 11 引入）：检查字符串是否为空白（包括空格、制表符等）。

String str1 = "";
String str2 = "   ";
System.out.println(str1.isEmpty());  // true
System.out.println(str2.isEmpty());  // false
System.out.println(str2.isBlank());  // true （Java 11+）

14. 字符串连接

• String join(CharSequence delimiter, CharSequence... elements)：使用指定的分隔符连接多个字符串。

String joined = String.join(", ", "apple", "banana", "orange");
System.out.println(joined);  // 输出：apple, banana, orange

16. 将其他类型转换为字符串

• String valueOf(int i)、String valueOf(double d)、String valueOf(boolean b) 等：将基本数据类型转换为字符串。

int number = 10;
String str = String.valueOf(number);  // "10"

19. 检查字符串的前缀和后缀

• boolean startsWith(String prefix)：判断字符串是否以指定的前缀开始。
• boolean endsWith(String suffix)：判断字符串是否以指定的后缀结束。

String str = "Hello, World!";
boolean starts = str.startsWith("Hello");  // true
boolean ends = str.endsWith("World!");  // true

20. String和char[] 之间的转换

public class Main {
    public static void main(String[] args) {
        char[] charArray = {'h', 'e', 'l', 'l', 'o'};
        // 将 char[] 转换为 String
        String str = new String(charArray);
		char[] CharArray = str.toCharArray();
        // 输出转换后的字符串
        System.out.println(str);  // 输出：hello
    }
}

public class Main {
    public static void main(String[] args) {
        String str = "hello World!";//由于String是不可变对象，因此我们可以通过将其转为char[]修改它，再变回String
        char[] charArray = str.toCharArray();
        charArray[0] = 'H';
        str = new String(charArray);
        System.out.println(str);  // 输出：Hello World!
    }
}

六、java的标准输入输出

（1）输出
输出可以直接使用内置类System(位于java.lang中)的System.out.println()和System.out.print()即可，该方法一次只能接受一个对象。都是用于在控制台输出内容的，但它们之间有一个关键的区别：

• System.out.println()：输出内容后会自动换行，也就是说输出内容后，光标会移动到下一行。
• System.out.print()：输出内容后不会自动换行，光标停留在当前行的末尾，后续输出会紧接在当前输出的内容后面。

public class Main{
	public static void main(String[] args){
		int a = 2, b = 3, c = 4;
		System.out.println(a + "," + b + "," + c);//输出2,3,4
		//注意不是System.out.println(a + ',' + b + ',' + c);//输出97，相当于五个int相加
	}
}

和C++类似，使用System.out.printf()也可以进行格式控制：

public class Main {
    public static void main(String[] args) {
        int x = 10;
        double y = 2.34567;
        String str = "Java";

        // 使用printf格式化输出
        System.out.printf("整数: %d, 浮点数: %.2f, 字符串: %s%n", x, y, str);//%n是平台无关的，它会根据当前操作系统自动选择合适的换行符。
    }
}

（2）输入
输入比较麻烦
在 Java 中，最常用的输入方法是通过 Scanner 类，它位于 java.util 包中，可以方便地从控制台读取各种类型的输入数据（如整数、浮点数、字符串等）。
除了String和数组，所有类对象都必须通过new的方式创建。使用Scanner的对象，需要传入参数System.in。例如:Scanner in = new Scanner(System.in);来创建一个Scanner对象。

基本单位输入：

示例：读取整数和字符串

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // 创建一个 Scanner 对象
        Scanner scanner = new Scanner(System.in);

        // 读取一个整数
        System.out.print("Enter an integer: ");
        int num = scanner.nextInt();

        // 读取一个字符串
        System.out.print("Enter a string: ");
        String str = scanner.next();

        // 打印输入的数据
        System.out.println("You entered integer: " + num);
        System.out.println("You entered string: " + str);

        // 关闭 Scanner
        scanner.close();
    }
}

关键方法：

• nextInt()：读取一个整数。跳过空格和换行符，直接读取下一个整数
• nextFloat()：读取一个浮点数。
• next()：读取一个字符串（不包括空格）。只会读取下一个非空格的字符串，遇到空格或换行符就停止
• nextLine()：读取一行字符串（包括空格和换行符）。读取整行。相当于c++的getline
• nextBoolean()：读取一个布尔值。
• Scanner中没有提供读取单个字符的方法只能按照字符串的方式读取scanner.next().charAt(0)

注意事项：

• 使用 nextLine() 读取完整的一行时，注意与其他 next() 方法混合使用时可能产生的换行符问题。在读取整行输入时，最好避免在之前调用 nextInt() 或 next()，否则会导致换行符在之前没被读取，导致这个nextLine()读取到换行符。

示例：处理整行输入

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Enter a string: ");
        String line = scanner.nextLine();  // 读取整行，包括空格

        System.out.println("You entered: " + line);

        scanner.close();
    }
}

数组式输入：//初学者还是算了因为可以直接使用循环输入

int[] arr = IntStream.range(0, n).map(i -> in.nextInt())  // 对范围内的每个索引，读取输入
                     .toArray();              // 转换为数组

未知长度的输入：
hasNextXX()：判断是否有下一个对应的数。如果输入结束（如通过 Ctrl+D 或 Ctrl+Z 触发 EOF），它会返回 false，循环终止。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);  // 创建 Scanner 对象
        int[] a = new int[1000];  // 创建大小为 1000 的数组
        int i = 0;  // 用来记录输入的元素个数
        // 循环读取整数，直到输入结束符（EOF）
        while (scanner.hasNextInt()) {
            a[i++] = scanner.nextInt();
        }
       
        // 输出数组中的元素
        for (int j = 0; j < i; j++) {
            System.out.println(a[j]);
        }
        scanner.close();  // 关闭 Scanner
    }
}

七、java的if、for、while、switch基本控制结构

Java 和 C++ 的控制结构完全相同， 存在一些细微差异：

• 条件表达式：在 Java 中，if 和 while 条件必须是布尔类型（boolean），而 C++ 允许使用整数值来表示 true（非零）和 false（零）。
• 增强型 for 循环：Java 提供了增强型 for 循环，用于简化数组和集合的遍历，C++ 没有类似的语法，但在 C++11 引入了范围 for 循环，功能类似。

public class Main {
    public static void main(String[] args) {
    	int[] arr = {1, 2, 3, 4, 5};
		for (int num : arr) {
    		System.out.println(num);
		}
		int j = 0;
		while(j < arr.length){
			System.out.println(arr[j ++]);
		}

		for(int i = 0; i < arr.length; ++ i){
			System.out.println(arr[i]);
		}
		switch(arr[0]){
 			case 2 : System.out.print(2);break;
			case 3 : System.out.print(3);break;
			default: System.out.print(0);
		}
    }
}

八、java的引用

java没有指针只有引用！
在 Java 中，引用的概念与 C++ 有一些不同。Java 的引用类似于 C++ 中的指针或对象的引用，而不是像 C++ 中的引用那样严格绑定到一个对象。因此，在 Java 中，引用是可以重新指向其他对象的。

九、java的函数

Java 和 C++ 的函数基本相同，不过java的函数必须写在类里，因此包含了static，private，public等问题。
Java 不支持默认参数，但可以通过方法重载来实现类似的功能。你需要定义多个重载方法，每个方法有不同的参数列表。

public class Example {
    public void display() {
        display(10, 20);  // 调用带有两个参数的方法
    }

    public void display(int a) {
        display(a, 20);  // 调用带有两个参数的方法
    }

    public void display(int a, int b) {
        System.out.println("a: " + a + ", b: " + b);
    }

    public static void main(String[] args) {
        Example obj = new Example();
        obj.display();       // 输出：a: 10, b: 20
        obj.display(30);     // 输出：a: 30, b: 20
        obj.display(30, 40); // 输出：a: 30, b: 40
    }
}