java笔记

复习java,顺便写一下java笔记

基础知识

常量

常量是不能被修改的。

java中final关键字可以用于声明属性(常量),方法和类。在变量前面添加关键词final即可声明一个常量。常量名必须大写。

语法格式:

    final 数据类型 常量名 = 值;

例如:

    final double PI = 10.2;

数据类型

整数

byte、short、int、long 四种基本数据类型表示整数,需要注意的是 long 类型,使用 long 修饰的变量需要在数值后面加上 L 或者 l

浮点数

float 和 double 类型表示浮点数,即可以表示小数部分。需要注意的是 float 类型的数值后面需要加上 F 或者 f,否则会被当成 double 类型处理。double 类型的数值可以加上 D 或 d,也可以不加。

char 类型

char 类型用于表示单个字符。需要将字符用单引号括起来

char a = 'a'

char 可以和整数互相转换

char a = 97。 

也可以用十六进制表示

char a = '\u0061'。

boolean 类型

boolean 类型(布尔类型)用于表示真值 true或者假值 false,Java 中布尔值不能和整数类型或者其它类型互相转换。

String

Java 中使用 String 类来定义一个字符串,字符串是常量,它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。

String 对象的初始化格式有如下两种:

String s0 = "abc";
String s1 = new String("abd");

String 类具有丰富的方法,比如计算字符串的长度、连接字符串、比较字符串、提取字符串等等。

计算字符串长度

length() 方法:

1
2
3
//方法原型
public int length(){
}

调用方法:字符串标识符.length(); 返回一个 int 类型的整数(字符串中字符数,中文字符也是一个字符)。例如:

1
2
3
4
String s1 = "abc";
String s2 = "Java语言";
int len1 = s1.length();
int len2 = s2.length();

则变量 len1 的值是 3,变量 len2 的值是 6。

字符串比较

equals() 方法,该方法的作用是判断两个字符串对象的内容是否相同。如果相同则返回 true,否则返回 false。

equals() 方法比较是从第一字符开始,一个字符一个字符依次比较。

equalsIgnoreCase() 方法,其用法与 equals() 一致,不过它会忽视大小写。

而使用 “==” 比较的是两个对象在内存中存储的地址是否一样。

字符串连接

字符串连接有两种方法:

  • 使用 + 比如 String s = “Hello “ + “World!”。而且使用 + 进行连接,不仅可以连接字符串,也可以连接其他类型。但是要求进行连接时至少有一个参与连接的内容是字符串类型。
  • 使用 String 类的 concat() 方法。
    1
    2
    3
    String a = "avx";
    String b = " w ";
    System.out.println(a.concat(b));

运算符

算术运算符

自增 (++) 和自减 (–) 运算符有两种写法:前缀 (++i,–i) 和后缀 (i++,i–)

前缀自增自减法 (++i,–i): 先进行自增或者自减运算,再进行表达式运算。(++i :是先把i+1,然后再拿出来使用;)

后缀自增自减法 (i++,i–): 先进行表达式运算,再进行自增或者自减运算(i++:是先把i拿出来使用,然后再+1;)

位运算符

  • & 按位与 如果相对应位都是 1,则结果为 1,否则为 0

  • 丨 按位或 如果相对应位都是 0,则结果为 0,否则为 1

  • ^ 按位异或 如果相对应位值相同,则结果为 0,否则为 1

  • ~ 按位补 翻转操作数的每一位,即 0 变成 1,1 变成 0

  • << 左移 左边最高位丢弃,右边补齐0

  • >> 右移 最高位是0,左边补齐0;最高位是1,左边补齐1

  • >>> 无符号右移 无论最高位是0还是1,左边补齐0

逻辑运算符

逻辑运算符是通过运算符将操作数或等式进行逻辑判断的语句。

表格中的例子中,假设布尔变量 a 为真(true),变量 b 为假(false):

&& 或 & 与 当且仅当两个操作数都为真,条件才为真

双目运算符    (a && b) 或 (a & b) 为假

|| 或 | 或 两个操作数任何一个为真,条件为真

