重学java基础的笔记(基础/IO/泛型/反射/File/Lambda等)

╰半橙微兮° 2022-10-11 00:52 104阅读 0赞

**常量**：final doubel PI = 3.1415927;

浮点数不能做比较；需要精确的小数使用BigDecimal可以处理任意长度数字

浮点数除于0不会报错，显示为Infinity；

**取余运算**：取余运算的结果是 a%b = 0到b-1之间

&&，&，||，|一般用&&和||，因为这两个运算时从左到右

**强转**：(int)num;

### 变量： ###

成员变量就是类变量和实例变量的总称；

**类（静态）变量**：staic num = 1;（类里面，方法外的变量）

一般用于常量；第一次访问时创建，程序结束销毁；

类里独一份，修改会影响全部；

**实例变量**：num = 1;（类里面，方法外的变量）

实例创建时创建，实例销毁后销毁；

每个实例的变量是不同的，修改不会影响别的实例对象；

**局部变量**：方法里的变量，局部变量没有默认值，初始化以后一定要赋值；

方法创建时创建，方法执行完后销毁；只在声明他的代码块中可见；

### 修饰符： ###

** 访问修饰符**：

**default (默认）**: 在同一包内可见，不使用任何修饰符。

使用对象：类、接口、变量、方法。

**  private :** 在同一类内可见。

使用对象：变量、方法。

注意：不能修饰类（外部类）

成员变量尽量用这个，然后用public的方法来操作变量；

构造方法使用private的话，需要配合一个静态(工厂)方法使用，用来检测参数的合法性；

例子：

class A(){
        // 构造函数
        private A(int a){}
        // 检测构造函数参数
        public static Jc(int a){
            if(a<=0){ return null; }
            return new A(a);
        }
         public static void main(String[] args){
            // 创建对象
            A  aa = A.Jc(10);
        }
    }

** public :** 对所有类可见。

使用对象：类、接口、变量、方法

public的方法和变量尽量不要改动，可以优化但是不修改参数和返回；

**protected :** 对同一包内的类和所有子类可见。

使用对象：变量、方法。

注意：不能修饰类（外部类）。

**非访问修饰符**：

** static 修饰符**：用来修饰类方法

（static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据）和类变量（static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量）。

**final 修饰符：**用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的；final修饰的引用变量指向的引用是可以修改的。

**abstract修饰符：**用来创建抽象类和抽象方法。

**synchronized 和 volatile 修饰符**：主要用于线程的编程。

检测类型：instanceof

结束循环：break，continue

判断语句：switch case default

### String类： ###

不可变；String存储的内容是private的，内容不能修改；

**StringBuffer和 StringBuilder：**

和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

StringBuffer 的方法线程安全

StringBuilder 的方法不是线程安全的（不能同步访问）

StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder

数组：Array固定大小，初始化时需要声明空间大小，大小不可变；

日期类：Calendar  GregorianCalendar

方法重载：方法名一样但是参数不一样；

构造函数：方法名与类名一样，没有返回值，一般用来做一些初始化；

可变参数：int... num；本质是一个数据；

### 继承： ###

class 子类 extends 父类 \{\}

class 类 implements 接口一,接口二 \{\}

子类可以访问父类所有非 private（私有） 的属性、方法

子类可以拥有自己的属性和方法，也可以用自己的方式实现父类的方法

所有类都是继承于java.lang.Object

覆盖才是继承的精髓，覆盖就是子类的方法名，参数，返回值都与父类的一样，子类覆盖掉不适合这个类的父类方法；

方法可以覆盖，属性不可以，所以尽量用方法访问河修改属性；

extends 关键字是继承父类（只能单继承）

implements 关键字是继承接口（可以多继承）

** super关键字：**我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类

**this关键字：**指向自己的引用；类下面的方法，变量都有一个this自引用，只是省略了而已；谁调用就是指向谁；static修饰的变量和方法不能使用this，因为这些事用来修饰类的不是修饰实例的；

子类构造函数默认会调用父类无参数构造函数，可以用super(xxx)调用父类带参数构造函数不手动调用父类有参数构造函数，默认都是调用无参数构造函数

super调用构造方法必须是子类构造方法的第一句；这里有个问题，就是子类构造方法使用this()调用其他构造方法也要放在语句的第一句，这样就和super()这个冲突了；这里的思路是弄一个初始化方法，把属性初始化都放在里面，比如init(xx, yy, cc)；然后让构造方法去调用它；

super和this是不一样的，this是一个自引用本质是个引用，可以return this；但是super不是一个引用，也无法return出来；

子类可以调用父类的（静态，实例）方法，如果子类覆盖调用的是子类方法，没有覆盖就是调用父类方法；

final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写

**for的另一种写法：**

for(类型 变量名 : 要循环的变量)\{ ....... \}

Object是所有类的父类，它不能实例化；

**hashCode 和 equals** 是最常覆盖的两个方法；equals为true，那么hashCode也应该一样；但是hashCode一样，equals不一定为true；

== 是判断引用是否一样，equals（没有覆盖）的判断是内容是否一样；字符串比较用这两个结果一样是因为字符串创建出来会扔到一个字符串池里，如果内容一样，指向都是池子里相同的字符串，当然这是有一个优化限制的，如果字符串很长很长超出了优化的限制，那么字符串还是会重新创建新的；

### Class类： ###

所有类都有一个Class对象；

例子（反射）：

HelloWorld x = new H();
    // 通过Object的getClass方法获得Class实例
    Class clazz  = x.getClass();
    // 通过类的Class实例可以获取类的变量，getField是访问有权限访问的变量
    Field field = clazz.getField("a");
    // 设置变量的值，第一个参数是对象，第二个参数是需要设置的值
    field.set(x, 2);
    // 获取变量的值，但这是返回值是Object对象
    field.get(x);
    // 获取静态变量
    Field sField = clazz.getField("A_A");
    // 因为静态变量类只有一个，所以可以用实例对象获取，也可以直接用null
    sField.get(null);
    // 访问 private 变量，这是直接对象访问做不到的，但是反射可以做到
    // getDeclaredField是访问声明的变量，不管什么权限
    Field pField = clazz.getDeclaredField("c");
    // 再将它设置为可以访问，这样就可以设置或者访问
    pField.setAccessible(true);
    pField.set(x, 5);
    pField.get(x);
    // 通过类的Class获取方法，这个方法第二参数是方法的形参类型，是一个变长参数
    Method method = clazz.getMethod("fatherA", int.class);
    // 执行方法，第一个参数是对象，第二个参数是方法的实参，这个返回值是一个Object
    // 调用静态方法和上面调用静态变量一样，对象改为null就可以了
    method.invoke(x,1);
    // 访问 private 方法和访问变量是一样的，使用 getDeclaredMethod 访问声明的方法
    Method Fmethod = clazz.getDeclaredMethod("fatherC");
    // 设置可以访问
    Fmethod.setAccessible(true);
    Fmethod.invoke(x);

**变长参数：**

A(String... str)\{ ...... \}，这样就是一个变长参数，本质是一个数组，但是不传参数的时候它默认是一个空数组，它必须是参数的最后一个；

**重写：**

1.方法重写时， 方法名与形参列表必须一致。

2.方法重写时，子类的权限修饰符必须要大于或者等于父类的权限修饰符。

3.方法重写时，子类的返回值类型必须要小于或者 等于父类的返回值类型。

4.方法重写时， 子类抛出的异常类型要小于或者等于父类抛出的异常类型。 Exception(最坏) RuntimeException(小坏)

**方法签名：**

方法名加参数类型；方法签名是唯一的，不能重复；

工具类不需要实例化，所有操作都是静态的；

**重载**：

1: 函数名要一致

2: 形参列表不一致（形参的个数或形参 的类型不一致）

3: 与返回值类型无关

4: 重载参数类型可以向下兼容，比如需要参数int类型传short也是可以的，但是传比int大的值比如long就不可以

重写是为了加强功能；重载是为了多样性；

**构造方法**：

1: 构造方法没有返回值，因为构造方法返回的就是new出来的实例的引用，再返回其他的值没有意义；

2: 构造方法可以调用其他重载的构造方法（不能调用自己不然死循环），通过this(xxx, ccc)这样的形式调用重载的构造方法，而且调用其他重载的构造方法必须是该构造方法里的第一行；

3: 构造方法不能调用成员变量（类，实例变量），因为调用构造方法的时候对象还没有完全初始化完成；

4: 直接赋值成员变量（类，实例变量）和构造方法都是被Java弄在一个<init>方法中；

**静态(static)方法：**

没有this自引用的方法，只能使用方法参数和静态变量(static)；但是可以在静态方法里调用实例或者new一个实例再使用实例变量；

**静态代码块**：

static\{ ... \}，静态代码块里也不能调用非static的方法和变量；静态代码块是在jvm加载类的时候执行，只会执行一次；Java把它弄在一个<clinit>方法里；

**多态：**

三要素：1：继承，2：覆盖（覆盖就是子类的方法名，参数，返回值都与父类的一样），3：父类引用指向子类对象：Parent p = new Child();

子类引用可以赋值给父类引用，叫父类引用指向子类对象；反之是不可以的，因为父类中没有子类的属性和方法；父类引用指向子类对象以后，如果子类覆盖了父类的非private方法，调用的还是子类的方法，否则还是调用父类的方法；如果是一个父类引用指向子类对象，那么这个对象可以强制转换成子类对象；

能用什么看引用，实际干了什么看指向的对象；

静态多态是重载；动态多态是覆盖；

**封装：**

public类设置private变量，通过public的get，set方法读取和设置

**接口：**

接口就相当于是个规范，他不管怎么实现，只要按这个规范实现就可以；

接口不能实例化，所以也不会有实例变量，实例方法；

接口里的方法只能用public abstract 修饰，所以可以不写；

接口里的变量都是 public static final 修饰，所以可以不写；

接口允许多继承；

定义一个接口：

[可见度] interface 接口名称 [extends 其他的接口名（可以多个）] {
            // 声明变量
            // 抽象方法不需要abstract
    }

实现一个接口：

class 类名 implements 接口名{
        // 这里需要实现所有接口的抽象方法
    }

1: 接口不能用于实例化对象

2: 接口没有构造方法

3: 接口中所有的方法必须是抽象方法；public abstract 修饰

4: 接口不能包含成员(实例)变量，接口变量都是public static final 修饰

5: 接口不是被类继承了，而是要被类实现；实现接口的类需要覆盖接口的所有方法，方法权限都是public

6: 接口支持多继承

7: 接口方法会被隐式的指定为 public abstract

8: 接口变量会被隐式的指定为 public static final

9: 和类一样，如果是public interface 的话，接口名要和文件名一样；

例子：

// 定义一个接口，如果是public的话接口名需要和文件名一样
    interface Itf{
        // 接口的方法都是开放的抽象方法， public abstract 可以不写
        // 接口方法只需要定义返回类型，参数类型，方法名就可以了
        int rA(int x);
        // 接口里的变量都是 public static final 修饰，所以可以不写
        int x = 9;
    }

System.currentTimeMillis() 获取当前时间戳；

**抽象类：**

抽象类是类和接口的混合体；

抽象类可以继承类，实现接口，这些和普通类一样，但是抽象类需要用abstract修饰；

抽象类可以有抽象方法，可以继承接口也可以自己定义；

抽象类不能被实例化，没有抽象方法的抽象类也不能被实例化；

抽象类可以有构造方法；

抽象类的作用是把能实现的先都实现了，不能实现的交给子类去实现；

定义一个抽象类：

[可见度] abstract 类名称{
    // 需要定义抽象方法
    }

Java8中接口允许有静态方法，私有方法和带缺省实现的抽象方法；

**静态内部类：**

基本和普通的类没有什么区别，它用static修饰，但是它可以访问包裹它的类的私有变量，包裹它的类也能访问静态内部类的私有变量；

静态内部类也可以在外部使用，使用方式为：

包裹类.静态内部类 变量名 = new 包裹类.静态内部类();

Phone.Cpu cpu = new Phone.Cpu();

**成员内部类：**

基本和普通的类没有什么区别，它没有用static修饰，而且它除了基础类型静态变量之外不可以有任何静态变量和方法，它也可以访问包裹它的类的私有变量，包裹它的类也能访问静态内部类的私有变量；

因为是成员类，所以它可以使用外部类的this自引用，比如：

Phone.this.screen；这就是用外部类的成员变量；

在创建成员内部类的时候相当于传了一个外部类；

比如在外部类中创建，可以用：

this.Cpu cpu = new Cpu();

如果在外部类以外的地方创建成员内部类，就需要：

Phone.Cpu cpu = Phone.new Cpu();  // 这种怪异的形式

**局部内部类：**

1: 局部内部类直接在类内部定义；

2: 局部内部类不可以包含任何静态变量和方法还有静态类；

3: 局部内部类不能有访问修饰符，但是可以有final；

4: 它可以访问包裹它的类的私有变量，包裹它的类也能访问静态内部类的私有变量；

5: 局部内部类有一个外部类的引用，可以用类名.this.变量/方法 的形式访问外部类属性和方法；

6: 局部内部类可以访问外部类的参数和局部变量，但是参数必须是final；

内部类可以有父类；

**匿名类：**

1: 匿名类是用来创建接口或者抽象类实例的；

2: 匿名类可以出现在任何有代码的地方；

3: 匿名类在哪里出现就和同类型的内部类一样，比如是在局部定义就和局部内部类一样，在成员变量处定义就和成员内部类一样；

4: 匿名类可以调用抽象类构造方法；

5: 成员匿名类就和成员内部类一样有外部类的this自引用；

6: 匿名类可以访问外部类的private属性；

使用方法：

类 实例名 = new 接口/抽象类(){
    // 这里实现接口/抽象类 的方法
    }

比如：

Phone p = new Cpu(){
    // 这里实现接口/抽象类 的方法
    }

类只有一个，只会创建一次；

做需求是先思考哪些可以抽象出来，再思考有哪些角色，角色和角色之间的互动，然后根据这些先设计出接口，先不去管怎么实现，先设计接口，Java是面向接口编程，最后才是实现；

**枚举(enum)：**

枚举是先定义实例名，而且这些实例名必须放在最开始，枚举的构造方法是priva的；

枚举的父类是Enum类；

枚举不能继承类/抽象类，但是可以实现接口；

enum 枚举名{
        // 实例名，实例名，实例名； 可以这种形式
        // 枚举可以写构造函数和普通函数
    }

// 每个枚举都是class内部实现的
    class 枚举类{
        // public static final 枚举类 实例名 = new 枚举类();
        // 所有值都是public static final
    }

常用方法：

values() 返回枚举类中所有的值。

ordinal()方法可以找到每个枚举常量的索引，就像数组索引一样。

valueOf()方法返回指定字符串值的枚举常量。

循环：

for(枚举类 临时变量: 枚举.values()){
        // 临时变量就是循环出来的枚举值
    }

###  ###

### **异常：** ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMwNTU2Nzg_size_16_color_FFFFFF_t_70][]

Throwable 有两个子类：Exception 程序本身的错误；和 Error 程序无法处理的错误；

只能捕捉Exception，不能捕捉Error；

Exception 分为：IO异常和runtime异常

异常捕捉：try catch finally；哪怕try或者catch里有return，finally也会执行；finally里不能有return，不然会覆盖掉前面的信息；

抛出异常：throws / throw

原则上可以处理的异常都用try，不能处理的交给调用者处理用throws；

当发生异常以后还需要程序继续执行下去的用try，不需要执行下去直接停止的用throws；

try{
        // 需要捕捉异常的代码
    } catch(Exception ex){
        // java会将异常信息封装到一个异常类的实例中，ex是指向实例的引用；
        // 异常处理的代码
        // ex.prinStackTrace(); 是将错误信息输出控制台；
    }
    // catch 语句结束以后代码会继续执行；

接口方法声明中有抛出异常，那么实现它的子类方法可以抛出也可以不抛出异常，如果抛出的话，只能抛出接口声明的异常一样或者这个异常类的子类；

// 接口方法throw一个异常
    int xx() throw 一个异常；

可以自己创建异常，比如一些公共方法，知道这里会有异常，可以反馈给调用者；

比如：

public static void xxx() throws 异常类 {
        // 代码逻辑
        throw new 异常类("");  // throw和throws后面的异常类要一样；
    }

**Java 异常传递：**

异常传递是根据方法调用栈的顺序一层一层往外执行的，如果这个异常到最后都没有被catch的话，线程就会直接退出；

**Java 自定义异常：**

可以创建一个自定义的异常类，继承Exception，覆盖它的构造方法（可以用idea自动生成）

不能用异常做程序跳转，异常的创建和处理都很耗资源；

**自动回收/关闭资源：**

实现 AutocLoseable 接口，覆盖它的close方法；像是一些IO操作可以直接使用因为已经实现这个接口；

class Zy implements AutocLoseable{
        // 弄一个read方法
        // 覆盖一下close方法
    }
    
    try(
        // 创建资源，可以创建多个
        Zy z1 = new Zy();
        Zy z2 = new Zy();
    ){
        // 这里可以使用这些资源
        z1.read();
        z2.read();
        // try里发生了异常，Java会自动调用close关闭资源
    }catch(Exception ex){
        ex.prinStackTrace();
    }

### Collection 集合： ###

如果没有泛型，集合添加的对象默认都是Object；

List 是有序可重复的集合（Collection），查询快，插入删除慢，因为会改变所有元素的位置。

Set 是无序不可重复的集合（Collection），查询慢，插入删除快

Map 键值对；可以通过 map.keySet()遍历key，然后map.get(key))取到值；也可以用map.entrySet()遍历，通过entry.getKey()获取key，通过entry.getValue()获取value

