java_总笔记:

java基础学习：

对象：实物

类名  变量名 = new 类名();

变量名：引用，首地址

new : 实例|对象 存储具体内容

this关键字：

1、this代表当前对象。只能出现在方法中，谁调用这个方法，this就是谁

2、this可以在构造器用来调用其他的构造器 this()

​ 必须在构造器中调用

​ 只能在第一行

​ 构造器之间的调用不能形成闭合的环

3、通过this调用其他方法 this.方法名()

带标签的break：

int i =0;
int j = 0;
label:while(true){
 //我是第一层循环
 while(true){
   //我是第二层循环
      if(j*i == 81)
       break label; // continue label
       j++;
    }
    i++;
 }  

label: 就是标签 要终止的位置

**break label ：**终止结束到标签 结束语句

continue label: 终止本次循环 跳到标签位置进行接下来的循环

static关键字：

1、static修饰的内容（属性、方法）先于对象存在的，跟随类的存在而存在

2、

​ 属性 ：非静态属性，每一个对象有自己的一份独有的。静态属性，所有对象共用一份

​ 方法：先于对象存在

非静态属性对象名.属性名， 非静态方法对象名.方法名()

静态属性:对象名.属性名, 类名.属性名;(推荐)

静态方法：对象名.方法名(), 类名.方法名(); (推荐)

在静态方法中，不能使用非静态内容。非静态方法中可以使用静态内容

代码块{}

静态块：类中方法外，同时被static修饰；在类加载的时候执行一次。 一些只是在类加载的时候执行一次的代码，静态块中出现

普通块：方法内,没有关键字修饰； 方法调用的时候执行

构造块：类中方法外 ， 没有关键字修饰；创建对象的时候执行，先于构造器执行； 每次创建对象都需要执行的操作

2020_10_10个人笔记：

封装

private, default, protected, public

重载(Overload)

在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同甚至是参数顺序不同）则视为重载。同时，重载对返回类型没有要求，可以相同也可以不同，但不能通过返回类型是否相同来判断重载。

继承

重写

两同，两小，一大

方法名相同，

形参列表相同，

返回值类型：如果是基本类型就必须相同，引用类型返回值可以为子类

抛出的异常类更小或相等，

访问权限相等或更大

1、子类需要父类的一切内容

2、除了有父类的内容之外还需要有自己特有的内容

子类是父类的延续+扩展

注意：在java中一个类只能有一个直接父类，但是可以间接继承多个类

如果一个类没有显示继承别的类，那么它的父类就是Object

instanceof方法：A instanceof B 判断A是否是B类或B的子类

super关键字

this 当前对象

super 父类对象， 通过super可以显示指定这个内容从父类中获取

调用构造器

访问属性

调用方法

子类对象的构造过程

先找父类，再找子类。而且必须首先找到父类对应的构造器。

在子类构造器的第一行，如果没有显示调用构造器（自己的，也可以是父类）会自动生成一个super()去调用父类的无参构造。 我们也可以通过super(...)手动调用父类构造器

this()

super()

父类中：父类静态块， 构造块， 构造器

子类中：子类静态块， 构造块， 构造器

父类静态块， 子类静态块， 父类构造块， 父类构造器，子类 构造块， 子类构造器

在一个类中找内容（属性、方法）， 沿着继承链找， 从下往上找。

重写

当存在继承关系的两个类中，如果父类的方法不能满足子类的需求， 按需在子类中重写父类中方法（只有方法才存在重写）

方法头部保持一致（权限修饰符， 返回值类型， 方法名，参数列表）

注解：@Override

private的方法，static 方法，final方法 不能重写

子类中的内容： 继承下来的方法， 重写之后的方法， 新增的方法​

抽象类

abstract

如果在父类中的某个方法，完全不能满足任何子类的需求。所以这个方法写了也没有意义，但是我需要子类必须存在这个方法。就可以将这个方法定义成抽象方法，也就是只提供方法头。子类必须重写这个方法。

一旦有了抽象方法，这个类就不完整了，也就变成了抽象类， 抽象类不能被实例化（new对象），只能被用来继承（extends）

接口 interface

