菜鸟学JAVA之——方法的定义和使用及部分String方法

方法（把相同相似的过程包裹起来）

格式：
访问控制 [static] 返回值类型 方法名 ( 参数列表 ) {
方法体
[return[返回值];]
}

public static int[] sort(int[] args){

//方法体
return args;

}

引入
假设现在需要给两个数组进行排序

import java.util.*;
public class Sort{
    public static void main(String[] args){
        int[] arrays1 = {55,78,33,26,42,99,102,50,4};
        int[] arrays2 = {5,8,3,44,56,22,10,123,222,32}; 
        //arrays1排序
        for(int i = 0; i < arrays1.length; i++){
            for(int j = i; j > 0;j--){
                if(arrays1[j] < arrays1[j-1]){
                    int temp = arrays1[j];
                    arrays1[j] = arrays1[j-1];
                    arrays1[j-1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arrays1));
         //arrays1排序
        for(int i = 0; i < arrays2.length; i++){
            for(int j = i; j > 0;j--){
                if(arrays2[j] < arrays2[j-1]){
                    int temp = arrays2[j];
                    arrays2[j] = arrays2[j-1];
                    arrays2[j-1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arrays2)); 
    }
}

那么问题来了，如果需要给100个数组排序，还需要写100遍排序算法吗？
这时发现每个排序大致都是一样的，有变化的只是数组的名称
所以将公共方法提取出来，打包成方法，这里就引入了方法

代码实现

import java.util.*;
public class Sort{//类名：大驼峰命名法
    public static void main(String[] args){
        int[] arrays1 = {55,78,33,26,42,99,102,50,4};
        int[] arrays2 = {5,8,3,44,56,22,10,123,222,32}; 
      	arrays1 = sort(arrays1); //调用sort方法给arrays1排序
        arrays2 = sort(arrays2); //调用sort方法给arrays2排序
        System.out.println(Arrays.toString(arrays1));               				System.out.println(Arrays.toString(arrays2));
    }
    //注意：方法不能声明在方法体中！
     public static int[] sort(int[] arr){ //方法名：小驼峰命名法
         for(int i = 0; i < arr.length; i++){
            for(int j = i; j > 0;j--){
                if(arr[j] < arr[j-1]){
                    int temp = arr[j];
                    arr[j] = arr[j-1];
                    arr[j-1] = temp;
                }
            }
        }
        return arr;
     }
}

这时，如果需要给100个数组排序只需调用100次sort()方法即可，这就大大降低了代码的冗余度。

String(部分关于String的知识，后续会补充完善)

String不是关键字，是一个类
数组定义了长度不能变，但是内容可以替换，但是字符串定义了内容就不能变

String  str = "zhangaoqi";
str = str + "3";   //此处的str并没有变，它只是更换了内存地址，改变了引用

//replace() 替换字符串
 str = str.replace("z","c");  //把z换成c
							//虽然输出str为changaoqi,但是这里的字符串还是没有变，只是新换了内存
str.replace("z","c");  //如果注释掉上行代码，然后再输出str，则输出的结果还是zhangaoqi ，因为str根本就没变

//split() 分割字符串
String[] s = str.split("");//不传关键字，按一个字符一个字符分割，传了关键字，按关键字分割
                           //输出s为[z,h,a,n,g,a,o,q,i]
String[] s = str.split("ao");//输出结果为[zhang,qi]
//toUpperCase()  将小写字母转为大写
System.out.println(str.toUpperCase()); //输出：ZHANGAOQI
//equalsIgnoreCase()  不区分大小写比较字符串
System.out.println(str.equalsIgnoreCase("ZhangAoQi")); //输出true;
//字符串也是一个容器，也可以定位，求长，替换（替换不可以在原地址上替换）
//定位
System.out.println(str.charAt(3));  //（知道位置求内容）,输出n
System.out.println(str.indexOf("h"));//（知道内容求角标），输出1
//如果需要知道第二个a的位置在哪，但是字符串中有两个a，则需要这样实现
str.indexOf("a",str.indexOf("a")+1);  //输出为5
//求长
str.length();

为什么字符串一旦定义就不可再改变了?
从String类的源码可以看出，Java中String类其实就是对字符数组的封装。value是String类封装的char型数组，且value声明是final的， 也就是说在String类内部，一旦value初始化了， 是不能被改变的。所以可以认为String对象是不可变的了。
String对象内容的改变实际上是通过内存地址“断开-连接”变化来完成的，改变了内容其实就是换了新的内存空间，而原字符串中的内容并没有任何的改变。