多 线 程
进程：正在执行中的程序，每一个进程中都有一个控制单元。
线程：就是进程中的一个独立控制单元，控制着进程的执行，虚拟机在启动时会有一个进程java.sexe，该进程至少有一个线程，在负责程序的执行，而这个线程运行的代码存放在main方法中，该线程称之为主线程。
创建线程的第一种方式：定义类实现Runnable接口，复写Runnbale类中的run方法，将实现了Runnable接口的子类对象，作为实际参数传递给Thread类中的构造函数。
随机性：因为多个线程都在获取执行权，cput执行到谁谁就运行，运行时间cpu说了算。
运行：具备执行资格，且具备执行权。
阻塞：具备执行资格，不具备执行权。
Wait：将线程对象存储到线程池中，线程会释放执行权和锁，不指定时间只能被notify与notifyall唤醒。
Start：开启一个线程，并执行run方法。
Sleep：必须指定时间，时间一到自动从冻结状态转成运行状态(临时阻塞状态)，线程会释放执行权，但不释放锁，在指定时间内等待，时间一到自动唤醒。
Notify：唤醒的是线程池中第一个被等待的线程，线程释放了执行权并释放了执行资格。
Notiyfall：唤醒的是线程池中的所有线程。
线程间通信：其实就是多个线程在操作同一个资源，但是操作的动作不同，将资源封装成对象，将现场执行到任务也封装成对象。
注意：这些方法都需要定义在同步中，因为这些方法必须要表示所属的锁，既然被锁调用，而锁又可以是任意对象，那么能被任意对象调用的方法一定定义在Object类中。
线程的停止：以前通过stop方法停止线程，但是现在这个方法过时了，让现场运行的代码结束，也就是run方法。
第一种方式：定义循环的结束标记。
第二种方式：如果线程为冻结状态，是不可能读到标记的，这时就需要通过Thread类中的interrupt方法，将冻结状态清除，让线程恢复到具备执行资格的状态，读取标记，并结束。
Join：等待该线程终止，用于加入临时线程。
同步：解决线程安全问题，
前提：必须有另个或者两个以上的线程，才需要同步，保证使用同一个锁。
函数：其实就是将同步关键字定义在函数上，让函数具备同步性，同步函数使用的锁是this，因为函数都有自己所属的对象，静态同步函数的使用的锁是该类的字节码文件对象。
弊端：相对降低性能，因为判断锁需要消耗资源，产生死锁。
死锁：通常只要将同步进行嵌套就可以看到现象，同步函数中有同步代码块，同步代码块中有同步函数。
Lock：显示的锁机制，以及显示的锁，对象中的等待唤醒机制，把锁进行封装，这样一个锁就可以对应多个Condition操作，解决现场安全问题，将同步代码块中替换成了显示的Lock操作，将Object中的wait、notify、notifyall替换成了Condition对象，该对象可以lock锁。
集合框架
Collection：集合框架，用于存储数据的容器。
特点：因为集合是可变长度的，对象多了也需要进行存储，集合用于存储对象，凡是可以操作角标的方法都是该体系中的特有方法。
Iterator：迭代器，可以对元素进行判断、取出、删除等操作。
ListIterator：Iterator的子接口，是List集合特有的迭代器，只能通过List集合获取该接口，可以对元素进行判断、取出、删除、添加、修改等操作。
迭代时：不可以用集合的方法操作元素，会发生并发修改异常，只能用迭代器的方法。
注意：对于List集合，底层判断元素用的是自身的equals方法，所以建议元素都要复写equals方法，建立元素对象自己的比较相同条件依据。
List：有序、可重复(元素存入和取出的顺序一致)
ArrayList：数组结构、线程不同步、查询速度快、增删慢。
LinkedList：链表结构、线程不同步、增删速度快、查询慢。
Vector：数组结构、线程同步、被ArrayList替代了，枚举是Vector特有的取出方法，和迭代器一样，因为枚举的名称以及方法名都过长，所以被迭代器取代。
Set：方法和Collection一致，Set接口取出方式只有一种，迭代器。
HashSet：哈希表结构、线程不同步、无序、搞笑、元素不可以重复，保证元素的唯一性是通过hashCode和equals两个方法，hashCode值相同，才会判断equals是否为true，为了提高效率，反之则不会。
LinkedHashSet：链表结构、有序、HashSet子类。
TreeSet：二叉树结构、线程不同步、可以对集合进行指定排序，排序需要元素自身具备比较性，如果元素不具备比较性，在运行时会发生ClassCastException。让元素自身具备比较性，实现Comparable接口，覆盖compareTo方法。让集合自身具备比较性，实现Comparator接口，覆盖compare方法，并将对象作为实际参数传递给TreeSet集合的构造函数。保证元素唯一参考比较方法的结果是否为0，返回0视为重复。
注意：当元素自身不具备比较性时，或者具备的比较性不是所需要的，这是就定义一个比较器，将比较器作为参数传递给TreeSet集合，当两种排序方式都存在时，一比较器为主。在进行比较时，如果判断元素不唯一，比如同姓名同年龄才是为统一元素，在判断时，分析主要条件和次要条件，主要条件相同时，在判断次要条件。
Map：集合、存储键值对、一对一对存、要保证键的唯一。
Hashtable：哈希表结构、线程同步、不可以存储null键null值。
HashMap：哈希表结构、线程不同步、可以存储null键null值，替代了Hashtable。
TreeMap：二叉树结构、可以对Map集合中的键进行指定排序。
第一种取出方式：Set<K> keySet：将Map集合中的所有的键存入到Set结合中，因为Set具备迭代器，所以可以通过迭代器方式去除所有的键，在根据get方法，获取每一个键对应的值。
第二种取出方式：Set<K,V>entrySet：将Map集合中的映射关系存入到Set集合，而这个关系的数据类型就是Map.Entry。
原理：将Map集合转成Set集合，再通过迭代器取出，Mao.Entry也是一个接口，他是Map接口中的一个内部接口。
Properties：可以将键值对进行持久化存储的对象，Map-Hashtable的子类，用于属性配置文件，键和值都是字符串类型。
特点：可以持久化存储数据，键值都是字符串，一般用于配置文件。
Load：方法可以将流中的数据加载进集合。
原理：其实就是将读取流和指定文件相关联，病毒去一行数据，因为数据的规则是key=value，所以获取一行后通过=切割即可，左边就是键，右边就是值，将数值鵆到Properties集合中。
Store：写入各个项后，刷新输出流。
List：将集合中的键值数据里出到指定的目的。
Collections：集合框架的工具类，内部提供的都是静态方法，将非同步的集合转为同步Collection中的XXX synchronizedXXX(XXX)方法。
原理：定义一个类，将集合所有的方法加入一把锁后返回。
Fill：该方法可以List集合中的所有元素替换成指定内容。
泛型：1.5版本后出现的一个安全机制。
好处：将运行期问题转移到编译期，避免了强制转换，让运行问题减少。
泛型技术：其实应用在编译时期，到了运行时期就不存在了。
泛型擦除：编译器检查了泛型的类型正确后，再生成类文件中是没有泛型的。
泛型补偿：泛型已经确定了同一类型元素，运行时获取到该元素的类型，在内部进行了一次强转，所以使用者不用再做强转动作了。
通配符：也可以理解为占位符，当操作类型不确定时闷酒可以定义通配符。
类泛型：字啊整个类中有效，如果被方法使用，那么该对象明确要操作具体的类型后，所有要操作的类型就已经固定，为了让不同方法可以操作不同类型，而且类型还不确定，可以将泛型定义在方法上。
特殊之处：静态方法不可以访问类上定义的泛型，如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。
泛型的限定：用了下限，这个集合只能刀座Object类型使用了，必须进行强转。
上限：？Extends E可以接受E类型或者E的子类类型。
下限：？Extends E可以接收E类型或者E的父类类型。
IO
IO：用于处理设备上的数据，读写都会发生IOException。
分类：输入流(写)、输出流(读)、因为处理的数据不同，分为字节流和字符流。
字符流：Wwriter、Reader因为每个国家的字符都不一样，涉及编码问题，GBK编码的中文用unicode解析是错误的，为了方便文字的解析，将字符流和编码表封装成对象。
字节流：InputStream、OutputStream处理字节数组的流对象，他们都以二进制鵆的，二进制的最终都是以一个8位单元进行体现的，最小数据单元就是字节，字节流可以处理所有数据。
操作：对象一建立就必须明确数据的存储位置，对象产生后，会在堆内存中有一个实体，调用系统底层资源。在指定位置创建文件，如果该位置出现同名文件，文件会被覆盖。
Flush：将缓冲区中的数据刷入到流中，该流可以继续使用。
Close：将缓冲区中的数据刷入到流中，该流就关闭了，该方法用于关闭流对象。
异常处理：一定要写finally
FileWriter写入数据的细节：续写数据，只需在构造函数中传入新的参数true。
FileReader读取数据的细节：返回-1读到结尾，要保证该文件存在，不存在会发生异常。
InputStream：字节读取流的超类，OutputStream：字节输入流的超类。
FileInputStream：读取图片DVD等文件字节，想要读取字符，建议使用FileReader
FileOutputStream：将数据写入File或FileDescriptor的输出流。
流的操作规律要明确源和目的：
数据源：就是需要读取，可以使用两个体系：InputStream、Reader
数据汇：就是需要写入，可以使用两个体系：OutputStream、Writer
操作数据是否是纯文本数据：
如果是：数据源：Reader、数据汇：Writer
如不是：数据源：InputStream、数据汇：OutputStream
明确操作数据的设备：
数据源对应的设备：硬盘(File)、内存(数组)、键盘(System.in)
数据汇对应的设备：硬盘(File)、内存(数组)、控制台(System.ou)
BufferedWriter：将文本写入字符输出流，缓冲各个字符，高效写入，跨平台的换行方法newLine，关闭关冲去其实就是在关闭流对象。
BufferedReader：从字符输入流读取文本，缓冲各个字符，从而实现字符，一次读一行的方法readLine，返回时不带换行符。
InputStreamReader：转换流可以将字节转换成字符，该类有操作文件字符流对象的子类，转换流的最强功能就是基于字节+编码表，没有转换，没有字符流，想要操作文件，必须要进行编码转换，而编码转换流已经完成了，所以操作文件的流对象只要继承自转换流就可以读取字符了，子类有一个局限性，子类中使用的编码是固定的，是本机默认编码，如果想要指定码表，必须使用转换流，凡是操作设备上的文本数据涉及编码转换的，必须使用转换流，转换流是字节和字符的桥梁。
PrintStream：打印流，提供了更多的功能，比如打印方法，可以直接打印任意类型的数据，他有一个自动刷新机制，创建该对象，制定参数，对于指定可以自动刷新，他使用的本机默认的字符编码表，该流的print方法不抛出IO异常，如果操作的数据是字符串，建议使用PrintWriter，因为PrintWriter是字符串的子类，可以直接操作字符串，还可以指定编码。
面向对象
面向对象：封装、继承、多态、找对象、建立对象、使用对象、维护对象、
类就是：对现实生活中事物的描述。
对象是：就是事物实实存在的个体。
定义类：就是在描述事物，就是在定义属性和行为。
特点：将复杂的事情简单化，将过程中的执行者变成了指挥者。面向对象这种思想是符合人们思考方式的一种思想，过程就是函数，对象是将函数等一些内容进行封装。
多态：每一种事物都有不同的具体体现。
多态的体现：父类的应用指向了子类对象，父类也可以接收自己的子类对象。
多态的好处：提高了程序的扩展性。
多态的弊端：只能使用父类的引用访问父类中的成员。
多态的前提：类与类要有关系，比如继承、实现、通常存在覆盖。
多态的成员函数：编译看左边，运行看右边。
多态的成员变量：编译运行都看左边。
多态的静态函数：编译运行都看左边。
匿名对象：当方法只执行一次，可以使用匿名对象，当执行多次，就给该对象起个名字。
Private：访问权限最低。只在本类中有效，私有的成员，类以外即使建立对象也无法访问，
好处：可以在类中提供访问方法，对数据进行操作，逻辑判断等，属性是用于存储数据的，直接被访问容易出现安全隐患，所以类中的属性通常都被私有化，并对外提供访问方式。
注意：私有仅仅是封装的一种体现形式而已。
构造函数：给对象进行初始化，对象一键立会调用与之对应的构造函数。
特点：该函数的名称和类名一致，该函数没有返回值。
This：代表本类对象，就是所在函数所属的对象引用，用于构造函数之间进行调用，那个对象调用了this所在函数，this就代表哪个函数，但凡本类内部使用到了本类对象，就用this。
注意：this语句只能定义在构造函数的第一行，因为初始化要先执行。
Static：想要实现对象中的共享数据，可以将这个数据进行静态修饰。
特点：被静态修饰的成员，可以直接被类名所调用，静态随着类的加载而加载，而且优先于对象存在，被所有对象共享，静态方法只能访问静态成员，不可以访问非静态成员，非静态方法不可以有this，super等关键字。
成员变量称为实例变量：存储于堆内存，成员变量随着对象被回收而消失，只能被对象调用。
静态变量称为类变量：存储于方法区中，静态变量随着类的消失而消失。
利：对象数据单独存储，节省空间，可以直接被类名调用。
弊：生命周期过长，访问出现局限性，(静态虽好，只能访问静态)
注意：当对象中出现特有共享数据时，对象特有数据要定义成非静态存储于堆内存中，成员变量称为对象的特有数据，静态变量称为对象的共享数据，当内部没有访问到对象的特有数据，就可以将该功能定义为静态的。
继承：提高了代码的复用性，让类与类之间产生了关系，
父类的由来：其实就是由多个类不断的向上抽取共性内容而来的，java中对于继承，java之支持单继承，java虽然不支持多继承，但是保留了这种机制，并进行改良，也就是多实现，多继承容易带来安全隐患，当多个父类中定义了相同的功能，但内容不同时，子类不确定要运行哪一个，java支持多继承，也就是一个继承体系，一个体系想要被使用，直接查阅父类功能即可知道体系的基本用法，简单一句话，查阅父类功能，创建子类对象。
成员特点：如果父类中出现了非私有的同名变量时，子类访问本类中的同名变量用this，子类访问父类的同名变量用super，super的使用与this几乎一致，this代表本类对象，super代表父类对象，当子父类中出现了一摸一样的方法时，这是另一种特性，叫做覆盖。当一个父类的功能内容需要修改时，可以通过覆盖来实现。
覆盖：子类覆盖父类，必须保证子类权限大于等于父类，静态只能覆盖静态。
重载：只看同名函数的参数列表。
Final：关键字、修饰符、可以修饰类、方法、变量。
被final修饰的类是一个最终类，不可以被继承。
被fianl修饰的方法是一个最终方法，不可以被覆盖。
被final修饰的变量是一个常量，只能赋值一次。
内部类定义在类中的局部位置上，只能访问被final修饰的吧Ian路。
抽象：不具体、看不懂、抽象类表象体现。抽象方法只能定义在抽象类中，抽象类和抽象方法必须由abstract关键字修饰，抽象方法只定义声明，并不定义主题，丑类不可以被实例化，只有通过子类继承抽象类，并覆盖所有抽象方法，子类才可以实例化，否则还是一个抽象类。
特点：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象，抽象类不可以和final、private、static共存。
接口：是不可以创建对象的，因为有抽象方法，可以认为是一个特殊的抽象类，当抽象类中的方法都是抽象的，可以用接口来表示。
常量：public static final
方法：public abstract
接口可以被类多实现，也就是多继承不支持的转换形式。
抽象类和机构的共享，都是不断向上抽取而来的。
内部类：当描述事物时，事物的内部还有事物，该事物用内部类来描述。内部类可以直接访问外部类中的成员，而外部类想访问内部类必须建立内部类对象。
当内部类定义在成员位置上时：可以使用成员修饰符：private static
当内部类定义在成员位置上非私有时：可以在其他类中建立对象访问。
党内部类定义在局部时：不可以被成员修饰符修饰，可以直接访问外部类中的成员，因为还持有外部类中的引用，但是只能访问外部类中的静态成员，出现了局限性，通常内部类被封装，相当于外部类，会出现访问局限性，只能访问静态成员。
注意：如果内部类定义了静态成员，那么该内部类也必须是静态的，内部类都持有一个外部类引用，这个引用就是this。内部类可以定义在外部类的成员位置上，也可以定义在外部类中的局部位置。
匿名内部类：没有名字的内部类，就是内部类的简写形式，其实就是一个匿名子类对象，而且这个对象有点胖，可以理解为带内容的对象，匿名内部类中定义的方法最好不要超过三个。
前提：内部类必须是继承一个类或者接口。
反射技术
反射技术：其实就是动态加载一个类，并获取该类中的所有内容，就是把java中的各种成分映射成相应的类，反射比较消耗资源，而且将字节码文件内容都封装成了对象，这样便于操作这些成员，简单说，反射技术可以对一个类进行解刨。
好处：增强了程序的扩展性。
步骤：获取指定类的字节码文件对象，实例化对象，获取类的属性，方法或构造函数，访问属性，调用方法，调用构造函数创建对象。
obj.getClass()：用于获得对象的类型，每个类都有getClass方法，弊端：必须要创建该类的对象，才可以调用该方法。
类名.class：用于获得指定类型，每个数据类型(基本数据类型和引用数据类型)都有一个静态的class。
Class.forName()：用于做类加载，前两种方式不利于程序的扩展，因为都需要在程序中明确具体的类来完成，使用Class类中的静态方法forName(“”);指定什么类名，就获取什么类的字节码对象，这种饭就是的扩展性最强，只要将类名的字符串传入即可。获取字节码文件对象后，最终都需要创建指定类的对象。
创建对象的两种方式：(其实就是对象在进行实例化时的初始化方式)
调用空参数的构造函数：使用Class类中的newInstance方法。
调用空参数的构造函数：先要获取指定参数列表的构造函数，然后通过构造函数对象的newInstance进行对象的初始化。
具有相同维数和元素类型的数组属于同于类型，具有相同的Class实例对象。
代表数组的Class实例对象的getSuperclass方法返回的是父类对应的Class。
基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]
Array：用于完成对数组的反射操作的工具类。
异常
异常：就是程序中出现不正常的情况。
Thriwble：可抛出的。
Error：不编写针对性的代码，一般是jvm发生的，需要对代码进行修正。
Exception：可以具有针对性的处理方式。
特点：所有类和对象都具备可抛性。
可抛体现：就是这个体系中的类和对象都可以被throw和throws关键字操作。
声明异常：建议声明更为具体的异常，这样可以处理的更具体。
Throw：定义在函数内，用于抛出一场对象。
Throws：定义在函数上，用于抛出异常类，可以抛出多个，用逗号隔开。
通常情况：函数内抛出异常对象，并未处理，函数上必须声明，否则编译失败。
特殊情况：RuntimeException以及其子类是编译不被检测的异常。
自定义异常：项目中出现了java中并没有定义过的问题时，就需要自定义异常。
编译被检测的异常：在函数内抛出未进行处理，必须在函数上声明，需要调用者对该异常进行处理，否则编译失败。
编译不被检测的异常：在函数内抛出不用再函数上声明，不需要调用者处理，因为程序无法继续运行，所以希望程序停止。
方法声明几个异常：就对应几个catch块，如果异常出现继承关系，父类异常放在最下面，定义catch时，一定要定义具体的处理方式。
子类覆盖父类方法时：父类抛出异常，子类只能抛出父类异常的子集，如果父类抛出多个异常，子类只能抛出父类异常的子类。
如果父类或者接口没有抛出异常：子类在覆盖方法时也不能抛出异常，如果子类发生的异常子类无法进行处理，影响了程序的运行，子类可以再方法中抛出运行时异常，或者其子类，这样子类的方法上就不用throws。
异常处理有三种结合：finally主要用于关闭资源，无论是否发生异常，资源必须关闭。Finally一定会执行，除非执行到System.exit(0);
网络编程
网络编程：通过使用套接字来表达进程间通信的就是网络编程。
逻辑端口：用于标示进程的逻辑地址，不同进程的标示。
有效端口：0-65535、其中0-1024被系统使用或为保留端口。
通讯规则：称为协议、国际组织定义了通用协议TCP/IP
UDP：面向连接、不安全、传输速度快，限定在64K内。
TCP：面向连接、安全、三次握手、传输速度慢。
图形化界 面
图形化界面：创建Format窗体，对窗体进行基本设置，比如大小，位置，布局。
定义组件：将组建通过窗体的add方法添加到窗体中，显示窗体。
事件监听：事件源、事件、监听器、事件处理。
事件源：就是awt包或swing包中的那些图形化界面组件。
事件：每一个事件源都有自己特有的对应事件和共性事件。
监听器：可以触发某一事件的动作都已经封装进了监听器中。
以上三者在java中都已经定义好了，直接获取其对象来用就可以，我们要做的事情就是对产生的动作进行处理。
File
File：将系统中的文件和文件夹封装成对象，提供了更多的属性和行为，可以对这些文件进行操作，这些是流对象办不到的，因为流只操作数据。
递归：就是函数自身调用函数，当一个功能被重复使用，而每一次使用功能时的参数不确定，都由功能上次运算的结果来确定。
简单说：功能内部又用到了该功能，但是传递的数值不确定，都由上次的功能参与运算的结果来确定。
条件：一定要定义递归的条件，递归的次数不要过多，容易出现栈内存溺出，其实递归就是在栈内存中不断的加载同一个函数。
正则表达式
正则表达式：其实是用来操作字符串的一些规则。
好处：正则的出现对字符串的复杂操作变的更为简单。
特点：将操作字符串的代码用符号来表示，简化了书写。
弊端：阅读性很差，更多是用于解决字符串操作问题。
组：每一个小括号表示一组，而且有默认的编号从1开始，只要使用组，对应的数字就是使用该组的内容，从左括号开始数即可，有几个左括号就有几个组。
获取：先要将正则表达式编译成正则对象，使用的Pattern中的静态方法，通过Pattern对象获取Matcher对象，Pattern用于扫描正则表达式进行解析，而降规则操作成字符串，需要从新封装到匹配器对象的Matcher中，通过Pattern对象中的matcher方法，该方法可以让规则与字符串关联，并返回匹配器对象，使用Matcher中的方法即可对字符串进行各项正则。
其他
Object：所有类的直接或者间接父类，该类中定义的就是所有对象都具备的功能，通常equals、toString、hashCode在引用中都会被复写，建立具体对象的特有内容。
关键字：其实就是赋予了某种特殊含义的单词。
保留字：其实就是还没有赋予特殊含义，但是准备日后使用的单词。
标示符：其实就是在程序中自定义的名字，类名，函数名，变量名，包含0-9a-z$ 标示符不可以使用关键字，不可以数字开头。
常亮：是在程序中不会变化的值。
变量：其实就是内存中的一个存储空间，用于存储常亮的数据
作用：方便运算，因为有些数据不确定，所以确定该数据的名词和存储空间。
特点：变量空间可以重复使用。
作用域：变量定义位置的大括号内有效。
生命期：变量定义的位置开始，到该变量所在的作用域结束。
基本数据类型：byte、char、short、int、float、long、double
引用数据类型：数组、接口、类。
自动类型转换：从低级别到高级别，系统自动转换。
强制类型转换：将一个级别的数值赋给另一个级别，byte、char、short之间不可以进行转换。
包装类：1.5以后使用包装类可以像使用基本数据类型一样，并进行运算。是按照面向对象思想将基本数据类型封装成了对象。
好处：可以通过对象中的属性和行为操作基本数据，可以实现基本数据类型和字符串自检的转换，包装类都有XXX parseXXX方法，只有一个雷没有，Character
String：对字符串进行对象的封装，值不可更改，是一个常量。可以对字符串数据进行方便操作，对象封装后，可以定义N多属性和行为，
StringBuffer：字符缓冲区，可变长度，是一个容器，可以对字符串内容进行添加，删除，修改、查找等操作。缓冲区可以存储任意类型对象，最终都需要变成字符串。
StringBuider：1.5新特性，该类被设计用作StringBuffer的建议替换，用在字符串缓冲区被单个线程使用的时候，方法和StringBuffer一样。
StringBuffer与StringBuffer的区别：
StringBuffer线程安全，StringBuilder线程不安全，
单线程操作：使用StringBuilder效率高。
多线程操作：使用StringBuffer安全。
数组：用于存储同一类型数据的一个容器。
好处：可以对容器中的数据进行编号，从0开始。数组用于封装数据，就是一个实体。
二维数组：每一个一维数组中都有二维数组，每一个二维数组中都有元素。
Arrays：用于操作数组的工具类，里面都是静态方法。
asList：将数组编程集合，不可以使用集合的增删方法，因为数组的长度是固定的。如果你增删了，会发生UnsUpprtedtionException。
如果数组中存储的是引用类型：直接作为集合的元素直接用集合方法操作。
如果数组中存储的是基本类型：asList会将数组实体作为集合元素存在。
集合变数组：Collection中的toArray方法。
好处：限定了对集合元素进行增删，只要获取这些元素即可，当指定类型的数组
长度大于了集合的size，该方法内会创建一个新的数组，当指定类型的数组长度小于了
集合的size，该方法不会创建数组，所以创建一个刚刚好的数组最优。
内存地址：寄存器、本地方法区、方法区、栈内存、堆内存
栈内存：存储的的是局部变量，局部变量的作用域结束，该数据就会被释放。
堆内存：存储对象与成员变量，也就是实体，就是用于封装多个数据，每一个实体都有内存首地址，堆内存中的变量都有默认的初始值，因数据类型不同，初始值也不一样。
高级for：foreach语句，foreach简化了迭代器。
局限：必须要有被遍历的目标。不能对元素进行赋值。建议使用传统for，因为传统for可以定义角标。
查表法：建立数据的对应关系。
条件：数据个数是确定的，而且有对应关系，如果对应关系的一方是数组，而且可以作为角标，那么可以通过数组来作为表。
可变参数：当要操作的元素个数不确定的时候就可以定义可变参数，可变参数其实就是数组的简写形式，不需要每一次都手动的建立数组对象，只要将要操作的元素作为实际参数传递即可，在使用时可变参数一定要定义在函数的列表的最后面。
设计模式：解决一类问题最行之有效的思想，java中有23中设计模式，
单例设计模式：解决一个类在内存中只存在一个对象。当多线程访问懒汉式时，因为懒汉式的方法对对象数据进行多条语句操作，容易出现安全隐患，加入同步机制，解决安全问题，但是却降低效率，为了效率问题，通过双重判断的形式解决。
模板设计模式：当功能内部实现时，一本分确定，一部分不确定，就可以把不确定的部分暴露出去，让子类去实现。
装饰设计模式：装饰类通常会通过构造方法接收被装饰的对象，并基于被装饰对象的功能，提供更强的功能，找到其参数的共同类型，通过多态的形式，可以提高效率，
特点：装饰模式比继承要灵活，避免了继承体系的臃肿，降低了类与类之间的关系。
包：定义包用package关键字，对类文件进行分类管理，给类文件提供多层命名空间。
包是一种封装形式，用于封装类，想要被包以外程序访问，该类必须public，类中的成员如果想被包以外访问，也必须public
包与包之间访问的权限只有两种：public protected
Import：为了简化类名的写法，导入指定包中的类，建议实际开发时，用到哪个类就导入哪个类。如果导入的两个包中存在着相同名称的类，如果用到该类，必须制定包名。
静态导入：导入类中的所有静态方法，简化了静态成员的书写。
Runtime：没有构造方法，不能new对象。说明该类中都是静态方法，但是还有非静态方法，说明该类肯定会提供方式获取本类对象，而该方法是静态的，该方法是Runtime etRuntime();
Date：日期类，月份从0-11
日期对象和毫秒之间的转换：
日期对象转成毫秒值：Date类中的getTime方法。
毫秒值转成日期对象：Date类中的setTime方法。
将日期字符串转换成日期对象，使用DateFormat方法中的Date parse();SimpleDateFormat作为可以指定用户自定义的格式来完成格式化。
Calendar：日历类，使用查表法。
Math：用于数学运算的工具类，属性和行为都是静态的，该类是fianl。
SequenceInputStream：序列流，可以将多个读取流合并，实现数据合并。
合并原理：多个读取流对应一个输出流。
切割原理：一个读取流对应多个输出流。
PipedInputStream：管道流，可以用connect方法对接。
注意：使用管道流要使用多线程，因为担心车容易残生死锁。因为read是阻塞式方法。
RandomAccessFile：该对象既可读又可写，该对象只能操作文件。该对象内部定义了数组通过指针来操作这个数组并封装了字节读写流。该类不算是IO体系中的子类，而是继承自Object，操作文件还有模式：r、rw、w、getFileProinerr获取指针位置，seek设置指定位置，skipBytes跳过指针位置。
DataOutputStream、DataInputStream：专门用于操作基本数据类型的对象。
ByteArrayInputStream、ByteArrayOutputStream：用于操作字节数组的流对象。
读取：在构造的时候，需要接受数据源，而且数据源是一个字节数组。
写入：在构造的时候，不同定义数据目的，因为该对象已经存在。内部封装了可变长度的字节数组，这就是数据目的。因为两个对象操作，没有使用系统资源，所以不用进行关闭。
设备源：键盘System.in。硬盘：FileStream。内存：ArrayStream。
设备汇：控制台System.out。硬盘：FileStream。内存：ArrayStream。
编码：字符串变成字符数组。
String-->byte[]; str.getBytes(charsetname);
解码：字节数组变成字符串。
Byte[]-->String; new String(byte[],charsetname);