**ArrayList：**基于数组实现，可以自动扩容，查询速度快，插入删除慢

**LinkedList：**基于双向链表，占内存，因为除了储存数据以外还要存储指向前后两个元素的引用，查询速度慢，插入删除快

// 创建 ArrayList 对象 Sites
    ArrayList<String> sites = new ArrayList<String>();
    
    // 创建 LinkedList 对象 Sites
    LinkedList<String> sites = new LinkedList<String>();

**HashSet：**

1: HashSet 基于 HashMap 来实现的，是一个不允许有重复元素的集合。

2: HashSet 允许有 null 值。

3: HashSet 是无序的，即不会记录插入的顺序。

4: HashSet 不是线程安全的， 如果多个线程尝试同时修改 HashSet，则最终结果是不确定的。 您必须在多线程访问时显式同步对 HashSet 的并发访问。

5: HashSet 实现了 Set 接口。

// 创建 HashSet 对象 Sites
    HashSet<String> sites = new HashSet<String>();

**HashMap：**

1: HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。

2: HashMap 实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。

3: HashMap 是无序的，即不会记录插入的顺序。

4: HashMap 继承于AbstractMap，实现了 Map、Cloneable、java.io.Serializable 接口。

5: 如果是自己写的类作为key，那么必须保证equals和hashcode唯一性的实现，而且是不可变的；

