JavaSE

(1)结束的是整个循环，它用于switch和循环结构里面

(2)结束的时本次循环，循环还会执行下一次，它用于循环结构里面

(1)for循环实现

int[] a = {10,20,30,40,50};

int a1 = new int[a.length * 2];

for(int i =0;i<a.length;i++){

a1[i] = a[i]; }  

int...= int[]

String... = String[]

char... = char[]

double... = double[]

method(x , xx[] , xx... );//可变长参数，是对数组的一种便利写法的补充(80%的场景用数组，20%的场 景用可变长参数)

实例：

传入的实参可以为m(1,2,23,3,4,5)或者m(arr)//arr为定义的数组

Public static void m(int... b)

相邻的两个值比较大小，互换位置。比如第一个值和第二个值比完后第二个值然后再和第三个比。。。。按照给定的if判断条件进行位置的互换。

记忆: 外层length-1 ;内层length -1-i

补充:嵌套循环约定俗称的变量命名，一重循环 i; 二重循环j;三重循环k;

固定值与其他值比较大小，互换位置。现将第一个值和其他后面各个值比较如果第一个值大于后面的某个值，那就将它两个调换位置，继续向后比较，这样循环一次的结果就是吧最小的值移到了最前面。

2).记忆:外层length-1 ;同时外层i作为固定值，内层的j=i+1 作为其他值的起始

声明、再分配空间:
数据类型[][] 数组名;
数组名= new数据类型[高维长度][低维长度];

声明、再分配空间:
数据类型[][] 数组名;
数组名= new数据类型[高维长度][低维长度];

声明并赋值(繁):
数据类型[][] 数组名= new数据类型[高维长度][]; //不规则数组， 自行new低维数组，这时候高维数组里面存的不是低纬数组的地址 而是null，前面数组的默认值里面提到的引用类型默认值为null

声明并赋值(简) :
数据类型[][] 数组名= { {v1,v2,v3},{v4,v5},{v6,v7,v8,v9} }; // 显示初始化

注意：高维数组中的每一个元素，保存了低维数组的地址。访问array[0]等价于在访问0x0000A111（"二维数组的内存分配图"）

特点:代表- -组任意类型的对象,无序、无下标。

方法:

boolean add(Object obj) //添加-一个对象。

boolean addAll(Collection c) //将一个集合中的所有对象添加到此集合中。

void clear() /清空此集合中的所有对象。

boolean contains(Object o) //检查此集合中是否包含o对象

boolean equals(Object o) //比较此集合是否与指定对象相等。

boolean isEmpty() /判断此集合是否为空

boolean remove(Object o) //在此集合中移除o对象,也可以传入下标

int size() //返回此集合中的元素个数。

Object[] toArray() //将此集合转换成数组。

I. public static <T extends Comparable<? super T>> void sort(List<T> list) //排序，要求：必须实现Comparable，必须可与自身类型比，以及父类类型比

II. public static void reverse(List<?> list) //反转、倒置元素

III. public static void shuffle(List<?> list) //随机重置顺序

I. 特点：无序、无下标、元素不可重复（当插入新元素时，如果新元素与已有元素进行equals比较，结果为true时，则拒绝新元素的插入）

II. 方法：全部继承自Collection中的方法

 foreach循环：

for(数据类型 变量名 : 容器名称){ //可遍历集合或数组（常用在无序集合上）

}

Set接口实现类

List基本属性及方法

List实现类

II. HashMap算法：拿到任何一个对象好，通过hash(key)做运算，key>>>16（除以16），只可能得到0~15之间的一个数组，作为插入数组的下标

JDK 1.2版本 线程不安全，运行效率快

III. Hashtable：HashMap的线程安全版本 

Properties

IV. TreeMap：自动对key做排序，根据compareTo的返回值去重

A). 实例泛型：

a). 类：创建对象时，为类所定义的泛型，进行参数化赋值

b). 接口：实现接口时，为接口所定义的泛型，进行参数化赋值

B). 静态泛型：

a). 定义在方法的返回值类型前面：<T>、<T extends Object>、<T extends Comparable<T>>、<T extends Comparable<? super T>>

2). 定义在方法的形参列表当中：<?>、<? extends Object>、<? super Integer>，不支持使用&

当泛型方法调用时，由传入的参数的类型确定

注意

概念

注意

