Java方法与数组

方法概述与定义

就是一个小功能，把一段代码存起来，以后可以重复使用。

public static void BNTang(){
    System.out.println("BNTang");
}

🐪方法注意点

方法必须声明到类（class）当中。

public class Test {
    
    public static void BNTang(){
        System.out.println("BNTang");
    }
    
    public static void main(String[] args) {

    }
}

创建的方法要定义在其它方法之外（跟其它的方法是兄弟关系）

public class Test {
    
    public static void BNTang(){
        System.out.println("BNTang");
    }
    
    public static void main(String[] args) {

    }
}

定义方法不分先后顺序。

public class Test {
    public static void main(String[] args) {

    }
    
    public static void BNTang(){
        System.out.println("BNTang");
    }
}

如果一个方法前面有 static，那么在该方法当中调用其它的方法前面也应该有 static。

public class Test {

    public static void BNTang(){
        System.out.println("BNTang");
    }

    public static void main(String[] args) {
        BNTang();
    }
}

一个类当中可以写多个方法。

public class Test {

    public static void BNTang(){
        System.out.println("BNTang");
    }

    public static void main(String[] args) {
        BNTang();
        JonathanTang();
    }

    public static void JonathanTang(){
        System.out.println("JonathanTang");
    }

}

两个方法的名称不能相同。

public class Test {

    public static void BNTang(){
        System.out.println("BNTang");
    }

    public static void main(String[] args) {
        BNTang();
        
        // 错误的因为存在了多个BNTang同名的方法
        BNTang();
    }

    public static void BNTang(){
        System.out.println("BNTang");
    }

}

方法必须得要先定义，再执行，再使用。

public class Test {
    public static void main(String[] args) {
        BNTang();// 方法没有定义
    }
}

🐤方法的完整形式

