Java基础

数据类型：

Java是强类型语言，其支持的类型有：基本类型和引用类型；

基本数据类型	整类型	byte	1个字节（-128~127）
		short	2个字节（-~-1）
		int	4个字节（-~-1）
		long	8个字节（-~-1）
	字符类型	char	2个字节（0~65535）
	浮点类型	float	4个字节
		double	8个字节
	布尔类型	boolean	1位

数组：

初始化：（并不是对数组变量执行初始化，而是在堆内存中创建数组对象，即为该数组对象分配一块连续的内存空间）

• 静态初始化：初始化时由程序员显示指定每个数组元素的初始值，由系统决定数组长度；
• 动态初始化：初始化时程序员只指定数组长度，由系统为数组元素分配初始值；

对象：

• 值传递：当调用方法时，如果传入的数值为基本数据类型（包含String）,形式参数的改变对实际参数不影响；
• 引用传递：当调用方法时，如果传入的数值为引用数据类型（不包含String）,形式参数的改变对实际参数有影响；

方法重载的要求：

• 同一个类中方法名相同，参数列表不同（方法返回值类型、修饰符等与重载无关）；

面向对象的三大特征：

• 封装：将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部信息，而是通过该类所提供的方法来实现对内部信息的操作和访问；

 

• 继承：重写：“两同两小一大”：方法名、参数列表相同，子类方法返回值类型应比父类方法返回值类型更小或相等，子类方法声明抛出的异常应比父类方法抛出的异常类更小或相等，子类方法的访问权限应比父类方法更大或相等；（覆盖方法和被覆盖方法要么都是类方法，要么都是实例方法）
• 多态：应用变量有两个类型：编译时类型由声明该变量时使用的类型决定，运行时的类型由实际赋给该变量的对象决定，如果编译时类型和运行时类型不一致就会出现多态；存在条件：继承、重写、父类引用指向子类对象；

多态的转型：

• 向上转型：多态本身就是向上转型过的过程；
• 向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用类型转为子类引用各类型；
• instanceof:用来判断前面的对象是否是后面的类，其子类，实现类的实例，返回值是布尔类型；

初始化块：

执行顺序：静态初始化块->初始化块->构造器->静态方法

包装类：

• 自动装箱：把一个基本类型变量直接赋给对应的包装类变量；
• 自动拆箱：把包装类对象直接赋给一个对应的基本类型变量；

Integer i=9;
int i1=i;
        

基本类型与字符串之间的装换，包装类(除Character)提供了parseXxx(String str)静态方法,用于将特定字符串转换成基本类型变量；String类里提供了多个重载valueOf()方法，用于将基本类型转换成字符串类型；

int num=9;
String str=String.valueOf(num);

String str1="111.3";
float f=Float.parseFloat(str1);

==和equals:

==:若是两个基本类型的变量，且都是数值类型，则只要两个变量的值相等，使用==判断就将返回true;若是两个引用类型的基本变量，必须它们指向同一个对象时，==才会返回true;

equals:用来判断两个引用变量是否相等；

正确的重写equals方法应该满足下列条件：

• 自反性：对任意x,x.equals(x)一定返回true;
• 对称性：对任意x和y，如果x.equals(y)返回true,则y.equals(x)也返回true;
• 传递性：对任意x,y,z,如果有x.equals(y)返回true,y.equals(z)返回true,则x.equals(z)一定返回true；
• 一致性：对任意x和y，如果对象中用于等价比较的信息没有改变,那么无论调用x.equals(y)多少次，返回的结果都应该保持一致；
• 对任何不是null的x,x.equals(null)一定返回false;

以下是String的equals方法源码：

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

但是由于instanceof的特殊性，当前面对象是后面类的实例或者其子类的实例都将返回true,所以实际重写时应用反射去判断，如下：

@Override
    public boolean equals(Object object){
        if(this==object){
            return true;
        }
        if(object!=null&&object.getClass()==Person.class){
            Person personObj=(Person) object;
            if(this.getName().equals(personObj.getName())){
                return true;
            }
        }
        return false;
    }

对象的克隆：

浅拷贝：拷贝对象时仅仅拷贝对象本身（包括对象中的基本变量），而不拷贝对象包含的引用指向的对象，

深拷贝：不仅拷贝对象本身，而且拷贝对象包含的引用指向的所有对象；

package clone;