双目运算符    (a || b) 或 (a | b) 为真

! 非 用来反转操作数的逻辑状态。如果条件为真,则逻辑非运算符将得到假

单目运算符    (!a)为假

^ 异或 如果两个操作数逻辑相同,则结果为假,否则为真

双目运算符    (a ^ b) 为真

&& 与 || 是具有短路性质,当按优先级顺序计算到当前表达式时,表达式的结果可以确定整个表达式的结果时,便不会继续向后进行判断和计算,而直接返回结果。

关系运算符

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

关系运算符生成的是一个 boolean(布尔) 结果,它们计算的是操作数的值之间的关系。如果关系是真实的,结果为 true(真),否则,结果为 false(假)。

Java 还有唯一的一个三目运算符 ?:

语法格式:

布尔表达式 ?表达式 1 : 表达式 2;

运算过程:如果布尔表达式的值为 true,则返回表达式 1的值,否则返回表达式 2的值。

注意:

  • == 和 != 适用于所有的基本数据类型,其他关系运算符不适用于 boolean,因为 boolean 值只有 true 和 false,比较没有任何意义。

  • == 和 != 也适用于所有对象,可以比较对象的引用是否相同。

关键字

Java 的关键字对 Java 的编译器有特殊的意义,他们用来表示一种数据类型,或者表示程序的结构等,关键字不能用作变量名、方法名、类名、包名。

方法

Java 中的方法,可以将其看成一个功能的集合,它们是为了解决特定问题的代码组合。

方法的定义语法:

访问修饰符 返回值类型 方法名(参数列表) {
    方法体
}

在上面的语法说明中:

访问修饰符: 代表方法允许被访问的权限范围,可以是 public、protected、private 或者省略(default)。

返回值类型: 方法返回值的类型,如果方法不返回任何值,则返回值类型指定为 void (代表无类型);如果方法具有返回值,则需要指定返回值的类型,并且在方法体中使用 return 语句返回值。

方法名: 是方法的名字,必须使用合法的标识符。

参数列表: 是传递给方法的参数列表,参数可以有多个,多个参数间以逗号隔开,每个参数由参数类型和参数名组成,以空格隔开。当方法被调用时,传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的,方法可以不包含任何参数。

方法体: 方法体包含具体的语句,定义该方法的功能。

当方法定义好之后,需要调用才可以生效,我们可以通过 main 方法(main 方法是 Java 程序的入口,所以需要用它来调用)来调用它。

方法重载

方法重载是指在一个类中定义多个同名的方法,但要求每个方法具有不同的参数的类型或参数的个数。方法重载一般用于创建一组任务相似但是参数不同的方法。

方法重载有以下几种规则:

  • 方法中的参数列表必须不同。比如:参数个数不同或者参数类型不同。
  • 重载的方法中允许抛出不同的异常
  • 可以有不同的返回值类型,但是参数列表必须不同。
  • 可以有不同的访问修饰符。

方法重写

子类可以继承父类的方法,但如果子类对父类的方法不满意,想在里面加入适合自己的一些操作时,就需要将方法进行重写。并且子类在调用方法中,优先调用子类的方法。

重写的方法一定要与原父类的方法语法保持一致,比如返回值类型,参数类型及个数,和方法名都必须一致。

if语句

多重 if 语句,在条件 1 不满足的情况下,才会进行条件 2 的判断,以此向下;当前面的条件均不成立时,最终执行 else 块内的代码。

语法:

1
2
3
4
5
6
7
8
9
10
if(条件1){
代码块1
}
else if(条件2){
代码块2
}
...
else {
代码块n
}

switch语句

当需要对选项进行等值判断时,使用 switch 语句更加简洁明了。

语法:

1
2
3
4
5
6
7
8
9
10
11
switch(表达式){
case 值1:
代码块1
break;
case 值2:
代码块2
break;
...
default:
默认执行的代码块
}