// 创建 HashMap 对象 Sites
    HashMap<Integer, String> Sites = new HashMap<Integer, String>();

HashMap的get()方法不需要泛型是因为只需要用到equals和hashcode方法得到唯一性就可以了，所以都是Object类型，返回值才需要使用泛型；

通过entry遍历map：

for(Map.Entry<String, String> entry: map.entrySet()){
        // entry.getKey(); 获取key
        // entry.getValue(); 获取value
    }

**迭代器 Iterator：**

Iterator 是 Java 迭代器最简单的实现，ListIterator 是 Collection API 中的接口， 它扩展了 Iterator 接口。

迭代器 it 的两个基本操作是 next 、hasNext 和 remove。

调用 it.next() 会返回迭代器的下一个元素，并且更新迭代器的状态。

调用 it.hasNext() 用于检测集合中是否还有元素。

调用 it.remove() 将迭代器返回的元素删除。

// 创建集合
    ArrayList<String> sites = new ArrayList<String>();
    // 获取迭代器
    Iterator<String> it = sites.iterator();

**泛型：**

1: 约束数据结构/类(接口)/方法的类型；

2: 泛型是告诉编译器需要做类型检查，是什么类型不重要，重要的是类型要一致；

3: 在使用的时候会默认做好强制转换；

数据结构，比如：

