计算两数之和

1、输入的值固定

package org.example;

import java.util.Arrays;
import java.util.*;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        //在静态方法中调用非静态方法，需要先创建该类的实例，然后通过实例来调用非静态方法
        Main obj = new Main();
        int[] re = obj.twoSum(new int[]{1,8,11,15},9);
        System.out.println(Arrays.toString(re));

    }

    public int[] twoSum(int[] nums, int target) {
        // 哈希表用于存储每个元素的下标，因为数组中可能有重复的
        Map<Integer, Integer> hashtable = new HashMap<Integer, Integer>();
        for (int i = 0; i < nums.length; ++i) {
            // 检查配对元素是否存在于哈希表中
            if (hashtable.containsKey(target - nums[i])) {
                // 如果配对元素存在，说明找到了满足条件的两个元素，返回两个元素的下标，通过get获得元素的下标。
                // hashtable.get(target - nums[i])获取的是满足条件的元素的下标。
                return new int[] { hashtable.get(target - nums[i]), i };
            }
            // 如果配对元素不存在哈希表中，说明查找不到满足条件的两个元素，那么判断哈希表中当前元素是否已经存在。
            hashtable.put(nums[i], i);
        }
        /*在函数或方法中返回一个空的整数数组。
        1、当找不到匹配的元素或者不满足某些预期的条件时，可能会返回一个空数组。
        2、在某些算法中，可能需要返回一个空数组来表示没有有效的结果或解。
         */
        return new int[0];
    }
}

输入的值，可随时变更

package org.example;

import org.testng.IResultMap;

import java.util.Arrays;
import java.util.*;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 输入数组的长度
        System.out.print("Enter the length of the array: ");
        int length = scanner.nextInt();

        // 创建一个整数数组
        int[] arr = new int[length];

        // 输入数组元素
        System.out.println("Enter the elements of the array:");
        for (int i = 0; i < length; i++) {
            arr[i] = scanner.nextInt();
        }

        // 输入一个整数值
        System.out.print("Enter an integer value: ");
        int value = scanner.nextInt();

        // 打印结果
        System.out.println("Array: " + Arrays.toString(arr));
        System.out.println("Value: " + value);
        scanner.close();

        //调用方法
        Main oe=new Main();
        int[] resurlt = oe.twoSum(arr,value);
        System.out.println(Arrays.toString(resurlt));
    }

    public int[] twoSum(int[] nums, int target) {
        // 哈希表用于存储每个元素的下标，因为数组中可能有重复的
        Map<Integer, Integer> hashtable = new HashMap<Integer, Integer>();
        for (int i = 0; i < nums.length; ++i) {
            // 检查配对元素是否存在于哈希表中
            if (hashtable.containsKey(target - nums[i])) {
                // 如果配对元素存在，说明找到了满足条件的两个元素，返回两个元素的下标，通过get获得元素的下标。
                // hashtable.get(target - nums[i])获取的是满足条件的元素的下标。
                return new int[] { hashtable.get(target - nums[i]), i };
            }
            // 如果配对元素不存在哈希表中，说明查找不到满足条件的两个元素，那么判断哈希表中当前元素是否已经存在。
            hashtable.put(nums[i], i);
        }
        /*在函数或方法中返回一个空的整数数组。
        1、当找不到匹配的元素或者不满足某些预期的条件时，可能会返回一个空数组。
        2、在某些算法中，可能需要返回一个空数组来表示没有有效的结果或解。
         */
        return new int[0];
    }
}

在同一个类的另一个方法中调用该类的某个方法

1、在静态方法中调用非静态方法，需要先创建该类的实例，然后通过实例来调用非静态方法
2、非静态方法中调用非静态方法，直接使用方法名调用。

public class MyClass {
    public void methodA() {
        System.out.println("This is method A.");
    }

    public void methodB() {
        System.out.println("This is method B.");
        methodA(); // 直接调用同类的另一个方法
    }

    public static void main(String[] args) {
    //1、在静态方法中调用非静态方法，需要先创建该类的实例，然后通过实例来调用非静态方法
        MyClass obj = new MyClass();
        obj.methodB();
    }
}

使用多种方法来打印一维数组的所有元素

使用 System.out.println() 和循环：

int[] arr = {1, 2, 3, 4, 5};
for (int i = 0; i < arr.length; i++) {
    System.out.print(arr[i] + " ");
}
System.out.println();

这将输出：1 2 3 4 5

使用 Arrays.toString() 方法：

int[] arr = {1, 2, 3, 4, 5};
System.out.println(Arrays.toString(arr));

这将输出：[1, 2, 3, 4, 5]