当 switch 后表达式的值和 case 语句后的值相同时,从该位置开始向下执行,直到遇到 break 语句或者 switch 语句块结束;如果没有匹配的 case 语句则执行 default 块的代码。(defualt 块不是必须的,默认为空)

while语句

while语法:

while(条件){
    代码块
}

while 的执行过程是先判断,再执行。

判断 while 后面的条件是否成立 ( true or false )
当条件成立时,执行循环内的代码。

do-while语句

do-while 语法:

do{
    代码块
}while(条件);

do-while 的执行过程是先执行一次,再循环判断 (所以循环内的代码至少会执行一次)

先执行一遍循环操作,然后判断循环条件是否成立。
如果条件成立,继续执行,直到循环条件不成立为止。

for语句

for 语法:

1
2
3
for(循环变量初始化①; 循环条件②; 循环变量值操作③){
循环操作④
}

for 相比 while 和 do-while 语句结构更加简洁易读,它的执行顺序:

  • 执行循环变量初始化部分(1),设置循环的初始状态,此部分在整个循环中只执行一次。

  • 进行循环条件的判断(2),如果条件为 true,则执行循环体内代码(4);如果为 false ,则直接退出循环。

  • 执行循环变量值操作部分(3),对循环变量的值进行修改,然后进行下一次循环条件判断(2)。

整个循环的流程可以简化为:

(1) -> [(2)->(4)->(3)] -> [(2)->(4)->(3)] -> ... => (2) 结果为 false, 退出循环。

跳转语句

break 关键字经常用在条件和循环语句中,用来跳出循环语句。

continue 关键字的作用是跳过循环体中剩余的语句执行下一次循环。

数组

语法:

1
2
3
数据类型[ ] 数组名;  
//或者:
数据类型 数组名[ ];

数组名为任意合法的变量名,如:

1
2
3
int ages[];      //存放年龄的数组,类型为整型
char symbol[]; //存放符号的数组,类型为字符型
String[] name; //存放名称的数组,类型为字符串型

声明数组后,需要为数组分配空间,也就是定义多大的数组。

语法:

数组名 = new  数据类型 [ 数组长度 ];

数组长度就是数组最多可存放元素的个数。可以在数组声明的时候初始化数组,或者在声明时就为它分配好空间,这样就不用再为数组分配空间。

语法:

1
2
3
4
5
int[] ages = {1,8,9,3,15,0};
//声明并初始化了一个整型数组,它有6个元素

char[] symbol = new char[10]
//声明并分配了一个长度为10的char型数组

分配空间后就可以向数组中放数据了,数组中元素都是通过下标来访问的。 如:

ages[0] = 12;

Java 中可以将一个数组赋值给另一个数组,如:

int[] a1 = {1,2,3};
int[] a2;
a2 = a1;

这里只是复制了一个引用,即 a2 和 a1 是相同数组的不同名称。a2的值变化,a1的值也会变

数组遍历:

1
2
3
4
5
6
int [] ages = {12, 18, 9, 33, 45, 60};
for(int i = 0; i < ages.length; i++){
//ages.length是获取数组的长度

System.out.println("数组中第"+(i+1)+"个元素是 "+ages[i]);
//注意数组下标是从零开始

注意:

  • 数组下标从 0 开始。所以数组的下标范围是 0 至 数组长度 -1(arr.length() - 1)。
  • 数组不能越界访问,否则会报错。

for 语句在数组内可以使用特殊简化版本,在遍历数组、集合时,foreach 更简单便捷。从英文字面意思理解 foreach 也就是“ for 每一个”的意思。

语法:

1
2
3
for(元素类型 元素变量:遍历对象){
执行的代码
}

二维数组

语法:

1
2
3
4
5
6
7
8
9
10
11
12
13
数据类型[][] 数组名 = new 数据类型[行的个数][列的个数];

//或者
数据类型[][] 数组名;
数组名 = new 数据类型[行的个数][列的个数];

//也可以
数据类型 [][] 数组名 = {

{第一行值1,第一行值2,...}
{第二行值1,第二行值2,...}
...
}

二维数组的赋值和访问,跟一维数组类似,可以通过下标来逐个赋值和访问,注意索引从 0 开始

数组名[行的索引][列的索引] = 值;

面向对象

类的定义:

  • 类是相同或相似对象的一种抽象,是对象的一个模板,它描述一类对象的行为和状态。
  • 类是具有相同属性和方法(行为)的对象的集合

类就是对象的抽象(或者模板),对象就是类的具体(或者实例)。

类由属性和方法两部分组成。

定义一个类

主要有三个步骤:

  • 定义类名,用于区分不同的类。如下代码中 public class 后面跟的就是类名。class是声明类的关键字,类名后面跟上大括号,大括号里面就是类的一些信息。public 为权限修饰符。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    public class 类名 {
    //定义属性部分(成员变量)
    属性1的类型 属性1;
    属性2的类型 属性2;
    ...
    //定义方法部分
    方法1
    方法2
    ...
    }
  • 编写类的属性。对象有什么,需要通过属性来表示。属性的定义是写在类名后面的大括号里,在定义属性时,要明确属性的类型。在一个类当中可以写一个或多个属性。也可以不定义属性。

  • 编写类的方法。方法也是写在大括号里面。可以定义一个方法或多个方法,也可以不定义方法。

一个类可以包含以下类型变量

  • 局部变量:在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中,方法结束后,变量就会自动销毁。
  • 成员变量:成员变量是定义在类中,方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
  • 类变量:也叫静态变量,类变量也声明在类中,方法体之外,但必须声明为 static 类型。

注:在使用时注意,成员变量可以被本类的所有方法所使用,同时可以被与本类有关的其他类所使用。而局部变量只能在当前的方法中使用。

作用域

作用域可以简单地理解为变量的生存期或者作用范围,也就是变量从定义开始到什么时候消亡。

  • 局部变量的作用域仅限于定义它的方法内。而成员变量的作用域在整个类内部都是可见的。

  • 同时在相同的方法中,不能有同名的局部变量;在不同的方法中,可以有同名的局部变量。

  • 成员变量和局部变量同名时,局部变量具有更高的优先级。

    对象

    创建对象的语法如下:

    类名 对象名 = new 类名();

定义类的时候不会为类开辟内存空间,但是一旦创建了对象,系统就会在内存中为对象开辟一块空间,用来存放对象的属性值和方法。

创建对象后,我们就要使用对象了,使用对象无非就是对属性和方法进行操作和调用。

语法如下:

    //引用对象属性

    对象名.属性

    //引用对象方法
    对象名.方法

构造方法

在面向对象中有一个非常重要的知识点,就是构造方法。每个类都有构造方法,在创建该类的对象的时候他们将被调用,如果没有定义构造方法,Java 编译器会提供一个默认构造方法。 创建一个对象的时候,至少调用一个构造方法。比如在新建一个对象 new Object(),括号中没有任何参数,代表调用一个无参构造方法(默认构造方法就是一个无参构造方法)。构造方法的名称必须与类名相同,一个类可以定义多个构造方法。

构造方法的具体内容:

  • 构造方法的名称与类名相同,且没有返回值。它的语法格式如下:

      //与类同名,可以指定参数,没有返回值
      public 构造方法名(){
      //初始化代码
      }

    下面是一个构造方法的例子:

      public class People{
          //无参构造方法
          public People(){
    
          }
          //有一个参数的构造方法
          public People(int age){
    
          }
      }

    又例如具体的构造方法:

      public class People {
          //属性(成员变量)有什么
              double height;     //身高
              int age;           //年龄
              int sex;       //性别,0为男性,非0为女性
    
          //构造方法,初始化了所有属性
          public People(double h, int a, int s){
              height = h;
              age = a;
              sex = s;
          }
      }

    //创建对象,调用我们自己定义的有参构造方法
    People XiaoMing = new People(168, 21, 1);

    上面的例子中通过 new 关键字将类实例化成对象,而 new 后面跟的就是构造方法。于是可以知道 new + 构造方法 可以创建一个新的对象。

  • 如果在定义类的时候没有写构造方法,系统会默认生成一个无参构造方法,这个构造方法什么也不会做。

  • 当有指定的构造方法时,系统不会再添加无参构造方法了。

  • 构造方法的重载:方法名相同,但参数不同 的多个方法,调用时会自动根据不同的参数选择相应的方法。

static

静态成员

Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有,而不是某个对象所有,即被类的所有对象所共享。静态成员可以使用类名直接访问,也可以使用对象名进行访问。

静态方法

被 static 修饰的方法是静态方法,静态方法不依赖于对象,不需要将类实例化便可以调用,由于不实例化也可以调用,所以不能有 this,也不能访问非静态成员变量和非静态方法。但是非静态成员变量和非静态方法可以访问静态方法。

final

final 关键字可以修饰类、方法、属性和变量

  • final 修饰类,则该类不允许被继承,为最终类
  • final 修饰方法,则该方法不允许被覆盖(重写)
  • final 修饰属性:则该类的属性不会进行隐式的初始化(类的初始化属性必须有值)或在构造方法中赋值(但只能选其一)
  • final 修饰变量,则该变量的值只能赋一次值,即常量

权限修饰符

权限修饰符可以用来修饰属性和方法的访问范围。

访问范围

默认 是什么修饰符都不加,默认在当前类中和同一包下都可以访问和使用。

封装

封装,即隐藏对象的属性和实现细节,仅对外公开接口,控制在程序中属性的读和修改的访问级别

  • 只能通过规定的方法访问数据。
  • 隐藏类的实例细节,方便修改和实现。

实现类的封装

  • 修改属性的可见性,在属性的前面添加修饰符 (private)
  • 对每个值属性提供对外的公共方法访问,如创建 getter/setter(取值和赋值)方法,用于对私有属性的访问
  • 在 getter/setter 方法里加入属性的控制语句,例如我们可以加一个判断语句,对于非法输入给予否定。

this

this 关键字代表当前对象。使用 this. 属性 操作当前对象的属性,this. 方法 调用当前对象的方法。

用 private 修饰的属性,必须定义 getter 和 setter 方法才可以访问到 .

如下:

1
2
3
4
5
6
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}