如果一个类中所有的方法都不能满足子类的需求，但是子类都必须有，这个类就被完全抽象了，完全抽象类，接口，接口只是提供标准，不提供任何的实现

对象转型：类型转换

自动： 子类->父类 （向上转型） ， 丢失子类的新特性 父类引用 = 子类对象

强制： 父类->子类 （向下转型）， 有可能出现类型转换异常 instanceof

多态

话不要说死了。提高程序的扩展性

多态是建立在有继承， 重写， 向上转型

当父类引用指向子类的对象，通过这个引用调用子类重写过的方法，就会发生多态，根据子类实际对象调用对应的方法。

2020_10_11个人笔记：

异常

异常就程序出现的结果和我们想象的不一样

产生：系统（错误，根本没办法， 错了就错了）。 程序员不小心（内部，外部）

处理：捕获（自己处理） ， 抛出（别人处理）

异常类结构体系：

可抛出的异常类 (Throwable)

​ 错误（Error） 管不了， 不管了

​ 异常（Exception） 可以管， 处理

​ (检查时异常接口)CheckedException(外部)，编译的时候已经有问题了，必须处理

​ (运行时异常) RuntimeException(内部)，编译的时候没有问题，运行的时候可能出问题， 避免

所有的继承自Exception而不继承RuntimeException的都是检查时异常

检查时异常

​ 编译的时候已经有问题了，必须处理

运行时异常

继承自RuntimeException的异常， 编译不出错，处理方式（避免），通过程序的健壮性避免

自定义异常

1、定义一个异常类 直接继承自Exception

2、在适当的时机产生异常

3、抛出异常

包装类

对8中基本类型的包装， int Integer, char Character

1、方便类型转换 String 和基本类型之间转换

2、满足容器|集合的需求

3、保存了一些数据的信息

Integer中

Integer a= //-128到127 常量池中 其他就new一个Integer对象
Integer.vauleOf();//相当于上面的，但是jdk9已经废弃
int a  =  //基本数据常量池中

Integer a=new Integer();创建对象

String a=new String(“a”)

String a=new String("a");
String b="a";

2020_10_12个人笔记：

包装类

String

StringBuffer StringBuilder//常用，

Date: new Date(), getTime(), new Date(long)

SimpleDateFormat: 字符串->日期 日期->字符串

LocalDateTime.of() , now() , LocalDateTime.parse(str,formatter) , date.format(formatter)

LocalTime 、 LocalDate 、

LocalDateFormatter

提供了一些计算时间|日期之差的类,Period,ChronoUnit

Math -> 静态的

File: File是文件的抽象，文件和文件夹

2020_10_13个人笔记：

当容器存放类数据的话，应该重写hashCode和equal方法，否则所有的对象都是不相同的。

1.2. 容器中的接口层次结构

​ 所有实现了Collection接口的容器类都有一个 iterator 方法用以返回一个实现了Iterator接口的对象。

Iterator对象称作迭代器，用以方便的实现对容器内元素的遍历操作。

4、容器的遍历

​ 普通for get(int)

​ 增强for

​ 迭代器

迭代器： 所有实现了Collection接口的容器类都有一个 iterator 方法用以返回一个实现了Iterator接口的对象。Iterator对象称作迭代器，用以方便的实现对容器内元素的遍历操作。

​ 1、先通过容器获取一个和当前容器相关的迭代器（游标）， 默认位置在第一个元素之前

​ 2、利用迭代器提供的方法，hasNext方法，判断是否有下一个元素

​ 3、如果有，就获取下一个元素，同时让游标向后走一个，next()

Collection接口

只是一个集合可以存储多个数据， 提供常用基本的操作

int size();   // 获取容器当前存储的元素的个数
boolean isEmpty();   // 判断容器中是否有元素
boolean contains(Object o);
Iterator<E> iterator();
Object[] toArray();
boolean add(E e);
boolean remove(Object o);
boolean containsAll(Collection<?> c);
boolean addAll(Collection<? extends E> c);
boolean removeAll(Collection<?> c);
boolean retainAll(Collection<?> c);
void clear();
boolean equals(Object o);

List 接口

List是一个容器，应该具有容器的功能，还规定了这种容器中存储的数据的特点有序，可以重复的

