JavaSE学习笔记

a = b = c
// 等效于
a = (b = c)

a + b + c
// 等效于
(a + b) + c

@Override
public Object clone() throws CloneNotSupportedException {   //提升clone方法的访问权限
    return super.clone();   //因为底层是C++实现，我们直接调用父类的实现就可以了
}

public enum Status {
    RUNNING("跑步"), STUDYING("学习")
      
    private final String name;
	public Status(String name) {
        this.name = name;
    }
  
    public String getName() {
        return this.name;
    }
}

Test b = new Test("小红");
Test.Inner inner2 = b.new Inner();  //依附于b创建的对象，那么就是b的
inner2.test();

// 假设都有name成员
name // 形参
this.name // 内部类成员
Outer.this.name // 外部类成员

public static void main(String[] args) {
    Study study = new Study() {
        @Override
        public void study() {
            System.out.println("我是学习方法！");
        }
    };
    study.study();
}

public static void main(String[] args) {
    Study study = () -> System.out.println("我是学习方法！");   //是不是感觉非常简洁！
  	study.study();
}

public interface Study {
    int sum(int a, int b);   //待实现的求和方法
}
public static void main(String[] args) {
    Study study = (a, b) -> Integer.sum(a, b);   //直接使用Integer为我们通过好的求和方法
    System.out.println(study.sum(10, 20));
}

public static void main(String[] args) {
    Study study = Integer::sum;    //使用双冒号来进行方法引用，静态方法使用 类名::方法名 的形式
    System.out.println(study.sum(10, 20));
}

([type arg1]...) -> {body} | exp

try {
  
} catch (Excpetion1 | Excpetion2 ...) {
  
} catch (Throwable ...) {
  
} finally {
  
}

assert (exp) : (msg)
// 如
int a = 10;
assert a > 10 : "我是错误信息";

public static void main(String[] args) {
    Test<int> test = new Test<>(); // 不行
    Test<Integer> test = new Test<>(); // 用Integer替代
  
    // 当然数组可以，因为数组是引用类型。
    Test<int[]> test = new Test<>();
}

static class A extends B<String> {...} // 确定类型
class A<T> implements B<T> {...} // 保持泛型

public <T> T test(T a)  // 需要放在返回类型 前面

<T extends Number> // 限定T为number或其子类
<? extends Integer> // 泛型通配符也支持

Score<? super Number> score = new Score<>("数据结构与算法基础", "EP074512", 10);

@FuntionalInterface // 装饰器

@FunctionalInterface
public interface Supplier<T> {
    T get();	// 实现此方法
}

//专门供给Student对象的Supplier
private static final Supplier<Student> STUDENT_SUPPLIER = Student::new;
public static void main(String[] args) {
    Student student = STUDENT_SUPPLIER.get();
    student.hello();
}

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);    //这个方法就是用于消费的，没有返回值

    default Consumer<T> andThen(Consumer<? super T> after) {   //这个方法便于我们连续使用此消费接口
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

//专门消费Student对象的Consumer
private static final Consumer<Student> STUDENT_CONSUMER = student -> System.out.println(student+" 真好吃！");
public static void main(String[] args) {
    Student student = new Student();
    STUDENT_CONSUMER.accept(student);
  

    STUDENT_CONSUMER   //我们可以提前将消费之后的操作以同样的方式预定好
            .andThen(stu -> System.out.println("我是吃完之后的操作！")) 
            .andThen(stu -> System.out.println("好了好了，吃饱了！"))
            .accept(student);   //预定好之后，再执行
}

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);   //这里一共有两个类型参数，其中一个是接受的参数类型，还有一个是返回的结果类型

    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

public class FunctionExample {

    // Function接口，接受一个Integer，返回一个String
    private static final Function<Integer, String> INTEGER_STRING_FUNCTION = Object::toString;