规定泛型确定类型的范围!

<?>

<? extends E>

<? super E>

(1)输入流：将<存储设备>中的内容读入到<内存>中

输出流：将<内存>中的内容写入到<存储设备>中

(1)字节流：以字节为单位，可以读写所有数据 。

(2)字符流：以字符为单位，只能读写文本数据

(1)节点流：具有实际传输数据的读写功能

(2)过滤流：在节点流的基础之上增强功能。

InputStream(抽象类)：字节输入流

public int read(){}

public int read(byte[] b){}

public int read(byte[] b,int off,int len){}

OutputStream(抽象类):字节输出流

public void write(int n){}

public void write(byte[] b){}

public void write(byte[] b,int off,int len){}

(1)BufferedOutputStream

(2)BufferedInputStream

(3)提供了IO效率，减少访问磁盘的次数。数据存放在缓冲区中。flush刷新缓冲区，提交数据

(1)ObjectOutputStream

(2)ObjectInputStream

(3)增强了读写8种基本数据类型和字符串功能

(4)读写对象，实现对象的持久化存储

(5)增强了读写对象的功能：

①readObject() 从流中读取一个对象

②writeObject(Object obj) 向流中写入一个对象

对象的属性必须实现Serializable接口

FileOutputStream：

public void write(byte[] b) //一次写多个字节，将b数组中所有字节，写入输出流。

FileInputStream：

public int read(byte[] b) //从流中读取多个字节，将读到内容存入b数组，返回实际

读到的字节数；如果达到文件的尾部，则返回-1

(1)必须实现Serializable接口。 标识序列化功能

(2)必须保证所有属性均支持序列化。

(3)Transient修饰的为临时属性，不参与序列化

(4)读取到文件末尾时：java.IO.EOFException 

Reader字符输入流

Writer字符输出流

FileReader字符输入节点流

FileWriter字符输出节点流

BufferedReader

BufferedWriter

PrintWriter

InputStreamReader

OutputStreamWriter

(3)可将字节流转换为字符流,可设置编码方式（编码与解码要一致）

使用步骤

//1.先创建字节输出流

OutputStream fos = new FileOutputStream("files\\fos.txt");

//编码2.创建桥转换流（转换为字符输出流）

OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");//指定输出的数据 编码格式

//3.包装成字符过滤流

PrintWriter prw = new PrintWriter(osw);

public interface FileFilter

boolean accept(File pathname)

当调用File类中的listFiles()方法时，支持传入FileFilter接口接口实现类，

对获取文件进行过滤，只有满足条件的文件或者文件夹的才可出现在listFiles()的返回

值中。

System.out.println(file.canExecute());//所有可以打开的文件或文件夹，都是可执行的！

// System.out.println(file.canWrite());//能不能修改文件

// System.out.println(file.canRead());//能不能执行文件

//

// System.out.println(file.createNewFile());//新建一个文件，如果不存在的话

// System.out.println(file.delete());如果文件存在，则删除，返回true

// Thread.sleep(2000);

// file.deleteOnExit();//JVM终止时，执行删除文件

// System.out.println(file.exists());



// System.out.println(file.getAbsolutePath());//绝对

// System.out.println(file.getPath());//相对

// System.out.println(file.getName());//文件名 名字.后缀

// System.out.println(file.getFreeSpace() / 1024 / 1024/ 1024);//获取硬盘的空闲空间

// System.out.println(file.getTotalSpace()/1024 / 1024 / 1024);//总空间

// System.out.println(file.getParent());//指定文件的上一级目录

第七层：应用层负责文件访问和管理、可靠运输服务、远程操作服务。（HTTP、FTP、SMTP）

第六层：表示层负责定义转换数据格式及加密，允许选择以二进制或ASCII格式传输。

第五层：会话层负责使应用建立和维持会话，使通信在失效时继续恢复通信。（断点续传）

第四层：传输层负责是否选择差错恢复协议、数据流重用、错误顺序重排。（TCP、UDP）

第三层：网络层负责定义了能够标识所有网络节点的逻辑地址。（IP地址）

第二层：链路层在物理层上，通过规程或协议（差错控制）来控制传输数据的正确性。（MAC）

第一层：物理层为设备之间的数据通信提供传输信号和物理介质。（双绞线、光导纤维）

一组用于实现网络互连的通信协议，将协议分成四个层次