接口中增加一些和位置相关的操作

boolean addAll(int index, Collection<? extends E> c);   // 添加一个集合的元素到指定位置
E set(int index, E element);  // 修改指定位置的元素
void add(int index, E element);
E remove(int index);
int indexOf(Object o);
int lastIndexOf(Object o);
List<E> subList(int fromIndex, int toIndex);
public E get(int index)

ArrayList类

Object[] elementData  ; 存放数据的地方

类就可以创建对象，也就可以存储数据，属性 数组

LinkedList类

类就可以创建对象，也就可以存储数据，属性 链表

**HashMap：**线程不安全：

1.在jdk1.7中，在多线程环境下，扩容时会造成环形链或数据丢失。

2.在jdk1.8中，在多线程环境下，会发生数据覆盖的情况。

HashSet

数据特点：无序，不可重复

重写了hashCode 和 equals方法

添加一个元素，先看是否有相同hashCode,如果没有直接添加。 如果有相同的hashCode值，再调用equasl方法进行详细比较

我们希望只要属性值相同，认为是相同的对象，不要再添加进去了

hashCode 的重写规则，帮我们剔除掉那些一眼就能看出来不和谁相同的对象，直接往里添， 达到提高效率的效果

2020_10_15个人笔记：

// 上下界 只能规定类型   数据
        List<? extends F> list  = null;
        List<Object> list1 = new ArrayList<Object>();

        List<S> list2 = new ArrayList<S>();
        list = list2;
        list2.add(new S());


class F{

}
class S extends F{

}

Collections工具类

Collections.sort()要求类型必须实现了Comparable接口 重写compareTo()方法，方法用来指定排序规则，默认升序排序，前面加个负号可以实现降序排序

Collections.sort() Collections.sort(list,comparator),

Comparable接口：

Collections.sort()

沉稳，写一次后面都可以用了。但是不够灵活。

1.类里面继承Comparable

2.重写CompareTo方法{里面写的是想要通过什么属性来做比较进行排序}

Comparator比较器

Collections.sort(list,comparator),

​ 1.可以自己写个类，实现Comparator接口，

​ 2.可以使用匿名内部类来实现comparator的方法

​ 3.lambda表达式实现

​ 4.使用引用其他地方的compare方法

灵活，但是每一次度需要给定

20201016个人笔记:

内部类：

不存在局部静态内部类：

类加载的时候先加载所有静态属性，静态内部类和所在的方法只能加载一个，同时加载逻辑上会有错误。如果都是静态的，内部类该加载在那个地方，

匿名内部类：

匿名内部类对象， 简化

如果存在一个接口， 接口里边只有一个抽象，再次进行简化 Lambda

interface Fly{
    void fly();
}

Fly fly=new Fly{
    @Override
    public void fly() {
        System.out.println("ni");
    }
};

Lambda表达式：

(参数)->{方法体}

​ 左侧：Lambda表达式的参数列表。对应接口中抽象方法的参数列表。 右侧：Lambda表达式中所需要执行的功能，即Lambda体。对应接口中抽象方法的 实现。

函数式接口

1、系统可以给

2、自己给（按需求给）

一个接口，只存在一个抽象类。能够使用Lambda

验证一个接口是否是函数式接口

@FunctionalInterface

消费型接口 Comsumer

​ 方法：void accept(T t)

供给型接口 Supplier

​ 方法：T get()

函数型接口 Function

​ 方法：R apply(T t)

断定型接口 Predicate

​ 方法：boolean test(T t)

方法引用

方法引用就是lambda的变形，简写。

假设我们需要实现的功能（方法），已经有人提供了， 我们就可以引用别人写好的方法。

功能是我要的，方法的返回值，参数列表要和我们的接口方法保持一致

方法调用：使用的结果

方法引用：使用的方法体

-> ::

语法格式：

对象::实例方法名 非静态方法

类名::静态方法名 静态方法

类名::实例方法名 非静态方法

类名::new 引用构造器

20201017学习笔记：

IO流：

File既可以表示文件也可以表示文件夹。

​ Reader 和Writer只能处理文本。

​ write(int a) //a自动转型为char型

​ BufferedReader 有readLine()方法。