    public static void main(String[] args) {
      
        // 使用apply方法，将传入的int参数转换为字符串
        String str = INTEGER_STRING_FUNCTION.apply(10);
        System.out.println(str);  // 输出: 10

        // 使用compose方法，将指定函数式的结果作为当前函数式的实参
        // 首先执行传入的lambda表达式 (String s) -> s.length() ，将字符串"lbwnb"转换为其长度5
        // 然后执行INTEGER_STRING_FUNCTION，将5转换为字符串"5"
        String composedStr = INTEGER_STRING_FUNCTION
                .compose((String s) -> s.length())   // 传入一个Function<String, Integer>
                .apply("lbwnb");   // 执行compose中的lambda表达式，返回字符串长度，再作为INTEGER_STRING_FUNCTION的输入
        System.out.println(composedStr);  // 输出: 5

        // 使用andThen方法，将当前函数式的返回值进行进一步处理
        // 首先执行INTEGER_STRING_FUNCTION，将10转换为字符串"10"
        // 然后执行String::isEmpty方法，判断字符串"10"是否为空，返回false
        Boolean result = INTEGER_STRING_FUNCTION
                .andThen(String::isEmpty)   // 传入一个Function<String, Boolean>
                .apply(10);   // 执行INTEGER_STRING_FUNCTION得到"10"，再作为andThen中lambda表达式的输入
        System.out.println(result);  // 输出: false

        // 使用identity方法，返回传入参数的原样
        Function<String, String> identityFunction = Function.identity();   // 原样返回
        String identityStr = identityFunction.apply("不会吧不会吧，不会有人听到现在还是懵逼的吧");
        System.out.println(identityStr);  // 输出: 不会吧不会吧，不会有人听到现在还是懵逼的吧
    }
}

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);    //这个方法就是我们要实现的

    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

public class PredicateExample {

    public static void main(String[] args) {
        Predicate<String> isHello = Predicate.isEqual("Hello");

        System.out.println(isHello.test("Hello")); // 输出: true
        System.out.println(isHello.test("World")); // 输出: false

        Predicate<String> isNull = Predicate.isEqual(null);

        System.out.println(isNull.test(null)); // 输出: true
        System.out.println(isNull.test("Hello")); // 输出: false
    }
}

Optional.ofNullable(exp)
    .ifPresent( exp -> "非空") // lambda
    .orElse( exp -> "为空")	// lambda

private static void test(String str){
    Optional
            .ofNullable(str)   //将传入的对象包装进Optional中
            .ifPresent(s -> System.out.println("字符串长度为："+s.length()));  
  					//如果不为空，则执行这里的Consumer实现
            .orElse("备选方案")
  
    // 原本需要进行判空，现在更优雅了
    if (str == null) return;
}

Integer i = Optional
        .ofNullable(str)
        .map(String::length)   //使用map来进行映射，将当前类型转换为其他类型，或者是进行处理
        .orElse(-1);

try (FileInputStream stream = new FileInputStream("......")) {}
// 等价于
FileInputStream stream = null;
try {
    stream = new FileInputStream("...");
} catch (e) {
    e.printStack();
} finally {
    try {
    	if (stream != null) stream.close();
    } catch (e) {
        e.printStack();
    }
}

public static void main(String[] args) {
    File file = new File("test.txt");   //直接创建文件对象，可以是相对路径，也可以是绝对路径
    System.out.println(file.exists());   //此文件是否存在
    System.out.println(file.length());   //获取文件的大小
    System.out.println(file.isDirectory());   //是否为一个文件夹
    System.out.println(file.canRead());   //是否可读
    System.out.println(file.canWrite());   //是否可写
    System.out.println(file.canExecute());   //是否可执行
}

File file = new File("/");
System.out.println(Arrays.toString(file.list()));   //快速获取文件夹下的文件名称列表
for (File f : file.listFiles()){   //所有子文件的File对象
    System.out.println(f.getAbsolutePath());   //获取文件的绝对路径
}

public static void main(String[] args) {
    try (BufferedReader reader = new BufferedReader(new FileReader("test.txt"))){
        System.out.println(reader.readLine());   //按行读取
    }catch (IOException e) {
        e.printStackTrace();
    }
}

public static void main(String[] args) {
    try (BufferedReader reader = new BufferedReader(new FileReader("test.txt"))){
        reader
                .lines()
                .limit(2)
                .distinct()
                .sorted()
                .forEach(System.out::println);
    }catch (IOException e) {
        e.printStackTrace();
    }
}

public static void main(String[] args) {
    try (BufferedWriter reader = new BufferedWriter(new FileWriter("output.txt"))){
        reader.newLine();   //使用newLine进行换行
        reader.write("汉堡做滴彳亍不彳亍");   //可以直接写入一个字符串
      	reader.flush();   //清空缓冲区
    }catch (IOException e) {
        e.printStackTrace();
    }
}

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);   //系统输入流，默认是接收控制台输入
    Scanner scanner = new Scanner(new FileInputStream("秘制小汉堡.txt"));  //将文件内容作为输入流进行扫描
}