第四层：应用层负责传送各种最终形态的数据，是直接与用户打交道的层，典型协议是HTTP、FTP等。

第三层：传输层负责传送文本数据，主要协议是TCP、UDP协议。

第二层：网络层负责分配地址和传送二进制数据，主要协议是IP协议。

第一层：接口层负责建立电路连接，是整个网络的物理基础，典型的协议包括以太网、ADSL等等

TCP

UDP

Internet Protocol Address 互联网协议地址/网际协议地址
分配给互联网设备的数字标签（唯一标识）。

IPV4

IPV6

公认端口：0~1023

注册端口：1024~49151

动态或私有端口：49152~65535

常用端口：

public static InetAddress getLocalHost() 获得本地主机地址对象

public static InetAddress getByName(String host) 根据主机名称获得地址对象

public static InetAddress[] getAllByName(String host) 获得所有相关地址对象

public String getHostAddress() 获取IP地址字符串

public String getHostName() 获得IP地址主机名

 Socket（套接字）是网络中的一个通信节点。

分为客户端Socket与服务器ServerSocket。

通信要求：IP地址 + 端口号

II.开发步骤

开发中有一个非常重要的原则“开闭原则”，对拓展开放、对修改关闭。

工厂模式主要负责对象创建的问题。

可通过反射进行工厂模式的设计，完成动态的对象创建。

单例（Singleton）：只允许创建一个该类的对象。

方式1：饿汉式（类加载时创建，天生线程安全）

方式2：懒汉式（使用时创建，线程不安全，加同步）

方式3：懒汉式（使用时创建，线程安全）

数据类型

变量名

值

先声明，后赋值

声明并赋值

多个同类型的变量声明并复制

int 整型

小数

boolean 布尔型

字符

String 字符串

数组

对象

自动类型的转换

强制类型的转换

+ - * / % ++ --

=，*=，+=，-=，/=，%=

&&，||，！

>,<,>=,<=,==,!=

boolean表达式 ? 结果1: 结果2；

形式参数是在函数定义的时候写的，他没有具体的值

实际参数是在函数调用的时候用到的，他需要和形式参数相对应并写入对应类型的值，具有实际值

比较的是内容

使用方法

相当于取反的意思

例子

返回值类型可以是基本数据类型和引用类型

返回值和返回值类型相匹配

应用在具有返回值类型的函数中:
return value; //表示结束当前函数,并伴有返回值，返回到函数调用处。

应用在没有返回值类型(void) 的函数中:
return; //表示结束当前函数，直接返回到函数调用处。

当需要解决的问题可以拆分成若千个小问题，大小问题的解决方法相同。
有固定规律，函数中自已调用自已。

设置有效的出口条件,避免无穷递归。

特别注意：递归应要注明出口条件

任何对象，一定有自己的特征和行为。

一切客观存在的事物都是对象，万物皆对象。
初期：看得见、摸得着、并真实存在，都是对象。

程序如何模拟现实世界

现实的对象从哪来

现实与程序

类名一定要清晰准确的表达出是什么类，
对象只是类的一个实例，可以new无限个

I. 类：定义了对象应具有的特征和行为，类是对象的模板。
II. 对象：拥有多个特征和行为的实体，对象是类的实例。

PS：
属性、实例变量、成员变量，三者等价
实例方法、成员方法，二者等价
reference - 引用、句柄、指针

定义位置

默认值

使用范围

命名冲突

this第一种用法：调用本类中的实例属性、实例方法。例如：this.name、this.run()

this第二种用法：调用本类中的其他构造方法。例如：this()、this(实参)。注意：必须在构造方法的首行，并且必须在构造方法中使用。

概念：尽可能隐藏对象的内部实现细节，控制对象的修改及访问的

private的访问修饰符，修饰属性，达到本类可见的效果。

get/set方法是外界访问私有属性的唯一通道，方法内部可对数据进行过滤。（可在set方法中添加过滤条件）

提供公共访问方法，以保证数据可以正常录入。

数据私有化行为公开化

 程序中的继承，是类与类之间特征和行为的一种赠与或获得。
类与类之间必须满足“is a”的关系。

父类的选择：功能越精细，重合点越多的，越接近直接父类。

父类的抽象：根据程序需要使用到的多个具体类，进行共性的提取，进而定义父类。