// 这个list里只处理String的数据
    ArrayList<String> sites = new ArrayList<String>();

类(接口)，比如：

// 这个类处理这两个类型，类型名其实就相当于占位符
    class A<First, Second>{ ...... }
    // 实例化的时候
    A<String, Object> a = new A<>();

方法，比如：

// 约束类型，这里在返回的时候强转，就不用在调用的地方一个个的强转了
    public <First> First getFirst(Object var, First aa){ 
        return (First)var;
    }
    
    // 调用方法是看变量的类型是啥就是啥，比如First的实际类型是String
    String f = a.getFirst(xx, yy);

这里注意：

如果这里类型与泛型类型不一致，报错会在调用返回的地方报错，为什么会这样呢，因为强转这个动作是在返回以后做的，上面的调用代码其实相当于：

String f = (String)a.getFirst(xx, yy);

还有一点，如果光调用方法，不去赋值，也就是没有强制类型转换这个动作，是不会报错的，因为都没有赋值Java会省略掉类型检查；

**泛型类型可以继承：**

class  A<B extends C>{
        // 这里实际引用的是父类C类型;
        private B  b;
        // 可以调用父类C的方法；
        b.getC();
    }

**泛型的协变与逆变：**

协变和逆变都是针对引用类型的，可以是返回值，参数等，创建对象不能使用；

