代码收藏家 【Java 学习】字符串、数组、方法、函数重载
目录
1. 字符串
1.1 String 类
String 类并不是数组，但它有一些与数组相似的特性。String 是一个不可变的字符序列，内部使用字符数组来存储数据。
基本概念：
不可变性：String 对象是不可变的，这意味着一旦创建了一个 String 对象，其内容就不能被修改。每次对 String 进行修改操作时，都会创建一个新的 String 对象。
//创建一个字符串
String str = "Hello";
//str是不可变的，但是 str+ "World" 拼接后
// 会生成一个新的字符串对象，并用str接收
//误认为str是可变的
str += "World";
System.out.println(str);
存储方式：String 对象在内存中的存储方式是通过一个字符数组实现的，通常是一个 char[] 数组。
1.2 String 类的使用
//创建字符串对象
String str1 = "Hello";
String str2 = "World";
//字符串拼接
String str3 = str1 + str2;
//字符串比较
boolean b = str1.equals(str2);
//字符串长度
int len = str1.length();
//字符串转大写
String str4 = str1.toUpperCase();
//字符串转小写
String str5 = str1.toLowerCase();
//字符串截取，返回的是从1到3的字符串
String str6 = str1.substring(1,3);
//查找字符串，返回的是第一个l的位置
int index = str1.indexOf("llo");
// 获取字符串中指定位置的字符
char ch = str1.charAt(1);
//字符串替换
String str7 = str1.replace("H","h");
//字符串分割
String[] str8 = str1.split("l");
//字符串格式化
String str9 = String.format("我的名字叫%s，今年%d岁。", "小明", 18);
2. 数组
1.1 数组的介绍
数组是一种线性数据结构，用于存储固定数量的相同类型的数据。数组中的每个元素都有一个索引（从 0 开始），可以通过索引来访问和修改数组中的元素。
1.2 静态数组
1.2.1 一维数组
静态初始化：在声明数组时同时赋值。
//声明一个长度为5的整数数组
int[] arr = { 1, 2, 3, 4, 5};
//修改数组的元素
arr[0] = 100;
//声明一个长度为5的字符串数组
String[] s = {"李明", "李华", "李红", "李蓝", "李绿"};
//修改数组的元素
s[0] = "小明";
动态初始化：在声明数组时指定数组的大小，但不立即赋值。
//声明一个长度为5的整数数组
int[] arr = new int[5];
Random r = new Random();
//赋值
for(int i=0; i<5; i++){
arr[i] = r.nextInt(100);
}
//打印内存地址表示形式
System.out.println(arr);
//遍历数组
for(int i = 0; i<5; i++){
System.out.println(arr[i]);
}
//修改数组的元素并遍历
for(int i = 0; i<5; i++){
arr[i] += 100;
System.out.println(arr[i]);
}
//声明一个长度为5的字符串数组
String[] s = new String[5];
//给数组的元素赋值
1.2.1 多维数组
静态初始化二维数组
//静态初始化二维数组,3行3列
int[][] arr = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
//遍历
for(int i=0; i<3; i++ ){
for(int j=0; j<3; j++){
//=打印第i+1行的第j+1列的值
System.out.print(arr[i][j] + " ");
}
System.out.println("");//换行
}
动态初始化二维数组
//创建Random对象
Random r = new Random();
//动态初始化3行3列的二维数组
int[][] arr = new int[3][3];
//赋值
for(int i=0; i<3; i++){
for(int j=0; j<3; j++){
//给i+1行且j+1列的元素赋值
arr[i][j] = r.nextInt(100);
}
}
//遍历
for(int i=0; i<3; i++ ){
for(int j=0; j<3; j++){
//=打印第i+1行的第j+1列的值
System.out.print(arr[i][j] + " ");
}
System.out.println("");//换行
}
// 修改并遍历
for(int i=0; i<3; i++ ){
for(int j=0; j<3; j++){
//修改i+1行和j+1行的值
arr[i][j] +=100;
//打印第i+1行的第j+1列的值
System.out.print(arr[i][j] + " ");
}
System.out.println("");//换行
}
1.3 动态数组
动态数组是一种能够在运行时调整其大小的数据结构。与固定大小的数组不同，动态数组可以在需要时增加或减少其容量。在 Java 中，虽然没有内置的动态数组类型，但可以使用 ArrayList 类来实现类似的功能。
示例：
import java.util.ArrayList;
public class Test {
public static void main(String[] args) {
// 创建一个 ArrayList 实例
ArrayList<Integer> list = new ArrayList<>();
// 添加元素
list.add(10);
list.add(20);
list.add(30);
// 打印当前列表
System.out.println("Initial list: " + list);
// 添加更多元素
list.add(40);
list.add(50);
// 打印添加更多元素后的列表
System.out.println("After adding more elements: " + list);
// 访问元素
int thirdElement = list.get(2);
System.out.println("Third element: " + thirdElement);
// 修改元素
list.set(2, 35);
System.out.println("After modifying the third element: " + list);
// 删除元素
list.remove(1); // 删除第二个元素
System.out.println("After removing the second element: " + list);
// 获取列表大小
int size = list.size();
System.out.println("Size of the list: " + size);
// 遍历列表
System.out.println("Iterating over the list:");
for (int num : list) {
System.out.println(num);
}
}
}
3. 方法（函数）
3.1 引入方法
场景：打印两个数之间的所有整数。
思考：打印两个数之间的所有的数需要用while 或 for 循环的，还要判断两个数哪个更小，从最小的数开始到最大的数终止。
实现：
// 打印 1-6
int start1 = 1;
int end1 = 6;
//假设end最大
if(end1 < start1){
int tmp = end1;
end1 = start1;
start1 = tmp;
}
//进行遍历
while(start1 <= end1){
System.out.print(start1 + " ");
start1++;
}
// 打印 10-16
int start2 = 10;
int end2 = 16;
//假设end最大
if(end2 < start2){
int tmp = end2;
end2 = start2;
start2 = tmp;
}
//进行遍历
while(start2 <= end2){
System.out.print(start2 + " ");
start2++;
}
//等等
// ·················
如果我们打印很多的区间数就需要写很多的重复代码，这样会显得写的代码很多，效率很低。
有没有一种便捷方法来提高打印区间数呢？
答：有，把打印区间数的代码包装起来，把它比作一个工具，想用的时候直接拿来用，这种包装这些代码后的工具就叫做方法，或则叫做函数。
3.2 使用无返回值的方法
在Java中，方法和函数是同一个概念，都是用来执行特定任务的代码块。方法可以有参数和返回值。
把上述的代码块包装起来：
public static void Fun_1(int start, int end){
// 假设end最大
if(end < start ){
int tmp = end;
end = start;
start = end;
}
// 遍历数
while(start <= end){
System.out.print(start + " ");
start++;
}
我们怎么用呢？直接调用函数的名字，输入数值：
// 遍历1-6
Fun_1(1,6);
//遍历10-16
Fun_1(10,6);
图解：
3.3 使用有回值的方法
假如你要使用一个计算圆面积方法，是不要得到计算的结果，这时方法需要在计算结果后返回一个数值。
示例：
// 主函数main
public static void main(String[] args){
//计算圆的面积，调用函数S
double s = S(5);
System.out.print("圆的面积：" + s);
}
// 计算圆的面积
public static double S(double r){
double s = 3.14 * r * r;
//返回圆的面积
return s;
}
4. 方法重载
4.1 为什么要有方法重载？
场景：假如你要两个数的相加，你需要写这些方法：
- 整数 + 整数
- 浮点数 + 浮点数
- 整数 + 浮点数
- 浮点数 + 整数
示例：
//整数 + 整数
public static int Add1(int a, int b){
return a + b;
}
//浮点数 + 浮点数
public static double Add2(double a, double b){
return a + b;
}
//浮点数 + 整数
public static double Add3(double a, int b){
return a + b;
}
//整数 + 浮点数
public static double Add4(int a, double b){
return a + b;
}
这些函数虽是好写，但是，用的时候你能准确的使用方法名子吗？
所以，方法重载解决了这个问题，可以让相同功能的函数使用同一个方法名。
4.2 方法重载的规则
方法重载（Method Overloading）是 Java 中的一种特性，允许在同一个类中定义多个同名的方法，但这些方法的参数列表必须不同。方法重载可以提高代码的可读性和复用性。下面通过几个示例来详细解释如何使用方法重载。
方法重载的规则：
4.3 示例
public static void main(String[] args){
int a = 10;
double b = 6.6;
// 整数+整数
int sum1 = Add(a,a);
// 浮点数 + 浮点数
double sum2 = Add(b,b);
// 整数 + 浮点数
double sum3 = Add(a,b);
// 浮点数 + 整数
double sum4 = Add(b,a);
}
//整数 + 整数
public static int Add(int a, int b){
return a + b;
}
//浮点数 + 浮点数
public static double Add(double a, double b){
return a + b;
}
//浮点数 + 整数
public static double Add(double a, int b){
return a + b;
}
//整数 + 浮点数
public static double Add(int a, double b){
return a + b;
}
5. main 方法
main 方法是Java应用程序的入口点。当运行这个程序时，JVM（Java虚拟机）会寻找这个方法并从这里开始执行程序。
public 表示这个方法可以被任何其他类访问。static 关键字意味着这个方法属于类本身而不是类的实例。因此，即使没有创建类的实例，也可以调用这个方法。void 表示这个方法不会返回任何值。String[] args 是一个字符串数组参数，用于接收命令行参数。当通过命令行运行Java程序时，用户可以在命令行中提供参数，这些参数会被传递给 main 方法的 args 参数。作者：Code哈哈笑