在一组相同或类似的类中，抽取出共性的特征和行为，定义在父类中，实现重用。

产生继承关系之后，子类可以使用父类中的属性和方法，也可定义子类独有的属性和方法。

完整的子类 = 父类共性 + 子类独有

好处：既提高代码的复用性，又提高代码的可扩展性。

Java为单继承，一个类只能有一个直接父类，但可以多级继承，属性和方法逐级叠加。

访问修饰符：//其他：不在一个包中，还没有继承关系

继承中的不可继承

继承中方法的重写/覆盖

定义语法

多态指允许不同类的对象（同一父类的子类对象）对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）同一类型变量（父类类型）在调用相同的方法（子类重写父类的方法）时结果不同。

概念：父类引用指向子类对象，从而产生多种形态。

构成多态的前提，二者之间必须具有直接或间接的继承关系，父类引用可指向子类对象，进而形成多态。

父类引用仅可调用父类中所声明的属性和方法，不可调用子类独有的属性和方法。

多态应用的两种场景

装箱和拆箱

instanceof关键字

多态的作用

abstract的意思：抽象的，似是而非的，像，却又不是，具备某种对象的特征，但不完整。

abstract修饰类，意为“不够完整、不够具体，不该独立存在”

抽象方法

静态与实例的区别：

静态的概念

静态的特点

类加载

静态代码块

总结

I. 修饰类：此类不能被继承

II. 修饰方法：此方法不能被覆盖

III.修饰变量

 不同常量类型的特点：

I. 相当于特殊的抽象类，定义方式、组成部分，与抽象类类似。

II. 接口中只能定义公开静态常量（变量）

III. 接口中只能定义公开抽象方法（方法）

IV. 接口不是类

相同：

1). 可以编译成字节码文件

2). 不能创建对象。（接口不是类，不是模板的概念，也没有构造方法）

3). 可以声明引用。

4). 具备Object定义的方法。

 不同：

1). 接口中的属性只能是公开静态常量（隐式使用public static final修饰）

2). 接口中的方法只能是公开抽象方法（隐式使用public abstract修饰）

3). 没有构造方法、没有动态代码块、没有静态代码块

I. 接口是种能力和约定

1). 接口的定义：能力

2). 方法的定义：约定

经验：Java为单继承，当父类的方法种类无法满足子类需求时，可实现接口扩充子类能力。

经验：接口支持多实现，可为类扩充多种能力。

I. 任何类在实现接口时，必须实现接口中所有的抽象方法，否则此类为抽象类。

II. 实现接口中的抽象方法时，访问修饰符必须是public。

同父类一样，接口也可声明为引用，并指向实现类对象。

注意：

1). 仅可调用接口中所声明的方法，而不可调用实现类中独有的方法。

2). 可强转回实现类的本身类型，进行独有的属性和方法的调用。（强转前通过instanceof判断）

I. 不再关注具体的类型，而是关注行为

I. 类与类：单继承，extends父类名称

II. 类与接口：多实现，implements 接口名称1,接口名称2,接口名称3

III. 接口与接口：多继承，extends 父接口名称1,父接口名称2

将多个常用于表示状态和固定值的变量，以形态常量的形式定义在接口中统一管理，提高代码的可读性。

I. 接口是一种标准。

II. 耦合度：模块与模块之间的关联程度，关联的越密切，耦合越高，关联的越松散，耦合越低。

1.class A实现接口CallBack callback——背景1

2.class A中包含一个class B的引用b ——背景2

3.class B有一个参数为callback的方法f(CallBack callback) ——背景3

4.A的对象a调用B的方法 f(CallBack callback) ——A类调用B类的某个方法 C

5.然后b就可以在f(CallBack callback)方法中调用A的方法 ——B类调用A类的某个方法D

I. 成员：

1). 在类的内部定义，与实例变量、实例方法同级别的类。

2). 属于外部类的一个实例部分，创建内部类对象，必须依赖外部类对象。

3). Outer out = new Outer();

Outer.Inner in = out.new Inner();

4). 当外部类、内部类存在重名属性时，有限访问内部类属性，通过外部类类名.this.外部类实例属性

5). 成员内部类不能定义静态成员。

II. 静态：

1). 不依赖外部类对象，可直接创建或通过类名访问，也可声明静态成员。

2). Outer.Inner.静态成员

