1.java基本语法

JAVA基本语法

〇、HelloWorld

1. 输出HelloWorld

创建.java结尾的文件
每个文件由类构成

类中有一个main方法，代表程序的入口

public class Main {
  public static void main(String[] args) {
    System.out.println("Hello World");
  }
}

2. 基本概念和运行原理

JDK：开发Java应用的工具包

JDK => 包含编译工具JAVAC、运行环境JRE、其他工具
JAVAC => 将.java文件编译成字节码文件.class
JRE => JRE中的JVM会将字节码文件转换为不同设备上的机器码运行 => 可以跨平台运行的原因

一、数据类型

1. 基本数据类型

包括 byte、short、int、long、float、double、boolean 和 char 8种

int myNum = 5;               // 整数
float myFloatNum = 5.99f;    // 浮点数
char myLetter = 'D';         // 字符
boolean myBool = true;       // 布尔值

数据类型	大小	描述
`byte`	1 字节	存储从 -128 到 127 的整数。
`short`	2 字节	存储从 -32,768 到 32,767 的整数。
`int`	4 字节	存储从 -2,147,483,648 到 2,147,483,647 的整数。
`long`	8 字节	存储从 -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807 的整数。
`float`	4 字节	存储小数。足以存储 6 到 7 位十进制数字。
`double`	8 字节	存储小数。足以存储 15 位十进制数字。
`boolean`	不确定	存储 true 值或 false 值。
`char`	2 字节	存储单个字符/字母或 ASCII 值

2. 引用数据类型

包括字符串、数组、类等

3. 包装类型

包装类型是 Java 中的一种特殊类型，用于将基本数据类型转换为对应的对象类型。

包装类型提供了许多实用的方法

// 3. 包装类型
Integer integerValue1 = new Integer(11);
Integer integerValue2 = Integer.valueOf(22);
Integer integerValue3 = 33;
System.out.println("integerValue1 = " + integerValue1);
System.out.println("integerValue2 = " + integerValue2);
System.out.println("integerValue3 = " + integerValue3);

// 将字符串转换为整数
String numberString = "123";
int parsedNumber = Integer.parseInt(numberString);
System.out.println("parsedNumber = " + parsedNumber);

// 数字比较
Integer a = 10;
Integer b = 20;
System.out.println(a.equals(b)); // 输出 false

对应基本数据类型的8种包装类型：
- Byte（对应 byte）
- Short（对应 short）
- Integer（对应 int）
- Long（对应 long）
- Float（对应 float）
- Double（对应 double）
- Character（对应 char）
- Boolean（对应 boolean）

4. 类型转换

放大转换（自动） - 将较小的类型转换为较大的类型
byte -> short -> char -> int -> long -> float -> double

// 4. 类型转换
// 4.1自动转换，小类型到大类型
int myInt = 3;
float myFloat1 = myInt; 	// 自动转为 float
char myChar = 'A';
myInt = myChar;
float myFloat2 = myChar;

System.out.println("myFloat = " + myFloat1);    // 输出 3.0,float类型
System.out.println("myInt = " + myInt);
System.out.println("myFloat2 = " + myFloat2);

float myFloat3 = 1.5f;
double myDouble = 1.2;
int num1 = 1;
int num2 = 2;
double res = myFloat3 * num1 + myDouble * num2;
System.out.println(res); // double类型

缩小转换（手动） - 将较大的类型转换为较小的类型
double -> float -> long -> int -> char -> short -> byte

// 3.2手动转换，大类型到小类型
int myInt2 = 50;
float myFloat4 = 2.1f;
char myChar2 = (char) myInt2;

// myInt2 = (int) myInt * myFloat4;  -> 错误写法,只是强转了后面的当个变量或表达式
myInt2 = (int) (myInt2 * myFloat4);

System.out.println("myChar2 = " + myChar2);		// 输出2(2对应的ACSII码为)
System.out.println("myInt2 = " + myInt2);      // 输出 9

踩坑点
```
int a = 1500000000, b = 1500000000;
int res1 = a + b;  // -1294967296
long res2 = a + b;	// -1294967296
long res3 = (long)a + b;	// 3000000000
long res4 = (long)(a + b);	// -1294967296
```
res1: 由于超出了int可存储的范围，溢出；

res2: 尽管隐式转换前已经溢出

res2: a被强转成long，此时再与b相加，b会隐式自动转为long，就不会溢出

res4: 同res2，再加法完成后已经溢出，再隐式转换还是强制转换都不管用了