[修饰符] 返回值类型 方法名（[形式参数...]）{
    方法体（要重复使用的代码）
[return 值]

public static String BNTang(String str){
    System.out.println(str);
    return str;
}

🍮方法的返回值

在方法中声明的变量，只在方法当中有效，出了方法，就没有效果，外界的名称也不会影响里面。

return 后面是什么类型，那么定义返回值时，就要定义什么类型。

定义了有返回值，接不接收返回值都可以。

public class Test {
    public static int sum(int a, int b) {
        int res = a + b;
        return res;
    }

    public static void main(String[] args) {
        sum(10, 20);
    }
}

🐤驼峰命名法

第一个字母小写，后面的每一个单词首字母大写。

public static String stringConcat(String str1, String str2) {
    String res = str1 + str2;
    return res;
}

方法重载

在同一个类中，允许方法名称相同，但是方法的参数必须不同。

方法的重载解决了，功能相同，参数不同，就不需要定义多个方法名称了。

🐤方法重载的规则

方法名称必须相同。

参数列表必须不同。

方法的返回类型可以相同也可以不相同。

仅仅返回类型不同不足以称为方法的重载。

public static int sum(int a, int b){
    return a + b;
}

public static double sum(double a, double b){
    return a + b;
}

数组

它是把相同的数据类型有序的组成在一起，我们称这样的集合为数组。

相同的数据类型。

有序的组成在一起。

🐤数组的定义格式

数据类型[] 数组的名称 = new 要存放的数据类型[]{存放指定数据类型的内容};

int[] arrs = new int[]{10, 20, 30};

数组：帮我们存放相同类型的东西。

存放的东西必须得是相同的数据类型。

存放的东西都是有序的，可以通过角标来获取存的内容。

public class Test {
    public static void main(String[] args) {
        int[] arr = new int[]{10, 20, 30};
        System.out.println(arr[0]);
    }
}

数组的初始化

🐤静态初始化

在创建数组时，就已经确定了有多少个元素。

并且把元素都放到了数组当中。

public class Test {
    public static void main(String[] args) {
        String[] str = new String[]{"BNTang"};
        System.out.println(str[0]);
        
        // 直接打印数组，打印的是数组的内存地址
        System.out.println(str);
    }
}

🐸动态初始化

一开始不知道要存多少个数据，所以先定义一个指定的空间大小。

public class Test {
    public static void main(String[] args) {
        String[] allPerson = new String[100];
        allPerson[0] = "BNTang";
        
        // ArrayIndexOutOfBoundsException: 数组索引越界异常(数组越界)
        System.out.println(allPerson[101]);
    }
}

数组长度

获取数组元素的个数, 数组名称.length。

public class Test {
    public static void main(String[] args) {
        String[] person = new String[]{"BNTang"};
        System.out.println(person.length);
    }
}

取出数组当中每一个元素, 称之为数组的遍历。

public class Test {
    public static void main(String[] args) {
        String[] persons = new String[]{"BNTang", "JonathanTang"};
        for (int i = 0; i < persons.length; i++) {
            System.out.println(persons[i]);
        }
    }
}

手写 Arrays.toString 内部的实现原理

public class Test {
    public static void main(String[] args) {
        printArray(new String[]{"BNTang","JonathanTang"});
    }

    public static void printArray(String[] array) {
        String res = "[";
        for (int i = 0; i < array.length; i++) {
            res = res + array[i];
            if (i == array.length - 1) {
                break;
            }
            res = res + ",";
        }
        res = res + "]";
        System.out.println(res);
    }
}

🐤Java 内部提供的方式打印, 内部提供的方法 Arrays.toString

public class Test {
    public static void main(String[] args) {
        System.out.println(Arrays.toString(new String[]{"BNTang", "JonathanTang"}));
    }
}

倒序打印数组

public class Test {
    public static void main(String[] args) {
        printArray(new String[]{"BNTang", "JonathanTang"});
    }

    public static void printArray(String[] array) {
        String res = "[";
        for (int i = array.length - 1; i >= 0; i--) {
            res = res + array[i];
            if (i == 0) {
                break;
            }
            res = res + ",";
        }
        res = res + "]";
        System.out.println(res);
    }
}

数组元素交换

public class Test {
    public static void main(String[] args) {
        printArray();
    }

    public static void printArray() {
        int[] arr = {11, 22};
        System.out.println(Arrays.toString(arr));

        int temp = arr[1];
        arr[1] = arr[0];
        arr[0] = temp;

        System.out.println(Arrays.toString(arr));
    }
}

排序算法

冒泡排序

演示地址：http://www.jsons.cn/sort/

从头开始比较每一对象元素, 如果第1个比第2个大就交换他们的位置。

执行完一轮后, 最大的元素在最后。

public class Test {
    public static void main(String[] args) {
        int arr[] = {7, 9, 4, 3, 6};
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < arr[i - 1]) {
                int temp = arr[i];
                arr[i] = arr[i - 1];
                arr[i - 1] = temp;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

当执行完一轮后, 最大的元素, 在后面。

还要继续执行和第1轮相同的操作, 索引的最大值要-1。

public class Test {
    public static void main(String[] args) {
        int arr[] = {7, 9, 4, 3, 6};
        for (int i = arr.length; i > 0; i--) {
            for (int j = 1; j < i; j++) {
                if (arr[j] < arr[j - 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

选择排序

从序列中找出最小的元素，然后与第一个元素进行交换。

执行完一轮后，第一个元素就是最小的。

每交换一次最小的值，位置向后移动一个。

public class Demo {
    public static void main(String[] args) {
        int[] arr = {5, 8, 3, 4, 7};
        for (int start = 0; start < arr.length; start++) {
            int minIndex = start;
            for (int next = start + 1; next <= arr.length - 1; next++) {
                if (arr[next] < arr[minIndex]) {
                    minIndex = next;
                }
            }
            int temp = arr[start];
            arr[start] = arr[minIndex];
            arr[minIndex] = temp;
        }
        System.out.println(Arrays.toString(arr));
    }
}

二分查找算法

二分查找（binary search）又叫 折半查找，它是一种在有序数组中查找某一特定元素的搜索算法。

🐤二分查找必要条件

必须为顺序存储结构。

必须按关键字大小有序排列。

原理

将有序数组分为三个部分

中间值前（中间值数之前的一组数据）

中间值

中间值后（中间值之后的一组数据）

将要查找的数与中间值数相比较

等于则退出查找。

小于则在中间值前进行比较。

大于在中间值后进行比较，依次循环操作，直至查找到对应的值为止。

当要查找数据结构为偶数时，中间值 mid 应向下取整处理。

代码实现

public static int binarySearch(int[] nums, int target) {
    int low = 0;
    int high = nums.length - 1;
    if (low > high || target > nums[high] || target < nums[low]) {
        return -1;
    }
    while (low <= high) {
        int mid = (high + low) / 2;
        if (nums[mid] == target)
            return mid;
        else if (nums[mid] < target)
            low = mid + 1;
        else if (nums[mid] > target)
            high = mid - 1;
    }
    return -1;
}

二维数组

在数组当中存放的每一个元素又是一个数组。

public class Demo {
    public static void main(String[] args) {
        int[] classAge1 = {18, 19, 20, 17};
        int[] classAge2 = {18, 19, 20};
        int[] classAge3 = {18, 19};
        int[][] allClassAges = new int[][]{classAge1, classAge2, classAge3};
    }
}

二维数组遍历。

public class Demo {
    public static void main(String[] args) {
        int[] classAge1 = {18, 19, 20, 17};
        int[] classAge2 = {18, 19, 20};
        int[] classAge3 = {18, 19};
        int[][] allClassAges = new int[][]{classAge1, classAge2, classAge3};
        for (int i = 0; i < allClassAges.length; i++) {
            int[] array = allClassAges[i];
            for (int j = 0; j < array.length; j++) {
                System.out.println(array[j]);
            }
        }
    }
}

快速遍历

普通遍历。

public class Demo {
    public static void main(String[] args) {
        int[] ages = {10, 20, 30};
        for (int i = 0; i < ages.length; i++) {
            System.out.println(ages[i]);
        }
    }
}

快速遍历(foreach)，是一个语法糖。

语法：for (数组类型遍历出来的元素 : 数组的名称)

public class Demo {
    public static void main(String[] args) {
        String[] names = {"zs", "ls", "BNTang"};
        for (String name : names) {
            System.out.println(name);
        }
    }
}

可变参数

数组当作参数传递

static void sum(int[] args) {
    int res = 0;
    for (int i = 0; i < args.length; i++) {
        res += args[i];
    }
    System.out.println(res);
}

可变参数，它是数组参数的一种简写，会自动把 ... 转成数组。

public class Demo {

    static void sum(int... args) {
        int res = 0;
        for (int i = 0; i < args.length; i++) {
            res += args[i];
        }
        System.out.println(res);
    }

    public static void main(String[] args) {
        int[] params = {1, 2, 3, 4};
        sum(params);
        sum(1, 2, 3, 4);
    }
}

变量作用域

能使用的范围，也就是生效的范围。

生效范围是：在创建变量的大括号当中生效。超过了大括号就不生效(不能再使用了)

在方法内部定义的变量，跟外界没有任何关系。

public class Demo {
    public static void main(String[] args) {
        {
            int b = 20;
            System.out.println(b);
        }
        int b = 30;
        System.out.println(b);
    }
}

posted @ 2020-08-02 21:59 BNTang 阅读(188) 评论(0) 编辑收藏举报

刷新页面返回顶部

BNTang