什么是泛型？

  1. 泛型是java语言的一个特性，类，接口，方法在定义的时候指定参 数类型。
  2. 泛型作用是编译时候检查类型安全，避免运行时发生类型转换错误。
  3. 泛型擦除是泛型保留在编译时期，运行时期不会保留。
  4. 泛型多应用在集合，数组。
  5. 泛型通配符<?>,除了这个还要泛型上限通配符，泛型下限通配符。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Box<T> {
    private T value;

    public Box(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }
}

Box<Integer> intBox = new Box<>(123);
Box<String> strBox = new Box<>("Hello, world!");

通配符实例

1
2
3
4
5
6
public static void printList(List<?> list) {
    for (Object obj : list) {
        System.out.print(obj + " ");
    }
    System.out.println();
}

什么是反射？

  1. 反射是程序在运行时候获取类的属性和方法
  2. 反射作用是动态获取类的信息，动态调用对象的属性和方法，反射缺点是破坏封装。
  3. 反射创建对象有3种方式，类名，路径，对象，举例：类名.class，Class.forName(类路径），对象实例.getClass（）
  4. 正射是在运行前就有了对象，反射是运行时动态创建对象。new创建对象是正射，反射比正射复杂。
  5. 放射应用场景有注解，切面，spring
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public class TestReflection {
 
    public static void main(String[] args) {
      //第一、通过Class.forName方式
        Class clazz1 = null;
        try {
            clazz1 = Class.forName("com.reflection.User");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
 
      //第二、通过对象实例方法获取对象
        Class clazz2 = User.class;
 
      //第三、通过Object类的getClass方法
        User user = new User();
        Class clazz3 = user.getClass();
 
        System.out.println(clazz1);
        System.out.println(clazz2);
        System.out.println(clazz3);
    }
}
public class ReflectionDemo1 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Writer writer = new Writer();
        writer.setName("zouwen");
        System.out.println(writer.getName());

        Class clazz = Class.forName("com.itwanger.s39.Writer");
        Constructor constructor = clazz.getConstructor();
        Object object = constructor.newInstance();

        Method setNameMethod = clazz.getMethod("setName", String.class);
        setNameMethod.invoke(object, "zouwen");
        Method getNameMethod = clazz.getMethod("getName");
        System.out.println(getNameMethod.invoke(object));
    }
}

异常是什么？异常处理方式有哪些？

  1. 异常有error和Exception，它们都继承throwable，error是很严重的，系统级别的，比如栈溢出。exception是可以被处理的，异常处理方式有try catch和抛出throws
  2. exception分为编译时异常和运行时异常，编译异常必须显示处理，
  3. 编译异常有：类找不到，文件找不到，运行异常有空指针，索引越界，
  4. throw和throws区别是throw是人为new出来，出现在方法体，后面是new出来异常对象，throws是出现异常程序主动抛出异常，出现在方法名称后面
  5. try，catch，finally，try里面是可能发生异常代码，catch是出现异常执行得代码，finally是一点会执行得代码

==和equals区别？

  1. ==如果是基本数据类型，那么比较数值，如果是对象，那么比较对象地址
  2. equals是用于对象之间比较，不能比较基本数据类型，比较的是对象地址
  3. 提示：包装类型的String和Integer因为重写了equals和hashcode方法，所以比较内容是否相等，不是地址

stream流是什么？

stream流被称为流式编程，是一种数据处理方式，高效处理集合对象。java8新特性

创建流，中间操作处理流，收集操作收集流

1.创建流，stream（）

1
2
3
4
5
6
7
8
9
10
11
12
List<String> list = new ArrayList<>();
list.add("武汉加油");
list.add("中国加油");
list.add("世界加油");
list.add("世界加油");

long count = list.stream().distinct().count();
System.out.println(count);

// arrays.stream()创建流
//.distinct()处理流，去重
//.count()收集流 统计个数

2.操作流有很多，过滤filter（），映射map（），匹配anyMatch（）

filter() 方法接收的是一个 Predicate（Java 8 新增的一个函数式接口，接受一个输入参数返回一个布尔值结果）类型的参数，因此，我们可以直接将一个 Lambda 表达式传递给该方法，比如说 element -> element.contains("王") 就是筛选出带有“王”的字符串。