System.out.println(dataInputStream.readBoolean());   //直接将数据读取为任意基本数据类型
dataOutputStream.writeBoolean(false);

 People people = new People("lbw");
 outputStream.writeObject(people);
outputStream.flush();
 people = (People) inputStream.readObject();
 System.out.println(people.name);

static class People implements Serializable{
    private static final long serialVersionUID = 123456;   //在序列化时，会被自动添加这个属性，它代表当前类的版本，我们也可以手动指定版本。

    String name;
	transient int age;
    public People(String name){
        this.name = name;
    }
}

Thread t1 = new Thread(() -> { sout("我是子线程") });
t1.start();

synchronized (object) {...} // 方法锁
static int synchronized add() {....} // 类实例锁
int synchronized sub() {...} // 对象锁

ThreadLocal<String> str = new ThreadLocal<>();
str.set("你干嘛")
str.get()

InheritableThreadLocal<String> str = new InheritableThreadLocal<>();
str.set("哈哈哎哟");
Thread t1 = new Thread(() -> {
    sout("我能获取到" + str.getI())
})

Timer timer = new TImer(new TimerTask(){
    @override
    public void run() {
        // doSomething.............
    }
}, sleep, period);
timer.cancel();

Thread t = new Thread();
t.setDaemon(true); // 设置为守护线程
t.start(); // 开始之前设置

public static void main(String[] args) throws ClassNotFoundException {
    Class<String> clazz = String.class;   //使用class关键字，通过类名获取
    Class<?> clazz2 = Class.forName("java.lang.String");   //使用Class类静态方法forName()，通过包名.类名获取，注意返回值是Class<?>
    Class<?> clazz3 = new String("cpdd").getClass();  //通过实例对象获取
}

int.class // 直接获取
Integer.TYPE // 通过包装类获取
int.class == Integer.TYPE // 返回true

Integer.class != int.class // 返回true

public static void main(String[] args) {
    Class<String[]> clazz = String[].class;
    System.out.println(clazz.getName());  //获取类名称（得到的是包名+类名的完整名称）
    System.out.println(clazz.getSimpleName());
    System.out.println(clazz.getTypeName());
    System.out.println(clazz.getClassLoader());   //获取它的类加载器
    System.out.println(clazz.cast(new Integer("10")));   //强制类型转换
}

Class<Integer> integerClass = int.class;
Integer i = integerClass.newInstance();

Constructor <Class<>> c = Class<>.getConstructor(Class<>...)

Class<Student> clazz = Student.class;
Constructor<Student> constructor = clazz.getDeclaredConstructor(String.class);
constructor.setAccessible(true);   //修改访问权限
Student student = constructor.newInstance("what's up");
student.test();

Method method = clazz.getMethod("test", String.class);   //通过方法名和形参类型获取类中的方法

method.invoke(instance, "what's up");   //通过Method对象的invoke方法来调用方法

Method method = clazz.getDeclaredMethod("test", String.class);   //通过方法名和形参类型获取类中的方法
method.setAccessible(true);
method.invoke(instance, "what's up");   //通过Method对象的invoke方法来调用方法

Field field = clazz.getField("i");   //获取类的成员字段i
field.set(instance, 100);   //将类实例instance的成员字段i设置为100

Field modifiersField = Field.class.getDeclaredField("modifiers");  //这里要获取Field类的modifiers字段进行修改
modifiersField.setAccessible(true);

Field modifiersField = Field.class.getDeclaredField("modifiers");  //这里要获取Field类的modifiers字段进行修改
modifiersField.setAccessible(true);
modifiersField.setInt(field,field.getModifiers()&~Modifier.FINAL);  //去除final标记

//定义一个自己的ClassLoader
static class MyClassLoader extends ClassLoader{
    public Class<?> defineClass(String name, byte[] b){
        return defineClass(name, b, 0, b.length);   //调用protected方法，支持载入外部class文件
    }
}

public static void main(String[] args) throws IOException {
    MyClassLoader classLoader = new MyClassLoader();
    FileInputStream stream = new FileInputStream("Test.class");
    byte[] bytes = new byte[stream.available()];
    stream.read(bytes);
    Class<?> clazz = classLoader.defineClass("com.test.Test", bytes);   //类名必须和我们定义的保持一致
    System.out.println(clazz.getName());   //成功加载外部class文件
}

@元注解
public @interface name {
    String value() default "默认值";
}

@name("你好") // 数组可以用初始化列表传值，也可以直接传单个元素
@name({"你", "好"})