Outer.Inner in = new Outer.Inner();

III. 局部：

1). 定义在外部类的方法中，作用范围和创建对象的范围仅限当前方法中。

2). 局部内部类访问外部类局部变量时，因无法保障变量的生命周期与自身相同，所以修饰为final。

3). 隐藏类的信息、限制类的使用范围。

IV. 匿名：

1). 没有类名的局部内部类

2). 必须继承一个父类或实现一个接口。

3). 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象。

4). 优：减少代码量，书写的思路流畅。

5). 劣：可读性较差。

getClass方法

hashCade

3.toString()方法

4.equals(Object obj)方法

5.protected void finalize() throws Throwable //了解（面试题中可能有坑）

I. 基本类型所对应的引用类型

II. Object可统一所有数据，包装类的默认值为null

III. 包装类中实际上就是持有了一个基本类型的属性，作为数据的存储空间（Byte中有一个byte属性），还提供了常用的转型方法，以及常量，

既可以存储值，又具备了一系列的转型方法和常用常量，比直接使用基本类型的功能更强大

IV. 包装类型中提供了若干转型的方法，可以让自身类型与其他包装类型、基本类型、字符串相互之间进行转换。

java.lang.Number父类为所有子类分别提供了6个转型的方法，将自身类型转换成其他数字型。

byteValue();  shortValue();    intValue();     longValue();     floatValue();     doubleValue();

 parseXXX(String s) 静态转型方法，8种包装类型都有

parseByte("123");
parseShort("123");
parseInt("123");
parseDouble("123.45");

......

valueOf(基本类型)、valueOf(字符串类型)，静态转型方法，8种包装类型都有

Byte b1 = Byte.valueOf( (byte)10 );

Byte b2 = Byte.valueOf( "20" );

注意：在使用字符串构建包装类型对象时，要保证类型的兼容，否则产生NumberFormatException。

特别留心........................

字符串是常量，创建之后不可改变。

字符串字面值存储在字符串池中，可以共享。

Strings= "Hello";产生-一个对象，字符串池中存储。

String s = new String("Hello"); //产生两个对象，堆、池各存储-一个。而s存储的是堆中的地址。

子主题

public char charAt(int index) :根据下标获取字符。

public boolean contains(tring str) :判断当前字符串中是否包含str。

public charD toCharArray( ):将字符串转换成数组。

public int indexOf(String str) :查找str首次出现的下标，存在，则返回该下标;不存在，则返回-1。

public int lastIndexOf(String str) :查找字符串在当前字符串中最后一次出现的 下标索引。

public int length():返回字符串的长度。

public String trim():去掉字符串前后的空格。

public String toUpperCase():将小写转成大写。

public boolean endWith(String str):判断字符串是否以str结尾。

public String replace(char oldChar, char newChat);将旧字符串替换成新字符串

public String] split(String str):根据str做拆分。

System.out.println( upperHi.equals(lowerHi) );//内容必须完全相同，包括大小写

System.out.println( upperHi.equalsIgnoreCase(lowerHi) );//内容必须完全相同，忽略大小写

String str = text.substring(0, 5); //获取字符串text的子串，传入的参数为截取开始下标和结束下标，截取的内容是开始下标值和结束下标值的前一个（左包右不包）

BigDecimal除法

除法: BigDecimal(BigDecimal bd,int scal,RoundingMode mode)

参数scal :指定精确到小数点后几位。

参数mode :

指定小数部分的取舍模式，通常采用四舍五入的模式，

取值为BigDecimal.ROUND_HALF_UP。

ErrorJVM、硬件、执行逻辑错误，不能手动处理。

Exception程序在运行和配置过程中产生的问题，可处理。

I.当程序在运行时遇到不符合规范的代码或结果时，会产生异常。

throw new 异常类型("实际参数");

1. try{}
catch(){}

2.try{}
catch(){}
catch(){}
......

3.try{}
catch(){}
finally{}

4.try{}
catch(){}
catch(){}
finally{}

5.try{}
finally{}

(1).无参构造方法题

(2)String message参数的构造方法。定义异常原因信息

I.轻量级进程

II.程序中的一个顺序控制流程，也是CPU的基本调度单位。

III.进程可以由单个或多个线程组成，彼此间完成不同的工作，交替执行，称为多线程