三、基本语法

运算、循环、分支同大多数语言

四、字符串

String S = "Hello";

Java 中的字符串实际上是对象，拥有可对字符串执行操作的方法。例如，可以用 length() 方法确定字符串的长度：

1. 字符串方法

System.out.println("===== 获取字符串信息 =====");
// 1. length(): 获取字符串长度
String str = "Hello, Java!";
int length = str.length();
System.out.println("字符串长度: " + length); // 输出: 12

// 2. charAt(int index): 获取指定索引处的字符
char ch = str.charAt(7);
System.out.println("索引 7 处的字符: " + ch); // 输出: J

// 3. indexOf(String str) 和 lastIndexOf(String str): 查找子字符串的位置
int firstIndex = str.indexOf("Java");
int lastIndex = str.lastIndexOf("Java");
System.out.println("第一次出现 'Java' 的位置: " + firstIndex); // 输出: 7
System.out.println("最后一次出现 'Java' 的位置: " + lastIndex); // 输出: 7


// ======================== 字符串比较 ========================
System.out.println("\n===== 字符串比较 =====");

// 4. equals() 和 equalsIgnoreCase(): 比较字符串内容
String str1 = "Java";
String str2 = "java";
boolean isEqual = str1.equals(str2);
boolean isEqualIgnoreCase = str1.equalsIgnoreCase(str2);
System.out.println("区分大小写比较: " + isEqual);           // 输出: false
System.out.println("忽略大小写比较: " + isEqualIgnoreCase); // 输出: true


// ======================== 字符串修改 ========================
System.out.println("\n===== 字符串修改 =====");

// 6. toLowerCase() 和 toUpperCase(): 大小写转换
String mixedCase = "Hello, World!";
String lowerCase = mixedCase.toLowerCase();
String upperCase = mixedCase.toUpperCase();
System.out.println("小写: " + lowerCase); // 输出: hello, world!
System.out.println("大写: " + upperCase); // 输出: HELLO, WORLD!

// 7. trim(): 去除首尾空白字符
String withSpaces = "   Hello, Java!   ";
String trimmed = withSpaces.trim();
System.out.println("去除空格后: '" + trimmed + "'"); // 输出: 'Hello, Java!'

// 8. replace(char oldChar, char newChar) 和 replace(CharSequence target, CharSequence replacement): 替换字符或子字符串
String original = "Hello, Java!";
String replacedChar = original.replace('J', 'L');
String replacedString = original.replace("Java", "Python");
System.out.println("替换字符: " + replacedChar);         // 输出: Hello, Lava!
System.out.println("替换子字符串: " + replacedString);   // 输出: Hello, Python!


// ======================== 字符串分割与拼接 ========================
System.out.println("\n===== 字符串分割与拼接 =====");

// 9. split(String regex): 按正则表达式分割字符串
String fruits = "apple,banana,cherry";
String[] parts = fruits.split(",");
System.out.print("分割后的字符串数组: ");
for (String part : parts) {
    System.out.print(part + " "); // 输出: apple banana cherry
}
System.out.println();

// 10. join(CharSequence delimiter, CharSequence... elements): 拼接字符串
String joined = String.join("-", "2023", "10", "05");
System.out.println("拼接后的字符串: " + joined); // 输出: 2023-10-05


// ======================== 字符串判断 ========================
System.out.println("\n===== 字符串判断 =====");

// 11. startsWith(String prefix) 和 endsWith(String suffix): 判断字符串是否以指定前缀或后缀开头/结尾
String sentence = "Hello, Java!";
boolean startsWithHello = sentence.startsWith("Hello");
boolean endsWithJava = sentence.endsWith("Java!");
System.out.println("以 'Hello' 开头: " + startsWithHello); // 输出: true
System.out.println("以 'Java!' 结尾: " + endsWithJava);     // 输出: true

// 12. isEmpty() 判断字符串是否为空或空白
String emptyString = "";
boolean isEmpty = emptyString.isEmpty();
System.out.println("是否为空字符串: " + isEmpty); // 输出: true


// ======================== 字符串提取 ========================
System.out.println("\n===== 字符串提取 =====");
// 13. substring(int beginIndex, int endIndex): 提取子字符串
String text = "Hello, Java!";
String subText = text.substring(7, 11);
System.out.println("提取的子字符串: " + subText); // 输出: Java

2. 字符串拼接

String firstName = "Bi";
String lastName = "ouwai";
System.out.println(firstName + lastName);
System.out.println(firstName.concat(lastName));

