|
如果对您有帮助 ，请多多支持，欢迎大家转载：转载请请添加源链接：https://blog.youkuaiyun.com/qq_30764991点击打开链接，非常感谢：
Java跨平台原理：依赖于不同操作系统上的虚拟机
Path和classPath的作用： Path：可以配置操作系统任何目录下可执行文件的路径，是提供给操作系统使用的变量。 Classpath：可以配置class文件所在的目录，是提供给java运行环境使用的变量。
classpath环境变量值结尾处是否需要加分号，有什么区别？ 如果不加分号，jvm只会去配置路径下寻找，如果没有就无法运行 如果加分号，配置路径下没有会去当前目录下寻找
8种数据类型： 整数：byte（1），short（2），int（4），long（8） 小数：float（4）,double（8） 字符：char（2） 布尔类型：boolean(1)
负数的二进制表现形式：当前这个负数对应的正数的二进制形式 取反 + 1
引用数据类型：类（class）、接口（interface）、数组（[]）
++或--的运算原则： ++或-- 在变量的右侧：它的运算原则是先把变量空间中的值在内存中临时开辟个空间保存，然后给当前参与运算的这个变量空间中+1或-1，接着使用临时空间中的数据和其他运算符运算。
++或--在变量的左侧：在运算的时候，会先给变量空间中+1或-1，然后使用改变后的这个变量空间中的数据参与其他运算。
异或：^ ：运算符两侧相同时为false，否则为true
按位异或：相同二进制数位上的数字相同为零，不同为1。一个数异或其本身结果为0
按位取反~：它是一个单目运算。它的运算原则是把0变1 ，1 变 0。 本质是：~值 = -值-1
按位左移：把指定的二进制数，向左移动指定的位数。高位移出的舍弃，低位空出的用0填补。规律：把一个数向左移动多少位 ，相当与给这个数乘以2的n次方（n移动的位数）。
按位右移：当一个数使用有符号右移，在移动的时候，高位空出来的要使用原来高位的数字填补。规律：把一个数向右移动多少位 ，相当与给这个数除以2的n次方（n移动的位数）。
do-while循环：不管条件是否成立，循环体最少都可以执行一次。
break：它可以使用循环中，也可以使用在switch语句中，当程序在执行的过程中遇到的break，程序此时就会停止当前break所在的switch或者循环的执行。 continue：它只能使用在循环中。当在执行循环的时候，遇到的continue关键字，这时JVM会停止本次循环的继续，而直接进入下一次循环。
重载的概念： 1、要求必须在同一个类中。 2、有多个同名的函数。 3、函数的参数列表不同。主要是参数的类型不同 注意：函数的重载和函数的返回值没有任何关系。
选择排序原则：先拿数组中第一个空间和其他数组空间的数据进行比较，找到一个最大或最小的保存在第一个空间中。
折半查找（二分法查找）：在数组中，我们先找数组中间位置上的值，然后和要查找的值进行大小比较，通过大小结果，进而判断在前一半还是在后一半继续查找。 | ||||||||||||||||||||||||||||||
| 面向对象 什么是面向对象： 其实就是把封装后的函数再封装到类中通过这个类创建一个对象，再利用这个对象来调用类中封装的功能，面向的是一个个封装的类。
面向对象的特点： 1.符合人的思维方式。 2.从一个执行者转变为一个指挥者。 3.提高代码的安全性。
面向过程和面向对象的区别： 面对过程面向的是一个个函数。 面向对象面向的是一个个类。
类和对象的区别： 1.类和对象的区别：类是用来描述事物的； 2.对象是类所描述事物的一个具体实体(个体、对象) 3.先有类的描述，再有对象的创建
局部变量和成员变量的区别： 1， 从定义上讲 成员变量定义在类中，属于对象的 局部变量定义函数中，属于函数的。（超函数外就无法访问） 2， 从存储位置上讲（内存位置） 成员变量随着对象的创建，在堆中空间存储 局部变量随着函数的调用，会存储在栈空间下 3， 从存活时间(生命周期)上讲 成员变量的存活时间是随着对象的创建而存在，随着对象的销毁而消失，来计算时间的 局部变量的存活时间是随着函数的入栈而存在，随着函数的弹栈而消失，来计算时间 4， 从使用上讲 成员变量必须是通过对象来访问（没有对象不能直接访问） 局部变量可以直接在当前函数中内访问 5， 从初始值上讲 成员变量都具备默认初始值 局部变量没有默认初始值，必须手动的给变量初始化
匿名对象：当对象对方法进行调用时，而且只调用一次可以简化成匿名对象。
基本数据传递过程：按值传递，修改函数中数值，主函数中的数值不变。 引用类型传递：按地址传递，修改函数中的数值，主函数中的数值也个改变。
| ||||||||||||||||||||||||||||||
| 封装 什么是封装：封装就是包装的意思，隐藏事物的一部分细节。
封装有什么用（好处）： 1， 提高程序中代码的复用性，提高程序代码的安全性 2， 封装可以隐藏事物的细节，但是需要对外提供一些可以访问这些隐藏细节的方式(函数) 3， 提升程序在后期的维护性
封装有哪些体现： 1， 函数：函数中封装的是一些相似的功能代码，函数就是封装的体现之一 2， 类：类中封装了事物的特征和功能
封装怎么用：关键字private. Private:表示成员只能在当前的类中使用，其他的类无法使用。 使用方式：通常是私有成员变量，对外提供public方法（赋值和取值）。
封装相关内容：构造函数
什么是构造函数： 1， 构造函数和类名相同（和类名大小写都一样） 2， 构造函数没有返回值类型，在书写时不能有void关键字（为了和普通的函数区分） 3，构造函数没有返回值（不需要书写return语句）
构造函数有什么作用：给对象初始化使用的。
构造函数有什么特点呢（细节）： 1，在一个类中可以有多个构造函数，他们的存在是一重载的形式体现的。 2，构造函数中也可以有return语句，用于结束初始化的作用，return后面没有返回值。 3，构造函数也可以被private修饰，表示只能本类中创建对象使用，其他的类不能创建该类的对象。 4，一般函数不能调用构造函数，而构造函数可以调用一般函数。 5，在构造方法中书写this（）语句，必须放在构造函数中的第一行。 6，当一个类中多个构造函数之间相互使用this语句时，容易发生死循环。
构造函数和一般函数有什么区别呢： 1， 从调用上讲 一般函数：只有创建完对象之后，使用对象名来调用一般函数 （在创建对象后） 构造函数：在创建对象时，由JVM自动调用的构造函数（在创建对象时） 2， 从调用次数上讲 一般函数：当对象创建完后，可以使用对象名多次调用一般函数（多次调用） 构造函数：在创建对象时，由JVM调用一次（一次调用）[初始化完后就销毁] 3， 从作用上讲 一般函数：用来描述事物中的功能（行为） 构造函数：对象初始化时使用的
构造函数之隐式三步： 第一步：super（），调用父类的构造方法。 第二步：显示初始化成员变量（非静态成员变量）. 第三步：执行构造代码块。
构造函数相关：this
This的有什么用：用于调用本类中的其他方法。可以用来区分成员变量和局部变量。
This关键字的使用： This（参数列表）：在一个构造函数中调用本类中其他的构造函数。 This.成员：可以访问当前对象的成员变量或成员函数。
| ||||||||||||||||||||||||||||||
| 关键字Static Static:静态的。
Static有什么用： 1，java语言中的一种修饰符号，可以用来修饰成员变量、成员函数 2，被static修饰的成员不会再随着对象的创建而出现，它是随着类的加载而出现
静态的应用 静态成员变量： 1，随着类的加载而存储在方法区的静态区域中，先进行默认初始化，然后再显式初始化, 2，通常代码是使用类名去访问 3，静态变量如果使用类名去操作时，存储的值是共享的
静态方法： 1，静态的成员方法，不会随着类的加载而自动调用，需要使用类名.成员方法名去调用 2，静态成员方法，要执行时也会进行到栈中（从方法区中的静态区域下）(静态随着类加载的而加载) 3，非静态成员方法，也是在栈中运行，（从方法区中非静态区域加载到栈中）(随着对象的创建，调用方法时，才会加载) 4，静态方法中只能使用静态的成员变量或调用其他的静态方法。 5，在非静态的方法中可以调用静态的方法。 6，在静态的方法中不可以使用关键字this，super
静态代码块： 在类加载过程中，当所有的静态成员变量显式初始化完后，自动调用静态代码块
三种代码块： 静态代码块：静态代码块是随着类的加载而出现；类只会被加载一次，所以静态代码块也会执行一次 构造代码块：构造代码块是随着对象的创建而出现；对象可以被多次创建，所以每创建一次对象就是执行一次构造代码块 局部代码块：就是为了控制局部变量的
单例设计模式 为什么使用单例设计模式：解决创建的对象是唯一的（对象开辟的空间只能为一个。）
步骤： 1，私有构造函数：只能在本类中创建该构造函数的对象。 2，在本类中创建一个私有的静态的对象。 3，对外提供一个公有的静态的可以访问所创建对象的方法。
| ||||||||||||||||||||||||||||||
| 类加载和对象创建过程 类的加载过程： 1， 当使用java命令运行java程序时，此时JVM启动，并去方法区下找java命令后面跟的类是否存在，如果不存在，则把类加载到方法区下 2， 在类加载到方法区时，会分为两部分：先加载非静态内容到方法区下的非静态区域内，再加载静态内容到方法区下的静态区域内 3， 当非静态内容载完成之后，就会加载所有的静态内容到方法区下的静态区域内 3.1 先把所有的静态内容加载到静态区域下 3.2 所有静态内容加载完之后，对所有的静态成员变量进行默认初始化 3.3 当所有的静态成员变量默认初始化完成之后，再对所有的静态成员变量显式初始化 4，当所有的静态成员变量显式初始化完成之后，JVM自动执行静态代码块（静态代码块在栈中执行）[如果有多个静态代码，执行的顺序是按照代码书写的先后顺序执行] 5，所有的静态代码块执行完成之后，此时类的加载完成
对象的创建过程： 1， 当在main方法中创建对象时，JVM会先去方法区下找有没有所创建对象的类存在，有就可以创建对象了，没有则把该类加载到方法区 2， 在创建类的对象时，首先会先去堆内存中开辟一块空间，开辟完后分配该空间(指定地址) 3， 当空间分配完后，加载对象中所有的非静态成员变量到该空间下 4， 所有的非静态成员变量加载完成之后，对所有的非静态成员进行默认初始化 5， 所有的非静态成员默认初始化完成之后，调用相应的构造方法到栈中 6， 在栈中执行构造函数时，先执行隐式三步，再执行构造方法中书写的代码 6.1 构造方法中的隐式三步： 第一步：执行super()语句 调用父类的没有参数的构造方法 第二步：对所有的非静态成员变量进行显式初始化（在定义成员变量时后面有赋值） 第三步：所有的非静态成员变量显式初始化完成之后，执行构造代码块 6.2 只有隐式三步执行完后，才会执行构造方法中书写的代码 当整个构造方法全部执行完，此对象创建完成，并把堆内存中分配的空间地址赋给对象名（此时对象名就指向了该空间）
| ||||||||||||||||||||||||||||||
| 继承 什么是继承：继承就是建立类与类之间的关系。关键字：extends
为什么使用继承：java使用类来描述事物时，把事物之间的关系给丢掉了，所以需要使用继承来解决类与类之间的关系。
继承的好处：提高代码的复用性，后期的维护性，建立类与类关系，为多态做前提。
继承有什么特点呢： 1，java语言仅支持单一继承 2，java支持多层次继承 3，父类中private成员不能继承 4，继承必须保证extends两边的事物属于同一类事物。
继承中的成员变量，构造方法： 成员变量： 当子类存在和父类相同变量时，创建子类对象时，所调用的成员变量属于子类的（通常父类中所描述的成员变量已经有了，子类直接使用就可以）
成员方法： 当子类存在和父类一模一样的成员方法时，创建子类对象时，调用的成员方法优先使用子类（这种方式称为重写） 方法重写注意的事项： 父类中的方法被子类重写时，父类的方法不能是private 子类重写的方法访问权限必须大于或等父类中方法的访问权限 父类中的静态方法在子类重写也必须是静态方法
构造方法： 子类中构造方法入栈后，会执行隐式三步： 1，super() 2，显式初始化成员变量 3,执行构造代码块 必须父类对象初始化完成后，再初始化子类对象。（只有父类对象初始化完成后，在堆中空间里的成员全部都初始化完成后，子类才可以使用父类中成员）
构造方法中的细节： 1，如果在构造方法中第一代码书写了this语句，隐式super()就不存在了。（在this所调用的构造方法中，再明确父类的构造方法） 2，如果父类中没有无参数构造方法时，子类中构造方法中就不能使用隐式的super语句，必须显式调用super(参数列表)
Final关键字 Final：表示最终的 Final特点： final修饰成员变量：成员变量变为常量（初始化之后，常量的值不能修改） final修饰成员方法：该成员方法不能被子类重写 final修饰类： 该类不能被其它类继承
Final的其他扩展： 1，接口的变量会final修改转变成常量，public static final 2，局部内部类不能使用函数中的局部变量，如果必须使用局部变量就需要把局部变量用final修饰符修饰变为常量。(因为局部变量是存储在栈内存中的，而局部内部类也是存储在栈内存中，所以无法调用。) 3，final不能与abstract共存
| ||||||||||||||||||||||||||||||
| 抽象类 什么是抽象类：抽象类是指事物无法进行具体的描述，就将该事物标记为抽象类。 关键字：abstract
为什么使用抽象类： ,1，把子类中一些共性的内容向上抽取，而抽取的功能中不确定功能体 ,2，除了需要子类去重写的功能外，还可以为子类提供一些具体的功能 3，在接口和子类中间建立一个桥梁（适配器模式） 适配器模式：解决子类实现接口中时，不需要接口中所有的功能，只需要接口中部分功能。这时就可以在接口的子类中间添加一个适配器类（没有抽象方法的抽象类）
抽象类有什么用（作用）： 1，父类中封装的是子类的共性内容，并且不希望父类能够实例化 2，当使用类来描述事物时，事物中的行为无法具体时，使用抽象类（抽象方法必须包含在抽象类中）
抽象类的特点： 1，抽象方法必须包含在抽象类中，并且抽象方法中不能有主体。 2，抽象类不能被实例化 3，子类在继承抽象类时，必须重写完抽象类中的所有抽象方法后，子类才可以创建对象。（如果没有重写完所有的抽象方法表示子类也是抽象的就不能创建对象）
抽象类的细节： 1，抽象类一定是父类 2，抽象类中有构造方法，仅仅是为子类对象初始化使用的。 3，抽象类中可以书写一般方法，也就是说抽象类比一般类多一个成员（该成员就是抽象方法。） 4，抽象类中abstract不能与private,static,final共存(如果抽象方法修饰为static，表示这个方法是随着类的加载而出现。抽象方法中没有具体的功能实现，类去加载或使用类名去调用这个抽象方法，没有任何意义)
| ||||||||||||||||||||||||||||||
| 接口 什么是接口：用来描述事物的扩展功能 接口的定义关键字：interface 接口的实现关键字：:implements
接口有什么用为什么使用接口（作用好处）: 1，接口用来描述事物的扩展功能 2，接口可以制定规则 3，接口可以降低程序的耦合度 4，接口可以解决java中单一继承的问题（接口可以多实现）。
接口的特点： 1， 接口不能实例化对象。（只能由子类实现，通过子类对象来操作） 2， 子类在实现接口时，必须重写接口中所有的抽象方法后，子类才可以创建对象 3， 接口中只能有常量和抽象方法 4，接口没有构造方法
接口的多实现：因为接口中定义的函数没有函数体，需要有子类自己完成。 接口的多继承： 1，类和类之间继承关系（is a关系）, 2，类和接口之间是实现关系 （like a关系） 3，接口和接口之间是继承关系
适配器模式：解决子类实现接口中时，不需要接口中所有的功能，只需要接口中部分功能。这时就可以在接口的子类中间添加一个适配器类（没有抽象方法的抽象类）
接口和抽象类的区别： 1， 接口不可以实例化，接口中只能定义抽象方法 抽象类也不可以实例化，抽象类中除了可以定义抽象方法外，还可以定义普通方法 2， 抽象类中有构造方法，而接口中没有构造方法 3， 接口是用来描述事物的扩展功能；抽象类是用来描述事物的，只是事物的行为不确定 4， 接口可以多实现； 抽象类只能单一继承
| ||||||||||||||||||||||||||||||
| 多态 什么是多态：是指一个事物以多种形式体现
多态的体现是： 父类 父类对象 = new 子类（） 接口 父类引用 = new 子类（）
为什么使用多态（好处）：可以提高程序中代码的扩展性
多态的弊端：不能使用子类中特有的方法
注意：在使用多态时，要保证父类(接口)中和子类中同时存在这个方法 使用多态调用的是父子类中共有的方法（子类中特有的方法不能被调用）
使用多态的前提是： 1，必须存在继承或者实现关系 2，通常子类会重写父类或接口中的方法
为解决多态的弊端，需要使用多态的转型： 向上转型：Animal a = new Cat(); 为什么向上转型：提高程序扩展性，隐藏子类类型 向下转型：Animal an = new Dog(); 为什么向下转型：解决父类引用不能使用子类中特有的方法 Dog dog =(Dog) an; 转型中的异常：ClassCastException
多态的调用： 成员变量：编译和运行时都等号左边作为参考 成员方法：编译时以等号左边作为参考，运行时以等号右边作为参考（因为子类重写了父类的方法） 静态方法：编译和运行都以等号左边作为参考（静态调用和对象没有关系）
| ||||||||||||||||||||||||||||||
| 内部类 Object类： java体系中最高的父类。所有的java的类都要继承Object类 在Object类中，经常会重写三个方法：equals()、toString()、hashCode()
什么是内部类？ 内部类：其实就是在一个类中包含另一个类。
为什么需要内部类？ 内部类也是一个类。只是这个类需要依赖于其它的类。
内部类可以书写在什么位置？ 成员位置、局部位置
内部类使用规则？ 内部类可以使用外部类的成员包括私有成员（因为内部类中存在一个外部类对象在编译时JVM自动添加的），而外部类中不能直接使用内部类的成员，必须在外部类中创建内部类的对象，通过对象来访问内部类的成员。
内部类的访问： 1，对Public类型的内部类进行调用：Outer.Inner in = new Outer().Inner(); 2，对静态内部类中的非静态成员进行调用：Outer.Inner in = new Outer.Inner(); 或 Outer.Inner in =new Inner(); 3，对静态内部类中的静态成进行调用：Outer.Inner.staticShow();
局部内部类注意： 局部内部类不能使用函数中的局部变量，如果必须使用就必须把局部变量变成常量（为局部变量添加final修饰符）。
什么时候使用匿名内部类？ 当一个内部类的声名只是创建此类的对象时调用了一次，而且要产生的新类需要继承了一个已有的父类或实现一个接口时，才考虑匿名内部类。
匿名内部类使用规则： 1，不能有构造函数 2，不能定义任何静态的成员方法 3，只能创建匿名内部类的一个实例
匿名内部类的弊端：每次使用匿名对象调用时，只能调用一个函数。
为了解决匿名内部类的弊端可以new一个实现接口的匿名内部类，然后new得到的匿名内部类的对象再向上转型为它实现接口中的其它方法。 InterA a = new InterA(){};
匿名内部类格式： new 类/接口(){ //重写方法 或 添加新方法 }.方法名() 以上方式的弊端：只能调用一个方法 类/接口 引用对象 = new 类/接口(){ //重写方法 }; 引用对象.重写方法名();
| ||||||||||||||||||||||||||||||
| 异常 什么是异常：程序在运行时出现的突发问题，造成程序的中断。 突发状况分两种：错误和异常。 异常处理：解决程序中的突发问题，确保程序不会中断，可以继续向下执行。 异常的抛出：throw new 异常类(描述信息);
自定义异常： 由开发人员自己书写的异常类，称为自定义异常。 注意：自定义异常必须继承java提供的异常类
异常的分类：Error(错误类)：系统级别的。 Exception(异常类)：程序级别的。
Exception(异常类)分类： 1，RuntimeException(运行时异常)：程序在编译时不会检测是否有异常的处理方案，编译直接通过编译 2，Exception(编译时异常)：程序在编译时会检测是否有异常的处理方案，如果没有处理方案，编译时会报错
声明：其实就是程序中遇到异常时，自己不处理，交给其它程序处理 关键字：throws
捕获：其实就是在程序中遇到异常时，不会交给其它程序处理，自己处理 关键字：try 、catch、finally 注意：1，在使用throw抛出异常代码的后面，不能书写任意代码。 2，如果使用try...catch...finally结构的，catch中抛出异常后面如果有其他语句，执行时先执行finally语句再去执行catch中的其他语句 3，try..catch..catch结构中必须按照子类到父类的顺序写
throw 和 throws 的区别： Throw在抛出异常时需要手动抛出。Throws声明异常后，只要方法中出现所声明的异常就会自动抛出。
继承中方法重写的异常： 1， 父类中的private方法，不参与重写 2， 子类重写方法的访问权限必须大于或等于父类中方法的访问权限 3， 父类的静态方法，子类必须静态重写 4， 父类中的方法上如果没有声明编译时异常，子类在重写该方法时也不能声明异常。那如果子类重写的方法中可能会存在异常，此时子类重写方法内只能使用捕获处理异常，而不能使用声明 5， 父类中的方法上如果有声明异常，子类在重写父类的方法时，也可以声明异常（子类重写方法上只能声明父类方法上的异常类或其子类） 6，父类中方法上声明了多个异常类，子类在重写父类方法时，子类重写方法上只能声明父类方法上异常类的子集（子集：可以是其中一部分异常类，也可以是异常类的子类）
包：用来管理class文件 1，编译时，需要指定class文件的存放位置(路径) 格式：javac -d <路径> Xxx.java 2，运行时，需要指定带有包名的类 注意：在使用import导入包下的所有类时，只能导入当前包下的类，包下的子包中的类不能导入
包和包之间的权限： public： 同一类中；不同类、不同包中不同子类；不同包类中的子类 protected: 同一个类、同一个包中的其它类、不同包中的子类 注意：1，protected修饰符必须是在子类对象创建之后，使用子类对象才可以访问父类中protected中的成员 2，protected修饰符不能修饰class，只能修饰成员变量和成员方法 default：同一个类中、同一个包下的子类或其它类 private: 表示只能在当前类中的访问
小结：
| ||||||||||||||||||||||||||||||
| String类 public final class String
String类介绍： 1， String是一个字符串类，只要被””包含的内容都属于String类的实例 2，String实例引用的都是字符串常量，换句来讲，就是String字符串在初始化完后不能修改其原值(原有数据)
String类的创建： 1， String str = new String(“字符串”); 2， String str = ”字符串”;
String类的方法介绍： 1，获取字符串长度
2，获取指定位置上的字符
3，获取指定字符在字符串中的位置
4，获取字符串是否以指定的内容开始
5,判断字符串相同
6，判断是否为空字符
7，判断字符串是否包含某个字符或字符串数据
8，把基本类型转成字符串
9，把字符串转为数组
10，字符串大小转换
11，截取子字符串（包头不包尾）
12，切割字符串
13，其他方法 trim：去除字符串两端的空格 例：“ N BA “ 结果为：” N BA” replace：按照指定的字符或子字符串对当前字符串的某个字符或子字符串进行替换 compareTo(String str)： 比较两个字符串大小 大返回1 小返回-1 相等返回0
| ||||||||||||||||||||||||||||||
| 字符串缓冲区 StringBuffer: 当字符串类型的数据频繁进行修改时，使用字符缓冲区对象。（其实就是在StringBuffer类中有一个内部的字符数组，这个字符数组是可变长度的数组） （注意：StringBuffer这个容器中只能存储字符数据，存储到StringBuffer中的任何数据都会转为字符数据）
为什么使用StringBuffer？ 为了解决String的弊端：不能频繁修改字符串,长度不可变
StringBuffer中的方法：
增： 添加(追加)：append() 向StringBuffer类中的字符数组中添加指定的数据。（注意：添加的任意数据存储到StringBuffer后，都会转为字符数据）
插入：insert() 在指定的位置上，插入新的字符数据
删： 删除：delete(int start , int end) 删除从指定位置开始到指定位置结束的字符（包含头角标不包含尾角标） deleteCharAt(int index) 删除指定位置上的字符
改： 修改：setCharAt(int index, char ch) 修改指定角标上的字符，替换为指定的新字符 替换：replace(int start,int end,String str) 替换从指定位置开始到指定位置结束的所有字符
其它方法： charAt(int index): 根据指定的角标获取StringBuffer中对应角标下的字符 indexOf(): 查找指定的字符第一次出现的位置（可以指定从哪个角标开始查找） lastIndexOf() substring():从指定的位置开始截取Stringbuffer中的子字符串 reverse():对StringBuffer中存储的字符进行反转
StringBuffer和StringBuilder的区别： StringBuffer：属于线程安全的字符缓冲区对象，在使用时因为线程安全，所以效率比较低。效率低的原因是StirngBuffer在操作时都会去检查数据同步。在开发中，对线程安全有要求时，可以使用StringBuffer StringBuilder：属于线程不安全的字符缓冲区对象，在使用因为线程不安全所以效率比较高，不会去检查数据同步。在开发中，如果对线程安全没有要求时可以使用StringBuilder。
| ||||||||||||||||||||||||||||||
| 正则表达式 Public final class Pattern
什么是正则表达式？ 正则表达式就是用来操作String的，可以简化字符串的相应操作
正则表达式中各种特殊含义的符号： 常规符号 含义 x 表示一个任意字符 例：[a-z]BA \\ 表示反斜线（\表示转义字符） 例：”\d” 使用\\d表示 \ 表示制表符 [abc] 表示在指定位置上只能是a或b或c []表示范围 例：N[ABC]A [^abc] 表示在指定位置上不能有a或b或c ^表示取反的意思 [a-zA-Z] 表示在指定位置上可以是26个大小写字母 例：[a-zA-Z]CNB [A-D[D-F]] 表示在指定的位置上可以是A-D或D-F [a-z&&[abc]] 表示在指定的位置上只能是a,b,c中的一个 [a-z&&[^a-d]] 表示在指定的位置上只能是除了a~d之间以外的任意小写字母
预定义字符 含义 . 表示任意一个字符 例： C.A \d 表示[0-9]之间的任意数字 \D 表示 [^0-9] \w 表示[A-Za-z_0-9] 26个英文大小写字母、下划线、数字 \W 表示[^A-Za-z_0-9]
边界符 含义 ^ 表示行的开头 $ 表示行的结尾 例：^hello$ 表示以h开头以o结尾
数量词 含义 ? 表示?前面的字符可以出现0次或1次 例：NB[0-9]? * 表示*前面的字符可以出现0次或多次 例：NB[123]* + 表示+前面的字符可以出现1次或多次 例：QB+ {n} 表示{n}前面的字符可以出现n次，必须是n次 {n,} 表示{n,}前面的字符至少出现n次，不能少于n次 {n,m} 表示{n,m}前面的字符至少出现n次，但不能多于m次
正则表达式中各种特殊含义的符号： 常规符号 含义 x 表示一个任意字符 例：[a-z]BA \\ 表示反斜线（\表示转义字符） 例：”\d” 使用\\d表示 \ 表示制表符 [abc] 表示在指定位置上只能是a或b或c []表示范围 例：N[ABC]A [^abc] 表示在指定位置上不能有a或b或c ^表示取反的意思 [a-zA-Z] 表示在指定位置上可以是26个大小写字母 例：[a-zA-Z]CNB [A-D[D-F]] 表示在指定的位置上可以是A-D或D-F [a-z&&[abc]] 表示在指定的位置上只能是a,b,c中的一个 [a-z&&[^a-d]] 表示在指定的位置上只能是除了a~d之间以外的任意小写字母
预定义字符 含义 . 表示任意一个字符 例： C.A \d 表示[0-9]之间的任意数字 \D 表示 [^0-9] \w 表示[A-Za-z_0-9] 26个英文大小写字母、下划线、数字 \W 表示[^A-Za-z_0-9]
边界符 含义 ^ 表示行的开头 $ 表示行的结尾 例：^hello$ 表示以h开头以o结尾
数量词 含义 ? 表示?前面的字符可以出现0次或1次 例：NB[0-9]? * 表示*前面的字符可以出现0次或多次 例：NB[123]* + 表示+前面的字符可以出现1次或多次 例：QB+ {n} 表示{n}前面的字符可以出现n次，必须是n次 {n,} 表示{n,}前面的字符至少出现n次，不能少于n次 {n,m} 表示{n,m}前面的字符至少出现n次，但不能多于m次
正则的功能介绍：
正则的匹配功能：
正则的切割功能：
正则表达式中的组： 在一个正则表达式中，如果后面的正则表达式想要使用前面已经存在的正则规则，那么就需要对前面的正则规则进行封装。 在后面的正则中如果想要使用前面封装的组，需要通过组号来调用，组号是从1开始的。 例如： \\1
正则的替换功能：
注意：如果想要在一个正则表达中使用另个一个正则表达式中的封装的组，可以通过$1来调用
正则表达式的获取功能： 1， 想要使用java中的正则表达式对象，需要先创建正则的对象 Pattern类 2， 使用创建正则对象获取匹配器对象 Matcher类 3， 使用Matcher类对象中的方法和Pattern类中正则表达式匹配
判断是否有下个子序列，并输出子序列：
| ||||||||||||||||||||||||||||||
| 包装类 什么是包装类：把java中8种基本数据类型进行了封装
为什么使用包装类？ 类中提供了封装的一些功能，把基本类型转为包装类，就可以使用对应类中的相关功能。 包装类在开发中，主要就是用来实现基本数据类型和字符串之间的转换
Java的基本8种类型： byte short int long float double char boolean 包装类： Byte Short Integer Long Float Double Character Boolean
基本类型转为字符串： 1，基本类型数据+“”； 2，String.valueOf(); 例：String s= String.valueOf(‘男’)； 3，包装类对象.toString()；
字符串转为基本数据类型(Character类型除外)： int i = Integer.parseInt(str);
基本类型转为包装类 1，使用包装类中构造方法实现。 例：Integer in = new Integer(100); 2，使用包装类中的静态方法valueOf()。 例：Integer in = Integer.valueOf(100); 3，JDK1.5后可以直接把基本类型转为包装类。例：Character ch = ‘男’；
包装类转基本类型数据 1，使用包装类中xxxValue（）方法把包装类中存储的数值赋给基本类型数据。例： Boolean b = true；boolean flag = b.booleanValue(); 2，使用包装类对象直接赋值给基本类型数据。例：int i = new Integer（100）；
把基本类型数据赋值给包装类称为：装箱 把包装类赋值给基本类型数据称为：拆箱
| ||||||||||||||||||||||||||||||
| 集合 什么是集合： 也是一种容器，用来存储多个数据。集合的大小是可以改变的，集合中只能存储引用类型数据，集合中可以存储不同类型的引用数据。
集合有什么作用？ 解决数组的局限性
Collection集合中的方法： boolean add(Object obj) 添加一个元素(对象) boolean addAll(Collection c) 添加指定集合中所有的元素 boolean remove(Object obj) 删除指定的元素对象 boolean removeAll(Collection c) 删除和指定集合中存储元素相同的元素对象 int size() 获取集合中存储元素的个数 boolean isEmpty() 判断集合是否为空（没有存储元素） boolean contains(Object obj) 判断指定元素是否包含在集合内 boolean containsAll(Collection c) 判断指定的集合中所存储的全部元素是否包含在集合里面
集合的遍历：
1，集合转数组遍历
2，Iterator迭代器 ava.util.Iterator 就是集合框架专用的遍历方式 boolean hasNext() 判断迭代器指向的集合中是否有下一个元素存在 Object next() 返回迭代器正在迭代的元素 void remove() 删除迭代器正在迭代的元素
集合的细节： 1，集合只能存储引用类型数据，在集合底层存储的其实就是地址 2，集合中不能存储基本类型数据（在JDK1.5以后可以在集合的添加删除等功能中书写基本数据类型，但是集合在存储时存储的是基本数据类型的包装类[对基本类型数据进行装箱]） 3，集合在存储元素时，所有的元素都会转为Object类型存储（向上转型）。 4，集合在遍历获取存储的元素时，所有的元素在取出时也是Object类型，如果需要使用特有的成员，需要向下转型注意在使用向下转型时使用instanceof避免异常）。
List集合 List集合： 1， 集合中存储的元素是有序（有序不是排序，有序的意义是存储的顺序和书写的代码一致） 2， List集合有角标，可以通过角标精确的访问所存储的元素 3， List集合允许存储重复元素、允许存储null值（可以多个null）
List集合特点：存取有序、允许存储重复的元素、有角标，可以通过角标精确访问元素
List集合中的常用方法： 添加方法： void add(int index, Object obj) 按照指定的角标添加相应的引用元素 删除方法： Object remove(int index) 删除集合中指定的角标元素，并返回被删除的元素 获取方法： Object get(int index) 获取集合中指定角标下的元素 修改方法： Object set(int index,Object obj) 修改集合中指定角标下的元素，修改为指定的元素，返回旧元素 其它方法： int indexOf(Object obj)在集合中查找指定的元素，返回第一次出现的角标 List subList(int fromIndex,int toIndex)截取集合中从指定位置开始到指定位置结束之间的元素，返回子集合
List特有迭代器ListIterator 注意：List集合的专用迭代器ListIterator可以对集合进行添加、删除、修改。但是需要注意必须使用迭代器对象本身调用添加、删除、修改方法
ArrayList集合特点： 1， ArrayList集合内部使用了可变数组作为底层存储结构 2， ArrayList集合因为实现了List接口，所以具备了List集合的特点 ArrayList集合查询效率比较高，增删效率比ArrayList： 3， 较低（适用于存储元素和遍历获取元素）
LinkedList： LinkedList集合特点： 1， LinkedList集合底层使用链表结构 2， LinkedList集合因为实现了List接口，所以具备了List集合的特点 3， LinkedList集合在查询遍历效率比较低，增删元素的效率比较高
LinkedList特有方法（围绕头和尾设计）
List下的子类总结： Collection集合（接口） |-----List集合：有序、允许存储重复元素、有角标，可以使用角标精确访问集合中的元素 |-----ArrayList集合：有序、允许存储重复元素、可以存储多个null、有角标 查询遍历效率比较高，增删效率比较低 底层使用可变数组结构 集合中的特有方法都是围绕着角标设计 |-----LinkedList集合：底层使用链表结构。有序、允许存储重复元素、也可以存储null 集合中的特有方法都是围绕着头和尾来设计 查询遍历效率比较低，增删的效率比较高 以上两个集合类都属于线程不安全的集合
|-----Vector集合：底层使用的是可变数组结构。属于线程安全的集合类 查询遍历效率比较高，增删效率比较低
学习了这么集合类，到底应该使用哪个呢？ 如果只是存储和获取，就使用ArrayList集合 如果对集合中元素频繁的添、删，使用LinkedList集合 如果实在不知道使用哪个集合类更适合就选择ArrayList集合类
| ||||||||||||||||||||||||||||||
| Set集合 Set集合特点：存取无序、不允许存储重复元素、只能存储一个null值、没有角标、只能通过迭代器遍历。 （set集合中的所有方法都来自Collection集合中的） Set集合最大弊端是：无角标，不能精确访问集合中的元素
HashSet集合 HashSet集合特点：实现Set集合：存取无序、不允许存储重复元素，只能存储一个null值，没有角标，只能通过迭代器遍历 底层使用哈希表结构（哈希表底层使用的还是数组，但这个数组使用了一种名为”哈希”的算法来获取和存储元素）， 查询效率和添加不重复元素效率比较高 保证元素唯一性的方式依赖于：hashCode()和equlas()方法。 哈希表 = 数组 + 哈希算法
HashSet存储元素的过程：在存储元素时，会先拿将要存储的元素和哈希算法结合，计算出存储的位置，如果位置上没有元素存在，则直接存储；如果位置上已经有存储元素了，则再使用equals方法进行比较(比较将要存储的元素和已经存储的元素)，比较结果为true:不存储；比较结果为false：再次计算元素要存储的位置
LinkedHashSet集合
LinkHashSet集合特点：存取有序，不允许存储重复元素，只能存储一个null值，无角标。 底层使用链表+哈希表结构；查询和增删效率较快
TreeSet集合 TreeSet集合特点：实现了set集合，存取无序、不允许重复元素、只能存储一个null值、没有角标。只能通过迭代器来遍历集合 底层使用二叉树结构，可以对存储的元素按照指定规则排序 保证元素唯一性依赖于：在添加元素时，会先判断元素是否已在TreeSet集合中存储，相等则不添加元素，不相等则添加 保证唯一性：
是怎么排序的？ 在添加元素时，会和已经存在的元素进行比较大小，大：向右存储； 小：向左存储
两种排序： 当TreeSet集合中即有比较器对象排序也有自然排序时，优先使用的是比较器对象排序 自然排序：使用Comparable接口中的compareTo方法进行比较。比较结果：0、1、-1 比较器排序：使用Comparator接口中的compare方法进行比较。比较结果：0、1、-1
Foreach循环： 格式：for(类型 变量/引用变量 ： 容器) { }
作用：使用foreach主要是简化迭代器的。 foreach遍历通常只用来遍历数组或集合，不会对数组或集合进行操作。
注意：Itreator迭代器没有添加功能，只有删除功能remove() ListIterator迭代器有添加，删除，修改功能：add(), remove(). set()
| ||||||||||||||||||||||||||||||
| Map集合 Map集合特点： 1，Map集合中存储的是键key-值value对应关系 2，Map集合中必须保证key是唯一的，key只能存储一个null值 3，Map集合中的对应关系只能是单一对应 4，Map集合存取无序，不能直接遍历 5，Map集合属于双列集合，实际存储的是两个单例集合
Map集合中的基本方法： 添加方法：Object put(Object key,Object value) put方法在存储对象时，会先去检查key是否已经存在。不存在则存储key和value的对应关系，返回null值；存在则会把之前已经存在的value对象覆盖并返回旧的value对象
删除方法：Object remove(Object key) remove方法在删除Map集合中的对象时，是根据key对象来删除key-value的对应关系，删除返回被删除的value对象
修改方法：修改方法也是put方法
获取方法：Object get(Object key) get方法是根据指定的key对象，来获取Map集合中key对应的value对象，如果key没有对应的value对象，则返回null
判断方法：containsKey(Object key) 根据指定的key对象判断Map集合中是否存在指定的key对象 containValue(Object value) 根据指定的value对象判断Map集合中是否存在指定的value对象
其它方法： clear(); 清空Map集合中的所有的存储对象 isEmpty() 判断Map集合中是否有存储对象 size() 获取Map集合中存储的key-value对应关系的个数
Map集合：keySet()方法 存储key对象：key对象的特点是不能重复。 使用Set集合存储 存储value对象：value对象的特点是可以重复。 使用Collection结合存储
注意：Map集合自身没有遍历方式，需要获取Map中的单列集合，再通过获取的单列集合进行遍历获取
Map集合：entrySet()方法 entrySet()方法：是用来获取Map集合中存储的key-value的映射关系 映射关系类型：Map.Entry类型
Map.Entry方法： getKey():返回对应的键 getValue()：返回对应的值 setValue():替换与此项对应的值
Map集合：values()方法 values()方法：用来获取Map集合中所有的value对象，获取的对象存储在Collection中
小结：
| ||||||||||||||||||||||||||||||
| 泛型 什么是泛型？ 在创建集合时，就明确容器中的元素类型 格式：<引用类型> 注意：泛型中只能用引用类型，不能使用基本数据类型
好处：1，安全进制 2，将运行时异常转移到编译时异常 3，泛型技术是给编译器使用的技术 4，省略了类型的强制转换
注意：1，泛型在使用时，必须保证两边泛型一致 2，接口中的泛型传递给子类后，子类还可以继续把泛型向下传递 3，泛型的传递必须在最后使用最终的子类在创建对象时，明确泛型的类型
通配符：<?>：表示任意引用了类型 什么情况下使用：当使用泛型类或接口时，传递的具体类型不确定时可以通过通配符表示
通配符的限定： 上限：< ? extends E > 表示接受E类型或者E的子类型 下限：< ? super E > 表示接受E类型或者E的父类型
，如果对您有帮助 ，请多多支持，欢迎大家转载：转载请请添加源链接：https://blog.youkuaiyun.com/qq_30764991点击打开链接，非常感谢：
|
扫一扫
04-22
1816
1816
01-25
3394
3394
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