1
2
3
4
5
6
7
8
9
10
11
public class FilterStreamDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("周杰伦");
        list.add("王力宏");
        list.add("陶喆");
        list.add("林俊杰");
        Stream<String> stream = list.stream().filter(element -> element.contains("王"));
        stream.forEach(System.out::println);
    }
}

map() 方法接收的是一个 Function（Java 8 新增的一个函数式接口，接受一个输入参数 T，返回一个结果 R）类型的参数，此时参数 为 String 类的 length 方法，也就是把 Stream<String> 的流转成一个 Stream<Integer> 的流。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class MapStreamDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("周杰伦");
        list.add("王力宏");
        list.add("陶喆");
        list.add("林俊杰");
        Stream<Integer> stream = list.stream().map(String::length);
        stream.forEach(System.out::println);
    }
}
//结果
3
3
2
3
  • anyMatch()，只要有一个元素匹配传入的条件，就返回 true。
  • allMatch()，只有有一个元素不匹配传入的条件，就返回 false；如果全部匹配，则返回 true。
  • noneMatch()，只要有一个元素匹配传入的条件，就返回 false；如果全部不匹配，则返回 true。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class MatchStreamDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("周杰伦");
        list.add("王力宏");
        list.add("陶喆");
        list.add("林俊杰");

        boolean  anyMatchFlag = list.stream().anyMatch(element -> element.contains("王"));
        boolean  allMatchFlag = list.stream().allMatch(element -> element.length() > 1);
        boolean  noneMatchFlag = list.stream().noneMatch(element -> element.endsWith("沉"));
        System.out.println(anyMatchFlag);
        System.out.println(allMatchFlag);
        System.out.println(noneMatchFlag);
    }
}

3.收集流，collect（）

既然可以把集合或者数组转成流，那么也应该有对应的方法，将流转换回去——collect() 方法就满足了这种需求。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class CollectStreamDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("周杰伦");
        list.add("王力宏");
        list.add("陶喆");
        list.add("林俊杰");

        String[] strArray = list.stream().toArray(String[]::new);
        System.out.println(Arrays.toString(strArray));

        List<Integer> list1 = list.stream().map(String::length).collect(Collectors.toList());
        List<String> list2 = list.stream().collect(Collectors.toCollection(ArrayList::new));
        System.out.println(list1);
        System.out.println(list2);

        String str = list.stream().collect(Collectors.joining(", ")).toString();
        System.out.println(str);
    }
}
List<Integer> list1 = list.stream().map(String::length).collect(Collectors.toList());
// [3, 3, 2, 3]

通过 stream() 方法创建集合的流后，再通过 map(String:length) 将其映射为字符串长度的一个新流，最后通过 collect() 方法将其转换成新的集合。

Collectors 是一个收集器的工具类，内置了一系列收集器实现，比如说 toList() 方法将元素收集到一个新的 java.util.List 中；比如说 toCollection() 方法将元素收集到一个新的 java.util.ArrayList 中；比如说 joining() 方法将元素收集到一个可以用分隔符指定的字符串中。

1
2
3
4
[周杰伦, 王力宏, 陶喆, 林俊杰]
[3, 3, 2, 3]
[周杰伦, 王力宏, 陶喆, 林俊杰]
周杰伦, 王力宏, 陶喆, 林俊杰

序列化和反序列化是什么？

  1. 序列化是将对象转化为可以存储或者传输的格式，反序列号是格式转回，java里面序列化是java对象转换为字节流，反序列化是字节流转换为java对象
  2. jdk自带的序列化器serializable接口不安全，serialVersionUID是反序列化时检查和类的序列化uid是不是一样
  3. 序列化作用：网络传输，远程调用，持久化存储，java对象转redis，文件，网络都要序列化
1
2
3
4
5
6
7
8
9
10
import java.io.Serializable;

public class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    
    private String name;
    private int age;
    
    // Constructors, getters and setters...
}

抽象类和接口区别是什么？

抽象类是类，有构造方法，接口没有构造方法，

抽象类变量任意，接口变量默认是常量，必须赋值，

抽象类是单继承，接口是多继承

一个类只能继承一个抽象类，一个类可以实现多个接口，