写入使用逆变，读取使用协变，因为逆变最高可以到Object类，读取协变更灵活；

为什么会有协变和逆变，是因为普通泛型只能检查类型相同，不会建成继承关系；

例子：

// 祖父类
    class GrandfatherC{}
    
    // 父类
    class FatherC extends GrandfatherC{}
    
    // 子类
    class SumC extends FatherC{}
    
    // 孙子类
    class GrandsonC extends SumC{}
    
    class TestC{
        // 需要传本身类型，如果需要传入子类或者后代类就需要用协变
        // 协变语法：<? extends 本身类型>
        public static void getSumV(List<? extends FatherC>  f) { }
    
        // 需要传入本身类型，如果需要传入父类或者更上层的类就需要逆变
        // 逆变语法：<? super 本身类型>
        public static void getGrandfatherV(List<? super SumC>  c) {}
    
        public static void main(String[] args) {
            // 使用协变以后就可以传入本身类型之外还能传入后代类型
            List<FatherC> fcList = new ArrayList<>();
            getSumV(fcList);
            List<SumC> scList = new ArrayList<>();
            getSumV(scList);
            List<GrandsonC> gcList = new ArrayList<>();
            getSumV(gcList);
    
            // 使用逆变就可以传入本身类型之外还能传入父类类型
            getGrandfatherV(scList);
            getGrandfatherV(fcList);
            List<GrandfatherC> grcList = new ArrayList<>();
            getGrandfatherV(grcList);
    
    // 这样是错误的，因为实例不能使用协变和逆变
    // new ArrayList<? extends FatherC>()，这样就不知道是通过哪个类型创建对象
    // 创建对象时需要明确是什么类型
    // List<? extends FatherC> ffcList 可以，是因为这是引用，所以可以宽泛
    // List<? extends FatherC> ffcList = new ArrayList<? extends FatherC>();
        }
    }