创建好了 getter 和 setter 方法后,我们发现方法中参数名和属性名一样。

当成员变量和局部变量之间发生冲突时,在属性名前面添加了 this 关键字。 此时就代表将一个参数的值赋给当前对象的属性。同理 this 关键字可以调用当前对象的方法。

继承

语法:

class 子类 extends 父类

继承的特点:

  • 子类拥有父类除 private 以外的所有属性和方法。
  • 子类可以拥有自己的属性和方法。
  • 子类可以重写实现父类的方法。
  • Java 中的继承是单继承,一个类只有一个父类。

注:Java 实现多继承的一个办法是 implements(实现)接口,但接口不能有非静态的属性,这一点请注意。

super

super 关键字在子类内部使用,代表父类对象。

  • 访问父类的属性 super.属性名。
  • 访问父类的方法 super.方法名()。
  • 子类构造方法需要调用父类的构造方法时,在子类的构造方法体里最前面的位置:super()。

多态

多态是指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。多态也称作动态绑定(dynamic binding),是指在执行期间判断所引用对象的实际类型,根据其实际的类型调用其相应的方法。

通俗地讲,只通过父类就能够引用不同的子类,这就是多态,我们只有在运行的时候才会知道引用变量所指向的具体实例对象。

多态的实现条件
Java 实现多态有三个必要条件:继承、重写和向上转型(即父类引用指向子类对象)。

只有满足上述三个条件,才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象,从而达到执行不同的行为。

多态的实现方式
Java 中多态的实现方式:继承父类进行方法重写,抽象类和抽象方法,接口实现。

向上转型

不能使用一个子类的引用去指向父类的对象,因为子类对象中可能会含有父类对象中所没有的属性和方法。

如果定义了一个指向子类对象的父类引用类型,那么它除了能够引用父类中定义的所有属性和方法外,还可以使用子类强大的功能。但是对于只存在于子类的方法和属性就不能获取。