抽象类是自下而上，先有基类再有共同父类，接口是自上而下，基于某些行为定义的接口，

方法重载和重写区别是什么？

方法重载是同一个类中，方法名称一样，参数不一样，方法重写是子类继承父类，重写父类的方法，实现多态，重写子类的方法参数和返回值要和父类一样，子类访问权限不能比父亲低，异常捕获不能比父亲高

什么是内部类，有什么作用？

内部类是再一个类内部定义的类，分为静态内部类，成员内部类，匿名内部类

作用是封装，简化代码

jdk8有哪些新特性？

lambda表达式，stream流，时间类，接口默认方法，optional

基本类型和包装类区别？

基本数据类型：byte（1）char（2）short（2）int（4）float（4）double（8）long（8）boolean（1），包装类型：Integer，Long，Float，Double，Character，Byte，Boolean，Short，内存占用不同，比较方式不同，基本数据类型==比较数值，包装类型==比较地址，equals比较数值，默认值不同，基本类型默认0，包装类型默认null

深拷贝和浅拷贝有什么区别？

深拷贝不仅复制对象内容，还好复制对象引用，完全独立，浅拷贝复制对象引用，修改对象会影响原来的对象，对于基本数据类型两者都会完全复制

Java的io流是什么？

io流是输入输出流，分为字节流和字符流，字节流包括InputStream及其子类，OutputStream及其子类，字符流包括Reader及其子类，Writer及其子类

Object有哪些方法？

equals（），hashcode（），toString（），getClass（），notify（），wait（），clone（），finalize（）

hashcode（）是什么？

hashcode是Object对象的一个方法，用于返回对象的哈希值，也就是索引，有什么用呢？举例，hashset是不允许重复，hashset首先判断存入值的hashcode是否和集合里面的某个元素哈希值一样，如果一样，再判断值是否一样，如果值也一样，就报错，hashcode相等两个对象不一定相等，hashcode相等的两个对象，值也相等，那就相等，hashcode不相等的两个对象，一定不相等

string和stringBuild和stringBuffer区别？

string是不可变的，stringBuild是可变但是线程不安全，stringBuffer是可变的，线程安全，因为加了同步锁。

bigDecimal有哪些方法？

bigDecimal是一个对象，用于处理浮点数精度丢失问题，a.compareTo(b)相等为0，不等为1，setScale（）

java和c语言的区别？

都是面向对象编程，封装，继承，多态，java的类是单继承，c语言是多继承，java有内存管理机制，不用手动释放内存

++在前和++在后区别？

单独运算没有区别，参与运算，++在前会加1，在后面不变，也就是后加

先自增再赋值，先赋值再自增。

静态方法和普通方法区别？

所属内容不同，静态方法属于类，实例方法属于对象，调用方式不同，静态方法类名调用，实例方法对象名调用，访问权限不同，静态方法访问静态变量，实例方法访问成员变量

Java时间类？

早期util包下的date，随后有了calendar包，其次是time包的localDateTime年月日时分秒，当时间LocalDate.now()，指定时间，LocalDate.of(2024,11)

将对象转换为二进制流怎么实现？

用序列化方式实现

序列化与反序列化自己实现？

我会考虑用fastjson框架，因为自带的虚列化不好用，有安全问题，而且序列化的流太大。

对象从一个JVM转移到另一个JVM？

  1. 序列化：ObjectInputStream和ObjectOutputStream
  2. 消息队列：Kafka，RabbitMQ
  3. Rpc远程调用：
  4. 数据：mysql，redis

听说过stream的并行API？

将一个stream流转化为多个小一点的stream流，进行多线程操作，最后再合并计算结果。

注解原理及作用域？

内部基于动态代理

  1. 注解用于描述类
  2. 注解用于描述方法
  3. 注解用于描述字段

JAVA创建对象的方式？

new创建对象

反射

序列化与反序列化

克隆

new的对象什么时候被回收？

当对象没有被引用的时候，就被回收，垃圾回收期不定期检查哪些对象没有被引用，然后回收

深拷贝的3种实现方式

  1. 序列化
  2. 克隆
  3. 手动递归复制

父子类都有静态代码块，new子类会发生什么？

执行顺序是这样的，

先执行父类的静态代码块，