IV.JVM虚拟机是一个进程，默认包含主线程(Main函数)，可以通过代码创建多个独立线程，与Main线程并发执行。

(1)CPU时间片：操作系统（OS）会为每个线程分配执行时间。

(2)运行数据：

①堆空间：存储线程需使用的对象，多个线程可以共享堆中的对象。

②栈空间：存储线程需使用的局部变量，每个线程都拥有独立的栈。 

（3） 线程的逻辑代码

第一种方法

.第二种方法

初始状态（new 线程对象）

就绪状态（执行start）

运行状态（竞争到时间片运行）

结束状态（线程运行完毕）

阻塞状态（线程未获得锁进入阻塞状态，获得锁之后进入运行状态）

限期等待

无限期等待

JDK5之后统一把就绪状态和运行状态统一叫Runnable

休眠

放弃

结合

I. 当多线程并发访问临界资源时，如果破坏了原子操作，可能会导致数据不一致。

II. 临界资源：共享资源（同一对象、堆空间），一次仅允许一个线程使用，才可保证其正确性

III.原子操作：不可分割的多步操作，被视作为一个整体，其顺序和步骤不能打乱或缺省。

I.每个对象都有一个互斥锁标记，用来分配给线程。

II.只有持有对象互斥锁标记的线程，才能进入对该对象加锁的同步操作中（同步方法、同步代码块）。

III.只有线程退出同步操作时，才会释放相应的锁标记

同步代码块

(1). synchronized(临界资源对象){

//原子操作

}

I.同步方法

(1). synchronized 返回值类型 方法名成(参数列表){

//原子操作

}

同步规则

I.等待

通知

线程池的概念：

2.线程池的原理及获取（创建）

public interface Callable<V>{

public V call() throws Exception;

}

JDK5加入，与Runnable接口类似，实现之后代表一个线程任务。

Callable具有泛型返回值、可以声明异常。

概念：异步接收ExecutorService.submit()所返回的状态结果，当中包含了 call()的返回值

方法：V get()以阻塞形式等待Future中的异步处理结果（call()的返回值）

同步

异步

JDK5加入，与synchronized比较，显示定义，结构更灵活。

提供更多实用性方法，功能更强大、性能更优越。

常用方法: void lock() //获取锁，如锁被占用，则等待。

boolean tryLock() //尝试获取锁（成功返回true。失败返回false，不阻塞），

void unlock() //释放锁

重入锁

一种支持一写多读的同步锁，读写分离，可分别分配读锁、写锁。

支持多次分配读锁，使多个读操作可以并发执行。

互斥规则：

创建方式：

 Collections工具类中提供了多个可以获得线程安全集合的方法。

public static <T> Collection<T> synchronizedCollection(Collection<T> c)

public static <T> List<T> synchronizedList(List<T> list)

public static <T> Set<T> synchronizedSet(Set<T> s)

public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)

public static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s)

public static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m) 

创建方式：

线程安全的ArrayList，加强版读写分离。

写有锁，读无锁，读写之间不阻塞，优于读写锁。

写入时，先copy一个容器副本、再添加新元素，最后替换引用。

使用方式与ArrayList无异（包括创建方式也一样）

add的主要实现代码及描述：

线程安全的Set，底层使用CopyOnWriteArrayList实现。

唯一不同在于，使用addIfAbsent()添加元素，会遍历数组，

如存在元素，则不添加（扔掉副本）。

add的实现方式：首先我们创建CopyOnWriteArraySet它的对象是，调用无参构造方法，方法内创建了一个CopyOnWriteArrayList对象，并赋值给了CopyOnWriteArraySet他的属性al。调用CopyOnWriteArraySet的add方法时他会调用用CopyOnWriteArrayList内部的addIfAbsent方法。主要实现代码如下：

//e是我们add内的参数

public boolean add(E e) {//CopyOnWriteArraySet下的add方法

return al.addIfAbsent(e);//调用的CopyOnWriteArrayList内部的addIfAbsent方法

}

//进入方法后

public boolean addIfAbsent(E e) {

Object[] snapshot = getArray();//获取了一个数组，相当于复制了一个数组，原数组没动

//下面代码的主要作用是去重，我们传入的e跟snapshot获取的数组内从下标0开始循环长度为数组长度，如果有跟我们传入的e相同的元素，则返回下标，如果没有返回-1（indexOf方法内部代码），然后根据返回的信息，重复的话就抛弃了传入的e不重复的话就吧e添加到了数组末尾（多追源码，清晰）

return indexOf(e, snapshot, 0, snapshot.length) >= 0 ? false :

addIfAbsent(e, snapshot);

} 