**类型擦拭：**

泛型的类型检查都是在编译阶段，加载到虚拟机中所有的类型都是Object；

**注解**：

@Override 覆盖父类方法或者实现了接口方法

@Deprecated 即将被弃用，不鼓励使用/重写/重载/覆盖

注解就是元数据显示，本身没有任何实现；

注解可以通过反射的getAnnotations来获取注解的数据；

**lambda：**

函数式编程，闭包，可以作为方法参数，方法返回值，赋值变量；

参数是接口的方法才能使用lambda；

lambda相当于Java后台帮助生成一个类来实现接口，并调用提供的方法；

lambda只可以取代只有一个抽象方法的接口；

lambda可以有返回值，也可以有异常，需要在调用封装后接口方法的地方处理异常；

语法例子：

class TsetLambda{
        // 静态多参数
        public static void getLambdaV(String a,String b){
            System.out.println(a+b);
        }
        // 静态单个参数
        private static void getLambdaV2(String s) {
            System.out.println(s);
        }
        // 实例单个参数
        public void getLambdaV3(String a){
            System.out.println(a);
        }
        // 实例多个参数
        public  void getLambdaV4(String a,String b){
            System.out.println(a+b);
        }
        public static void main(String[] args) {
            // 创建一个局部变量
            String s = "hello";
            // 创建一个字符串List
            List<String> listS = new ArrayList<>();
            listS.add("111");
            listS.add("222");
            listS.add("333");
            // 调用List的forEach方法，顺序传入参数str作用到方法上；
            // 语法：(参数)->{代码块;}
            listS.forEach((str)-> {getLambdaV(s,str);});
            // 只有一个参数语法：参数->代码块
            listS.forEach(str-> getLambdaV(s,str));
            // 不使用外部变量的静态方法简写语法：类::方法
            listS.forEach(TsetLambda::getLambdaV2);
            TsetLambda t = new TsetLambda();
            // 不使用外部变量的实例方法简写语法：实例::方法
            listS.forEach(t::getLambdaV3);
            // 因为知道List里都是String类型元素，所以可以使用
            listS.forEach(String::toUpperCase);
    
            Map<String, String> mapS = new HashMap<>();
            mapS.put("1","a");
            mapS.put("2","b");
            mapS.put("3","c");
            // 多参数用法
            mapS.forEach((k, v)->{getLambdaV(k,v);});
            mapS.forEach(TsetLambda::getLambdaV);
            mapS.forEach(t::getLambdaV4);
    
            // stream，感觉就是一个链式处理，一步接着一步的执行下去
            listS.stream().filter(x -> x.length()>4).map(String::toUpperCase).forEach(System.out::println);
            // collector，将处理后的数据能生成一个新的集合，通过collect(Collectors.toList())返回List
            List<String> newListS = listS.stream().filter(x -> x.length()>3).map(String::toUpperCase).collect(Collectors.toList());
            newListS.forEach(System.out::println);
        }
    }