再执行子类静态代码块，

执行父类的构造函数，

执行子类的构造函数

接口可以有构造函数吗？

不能

抽象类可以实例化吗？

不能

接口可以用哪些方法？

抽象，默认（有实现），静态，私有

抽象类能加final吗？

不能

抽象类和普通类的区别？

抽象类不能实例化，普通类可以实例化

普通类的方法要有方法体，抽象类的方法可以有方法体，可以没有方法体。

哪些地方看出是多态？

方法重载，方法重写，接口与类，类向上向下转型

说一下integer的缓存？

范围-128-127，当静态缓存池数值在这个范围内会复用

integer与int的区别

  1. Int是基本数据类型，integer是引用数据类型必须实例化才能使用。
  2. integer是int的包装类，有自动拆箱装箱功能。
  3. integer如果没有赋值就操作，会发生空指针异常

java为什么要integer？

泛型需要，集合需要，自动装箱拆箱需要

自动装箱的弊端？

循环的时候会创建多个对象，造成浪费

装箱和拆箱是什么？

基本数据类型与包装类型的转换吗，装箱的出现是赋值和方法调用。

为什么用bigdecimal？

doubel数计算会出现精度度丢失，bigdecimal不会精度丢失

数据转化会出现什么问题？

  1. 数据丢失，大范围的数转为小范围的数
  2. 数据溢出，小范围的数转为大范围的数
  3. 精度丢失，浮点数类型转换

数据类型转换方式有哪些？

  1. 自动类型转换（隐式转换）
  2. 强制类型转换（显示转换）
  3. 数字与字符串之间的转换

Long和int可以互转吗？

可以的，但是会出现数据丢失和数据溢出

JAVA与python的区别？

JAVA是编译与解释并存的语言

Python是解释性语言，程序边执行边解释。

jvm jdk jre的关系？

JVM是JAVA虚拟机，执行已经编译好的class文件，

Jdk是JAVA工具包，例如jdk 8 jdk 17 jdk 21，包括开发，编译，调试

jre里面包括了JVM，还包括一些库，util，date，io

JAVA语言的特点？

平台无关性，面向对象，内存管理机制，多线程

逻辑与与短路与的区别？

  1. 共同点两边都为true，结果为true
  2. 短路与，左边为false，右边不参与运算

Switch能否用在byte/string/long上面？

long不可以，其他可以

break，continue，return区别？

  1. break跳出整个循环，
  2. continue跳出当前循环
  3. return返回结果

多态的前置条件？

  1. 子类继承父类
  2. 类重写父类方法
  3. 父类引用指向子类对象

访问修饰符有哪些，以及作用域？

Private，Default ，Protected，public

  1. Private是类内可以看见
  2. Default是包
  3. Protected是包和子类
  4. Public是不同包

this关键字的作用？

  1. this指向当前对象本身
  2. 类里面的方法形参与成员变量重命名，this指向成员变量，
  3. this引用指向本类构造方法

final关键字有什么作用？

  1. 修饰类不能被继承，
  2. 修饰方法不能被重写，
  3. 修饰变量不能被改变

java是值传递还是引用传递？

值传递

了解native吗？

加载外部语言的一个关键字

String str=“abc”和String str=new “abc”区别？

1
2
3
4
5
6
String s1 = "zouwen";
String s2 = "zouwen";
String s3 = new String("zouwen");

System.out.println(s1 == s2); // 输出 true，因为 s1 和 s2 引用的是字符串常量池中同一个对象。
System.out.println(s1 == s3); // 输出 false，因为 s3 是通过 new 关键字显式创建的，指向堆上不同的对象。

String str=“abc”会直接把常量值有的值赋值给新变量。

String str=new “abc”会在堆里面创建地址，如果常量池里面有值不会创建值，如果没有会创建值。

String怎么转成Integer？

调用方法：Integer.parseInt(String s)或者Integer.valueOf(String s)

Optional了解吗？

Optional是用于防范NullPointerException。

1
2
3
4
5
6
7
Optional<String> optional = Optional.of("bam");

optional.isPresent();           // true
optional.get();                 // "bam"
optional.orElse("fallback");    // "bam"

optional.ifPresent((s) -> System.out.println(s.charAt(0)));     // "b"