向上转型,在运行时,会遗忘子类对象中与父类对象中不同的方法,也会覆盖与父类中相同的方法——重写(方法名,参数都相同)。

抽象类

在定义类时,前面加上 abstract 关键字修饰的类叫抽象类。

抽象类中有抽象方法,这种方法是不完整的,仅有声明而没有方法体。抽象方法声明语法如下:

abstract void f();  //f()方法是抽象方法

抽象类是限制规定子类必须实现某些方法,但不关注实现细节。

抽象类规则如下:

  • 用 abstract 修饰符定义抽象类。
  • 用 abstract 修饰符定义抽象方法,只用声明,不需要实现。
  • 包含抽象方法的类就是抽象类。
  • 抽象类中可以包含普通的方法,也可以没有抽象方法。
  • 抽象类的对象不能直接创建,通常是定义引用变量指向子类对象。

接口

接口用于描述类所具有的功能,而不提供功能的实现,功能的实现需要写在实现接口的类中,并且该类必须实现接口中所有的未实现方法。

接口的声明语法格式如下:

1
2
3
4
修饰符 interface 接口名称 [extends 其他的接口名] {
// 声明变量
// 抽象方法
}

在 Java8 中:

  • 接口不能用于实例化对象。
  • 接口中方法只能是抽象方法、default 方法、静态方法。
  • 接口成员是 static final 类型。
  • 接口支持多继承。

在 Java9 中,接口可以拥有私有方法和私有静态方法,但是只能被该接口中的 default 方法和静态方法使用。

多继承实现方式:

1
2
3
4
5
6
7
修饰符 interface A extends 接口1,接口2{

}

修饰符 class A implements 接口1,接口2{

}

内部类

将一个类的定义放在另一个类的定义内部,这就是内部类。而包含内部类的类被称为外部类。

内部类的主要作用如下:

  • 内部类提供了更好的封装,可以把内部类隐藏在外部类之内,不允许同一个包中的其他类访问该类
  • 内部类的方法可以直接访问外部类的所有数据,包括私有的数据
  • 内部类所实现的功能使用外部类同样可以实现,只是有时使用内部类更方便
  • 内部类允许继承多个非接口类型

注:内部类是一个编译时的概念,一旦编译成功,就会成为完全不同的两类。对于一个名为 outer 的外部类和其内部定义的名为 inner 的内部类。编译完成后出现 outer.class 和 outer$inner.class 两类。所以内部类的成员变量 / 方法名可以和外部类的相同。

成员内部类的使用方法:

  • 内部类相当于外部类的一个成员变量,所以内部类可以使用任意访问修饰符。
  • 内部类里可以直接访问外部类的方法和属性,反之不行。
  • 定义成员内部类后,必须使用外部类对象来创建内部类对象,即 内部类 对象名 = 外部类对象.new 内部类();或者 外部类.内部类 对象名 = 外部类对象.new 内部类() 。
  • 如果外部类和内部类具有相同的成员变量或方法,内部类默认访问自己的成员变量或方法,如果要访问外部类的成员变量,可以使用 this 关键字。

注:成员内部类不能含有 static 的变量和方法,因为成员内部类需要先创建了外部类,才能创建它自己的。

静态内部类

静态内部类是 static 修饰的内部类,这种内部类的特点是:

  • 静态内部类不能直接访问外部类的非静态成员,但可以通过 new 外部类().成员 的方式访问。
  • 如果外部类的静态成员与内部类的成员名称相同,可通过 类名.静态成员 访问外部类的静态成员;如果外部类的静态成员与内部类的成员名称不相同,则可通过 成员名 直接调用外部类的静态成员。
  • 创建静态内部类的对象时,不需要外部类的对象,可以直接创建 内部类 对象名 = new 内部类();。

局部内部类

局部内部类,是指内部类定义在方法和作用域内。

局部内部类也像别的类一样进行编译,但只是作用域不同而已,只在该方法或条件的作用域内才能使用,退出这些作用域后无法引用的。

