马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。
您需要 登录 才可以下载或查看，没有账号？立即注册
×
字符串存储的标题
char 和字符串都是字符的聚集，它们之间简直有相似性，但在 Java 中它们有着差异的存储机制和处置惩罚方式。让我从 char 和 String 的本质区别入手来表明。
1. char 和 String 的区别
- char 是根本范例：char 是 Java 中的根本数据范例，用来存储单个字符，占用固定的内存空间（2 字节）。由于 char 是根本范例，以是它不存储在常量池或堆中，而是直接在栈上分配内存。
- String 是对象：String 是一个引用范例，本质上是字符数组的封装。字符串存储在堆内存中，而且不可变。
2. 常量与非常量的区别
- 字符串常量：字面量字符串在 Java 中存储在字符串常量池中。只要内容类似，步调中多次利用类似的字符串字面量时，它们都会指向常量池中的同一个对象。
- char 常量：char 可以是常量（比方 'a'），也可以是变量，但它本质上是一个根本数据范例，不是对象。char 常量并没有像字符串那样的“常量池”机制。
3. 为什么 charAt() 不会创建新对象
当你利用 charAt() 获取字符串中的某个字符时，返回的只是一个根本范例的 char 值，不会涉及到对象的创建或字符串的拼接，因此不会像 substring() 那样在堆内存中创建新对象。- String str = "hello";
- char ch = str.charAt(1); // 返回 'e'
4. substring() 与 charAt() 的差异
- substring()：substring() 方法截取字符串，创建新的字符串对象，并返回这个对象。纵然你从一个常量字符串中截取了一部门，substring() 返回的效果仍然是一个新的字符串对象。
- charAt()：charAt() 返回的是一个 char 根本范例的值，而不是一个对象。由于 char 是根本范例，因此不会像字符串对象那样须要额外的内存分配和对象创建。
5. char 和 String 常量的区别
- char 常量：好比 'a'，是根本范例，它的值直接存在栈上，不像字符串那样有常量池的概念。你可以在任何地方直接利用 char 常量，它不会像字符串一样占用大量内存。
- String 常量：字符串常量存储在常量池中，答应多个引用指向类似的内存所在，节流内存空间。
6. 总结：为什么 char 和 String 不一样
- char 是一个根本数据范例，其值直接存储，不涉及对象创建。
- String 是一个引用范例，是对象，涉及到对象的创建和内存管理。
- charAt() 返回一个 char 值，它只是提取字符，不须要创建新的对象。
- substring() 创建并返回的是一个新的字符串对象，纵然它是从常量字符串中截取的。
因此，char 和 String 的区别重要在于存储机制和数据范例的差异，这是 Java 为了性能和内存优化做出的计划。
常量字符串我也可以截取内里的部门，当做一个正常的常量字符串利用？
是的，常量字符串中的部门可以通过方法截取
1.截取常量字符串的部门
当你利用 substring() 等方法从常量字符串中截取一部门时，如果这部门字符串是从一个编译期确定的常量字符串中截取的，而且符合常量表达式的规则，Java 编译器会将其视为一个新的常量字符串，并存储在常量池中。- String str = "hello world";
- String subStr = str.substring(0, 5); // 截取 "hello"
2. 运行时截取和常量池
如果你是在运行时举行字符串截取（比方利用的不是编译时确定的字符串），那么 Java 会在堆内存中创建一个新的字符串对象，而不是将效果存储在常量池中。- String str1 = new String("hello world");
- String subStr1 = str1.substring(0, 5); // 运行时创建一个新的字符串对象 "hello"
1. 字符串常量池的计划目的：优化性能和内存利用
Java 中的字符串常量池（String Pool）是为了优化内存利用。它的作用是制止在步调中创建重复的字符串对象。
- 当你声明一个字符串字面量时，好比：
String str1 = "hello";
- String str2 = "hello";
这两个字符串指向的是常量池中同一个字符串对象，不会重复创建。这种机制极大地淘汰了内存斲丧，特殊是在字符串频仍出现重复内容时。
- 由于常量字符串是不可变的，同一个字面量字符串可以被多个引用共享而不产生标题。这就是常量池的作用：复用类似的字符串对象，淘汰内存的利用和垃圾采取的负担。
2. new String() 为什么要创建新的字符串对象？
new String() 会在堆内存中创建一个新的字符串对象，纵然内容与常量池中的字符串类似。
- 为什么须要 new String()？由于偶然间你须要明白创建一个新的对象，而不是利用共享的常量池对象。好比，在某些特定场景下，步调大概须要对字符串对象的引用举行利用，不盼望与其他引用共享类似的对象。
- 堆内存中的对象可以被独立利用和管理，而常量池中的对象则是全局共享的，不能被修改（由于字符串是不可变的）。new String() 提供了一个创建全新对象的方式，制止了在某些场景下的不测副作用。
字符串拼接和内存
当涉及到字符串拼接时，Java 大概会创建新的字符串对象：
- 如果拼接的是常量字符串，Java 会在编译时将它们归并为一个常量，并存储在常量池中，不会创建新的对象。
- 如果拼接的是运行时动态天生的字符串，Java 会在堆内存中创建新的字符串对象。
- String str1 = "hello";
- String str2 = new String(" world");
- String result = str1 + str2; // 运行时生成新的字符串对象
在 Java 中，无论是常量字符串照旧通过 new String() 创建的字符串，当你利用 charAt() 获取某个字符时，不会创建新的字符串或字符对象。charAt() 的效果是返回该字符串中指定位置的字符，而这个字符是根本数据范例 char，因此不会涉及到新建对象。
1. charAt() 的处置惩罚方式
1. 直接声明字符串常量2. new String("asdasd") 创建新的字符串 - String str = new String("asdasd");
利用字符串常量下标获取字符- String str = "example";
- char ch = str.charAt(2); // 获取下标为2的字符
常量字符串是由常量字符拼接起来的吗？
不美满是如许。常量字符串（字面量）本身存储在字符串常量池中，并不是由单个字符的拼接直接构成的。常量字符串在编译时已经是完备的字符串对象，而不是通过逐个字符拼接成的。
当你声明一个字符串字面量时，Java 会在编译阶段将它存储在字符串常量池中。纵然你像下面如许拼接两个字符串常量，Java 也会在编译时优化为一个完备的常量字符串。- String str = "he" + "llo"; // 编译时优化为 "hello"
匿名内部类
类的访问修饰符
- public：
- 类可以被任何其他类访问。
- 实用于须要在整个应用步调中被广泛利用的类。
- private：
- 仅能在界说该类的外部类（在嵌套类的环境下）访问。
- 如许的类通常用于只在特定上下文中利用，其他类无法直接创建或利用它们。
- protected：
- 类可以被同一包中的其他类和任何继续该类的子类访问。
- 实用于盼望让子类访问的类，但不盼望其他类直接利用的环境。
- internal（C# 特有）：
- 类只能在同一步调集内访问。
- 实用于盼望限定访问到特定步调集的类。
- 默认（无修饰符）（Java 特有）：
- 类在同一包中可见，其他包中的类无法访问。
- 用于在包内部共享类，但不想对外部可见。
c#里
- 如果不显式指定访问修饰符，类和接口的默认访问级别都是 internal。
- 要让它们在整个应用步调中可见，您须要显式地将它们声明为 public。
在 Java 中，类和接口的默认访问修饰符是“包私有”（package-private），即如果没有显式指定访问修饰符，类和接口只能在同一包内被访问。
接口
在 C# 中，接口的只读属性是实例成员，每个实现这个接口的类可以独立实现该属性，并返回差异的值。
java里则严酷要求，不能让实现类里有接口带来的实例属性，实现类只能利用接口中的常量，而不能修改它们。- public interface MyInterface {
- int CONSTANT_VALUE = 100; // 必须赋值，且是 public static final
- }
- 接口中只能界说方法的署名，不能包罗实现。
- 接口中的方法默认是 public，且不能利用其他访问修饰符。
在 C# 中，接口中的成员（包罗方法、属性、变乱等）默认是 public。如果你没有显式地指定访问修饰符，编译器会将它们视为 public。比方：- public interface IMyInterface
- {
- void MyMethod(); // 默认是 public
- }
- public interface IMyInterface
- {
- void MyMethod();
-
- void DefaultMethod()
- {
- // 默认实现
- }
- }
关于常量
接口这个东西，可以设置static常量附着在该接口类上，在接口中写的全部，都为public，public为接口特色，
在c#，可以界说只读属性，附着在该接口类上，java里，则是可以界说static final int 常量，通过该方式界说常量
在 Java 中，接口中界说的常量是 public static final 的，必须在接口中赋值，不能在实现类中重新赋值。
java
Java 8，引入了默认方法和静态方法的实现。
属性：
- 接口中可以界说常量（static final），但不能界说实例变量。常量必须是 public static final，通常省略修饰符：
- public interface MyInterface {
- void doSomething();
-
- default void doDefault() {
- // 默认实现
- }
- }
- public interface MyInterface {
- int MY_CONSTANT = 10; // 默认是 public static final
- }
- public interface MyInterface {
- static void myStaticMethod() {
- // 静态方法实现
- }
- }
实现接口的类必须提供全部方法的实现（除非类是抽象类）- public class MyClass implements MyInterface {
- @Override
- public void doSomething() {
- // 实现代码
- }
- }
总结一下，全部的接口，满是public是一大特性，
然后在java里，接口更加独立于实现类，对于常量，都static final属于接口且必须赋值，
而在C#里，对于常量，有非静态只读属性，可以只在接口里声明，然后在各个差异的实现类里各自设置只读属性值，
对于方法，两者都可以只界说，也可以在接口里预先实现，并可在实现类中重写
构造器
java的访问修饰符
子类继续之后，父类的私有只是不能访问而已，但是依然存在，
子类不能继续父类的私有成员，意思是子类会开一块地域，父类也开一块地域，两个所处内存位置差异，但由于继续的关系，子类可以调用父类内存地域的方法
父类的数据存储在子类对象的内存中，子类只是不能直接访问父类的 private 成员而已。
这是由于子类对象不但包罗子类本身的成员，还包罗父类的成员——无论是 private、protected 照旧 public 成员，只管 private 成员只能在父类内部访问。
子类只能继续父类的非私有成员
父类中的私有成员和方法不能被子类继续
父类中的私有也不能被子类重写
java的static
在Java中，可以利用类对象来访问静态变量，但现实上这是不保举的
在C#中，静态变量必须通过类名来访问，不能通过对象来访问
c的static相干增补
c中的静态变量是属于界说的函数的，只不外是全局存在的
如果在外部界说，和直接界说的变量差异的是，静态变量只限于本文件内可以用，
- static局部变量：生命周期是整个步调运行期间，但作用域限定在函数内。
- static全局变量：作用域限定在当前源文件，生命周期是整个步调。
- 非static全局变量：可以被整个步调中的其他源文件引用。
假设有两个文件：file1.c 和 file2.c。
- 在 file1.c 中界说一个全局变量。
- 在 file2.c 中利用 extern 关键字来声明该全局变量，如许就可以在 file2.c 中访问和修改 file1.c 中的全局变量。
- 文件1: file1.c
- #include <stdio.h>
- int sharedVariable = 42; // 定义全局变量
- void modifyVariable() {
- sharedVariable++; // 修改全局变量
- printf("In file1.c, sharedVariable = %d\n", sharedVariable);
- }
- ---------------------------------------------------------------------
- 文件2: file2.c
- #include <stdio.h>
- extern int sharedVariable; // 声明 file1.c 中的全局变量
- void printVariable() {
- printf("In file2.c, sharedVariable = %d\n", sharedVariable);
- }
- int main() {
- printVariable(); // 输出 file1.c 中的 sharedVariable 值
- sharedVariable += 10; // 修改该变量
- printVariable(); // 输出修改后的 sharedVariable 值
- return 0;
- }
- 比方，在文件 file1.c 中界说了全局变量 int a;，那么在 file2.c 中，利用 extern 时必须写作 extern int a;，如许才气精确引用到 file1.c 中的变量 a。
- 如果没有利用 static 修饰符，全局变量在同一个步调的差异源文件中不能重名，否则会导致重界说错误。编译器在链接阶段会报错，由于它发现同名的全局变量在差异文件中有多个界说。
- 如果你盼望在差异文件中利用同名的全局变量，就用 static 修饰符将变量的作用域限定在各自的文件内，如许纵然同名变量在差异文件中界说，它们也不会辩说。static 关键字会将变量的作用域限定在界说它的文件中，从而制止辩说。
Java中，类中的成员变量（也称为字段）默认并不是private
访问修饰符的默认活动：
- private: 变量只能在类的内部访问。
- default（没有修饰符）: 变量只能在同一个包内的类中访问。
- protected: 变量可以在同一个包内，大概在其他包中的子类中访问。
- public: 变量可以在任何地方访问。
ASCII 表中
ASCII 表中，巨细写字母并不是细密相连的
大写字母 (A 到 Z) 对应的码值是 65 到 90
中心的 91 到 96
- 91: [
- 92: \
- 93: ]
- 94: ^
- 95: _
- 96: `
小写字母 (a 到 z) 对应的码值是 97 到 122。
java输出
随机数的天生
Math.random天生0到1之间的随机小数
Random r=new Random();//天生一个随机数对象
通过r.nextInt(int整数);天生0到int数之间的随机一个数
注：绝大多数的随机数都是包前不包后
enum
Java 不答应将整数直接赋给 enum 范例变量。你必须利用 enum 范例界说的常量。
也不答应 enum 范例通过整型逼迫转换- Color myColor = Color.RED; // 正确
- // Color myColor = 0; // 编译错误
- Color myColor = (Color)0; // 强制转换
- // Color myColor = 0; // 编译错误
C#和C和C++都可以给罗列赋超出范围的整数值，该罗列变量会记取这个值，
只不外体现的更像一个数而不是罗列
switch
java
C#也一样不能用float，double，long
c和c++本质是把switch当做整数继续器，enum只是别的一种整型的体现方式，以是，c的switch传入的enum要强转回整数，c++固然优化了不消强转回整数继续，但本质上照旧继续整数
而java和c#则是把switch当做范例继续器，传入的范例肯定要和case标签范例类似，差异的是，在enum的传入上，java必须传入enum范例不能用整数强转，而c#支持整数的强转成对应的enum
Java 的 switch 语句支持的范例有：
- byte
- short
- char
- int
- enum（从 Java 5 开始）
- String（从 Java 7 开始）
- var（Java 12 中的加强型 switch 表达式）
C# 中的 switch 语句支持的范例类似于 Java，包罗：
- char
- string
- bool
- enum
- 整型范例（int、byte、short 等）
- C# 7 之后，支持模式匹配（switch 表达式的加强）
在全部语言中，switch 不会自动举行范例转换，范例必须严酷匹配。
都不支持float和double作为case标签的数据范例
c#和java：支持整数、罗列、字符串等范例作为 switch 表达式和 case 标签
c和c++：只支持整数和罗列
罗列范例在C和C++中有所差异。在C语言中，罗列范例（enum）固然本质上是整数，但不能直接用于switch语句中，必须通过逼迫范例转换将罗列值转换为整数范例。- #include <stdio.h>
- enum Color {
- RED, // 默认值为 0
- GREEN, // 默认值为 1
- BLUE // 默认值为 2
- };
- int main() {
- enum Color myColor = 0; // 设置为 0，相当于 RED
- /*在c++中
- Color myColor = GREEN;
- 或者
- Color myColor = static_cast<Color>(0);//设置为RED
- 也可以将整数值 0 直接赋给 enum 类型的变量
- Color mycolor=0;
- */
-
- //c++仅仅是优化了不用强转int的操作，本质上仍与c相同
- switch (1) {//会进入GREEN//这与在c++中相同
- case RED:
- printf("Color is RED\n");
- break;
- case GREEN:
- printf("Color is GREEN\n");
- break;
- case BLUE:
- printf("Color is BLUE\n");
- break;
- default:
- printf("Unknown color\n");
- break;
- }
- return 0;
- }
C, C++, Java, C# 等语言中，按位运算符（&, |, ^）遵照范例提升规则：
- 整数范例提升：如果利用数是小于 int 的范例（如 char, short 等），它们会先提升为 int。
- 如果利用数有差异的宽度（好比一个是 int，另一个是 long），较窄的范例会被提升为较宽的范例。
- 如果一个利用数是有符号范例，另一个是无符号范例，通常会将有符号范例提升为无符号范例（详细规则依赖于语言的实现）。
- 位运算直接利用的是数据的二进制位，以是只能用于整数范例。
都可以举行位运算- int a = 5; // 0101
- int b = 3; // 0011
- int result = a & b; // 0001, result is 1
- int result = a | b; // 0111, result is 7
- int result = a ^ b; // 0110, result is 6
在 C 和 C++ 中，&, |, ^ 只能作为按位运算符，它们对整数的每一位举行利用，不能用于逻辑运算。逻辑运算必须利用 &&（逻辑与）和 ||（逻辑或）。
比力运算符
关系运算符比力，如果双方的范例不一样也会转成最高范例再比力- int a = 5;
- double b = 5.5;
- boolean result = a < b; // a 被提升为 double 进行比较
在 Java 中，差异范例之间举行关系运算时，会遵照自动范例提升的规则：
- 如果一个利用数是 byte, short, char，则它们会先提升为 int 范例。
- 如果一个利用数是 int 而另一个是 long，则 int 会被提升为 long。
- 如果一个利用数是 float 而另一个是 double，则 float 会被提升为 double。
- 数值范例（如 int, long, float, double）会根据双方的最大范例举行提升。
在 C# 中，类似的规则也实用：
- 如果双方范例差异，较小的范例将提升为较大的范例，以举行比力。
- int 会被提升为 long，float 会被提升为 double，等等。
在 C 和 C++ 中，范例提升也是相似的：
- char, short 等会被提升为 int。
- int 会提升为 long、float、double 等更高精度的范例。
- 如果一个利用数是 float，另一个是 double，则 float 会被提升为 double。
+运算符
从前以后算，能相加优先相加，不能相加则拼接
char是可以转成数相加的，在没有拼接需求之前，char都可以看做数去相加
java的Scanner输入
（须要先导包）import java.util.Scanner- Scanner scanner = new Scanner(System.in);
- next(): 读取下一个以空格或换行分隔的字符串。
- nextLine(): 读取一整行输入，直到碰到换行符。
- nextInt(): 读取下一个整数。
- nextDouble(): 读取下一个浮点数。
- hasNext(), hasNextInt(), hasNextDouble(): 用于检测是否有下一个可读取的输入数据。
注意事项：
- 输入不匹配：当用户输入与预期的数据范例不匹配时，大概会抛出 InputMismatchException。比方，调用 nextInt() 时输入了一个字符串。
- 资源管理：在读取输入完成后，发起调用 scanner.close() 关闭 Scanner，防止资源泄漏。
通过创建Scanner类的对象，调用对象的next方法
字面量，字面上的量
一个方法中，该方法名和此中的变量名可以类似
API为什么叫API
API（应用步调接口，Application Programming Interface）
规范化的交互方式
面向对象编程中的接口是你必须实现的，而 API 是你直接利用的。
但两者的相似点在于：它们都提供了一组明白的规则和方法来与其他代码或体系举行交互。- List<String> list = new ArrayList<>();
- list.add("Hello");
一组可以让差异软件组件或体系之间举行交互的界说和协议
提供现成的功能供开辟者利用，不是为了让你去实现，而是为了调用，从而完成特定任务。
API 大概包罗库、函数、类、大概在线服务的调用
自动范例转换
扩展运算符自带强转自身范例（实用多种语言c，c++，c#）- int a = 5;
- double b = 2.5;
- a += b; // a = (int)(a + b)，结果是 7
- a + b 会先转换为 double 范例（由于 double 是更高精度的范例），
- 效果是 7.5，然后由于 a 是 int，终极的效果会被逼迫转换为 int，舍弃小数部门，变为 7。
效果终极肯定会匹配左侧变量的范例
在java中，如果想byte之间相加，不消扩展赋值运算符，赋值给byte时必须强转，由于相加时默认都转为int了，必须转返来否则报错，在c#也类似
Java 和 C#: byte （char范例也一样）范例相加效果会提升为 int，必须显式 逼迫转换回 byte（大概char） - char a = 'A'; // Unicode 65
- char b = 'B'; // Unicode 66
- int sum = a + b; // sum 是 int 类型
- char result = (char) (a + b); // 需要强制转换回 char
C 和 C++
- char 可以作为整数范例：在 C 和 C++ 中，char 现实上是一个整数范例，通常占用 8 位（signed 或 unsigned）。char 范例的变量在算术运算中可以与 int 范例交换，因此可以直接举行算术运算而不须要显式转换。
- char a = 'A'; // ASCII 65
- char b = 'B'; // ASCII 66
- int sum = a + b; // sum 是 int 类型
- char result = a + b; // 结果会被隐式转换为 char，但可能会有溢出
但扩展赋值运算符，这些语言都一样，会末了举行强转
表达式中运算，小范围byte，short，char，优先转为int后，再开始判定运算
纵然是byte+byte也会得到int
double在float之上，而float在long之上
效果取决于整个运算表达式的最高范例，无论次序- int a = 5;
- double b = 2.0;
- double result = a / b; // 结果为 2.5
- C# 和 Java 的自动范例转换大要相似，都能隐式地从较小范围范例转换为较大范围范例。
- C# 支持用户自界说的隐式和显式转换（implicit 和 explicit 关键字），而 Java 不答应用户界说范例转换。
- //隐式转换
- class Celsius
- {
- public double Degrees { get; set; }
- public static implicit operator Celsius(double d)
- {
- return new Celsius { Degrees = d };
- }
- }
- Celsius temp = 36.5; // 隐式转换
- 泛型协变与逆变 是 C# 特有的功能，而 Java 利用通配符来实现类似功能。
- 装箱和拆箱 在两者中都存在，但 Java 的自动装箱/拆箱机制更加轻便。
PATH
- PATH 变量 是利用体系的环境变量之一，包罗了一系列目次路径，利用体系在运行步调时会在这些目次中查找可实行文件。
- 比方，当你在下令行中输入 java 或 javac，利用体系会在 PATH 变量中列出的目次中查找这些下令的可实行文件。
bin
bin 文件夹：Java Development Kit (JDK) 安装目次下的 bin 文件夹包罗了 Java 编译器（javac）、Java 运行时环境（java）等下令行工具。
添加到 PATH：将 bin 文件夹添加到 PATH 变量中，可以让你在任何下令行窗口中直接运行 Java 相干的下令，而不须要每次都导航到 JDK 的安装目次。
验证设置：
- 打开下令提示符（cmd），输入 java -version 和 javac -version，查抄是否能精确输出 Java 版本信息。
更新上下文菜单
上下文菜单 是指在利用体系的文件资源管理器中，右键点击文件或文件夹时弹出的菜单。这个选项的作用是将一些功能（如打开特定文件范例的 IDE）添加到文件的右键菜单中。
- 作用：通过选择"更新上下文菜单"，你可以将 IntelliJ IDEA（或其他工具）集成到利用体系的上下文菜单中。比方，你可以右键点击一个 .java 文件，然后选择“用 IntelliJ IDEA 打开”来快速启动 IDE 并打开该文件。
- 方便性：这使得文件和项目的管理更加便捷，尤其是在处置惩罚多个文件时。
创建关联
文件关联 指的是将特定文件范例与一个步调关联，使得在打开该文件时，利用体系会默认利用这个步调。
- 作用：选择"创建关联"可以将 IntelliJ IDEA 设置为打开特定范例文件的默认应用。比方，你可以将 .java、.xml 或 .html 文件与 IntelliJ IDEA 关联，如许双击这些文件时会自动用 IntelliJ IDEA 打开。
- 方便性：这种关联使得文件打开变得更加高效，无需每次都手动选择步调来打开文件。
更新上下文菜单：将 IDE 或其他工具添加到文件资源管理器的右键菜单中，方便快速打开文件。
创建关联：将特定范例的文件与 IDE 关联，使得打开这些文件时自动利用 IDE。
|
发表于 2026-1-15 02:56:04