​ BufferedWriter有writeLine()方法。

InputStream --> FileInputStream 字节流，出现乱码时可read(byte[])稍微避免

OutputStream --> FileoutputStream

Reader->FileReader 对文本（字符流）进行操作 出现乱码不可避免

Writer->FileWriter

加Buffer前缀 使用缓冲流

BufferInputStream BufferoutputStream

BufferReader 新增readLine() BufferWriter新增writeLine() 提高性能读取文件

ByteArrayInputStream和ByteArrayOutputStream 不常用，不能对文件操作

InputStreamReader 可设计编码方式 对象 放入BufferReader中

// 解决乱码而且方便
        // 通过字节流读取文件内容， 由转换流内部帮我们将字节转为字符，而且我们设置了 编码
        InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"), "GBK");
        BufferedReader bufferedReader = new BufferedReader(isr);

DataInputStream 和DataInputStream 一个一个按格式存，一个一个按格式取

ObjectInputStream和ObjectOutputStream 对对象进行操作

类需要实现序列化接口，类中的属性可以加transient该属性的值就不能被序列化

20201019学习笔记：

多线程：

接口不能继承类，只能继承接口。

多线程：三种实现方法

**Thread ：**将需要实现线程的类继承Thread类，重写run()方法,run中内容就是可以多线程的。但是，Java中是单继承的，所以使用这种方法比较少。

**Runnable ：**实现Runable接口，实现run()方法。常用

​ Thread th=new Thread(类对象)或Thread th=new Thread(类对象，需要传入的名称)

​ 方法中用Thread.currentThread().getName()获取

**Callable：**实现Callable接口，实现call方法，创建实现类对象，由Callable创建一个FutureTask对象，由FutureTask创建一个Thread对象。启动线程。不常用 不过有返回值。

Runable：

1. 创建线程类: 继承 Thread类 +重写 run() 方法

2. 构造线程类对象： 创建 子类的对象

3. 启动线程: 通过子类对象调用 start() 方法

线程的5种状态：

​ 新建 : new就是新生
​ 就绪 : 当一个线程调用start(),就进入到就绪队列进行等待,等待cpu的调度
​ 运行 : 当cpu分配时间片给哪一个线程,这个线程才能运行
​ 阻塞 : 不是一定会出现的,非正常运行了 sleep
​ 死亡|终止 : 线程结束

    如何控制线程进入终止状态:
        1.正常运行结束   2.stop ,destroy() 过时    3.通过标识判断

    如何进入就绪状态:
        1.start  2.线程切换  3.yield 礼让线程   4.阻塞解除

    如何进入阻塞状态
        1.sleep    2.join 插队   3.wait（notify和notify唤醒）    4.IO


    注意:
        一个线程如果进入阻塞状态,阻塞解除没有办法直接恢复到运行,会直接恢复就绪
        一个线程如果一旦终止,没有办法恢复

   sleep 线程休眠|睡眠  (ms)
      静态方法
      抱着资源睡觉
      当一个执行到sleep方法,当前线程就会休眠指定时间,在休眠过程中,让出cpu的资源

礼让线程 yield
    让出cpu的资源,同时恢复就绪状态,等待cpu重新调度,是否还是会调度到原线程,不一定

状态：thread.getState()得到状态。

join方法: //插入thread.join();插入并执行完

//hread.join(1000)插入并执行1秒或更少（结束）

wait（）方法

语义：使得当前线程立刻停止运行，处于等待状态（WAIT），并将当前线程置入锁对象的等待队列中，直到被通知（notify）或被中断为止。

notify（）方法

语义：唤醒处于等待状态的线程

使用条件：notify（）也必须在同步方法或同步代码块中调用，用来唤醒等待该对象的其他线程。如果有多个线程在等待，随机挑选一个线程唤醒（唤醒哪个线程由JDK版本决定）。notify方法调用后，当前线程不会立刻释放对象锁，要等到当前线程执行完毕后再释放锁。

优先级

每一个线程都有优先级别问题 优先执行谁 ,概率问题,但是 不能控制一个线程是否先执行

thread.getPriority()得到优先级

sleep ：抱着资源睡觉，在sleep的时候一直使用着锁的资源。