public class FleetClone {
    public static void main(String[] args) {
        Person person=new Person("person");
        Student student=new Student(person);
        Student student1=(Student) student.clone();
        student1.person.setName("new");
        System.out.println(student.person.getName());
        System.out.println(student1.person.getName());
    }
}
class Person{
    private String name;
    public Person(String name){
        this.name=name;
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
class Student implements Cloneable{
    public Person person;
    public Student(Person person){
        this.person=person;
    }
    public Object clone(){
        Student student=null;
        try {
            student=(Student) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }return student;
    }
}

package clone1;

public class DeeplyClone {
    public static void main(String[] args) {
        Person person=new Person("deeply");
        Student student1=new Student(person);
        Student student2=(Student) student1.clone();
        student2.person.setName("new deeply");
        System.out.println(student1.person.getName());
        System.out.println(student2.person.getName());
    }


}
class Person implements Cloneable{
    private String name;
    public Person(String name){
        this.name=name;
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public Object clone(){
        Person person=null;
        try {
            person=(Person) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }return person;
    }
}
class Student implements Cloneable{
    public Person person;
    public Student(Person person){
        this.person=person;
    }
    public Object clone(){
        Student student=null;
        try {
            student=(Student) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        student.person=(Person) person.clone();//把其它对象的引用也做克隆
        return student;
    }
}

 

• this:指向调用该方法的对象；
• super:在子类方法中调用父类中被覆盖的方法；

抽象类：

抽象方法和抽象类必须使用abstract修饰符来定义，有抽象方法的类只能被定义为抽象类，抽象类里可以没有抽象方法；

抽象类和抽象方法的规则如下：

• 抽象类必须使用abstract修饰，抽象方法也必须使用abstract修饰，抽象方法不能有方法体；
• 抽象类不能被实例化，无法使用new;
• 抽象类可以包含属性、方法（普通或者抽象）、构造器、初始化块、内部类、枚举类，抽象类的构造器不能用于创建实例，主要用于被其子类调用；
• 含有抽象方法的类（包括直接定义了一个抽象方法；继承了一个抽象父类，但没有完全实现父类包含的抽象方法；以及实现了一个接口，但没有完全实现接口包含的抽象方法三种情况）只能被定义为抽象类；

接口：

是抽象方法和常量值的定义集合，一个接口可以继承多个父接口；

接口里可以包含属性（只能是常量）、方法（抽象实例方法）、内部类和枚举类，不包含构造器和初始化块，

接口和抽象类的差别：

• 接口内只能包含抽象方法，抽象类可以包含普通方法；
• 接口不能定义静态方法，抽象类可以；
• 接口只能定义静态常量属性，不能定义普通常量属性；抽象类则都可以；
• 接口不包含构造器；抽象类可以包含构造器，但只是用来让其子类调用构造器完成抽象类的初始化操作；
• 接口不包含初始化块，但抽象类包含初始化块，
• 类可以实现多接口，但只能继承一个抽象类；
• 接口可以多继承；

内部类：

一个类放在另一个类的内部定义，这个定义在其他类内部的类即为内部类；

内部类的作用：

• 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类；
• 内部类成员可以访问外部类的私有数据；
• 匿名内部类适合用于创建仅需要一次使用的类；

匿名内部类：

• 匿名内部类不能是抽象类，系统在创建匿名内部类得到时候，会立即创建匿名内部类的对象；
• 匿名内部类不能定义构造器，因为匿名内部类无类名；

常用类：

Object类：

  是所用类、数组、枚举类的父类，Java允许把所有任何类型的对象赋给Object类型的变量，当定义一个类时没有使用extends关键字为它显示指定父类，则该类默认继承Object类；

 提供常用的方法：

• boolean equals(Object obj):判断指定对象与该对象是否相等；
• protected void finalize():当系统中没有引用变量引用到该对象时，垃圾回收器调用此方法来清理该对象的资源；
• Class getClass():该方法返回该对象的运行时类；
• int hashCode:返回该对象的hashCode值；
• String toString():Object的该方法返回“运行时类名@十六进制hashCode值”格式的字符串；
• 除此之外还包括wait()、notify()、notifyAll()来控制线程的暂停和运行；

String、StringBuilder、StringBuffer区别:

•   速度：StringBuilder》StringBuffer》String；
• StringBuilder/StringBuffer是字符串变量，是可以改变的对象，实际是在一个对象上操作，String是创建一些对象；
• StringBuilder：线程不安全；StringBuffer：线程安全；

BigDecimal类：

  因为float、double容易引起精度丢失，为了精确计算浮点数，Java提供了BigDecimal类；创建该对象时一般采用如下两种方式:

BigDecimal bigDecimal=new BigDecimal("1.2");
BigDecimal bigDecimal2=BigDecimal.valueOf(1.2);

Math类：

字段摘要
static double	E           比任何其他值都更接近 e（即自然对数的底数）的 double 值。
static double	PI           比任何其他值都更接近 pi（即圆的周长与直径之比）的 double 值。

 

方法摘要
static double	abs(double a)           返回 double 值的绝对值。
static float	abs(float a)           返回 float 值的绝对值。
static int	abs(int a)           返回 int 值的绝对值。
static long	abs(long a)           返回 long 值的绝对值。
static double	acos(double a)           返回一个值的反余弦；返回的角度范围在 0.0 到 pi 之间。
static double	asin(double a)           返回一个值的反正弦；返回的角度范围在 -pi/2 到 pi/2 之间。
static double	atan(double a)           返回一个值的反正切；返回的角度范围在 -pi/2 到 pi/2 之间。
static double	atan2(double y, double x)           将矩形坐标 (x, y) 转换成极坐标 (r, theta)，返回所得角 theta。
static double	cbrt(double a)           返回 double 值的立方根。
static double	ceil(double a)           返回最小的（最接近负无穷大）double 值，该值大于等于参数，并等于某个整数。
static double	copySign(double magnitude, double sign)           返回带有第二个浮点参数符号的第一个浮点参数。
static float	copySign(float magnitude, float sign)           返回带有第二个浮点参数符号的第一个浮点参数。
static double	cos(double a)           返回角的三角余弦。
static double	cosh(double x)           返回 double 值的双曲线余弦。
static double	exp(double a)           返回欧拉数 e 的 double 次幂的值。
static double	expm1(double x)           返回 ex -1。
static double	floor(double a)           返回最大的（最接近正无穷大）double 值，该值小于等于参数，并等于某个整数。
static int	getExponent(double d)           返回 double 表示形式中使用的无偏指数。
static int	getExponent(float f)           返回 float 表示形式中使用的无偏指数。
static double	hypot(double x, double y)           返回 sqrt(x2 +y2)，没有中间溢出或下溢。
static double	IEEEremainder(double f1, double f2)           按照 IEEE 754 标准的规定，对两个参数进行余数运算。
static double	log(double a)           返回 double 值的自然对数（底数是 e）。
static double	log10(double a)           返回 double 值的底数为 10 的对数。
static double	log1p(double x)           返回参数与 1 之和的自然对数。
static double	max(double a, double b)           返回两个 double 值中较大的一个。
static float	max(float a, float b)           返回两个 float 值中较大的一个。
static int	max(int a, int b)           返回两个 int 值中较大的一个。
static long	max(long a, long b)           返回两个 long 值中较大的一个。
static double	min(double a, double b)           返回两个 double 值中较小的一个。
static float	min(float a, float b)           返回两个 float 值中较小的一个。
static int	min(int a, int b)           返回两个 int 值中较小的一个。
static long	min(long a, long b)           返回两个 long 值中较小的一个。
static double	nextAfter(double start, double direction)           返回第一个参数和第二个参数之间与第一个参数相邻的浮点数。
static float	nextAfter(float start, double direction)           返回第一个参数和第二个参数之间与第一个参数相邻的浮点数。
static double	nextUp(double d)           返回 d 和正无穷大之间与 d 相邻的浮点值。
static float	nextUp(float f)           返回 f 和正无穷大之间与 f 相邻的浮点值。
static double	pow(double a, double b)           返回第一个参数的第二个参数次幂的值。
static double	random()           返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
static double	rint(double a)           返回最接近参数并等于某一整数的 double 值。
static long	round(double a)           返回最接近参数的 long。
static int	round(float a)           返回最接近参数的 int。
static double	scalb(double d, int scaleFactor)           返回 d × 2scaleFactor，其舍入方式如同将一个正确舍入的浮点值乘以 double 值集合中的一个值。
static float	scalb(float f, int scaleFactor)           返回 f × 2scaleFactor，其舍入方式如同将一个正确舍入的浮点值乘以 float 值集合中的一个值。
static double	signum(double d)           返回参数的符号函数；如果参数为 0，则返回 0；如果参数大于 0，则返回 1.0；如果参数小于 0，则返回 -1.0。
static float	signum(float f)           返回参数的符号函数；如果参数为 0，则返回 0；如果参数大于 0，则返回 1.0；如果参数小于 0，则返回 -1.0。
static double	sin(double a)           返回角的三角正弦。
static double	sinh(double x)           返回 double 值的双曲线正弦。
static double	sqrt(double a)           返回正确舍入的 double 值的正平方根。
static double	tan(double a)           返回角的三角正切。
static double	tanh(double x)           返回 double 值的双曲线余弦。
static double	toDegrees(double angrad)           将用弧度表示的角转换为近似相等的用角度表示的角。
static double	toRadians(double angdeg)           将用角度表示的角转换为近似相等的用弧度表示的角。
static double	ulp(double d)           返回参数的 ulp 大小。
static float	ulp(float f)           返回参数的 ulp 大小。

从类 java.lang.Object 继承的方法
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Random类：

  Random类专门用于生成一个伪随机数，

构造方法摘要
Random()           创建一个新的随机数生成器。
Random(long seed)           使用单个 long 种子创建一个新的随机数生成器。

 

方法摘要
protected  int	next(int bits)           生成下一个伪随机数。
boolean	nextBoolean()           返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 boolean 值。
void	nextBytes(byte[] bytes)           生成随机字节并将其置于用户提供的 byte 数组中。
double	nextDouble()           返回下一个伪随机数，它是取自此随机数生成器序列的、在 0.0 和 1.0 之间均匀分布的 double 值。
float	nextFloat()           返回下一个伪随机数，它是取自此随机数生成器序列的、在 0.0 和 1.0 之间均匀分布的 float 值。
double	nextGaussian()           返回下一个伪随机数，它是取自此随机数生成器序列的、呈高斯（“正态”）分布的 double 值，其平均值是 0.0，标准差是 1.0。
int	nextInt()           返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。
int	nextInt(int n)           返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int 值。
long	nextLong()           返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 long 值。
void	setSeed(long seed)           使用单个 long 种子设置此随机数生成器的种子。

正则表达式：

 

方法摘要
Matcher	appendReplacement(StringBuffer sb, String replacement)           实现非终端添加和替换步骤。
StringBuffer	appendTail(StringBuffer sb)           实现终端添加和替换步骤。
int	end()           返回最后匹配字符之后的偏移量。
int	end(int group)           返回在以前的匹配操作期间，由给定组所捕获子序列的最后字符之后的偏移量。
boolean	find()           尝试查找与该模式匹配的输入序列的下一个子序列。
boolean	find(int start)           重置此匹配器，然后尝试查找匹配该模式、从指定索引开始的输入序列的下一个子序列。
String	group()           返回由以前匹配操作所匹配的输入子序列。
String	group(int group)           返回在以前匹配操作期间由给定组捕获的输入子序列。
int	groupCount()           返回此匹配器模式中的捕获组数。
boolean	hasAnchoringBounds()           查询此匹配器区域界限的定位。
boolean	hasTransparentBounds()           查询此匹配器区域边界的透明度。
boolean	hitEnd()           如果匹配器执行的最后匹配操作中搜索引擎遇到输入结尾，则返回 true。
boolean	lookingAt()           尝试将从区域开头开始的输入序列与该模式匹配。
boolean	matches()           尝试将整个区域与模式匹配。
Pattern	pattern()           返回由此匹配器解释的模式。
static String	quoteReplacement(String s)           返回指定 String 的字面值替换 String。
Matcher	region(int start, int end)           设置此匹配器的区域限制。
int	regionEnd()           报告此匹配器区域的结束索引（不包括）。
int	regionStart()           报告此匹配器区域的开始索引。
String	replaceAll(String replacement)           替换模式与给定替换字符串相匹配的输入序列的每个子序列。
String	replaceFirst(String replacement)           替换模式与给定替换字符串匹配的输入序列的第一个子序列。
boolean	requireEnd()           如果很多输入都可以将正匹配更改为负匹配，则返回 true。
Matcher	reset()           重置匹配器。
Matcher	reset(CharSequence input)           重置此具有新输入序列的匹配器。
int	start()           返回以前匹配的初始索引。
int	start(int group)           返回在以前的匹配操作期间，由给定组所捕获的子序列的初始索引。
MatchResult	toMatchResult()           作为 MatchResult 返回此匹配器的匹配状态。
String	toString()           返回匹配器的字符串表示形式。
Matcher	useAnchoringBounds(boolean b)           设置匹配器区域界限的定位。
Matcher	usePattern(Pattern newPattern)           更改此 Matcher 用于查找匹配项的 Pattern。
Matcher	useTransparentBounds(boolean b)           设置此匹配器区域边界的透明度。

 

@Test
    public void t1(){
        //Pattern pattern=Pattern.compile("[b]");
        Matcher matcher=Pattern.compile("[b]").matcher("aaab");
        while (matcher.find()){
            System.out.println(matcher.group());
        }
    }