为了更好地组织类,Java 提供了包机制,用于区别类名的命名空间。

包的作用

  • 把功能相似或相关的类或接口组织在同一个包中,方便类的查找和使用。
  • 包采用了树形目录的存储方式。同一个包中的类名字是不同的,不同的包中的类的名字是可以相同的,当同时调用两个不同包中相同类名的类时,应该加上包名加以区别。
  • 包也限定了访问权限,拥有包访问权限的类才能访问某个包中的类。

定义包语法:

1
2
package 包名
//注意:必须放在源程序的第一行,包名可用"."号隔开

Java系统中的包

使用 import 关键字进行导包。

包的命名规范是全小写字母拼写。

常用类

Arrays

Arrays常用方法

Arrays 类包含用于操作数组的各种方法(例如排序和搜索)。还包含一个静态工厂,允许将数组转为 List。

方法 描述
List asList(T… a) 返回由指定数组构造的 List
void sort(Object[] a) 对数组进行排序
void fill(Object[] a, Object val) 为数组的所有元素都赋上相同的值
boolean equals(Object[] a, Object[] a2) 检查两个数组是否相等
int binarySearch(Object[] a, Object key) 对排序后的数组使用二分法查找数据

StringBuilder

StringBuilder 类是可变的。它是 String 的对等类,它可以增加和编写字符的可变序列,并且能够将字符插入到字符串中间或附加到字符串末尾(不用创建其他对象)。

StringBuilder 的构造方法:

构造方法 说明
StringBuilder() 构造一个其中不带字符的 StringBuilder其初始容量为 16 个字符
StringBuilder(CharSequence seq) 构造一个 StringBuilder,它包含与指定的 CharSequence 相同的字符
StringBuilder(int capacity) 构造一个具有指定初始容量的 StringBuilder
StringBuilder(String str) 并将其内容初始化为指定的字符串内容

StringBuilder 类的常用方法:

方法 返回值 功能描述
insert(int offsetm,Object obj) StringBuilder 在 offsetm 的位置插入字符串 obj
append(Object obj) StringBuilder 在字符串末尾追加字符串 obj
length() int 确定 StringBuilder 对象的长度
setCharAt(int index,char ch) void 使用 ch 指定的新值设置 index 指定的位置上的字符
toString() String 转换为字符串形式
reverse() StringBuilder 反转字符串
delete(int start, int end) StringBuilder 删除调用对象中从 start 位置开始直到 end 指定的索引(end-1)位置的字符序列
replace(int start, int end, String str) StringBuilder 使用一组字符替换另一组字符。将用替换字符串从 start 指定的位置开始替换,直到 end 指定的位置结束

Date

Date 类表示日期和时间,里面封装了操作日期和时间的方法。Date 类经常用来获取系统当前时间。

Date 中定义的未过时的构造方法:

  • Date() 构造一个 Date 对象并对其进行初始化以反映当前时间
  • Date(long date) 构造一个 Date 对象,并根据相对于 GMT 1970 年 1 月 1 日 00:00:00 的毫秒数对其进行初始化

System

System 类提供了以下功能:

  • 标准输入,标准输出和错误输出流;
  • 访问外部定义的属性和环境变量;
  • 加载文件和库的方法;
  • 用于快速复制数组的实用方法。

System 不可以被实例化,只可以使用其静态方法。

1
2
3
4
5
6
7
8
9
10
11
12
//从指定的源数组中复制一个数组,从源数组指定的位置开始,到目标数组指定的位置
public static void arraycopy(Object src,int srcPos, Object dest,int desPos,int length)
//返回以毫秒为单位的当前时间(从1970年到现在的毫秒数)
public static long currentTimeMillis()
//终止当前正在运行的Java虚拟机,status为 0时退出
public static void exit(int status)
// 运行垃圾收集器
public static void gc()
// 取得当前系统的全部属性
public static Properties getProperties()
//获取指定键的系统属性
public static String getProperty(String key)

Random

Random 类用于生成伪随机数流,在 java.util包下。

Random random = new Random();

泛型