【无标题】

1.两数之和

方法一：双层循环暴力枚举

import java.util.Scanner;
public class test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = sc.nextInt();
        }
        int target = sc.nextInt();
        twoSun(arr, target);
    }
    static void twoSun(int[] nums, int target){
        int length = nums.length;
        // 第一遍遍历循环，由于我们要和该元素的后一个元素比较，所以这里条件为（i < length - 1）
        for(int i = 0;i < length-1;++i){
        // 从该数的下一个（因为不能使用重复元素，j = i + 1）开始往后遍历
            for (int j = 0; j < length; j++) {
                if (nums[i] + nums[j] == target){
                    System.out.println(i+" "+j);
                    return;
                }
            }
        }
    }
}

方法二：哈希表

	class Solution {
    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])) {
                return new int[]{hashtable.get(target - nums[i]), i};
            }
            hashtable.put(nums[i], i);
        }
        return new int[0];
    }
        public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = sc.nextInt();
        }
        int target = sc.nextInt();
        twoSun(arr, target);
    }
}

2.最长公共前缀

import java.util.Scanner;
public class test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        String[] arr = new String[n];
        String s = sc.nextLine();
        for (int i = 0; i < n; i++) {
            arr[i] = sc.nextLine();
        }
        String ans = arr[0];
        for (int i = 1; i < arr.length; i++) {
            ans = tool(ans,arr[i]);
        }
        if (ans.isEmpty()){
            System.out.println("NO");
        }else {
            System.out.println(ans);
        }
    }
    static  String tool(String str1, String str2) {
        int len = Math.min(str1.length(), str2.length());
        String ans = " ";
        for (int index = 0; index < len; index++) {
            if (str1.charAt(index) == str2.charAt(index)) {
                ans += str1.charAt(index);
            } else {
                break;
            }
        }
        return ans;
    }    
}

3.泛型和构造方法

1.构造方法和成员方法的区别

A. 格式区别 构造方法名和类名相同，并且没有返回值，也没有返回值类型，连void都没有 普通成员方法可以任意起名，必须有返回值类型，可以没有返回值

B. 作用区别 构造方法用于创建对象，并进行初始化值 普通成员方法是用于完成特定的功能

C. 调用区别 构造方法是在创建对象时被调用的，一个对象的建立，只调用一次相应的构造函数 普通成员方法是创建好的对象调用，一调用多次

2.==和equals比较时的区别

== 既可以比较 基本数据类型，又可以比较引用类型。
当== 两边操作数是基本数据类型时，比较的是值本身。
当 == 两边是引用类型时比较的是引用地址值equals() 只能比较引用类型。Object中的equals()的作用和 == 作用相同，比较的都是引用类型的地址值，若想比较对象的内容，对象所在的类必须重写equals()方法

3.Collection：单列集合类的根接口，用于存储一系列符合某种规则的元素，它有两个重要的子接口，分别是什么？

这两个子接口的特点是什么？主要实现类又都有哪些？分别是java.util.List和java.util.Set。其中，List的特点是存储有序、元素可重复。Set的特点是存储无序，而且不可重复。List接口的主要实现类有ArrayList和LinkedList，Set接口的主要实现类有HashSet和TreeSet。

4.String,StringBuilder,StringBuffer的相同点和不同点?

1. 相同点：三者都可以操作字符串。String 是不可变字符串对象，每次修改字符串都会创建新对象StringBuilder、StringBuffer 是可变字符串序列（对象），StringBuilder 和 StringBuffer 在修改字符串时不会创建新对象当需要对字符串频繁的修改时，推荐使用StringBuilder 或 StringBufferStringBuffer是jkd 1.0 提供的。StringBuilder是jdk 1.5提供的，二者的常用方法名 和实现原理是一样的。
2. 不同点：区别在于StringBuffer是线程安全的，StringBuilder是线程不安全的。如果不涉及线程安全问题，推荐使用StringBuilder,因为它的效率会更高一些

5.Java中的泛型是什么？使用泛型的好处是什么？

Java泛型(generics)是JDK5中引入的一个新特性，泛型提供了编译时类型安全监测机制，该机制允许我们在编译时检测到非法的类型数据结构；泛型的本质就是参数化类型，也就是所操作的数据类型被指定为一个参数；泛型的好处

1. 类型安全。泛型的主要目的就是提高Java程序的类型安全。通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程度上验证类型假设。没有泛型，这些假设只能我们自己记或者代码注释；
2. 消除强制类型转换。泛型一个附带好处是，消除代码中许多强制类型的转换。减少代码出错率，更好阅读；
3. 潜在的性能收益。可以带来更好的优化可能。在泛型的初始实现中，编译器强制类型转换(没有泛型的话，程序员会指定这些强制类型转换，插入生成的字节码中。但是更多类型信息可用于编译器这一事实，为以后的JVM可以带来更好的优化。由于泛型的实现方式，支持泛型几乎不需要JVM或类文件更改，所有工作都在编译器中完成，编译器生成的类没有泛型(和强制类型转换)，只是来确保数据类型安全；

4.构造类

public abstract class Product {
    private String name;
    private double price;
    public abstract String getDescription();// 表示获取商品的描述

    public Product(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }
}

public class Electronics extends Product {
    private String brand;

    public Electronics(String name,Double price, String brand) {
        super(name,price);
        this.brand = brand;
    }

    @Override
    public String getDescription() {
        return "Electronics:" + getName() + ",brand:" + this.brand;
    }
}

public class Clothing extends Product{
    private String size;

    public Clothing(String name, Double price, String size){
        super(name,price);
        this.size = size;
    }

    @Override
    public String getDescription() {
        return "Clothing:" + getName()+",size:" + this.size;
    }
}

import java.util.ArrayList;
import java.util.List;
// **泛型这里T要继承Product**
public class ShoppingCart<T extends  Product>{
    private List<T> items;

    public ShoppingCart(){
        this.items = new ArrayList<>();
    }

    public void addItems(T item){
        items.add(item);
    }

    public double calculateTotalPrice(){
        double totalPrice = 0;
        for (T item : items){
            totalPrice += item.getPrice();
        }
        return totalPrice;
    }

    public void displayItems(){
        for (T item : items){
            System.out.println(item.getDescription());
        }
    }

}

public class Test5 {
    public static void main(String[] args) {
        ShoppingCart<Product> cart = new ShoppingCart<>();
        Electronics laptop = new Electronics("laptop",9999.9,"联想");
        Clothing shirt = new Clothing("shirt",299.9,"M");

        cart.addItems(laptop);
        cart.addItems(shirt);

        cart.displayItems();
        double totalPrice = cart.calculateTotalPrice();
        System.out.println("总价"+ totalPrice);
    }
}