**基础类型的自动装箱/拆箱：**

自动装箱/拆箱，Java会有一定量的缓存；

封装类是不可变的；

例子：

class PackBoxes{
        public static void main(String[] args) {
            // 自动装箱，编译器自动将基础类型打包成对象
            Integer a = 10;
            // 这里idea其实会提醒不必要的装箱，因为可以直接赋值，编译器会自动装箱
            Integer integ = new Integer(10);
            // 将包装类的对象赋值给一个对应基础类型变量时，编译器会自动拆箱
            int b = integ;
            // List，Map操作的都是Object对象，但是自动装箱会将基础类型转换为对应的类
            Map<Integer, String> myMap = new HashMap<>();
            // map明明是需要Integer, String这两个类型的对象，但是传入基础类型也可以就是因为自动装箱
            myMap.put(1, "壹");
            // 注意：myMap.put(null, "空");因为所有的Object对象默认值都是null，所以这里的put是没有问题的，但是到下面for循环中用了int，自动拆箱，null是不能装成int的，所以会报一个空指针
            // get方法接收的是一个Object对象，这里传基础类型没问题也是因为自动装箱，将基础类型装箱成类对象
            myMap.get(1);
            // 这里获取的key其实是Integer对象，但是赋值给int没有问题，就是因为自动拆箱
            for(int i: myMap.keySet()){
                System.out.println(i);
            }
        }
    }

**File类：**

文件分割符：File.separator

环境变量(path)分割符：File.pathSeparator

例子：

class FileTest{
        public static void main(String[] args) throws IOException {
            // 文件路径分割符
            System.out.println(File.separator);
            // 环境变量分割符
            System.out.println(File.pathSeparator);
            // 当前路径
            final String ROOT = '.' + File.separator;
            File f1 = new File(ROOT+"newFile"+File.separator+"files");
            // exists()判断文件/文件夹是否存在，isDirectory()判断是否是目录
            if(f1.exists() && f1.isDirectory()){
                System.out.println("文件夹已经存在:"+f1);
            }else{
                // 如果是一下子创建多层目录结构需要用mkdirs()，不然会创建失败
                // 如果只是创建单层目录结构使用mkdir()
                boolean isSuccess = f1.mkdirs();
                if(isSuccess){
                    System.out.println("文件夹创建成功");
                }else{
                    System.out.println("无法在"+ROOT+"下创建文件夹");
                }
            }
            File ftxt = new File(f1.getPath(),"test.txt");
            if(ftxt.exists() && ftxt.isFile()){
                System.out.println("文件已经存在:"+ftxt);
            }else{
                // createNewFile()创建新文件，这里会有异常
                boolean isFileSuccess = ftxt.createNewFile();
                System.out.println("文件创建成功");
            }
            // 重命名需要新的File实例
            // getPath()获取当前对象的所在目录相对路径
            File newFtxt = new File(f1.getPath(),"new_test.txt");
            // renameTo()重命名，文件/文件夹都用这个方法
            boolean isRename = ftxt.renameTo(newFtxt);
            if(isRename){
                System.out.println("文件"+ftxt.getName()+"重命名"+newFtxt.getName()+"成功");
            }else{
                System.out.println("文件重命名失败");
            }
            // delete() 文件和文件夹都是这个方法删除
            // 需要注意的是删除需要用新的File实例
            boolean isDel = newFtxt.delete();
            if(isDel){
                System.out.println(newFtxt.getName()+"文件删除成功");
            }else{
                System.out.println("文件删除失败");
            }
            // 文件夹也是一样的，重命名需要新的File实例
            File f2 = new File(ROOT+"newFile"+File.separator+"new_files");
            boolean isFolderRename = f1.renameTo(f2);
            if(isFolderRename){
                System.out.println("文件夹"+f1.getName()+"重命名"+f2.getName()+"成功");
            }else{
                System.out.println("文件夹重命名失败");
            }
            boolean isFolderDel = f2.delete();
            if(isFolderDel){
                System.out.println(f2.getName()+"文件夹删除成功");
            }else{
                System.out.println("文件夹删除失败");
            }
        }
    }