初始容量默认为16段（Segment），使用分段锁设计。

不对整个Map加锁，而是为每个Segment加锁。

当多个对象存入同一个Segment时，才需要互斥。

最理想状态为16个对象分别存入16个Segment，并行数量16。

使用方式与HashMap无异

版本差异：

Collection的子接口，表示队列FIFO（First In First Out）

常用方法：

线程安全、可高效读写的队列，高并发下性能最好的队列。

无锁、CAS比较交换算法，修改的方法包含三个核心参数（V,E,N）

V：要更新的变量、E：预期值、N：新值。

只有当V==E时，V=N；否则表示已被更新过，则取消当前操作

Queue的子接口，阻塞的队列，增加了两个线程状态为无限期等待的方法。

方法：

void put(E e) //将指定元素插入此队列中，如果没有可用空间，则等待。

E take() //获取并移除此队列头部元素，如果没有可用元素，则等待。

可用于解决生产生、消费者问题。仔细品一品。

实现类

Consumer<T> 消费型接口 void accept(T t);

Supplier<T> 供给型接口 T get();

Function<T,R> 函数型接口 R apply(T t);

Predicate<T> 断言型接口 boolean test(T t);

Consumer<String> con2 =System.out::println;//对象System.out调用了他的一个实例方法println

con2.accept("嘿嘿嘿");//我们往println里面传入了参数（System.out::println为accept的具体实现） 

Comparator<Integer> com = Integer::compare;

int result = com.compare(1, 2);

//Employee中有一个getName的方法，获取对象的姓名

Function<Employee,String> fun = Employee::getName;//方法引用

String name = fun.apply(e);//我们传入的e就相当于Employee，e.getName返回String，apply接受到了

目前来看要用类::实例方法，实例方法必须为没有参数的方法。

Supplier<Employee> supp =Employee::new;//相当于new了一个Employee类的对象，并返回了

Employee emps = supp.get();//调用方法，获得Employee对象

• Stream<T> filter(Predicate<? super T> predicate); 过滤

• Stream<T> limit(long maxSize); 截断，不超过给定数量

• Stream<T> distinct(); 筛选，利用hashCode和equals

• <R> Stream<R> map(Function<? super T, ? extends R> mapper); 根据Function传入的接口实现，将返回的R存入流中

• Stream<T> sorted(); 自然排序

• Stream<T> sorted(Comparator<? super T> comparator); 定制排序

注意：以上所有的中间操作都是将括号内自己指定的规则，筛选过后存入到流中，然后在进行最终的操作（看返回值）

• long count(); 返回流中元素的总个数

• void forEach(Consumer<? super T> action); 遍历

• boolean anyMatch(Predicate<? super T> predicate); 是否至少匹配一个

• boolean allMatch(Predicate<? super T> predicate); 是否匹配所有元素

• boolean noneMatch(Predicate<? super T> predicate); 是否没有匹配

• Optional<T> findFirst(); 返回第一个

• Optional<T> findAny(); 返回任意

• Optional<T> min(Comparator<? super T> comparator); 返回最小

• Optional<T> max(Comparator<? super T> comparator); 返回最大

注意：看终止操作的返回值，那是最后得到的结果

中间操作（延迟方法）

终止操作（终结方法）

常量

抽象方法

抽象方法

常量

静态方法

默认方法

默认方法

静态方法

常量

抽象方法

private方法

public enum MySingleClass04 {

INSTANCE

}

solid

Single Responsibility Principle

每个模块、每个类、每个方法都只负责一件事情

Open Close Principle

Liskov Substitution Principle

Interface Segregation Principle

Dependency Inversion Principle

SOLID原则

Single Responsibility Principle

每个模块、每个类、每个方法都只负责一件事情

Open Close Principle

对功能扩展开放，对源码修改关闭

注意

Liskov Substitution Principle

概念

注意

Interface Segregation Principle

概念

注意

Dependency Inversion Principle

要求面向抽象进行编程，不要面向具体进行编程，这样就降低了客户与实现模块间的耦合。

注意

Law of Demeter

概念

总结