// 与数字拼接
int x = 10;
int y = 20;
int z = x + y;      // z 将是 30（整数/数字）

String x = "10";
String y = "20";
String z = x + y;   // z 将是 1020（字符串）

3. 特殊字符

因为字符串必须写在引号内，Java 会误解包含引号的字符串，并产生错误：

String txt = "abc"d"e.";

反斜杠 (\) 转义字符将特殊字符转换为字符串字符：

转义字符	结果
'	'
"	"
\	\
\n	新行
\r	回车
\t	制表符
\b	退格

五、数组

存储固定大小的相同类型元素 的数据结构

1. 基本特点

固定大小 ：一旦创建，数组的大小不能改变。
同类型元素 ：数组中的所有元素必须是相同的类型。
连续内存 ：数组在内存中是连续存储的，因此可以通过索引快速访问元素。
零基索引 ：数组的第一个元素的索引是0，最后一个元素的索引是length - 1，访问数组时超出索引会报错。

2. 声明与初始化

// 数组基本概念
// 1. 声明并静态初始化一个数组
int[] numbers = {10, 20, 30, 40, 50};
System.out.println("初始化的数组:");
printArray(numbers);

// 2. 访问数组元素
System.out.println("\n访问数组元素:");
System.out.println("numbers[0]: " + numbers[0]);  // 输出第一个元素
System.out.println("numbers[2]: " + numbers[2]);  // 输出第三个元素

// 3. 修改数组元素
numbers[1] = 25;  // 修改第二个元素
System.out.println("\n修改后的数组:");
printArray(numbers);

// 4. 获取数组长度
System.out.println("\n数组的长度: " + numbers.length);

// 5. 遍历数组
System.out.println("\n遍历数组:");
for (int i = 0; i < numbers.length; i++) {
    System.out.println("Element at index " + i + ": " + numbers[i]);
}

// 6. 使用增强型for循环遍历数组
System.out.println("\n使用增强型for循环遍历数组:");
for (int num : numbers) {
    System.out.println(num);
}

// 7. 多维数组的静态初始化
int[][] matrix = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
};
System.out.println("\n二维数组matrix:");
for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        System.out.print(matrix[i][j] + " ");
    }
    System.out.println();
}

// 打印一维数组的方法
public static void printArray(int[] arr) {
    for (int num : arr) {
        System.out.print(num + " ");
    }
    System.out.println();
}

3. 数组常用方法

// 数组常用方法
// 1. 排序数组 (Arrays.sort)
Arrays.sort(numbers);  // 对数组进行升序排序
System.out.println("\n排序后的数组:");
printArray(numbers);

// 2. 复制数组 (Arrays.copyOf)
int[] copiedArray = Arrays.copyOf(numbers, numbers.length);
System.out.println("\n复制后的数组:");
printArray(copiedArray);

// 3. 填充数组 (Arrays.fill)
Arrays.fill(copiedArray, 10);  // 将数组的所有元素设置为10
System.out.println("\n填充后的数组:");
printArray(copiedArray);

// 4. 查找元素 (Arrays.binarySearch)
// 注意：使用binarySearch前需要确保数组已排序
int searchKey = 3;
int index = Arrays.binarySearch(numbers, searchKey);
if (index >= 0) {
    System.out.println("\n元素 " + searchKey + " 在数组中的索引位置是: " + index);
} else {
    System.out.println("\n元素 " + searchKey + " 不在数组中");
}

// 5. 比较数组 (Arrays.equals)
int[] array1 = {1, 2, 3};
int[] array2 = {1, 2, 3};
boolean isEqual = Arrays.equals(array1, array2);  // 比较两个数组是否相等
System.out.println("\narray1 和 array2 是否相等: " + isEqual);

// 6 转换数组为字符串 (Arrays.toString)
System.out.println("\n将数组转换为字符串:");
System.out.println(Arrays.toString(numbers));

// 7. 多维数组的操作 (Arrays.deepToString)
System.out.println("\n二维数组matrix:");
System.out.println(Arrays.toString(matrix));
System.out.println(Arrays.deepToString(matrix));  // 使用deepToString打印多维数组

// 打印一维数组的方法
public static void printArray(int[] arr) {
    for (int num : arr) {
        System.out.print(num + " ");
    }
    System.out.println();
}

posted @ 2025-12-15 14:59 Godjian 阅读(7) 评论(0) 收藏举报

刷新页面返回顶部

Godjian

欲望以提升热枕，毅力以磨平高山！