yelid ：礼让线程

synchronized：同步锁，

​ 可以锁类：类名.class

​ 可以锁类对象：this 或者自己定义好的类对象都行，不变的

​ 可以锁资源：通常使用地址不变的资源，类的属性。

​ 同步块: 资源,一定要锁不变的东西,引用数据类型 -->自定义的 引用数据类型的地址

方法也能加synchronized

死锁

​ 尽量避免嵌套锁。

20201020学习笔记：

网络编程:
        IP : 定义网络上的节点
        端口 : 区分不同的软件
        URL : 统一资源定位符

        网页编程  : 应用  js  jsp ...
        网络编程  : 协议  底层  数据的传输 ...

        ***协议
            udp :  写信  不安全  效率高  协议简单   大小一般不超过60k
            tcp :  打电话  安全  协议复杂 麻烦  没有限制

InetAddress类：

​ 构造方法不是public，只能使用它的方法。

常用方法：

​ InetAddress.getLocalHost(); 返回本机主机的地址，返回一个InetAddress对象

​ InetAddress.getByName(“www.baidu.com”); //通过域名

​ InetAddress.getByName(“103.235.46.39”);//通过地址

​ InetAddress实例对象.getHostAddress()//返回IP地址

​ InetAddress实例对象.getHostName()//返回IP地址

InetSocketAddress

​ 比InetAddress类多了一个端口号

URL类实现网络爬虫。

UDP编程:

DatagramSocket**，**

DatagramSocket(int port)//设置自己的端口

public DatagramPacket(byte buf[], int offset, int length) //接收端，服务端

public DatagramPacket(byte buf[], int offset, int length, SocketAddress address)//发送端，客户端

DatagramPacket 数据包

TCP编程：

Socket:客户端

ServerSocket:服务端

20201021学习笔记：

CompareTo:容器中sort排序时，可以需要重写的方法CompareTo，实现Comparable接口。

使用set，map，存放类数据中可能需要重写hashCode和equals方法；

要clone是需要实现接口cloneable，

ObjectOutputstream：存放类对象时需要实现序列化接口 Serializable ；

20201022学习笔记：

数组的底层原理：

​ 在堆中开辟一段连续的内存，并将首地址放入栈中。

多态，重写。

多态利用父类代码重写实现的。

反射：

反射 是发生在程序运行期间的行为
Java反射机制，可以实现以下功能：
①在运行时判断任意一个对象所属的类；
②在运行时构造任意一个类的对象；
③在运行时判断任意一个类所具有的成员变量和方法；
④在运行时调用任意一个对象的方法；
⑤生成动态代理；

反射的源头: Class
Class 类的实例表示正在运行的 Java 应用程序中的类和接口

    Class 对象
        在类加载 到内容中时就有了表示这个类型的Class对象
        Class对象是唯一的,不会改变的

三种获得Class对象的方法：

​ 1.类名.class

​ 2.类对象名.getclass()

​ 3.Class.forName(“包名.类名”)；常用

得到类对象：

​ 通过Class类对象.newInstance()方法获得Object类，在进行转型得到对象。

由class对象可以得到类的方法，类的属性，类的构造器：

方法：

getConstructors() 得到类所有的public构造方法，

getConstructor(Class<?>… parameterTypes) 通过传入的传输类型判断调用的构造器。

getDeclaredConstructors() 得到类的所有的构造方法

getDeclaredConstructor(Class<?>… parameterTypes)

获取属性：

getFields()

getField()

getDeclaredField()

getDeclaredFields()

setAccessible(true); //开放权限
set(Object obj, Object value)  //设置值

获取方法：

getDeclaredMethods()

getDeclaredMethod()

getMethod()

getMethods()

invoke(Object obj, Object... args)   //前面是类对象，后面是参数

注解：

根据参数分类：标记注解，单值注解，完整注解。

根据用途分类：

jdk内置系统注解：比如@Override ,@Deprecated,@SuppressWarnings

元注解:

​ @Target: 描述注解的使用范围

​ @Rentention: 描述注解的生命周期

​ @Document: 表示这个注解会存在于API文档中

​ @Inherited: 标识可以被继承

自定义注解:

自定义注解
1.使用@interface定义注解

    注解:
        1.默认隐示实现了java.lang.Annotation接口
        2.自定义的注解类不能继承其他父类或者实现其他接口
        3.注解属性,在属性名的后面添加一对()
        4.注解类的属性的 修饰符只能为public|default
        5.注解类的属性的数据类型只能为基本数据类型,String,annotation,枚举,以上类型的数据
        6.如果枚举类的数据只有一个,建议你设置属性名字为value,如果只有一个属性并且属性名字为value,赋值可以省略属性名,否则属性名=属性值\
        7.使用注解类时候如果存在多个参数 ,需要放在一对{}中赋值
        8.使用default为属性添加默认值

public @interface 注解名{定义体}

参数：

修饰符：

方法的类型：

​ （int，float，boolean,byte,double,char,long.short);

​ String 类型

​ Class类型，

​ enum类型；

​ Annotation类型；

​ 以上所有类型的数组

命名（方法的名字）

对取名没有要求，如果只有一个参数成员,最好把参数名

称设为"value"，后加小括号。

参数

注解中的方法不能存在参数

默认值

可以包含默认值，使用default来声明默认值

@Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) 
@interface Programmer{
    String value() default "马云";
    int name;
}

20201023学习笔记：

xml:

<?xml version="1.0" encoding="utf-8" ?> //xml头部标识

常用dom4j来解析XML文件。需要导入dom4j包。

获得document对象：

SAXReader reader=new SAXReader(); 

Document document=reader.read(newFile("input.xml"));

document对象就能操作xml文件了，

ElementrootElm=document.getRootElement();//获得根节点 

Element memberElm=root.element("member"); //获得点memeber标签的子节点

String text=memberElm.getText();//获得节点文本 

Element ageElm=memberElm.addElement("age");//添加子节点

ageElm.setText("29");//设置节点文本 

parentElm.remove(childElm);//）删除某节点

编写xml文件重要步骤：

 //1.创建Document对象
        Document document = DocumentHelper.createDocument();
        //2.添加根节点
        Element root = document.addElement("sxt");
        //3.跟标签中添加子元素
        Element bjsxt =root.addElement("bjsxt");
        //4.添加属性
        bjsxt.addAttribute("location","西三旗");
        //5.添加子元素
        bjsxt.addElement("name").addText("北京尚学堂");

//1.XMLWriter 写出
        XMLWriter writer = null;

        //2.指定写出的docuemnt内容的格式器
        //OutputFormat format = OutputFormat.createCompactFormat();
        OutputFormat format = OutputFormat.createPrettyPrint();

        //3.创建这个流,指定 使用哪一种格式写出
        writer = new XMLWriter(new FileWriter(path),format);

        //4.写出
        writer.write(document);

删除：
root.remove(e);

正则表达式：

​ 正则表达式是用来描述具有一定特征的字符串的特殊字

符串。

常用的一些：

由 [] 组，只匹配一个， 需要注意以下四个:

​ ^ : 如果在第一个位置，表示取反的含义。其他位置就是普通符号^

​ - ：表示一个区间即范围

​ ] : 最近一个位置为:结束 ，如果要表示普通的]请加 \

​ \ : 转义

. : 全部类型；

\d：数字0到9；

\w:A到Z，a到z，0到9.

量词：

*:0个及以上

+:1个及以上

？：0或1个

{n}：n次，非负数

{n,}:大于等于n次

{n，m}：大于等于n次，小于等于m次

贪婪模式：

懒惰模式：

独占模式：

边界：

​ 1)、边界不占用宽度，只是一个界限

​ 2)、 ^ ：开始 \b ：单词边界 \B ：非单词边界

​ $ ：结束

​ ^ ：多行代表每行头 单行代表整个字符串的开始

​ $ : 多行代表每行尾 单行代表字符串的结尾

​ \b : 匹配前面或后面的不是\w

​ \B : 匹配前面或后面的是\w

	查找开头的 hello -> ^hello 
    找出 独立的单词 world -> \bworld\b 
    查找结尾的 world -> world$

选择符 |

| ->优先级低 ,满足匹配则停止，不会查找更优的方案

he|hello –>只匹配 he,不匹配 hello