### Java IO： ###

写入例子：

class WriteToFile{
        // 只是为了记录功能所以都放在一个main方法中
        public static void main(String[] args) throws IOException {
            final String ROOT = '.' + File.separator;
            File newFolder = new File(ROOT+"newFile");
            if(newFolder.exists() && newFolder.isDirectory()){
                System.out.println("文件夹已经存在");
            }else {
                boolean isFolder = newFolder.mkdir();
                if(!isFolder){
                    System.out.println("文件夹创建失败");
                }
            }
            // 创建一个文件
            File newFile = new File(newFolder.getPath(),"test.txt");
            if(newFile.exists() && newFile.isFile()){
                System.out.println("文件已经存在");
            }
            boolean isFile = newFile.createNewFile();
            if(!isFile){
                System.out.println("文件创建失败");
            }
            // 使用try的话自动回收/关闭资源，会自动调用close方法，不需要手动关闭
            // 将需要关闭的资源放在try(xxx; yyy;zzz;)
            // 流的关闭是有顺序的，自己手动关闭很繁琐，自动关闭大大降低了难度，非常方便
            try(
                // 创建一个FileOutputStream，Output是写入，文件的byte数据传输流
                FileOutputStream fos = new FileOutputStream(newFile);
                // FileOutputStream是通过byte字节流的，OutputStreamWriter是将字节流包装成想要的字符集的字符流写入
                OutputStreamWriter osw = new OutputStreamWriter(fos, StandardCharsets.UTF_8);
                // 使用PrintWriter，可以方便的写入一行字符
                PrintWriter pw = new PrintWriter(osw);
            ){
                String[] strArray = {"这是第一段新的文件新的内容", "这是第二段新的文件新的内容", "这是第三段新的文件新的内容"};
                for(String str: strArray){
                    // println是每段换行写入，print是不换行写入
                    // 写入其实是一层一层走的，先是写入内容进入PrintWriter中，然后再OutputStreamWriter根据编码转成字节byte，然后再是FileOutputStream字节流写入文件
                    pw.println(str);
                    // 清空缓冲区，因为数据是先进入缓冲区再写入文件，需要在关闭前将缓冲区的数据全部写入文件才算完成，这样才能关闭整个流，缓存区的作用是，一个字节一个字节写入太费事儿，所以会等到一定量的字节再一起写入，所以会出现一种可能就是缓存区还有少量的字节因为没达到量没有写入，所以需要清空一下，将里面所有剩余的字节都写入
                    pw.flush();
                }
            }catch (FileNotFoundException e){
                e.printStackTrace();
            }
        }
    }

读取例子：

class ReadToFile{
        public static void main(String[] args) {
            //不重新写一个文件了，直接用直接写入的那个文件读取
            final String ROOT = '.' + File.separator;
            File readFile = new File(ROOT+"newFile"+File.separator+"test.txt");
            // 使用try的话自动回收/关闭资源，会自动调用close方法，不需要手动关闭
            // 将需要关闭的资源放在try(xxx; yyy;zzz;)
            // 流的关闭是有顺序的，自己手动关闭很繁琐，自动关闭大大降低了难度，非常方便
            try(
                // 创建一个FileInputStream，Input是写入，文件的byte数据传输流
                FileInputStream fis = new FileInputStream(readFile);
                // FileInputStream是通过byte字节流的，InputStreamReader是将字节流包装成想要的字符集的字符流写入
                InputStreamReader isr = new InputStreamReader(fis, StandardCharsets.UTF_8);
                // 使用BufferedReader，增加缓存，可以方便的写入一行字符
                BufferedReader reader = new BufferedReader(isr);
            ){
                // reader.lines().map(String::trim).forEach(System.out::println); 这是一种lambda写法，效果和下面一样
                String str = null;
                // 为什么要放在while的条件里面赋值呢？是因为readLine()一行一行读取如果到文件结尾了会返回一个null，如果放在while的代码体里赋值，就需要多一步null的判断
                // 读取和写入正好相反，是先从文件读取内容到缓存区，然后从缓存区读出来
                while ((str = reader.readLine()) != null){
                    System.out.println(str);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

### socket： ###

**  pass**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTMwNTU2Nzg_size_16_color_FFFFFF_t_70]: /images/20221005/aaef1098e8254de4b83446250b6c7928.png