hello|he->匹配 he 与 hello

分组：

匹配 ab c -> ab|c 
    匹配 ab ac -> a(b|c) 
    只匹配 get -> \bget\b 
    匹配 get 和 getValue -> getvalue|get 
    get(value)? 
    获取 and or -> \band\b|\bor\b   \b(and|or)\b

反向引用：

​ 内部默认缓存,从第一个左括号计算，编号为 1 开始。

\i 的内容和前面第i个组的内容相同

(")test\1 –> “第 1 个左括号中  可识别"test"
((")test)\2 –> “第 2 个左括号中   
((("))test)\3 –> “第 3 个左括号中 
(["'])([^"']+)\1 ->找出合法的字符串"" 或''  可识别"12"

非捕获组: (?:xxx) ： 不缓存组

(["'])(?:[^"']+)\1 ->不缓存第二组，不能引用第二组 
(?:["'])(?:[^"']+)\1 –>所有的组都没有缓存，不能再引用了。

零宽断言

前瞻和后顾

(\w+)(?<=ing) –>匹配 singing testing --->sing test整个单词 ->后顾
(\w+)(?=ing) -->匹配ingsing ingtest  sing test->前瞻

常用类

java.util.regex , Pattern , Matcher, String

String str ="and"; //完全匹配 
boolean flag =str.matches("\\b(and|or)\\b"); System.out.println(flag);
str="\"happy\" and \"regex\" \"baidu\" or \"google\""; //替换所有
str =str.replaceAll("\\b(and|or)\\b", "-->"); 
System.out.println(str); //分割 
str="\"happy\" and \"regex\" \"baidu\" or \"google\""; //切割 
String[] arr=str.split("\\b(and|or)\\b");
for(String temp:arr){
    System.out.println(temp); 
}
arr=str.split("m");

Pattern：

compile(String regex) 将给定的正则表达式编译为模式

compile(String regex,int flags) 将给定的正则表达式编译为带有给定标志的模式

matcher(CharSequence input) 创建一个匹配器，匹配给定的输入与此模式。

mathches(String regex,CharSequence input) 编译一个给定的正则表达式，并尝试匹配给定的输入

Matcher:

find() 尝试找到匹配模式的输入序列的下一个子序列。

find(int start) 重新设置该匹配器，然后尝试从指定的索引开始找到匹配模式的输入序列的下一个序列。

matches()尝试整个区域与模式进行匹配。

20201024学习笔记：

Stream流：

泛型参数不能为基本类型，改为包装类。是基于Object的

因为基本数据类型不能转object类型。

Stream的操作三个步骤

1、创建Stream

一个数据源（如：集合、数组），获取一个流

2、中间操作

一个中间操作链，对数据源的数据进行处理

3、终止操作

一个终止操作，执行中间操作链，并产生结果

Stream的中间操作

多个中间操作可以连接起来形成一个流水线,除非流水线上触发终止操作,否则中间

操作不会执行任何的处理,而在终止操作时一次性全部处理,称为”惰性求值”。

filter ：筛选。

limit ：截断流

distinct ：去重复

sorted(Comparable)-自然排序

sorted(Comparator)-定制排序

查找与匹配

// allMatch-检查是否匹配所有元素
// anyMatch-检查是否至少匹配一个元素
// noneMatch-检查是否没有匹配所有元素
// findFirst-返回第一个元素
// findAny-返回当前流中的任意元素emps.parallelStream()// 并行流-多条线程进
// count-返回流中元素的总个数
// max-返回流中最大值
// min-返回流中最小值
// map   {{}，{}，{}}
// flatMap  {}

收集

// List-把流中所有元素收集到List中
// Map-把流中所有元素收集到Map中，当出现相同的key时会抛异常

20201027学习笔记：

成员变量和局部变量的区别：

​ 成员变量：（实例变量）

​ 1、成员变量定义在类中，在整个类中都可以被访问。

​ 2、成员变量随着对象的建立而建立，随着对象的消失而消失，存在于对象所在的堆内存中。

​ 3、成员变量有默认初始化值。

局部变量：

​ 1、局部变量只定义在局部范围内，如：函数内，语句内等，只在所属的区域有效。

​ 2、局部变量存在于栈内存中，作用的范围结束，变量空间会自动释放。

​ 3、局部变量没有默认初始化值

类变量（静态变量）：

​ 1.随着类加载而加载，

​ 2.由于对象存在，

​ 3.被所有的对象所共享

​ 4.可以直接被类名调用

单例模式:

​ 实例保证只能有一个(对象地址相同)

饿汉式 :  类加载的时候就创建对象                  ->线程安全
懒汉式 :  当方法调用的时候(要的时候)才创建对象    ->线程不安全,相对效率高
    通过同步控制懒汉式线程安全问题

步骤:
    1.私有的构造器
    2.私有的静态该类的引用
    3.公共的静态的访问方式

静态代理:

​ 1.代理角色和真实角色实现相同的接口
​ 2.代理持有真实角色的引用 (通过成员变量来控制之间的关联关系)
​ 3.代理行为

抽象类和接口的异同之处：

1.都不能被实例化。

2.抽象类的子类度必须实现抽象类中的全部的抽象方法，才可以被实例化，不然任然为抽象类。

3.抽象类可以有构造方法，也可以有普通方法。接口不行

4.抽象类中的变量可以是普通变量，接口中定义的变量只能是公共的静态的变量。

容器中线程安全问题:

​ vector，HashTable、Properties是线程安全的。

​ ArrayList、LinkedList、HashSet、TreeSet、HashMap、TreeMap等都是线程不安全的。

节点流和处理流：

节点流：inputStream & outputStream & Reader & writer 之类的 ，new是前面加File的

处理流，需要加在节点流的基础上。

经典问题：

public class Test {
    public Test() {
    }
    static void print(List<Integer> al) {
        al.add(2);
        al = new ArrayList<Integer>();
        al.add(3);
        al.add(4);
    }
    public static void main(String[] args) {
        List<Integer> al = new ArrayList<Integer>();
        al.add(1);
        print(al);
        System.out.println(al.get(1));
    }
}

//输出2

float f=3.4f; 
Float f2=3.4f;
double d=3.4;
Double d2=3.4;
Double d3=34D;
long l1=345;
Long l2=224L;
System.out.println(1>0?9:9.9);//自动向上转输出9.0

​ 3.被所有的对象所共享

​ 4.可以直接被类名调用

单例模式:

​ 实例保证只能有一个(对象地址相同)

饿汉式 :  类加载的时候就创建对象                  ->线程安全
懒汉式 :  当方法调用的时候(要的时候)才创建对象    ->线程不安全,相对效率高
    通过同步控制懒汉式线程安全问题

步骤:
    1.私有的构造器
    2.私有的静态该类的引用
    3.公共的静态的访问方式

静态代理:

​ 1.代理角色和真实角色实现相同的接口
​ 2.代理持有真实角色的引用 (通过成员变量来控制之间的关联关系)
​ 3.代理行为

抽象类和接口的异同之处：

1.都不能被实例化。

2.抽象类的子类度必须实现抽象类中的全部的抽象方法，才可以被实例化，不然任然为抽象类。

3.抽象类可以有构造方法，也可以有普通方法。接口不行

4.抽象类中的变量可以是普通变量，接口中定义的变量只能是公共的静态的变量。

容器中线程安全问题:

​ vector，HashTable、Properties是线程安全的。

​ ArrayList、LinkedList、HashSet、TreeSet、HashMap、TreeMap等都是线程不安全的。

节点流和处理流：

节点流：inputStream & outputStream & Reader & writer ，new是前面加File的

其他都是处理流，需要加在节点流的基础上。

经典问题：

public class Test {
    public Test() {
    }
    static void print(List<Integer> al) {
        al.add(2);
        al = new ArrayList<Integer>();
        al.add(3);
        al.add(4);
    }
    public static void main(String[] args) {
        List<Integer> al = new ArrayList<Integer>();
        al.add(1);
        print(al);
        System.out.println(al.get(1));
    }
}

//输出2

float f=3.4f; 
Float f2=3.4f;
double d=3.4;
Double d2=3.4;
Double d3=34D;
long l1=345;
Long l2=224L;
System.out.println(1>0?9:9.9);//自动向上转输出9.0