JAVA的基础知识

JAVA

---

基本语法

• 类名的首字母应该大写
• 方法名都应该以小写字母开头，后面的每个单词首字母大写

标识符

• 以字母（A-Z 或者 a-z）,美元符（$）、或者下划线（_）开始
• 首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合
• 标识符是大小写敏感的

修饰符

• 访问控制修饰符 : default, public , protected, private
• 非访问控制修饰符 : final, abstract, static, synchronized

变量

• 局部变量

  • 定义在方法，构造方法和语句块中。
  • 变量声明及其初始化都是在方法中。
  • 方法结束后，变量就会自动销毁。

• 类变量（静态变量）

  • 声明在类中，方法体外，且必须声明static类型

• 成员变量（非静态变量）

  • 声明在类中，方法体外，可以被类中方法、构造方法和特定类的语句块访问。

关键字

类别	关键字	说明
访问控制	private	私有的
	protected	受保护的
	public	公共的
	default	默认
类,方法和变量修饰符	abstract	声明抽象
	class	类
	extends	扩充继承
	final	最终值，不可改变的
	implements	实现（接口）
	native	本地，原生方法（非java实现）
	new	新，创建
	static	静态
	strictfp	严格，精准
	synchronized	线程，同步
	transient	短暂
	volatile	易失
程序控制语句	break	跳出循环
	case	定义一个值以供swich选择
	continue	继续
	default	默认
	do	运行
	else	否则
	if	如果
	instanceof	实例
	return	返回
	swich	根据值选择执行
	while	循环
错误处理	assert	判断表达式是否为真
	catch	捕捉异常
	finally	有没有异常都执行
	throw	抛出一个异常对象
	throws	声明一个异常可能被抛出
	try	捕捉异常
包相关	import	引入
	package	包
基本类型	boolean	布尔型
	byte	字节型
	char	字符型
	double	双精度浮点
	float	单精度浮点
	int	整型
	long	长整型
	short	短整型
变量引用	super	父类，超类
	this	本类
	void	无返回值
保留关键字	goto	是关键字，但不能使用
	const	是关键字，但不能使用

• Java 的 null 不是关键字，类似于 true 和 false，它是一个字面常量，不允许作为标识符使用。

继承

• 被继承的类称为超类（super class），派生类称为子类（subclass）。

接口

• 接口可理解为对象间相互通信的协议。接口在继承中扮演着很重要的角色。

  接口只定义派生要用到的方法，但是方法的具体实现完全取决于派生类。

java的基本概念

• 多态

• 继承

• 封装

• 抽象

• 类

• 对象

• 实例

• 方法

• 重载

---

---

1. 类 class：类是一个创建对象的模板，它描述一类对象的属性和动作行为。
2. 对象 object：对象是类的一个实例，有属性和动作行为。

（1）void定义类中的方法

public class Dog {
    String breed;
    int size;
    String colour;
    int age;
 
    void eat() {
    }
    void name(){
    }
}

（2）public定义构造方法

，创建一个对象时，至少调用一个构造方法。构造方法的名称必须与类同名

public class One{
	public One(){
	}
	public One (String name){
			//这个构造函数仅有一个参数：name
    }
}

（3）创建对象

声明：声明对象，包括对象名称及其类型

实例化：使用new创建一个对象

初始化：使用new时，会调用构造方法初始化对象

public class Two{
	public Two (String name){
		//这个构造器仅有一个参数：name
		System.out.println("我的名字是：" + name);
	}
	public static void main(String[] args){
        //下面的语句将创建一个Two对象
		Two myTwo = new Two("TOM");
	}
}

（4）源文件声明规则

• 一个源文件只能有一个 public 类
• 源文件的名称应该和 public 类的名字一致
• 若一个类定义在包中，则 package 语句应该在源文件的首行
• 若源文件包含 import 语句，那么应该放在 package 语句和类定义之间。若没有 package 语句，则 import 语句应该在源文件中最前面

（5）java包：对类和接口进行分类

（6）import语句：提供一个合理的路径，使得编译器可找到某个类

例子1

（i）Employee.java 文件代码

import	java.io.*;
public class Employee{
    String name;
    int age;
    String designation;
    double salary;
    //	Employee的类构造器
    public Emplooyee(String name){
        this.name = name;
    }
    //	设置age的值
    public void empAge(int empAge){
        age = empAge;
    }
    //	设置designation的值
    public void empDesignation(String empDesignation){
        designation = empDesignation;
    }
    //	设置salary的值
    public void empSalary(double salary){
        salary = empSalary;
    }
    
    /*输出打印信息*/
    public void printfEmployee(){
        System.out.printf("名字："+name);
        System.out.printf("年龄："+age);
        System.out.printf("职位："+designation);
        System.out.printf("薪水："+salary);
    }
}

（ii）EmployeeTest.java测试文件代码

import java.io.*;
public class EmployeeTest{
    public static void main(String[] args){
        //使用构造器创建两个对象
        Employee empOne = new Employee("张三");
        Employee empTwo = new Employee("李四");
        
        /*调用这两个对象的成员方法*/
        empOne.empAge(21);
        empOne.empDesignation("老鸟");
        empOne.empSalary(5000);
        empOne.printfEmployee();
       	
        empTwo.empAge(20);
        empTwo.empDesignation("菜鸟");
        empTwo.empSalary(1000);
        empTwo.printfEmployee();
    }
}

（iii）运行结果

$ javac EmployeeTest.java

$ java EmployeeTest

名字：张三

年龄：21

职位：老鸟

薪资：5000

名字：李四

年龄：20

职位：菜鸟

薪资：1000

基本数据类型

简单类型	boolean	byte	char	short	int	long	float	double	void
二进制类型	1	8	16	16	32	64	32	64	--
封装器类	Boolean	Byte	Character	Short	Integer	Long	Float	Double	Void

1 . 简单类型

byte :

• byte数据类型是8位，有符号，以二进制补码表示的整数；
• 最大值：127 ；最小值：-128；
• 默认值是 0 ；
• 用在大型数组中节约空间，主要代替int，byte 变量占用的空间只有 int 类型的四分之一；

short :

• short 数据类型是 16 位、有符号的以二进制补码表示的整数
• 最小值是 -128（-2^7）；最大值是 127（2^7-1）；
• 默认值是 0 ；

int :

• int 数据类型是32位、有符号的以二进制补码表示的整数；
• 最小值是 -2,147,483,648（-2^31）；最大值是 2,147,483,647（2^31 - 1）；
• 默认值是 0 ；

long :

• long 数据类型是 64 位、有符号的以二进制补码表示的整数；
• 最小值是 -9,223,372,036,854,775,808（-2^63）;最大值是 9,223,372,036,854,775,807（2^63 -1）；
• 默认值是 0L

float :

• float 数据类型是单精度、32位、float 在储存大型浮点数组的时候可节省内存空间；
• 默认值是 0.0f；

double :

• double 数据类型是双精度、64 位；
• 浮点数的默认类型为 double 类型,0.0d

boolean :

• boolean数据类型表示一位的信息,只有两个取值：true 和 false；
• 默认值是 false；

char :

• char 类型是一个单一的 16 位 Unicode 字符；
• 最小值是 \u0000（十进制等效值为 0）,最大值是 \uffff（即为 65535）；
• 默认值 ‘ u0000 ’
• char 数据类型可以储存任何字符；

String :

• 默认值 null

2 . 引用类型

Java有 5种引用类型（对象类型）：类 接口 数组 枚举 标注

引用类型：底层结构和基本类型差别较大

JVM的内存空间：（1）. Heap 堆空间：分配对象 new Student（）

​ （2）. Stack 栈空间：临时变量 Student stu

​ （3）.Code 代码区 ：类的定义，静态资源 Student.class

eg：

​ Student stu = new Student（）； //new 在内存的堆空间创建对象

注：stu.study(); //把对象的地址赋给stu引用变量

​ 上例实现步骤：

​ a.JVM加载Student.class 到Code区

​ b.new Student()在堆空间分配空间并创建一个Student实例

​ c.将此实例的地址赋值给引用stu， 栈空间

3. 常量修饰 ——(在程序运行时不能被改变)

   常用大写字母表示常量

   Java 中使用 final 关键字来修饰常量，声明方式和变量类似：

   final double PI = 3.1415927;
   

   Java支持一些特殊的转义字符序列。

   符号	字符含义
   \n	换行 (0x0a)
   \r	回车 (0x0d)
   \f	换页符(0x0c)
   \b	退格 (0x08)
   \0	空字符 (0x0)
   \s	空格 (0x20)
   \t	制表符
   "	双引号
   ’	单引号
   \	反斜杠
   \ddd	八进制字符 (ddd)
   \uxxxx	16进制Unicode字符 (xxxx)

4. 类型的转换

   byte,short,char—> int —> long—> float —> double 
   

5. 强制类型转换

   格式：(type)value type是要强制类型转换后的数据类型 实例：

   public class QiangZhiZhuanHuan{
    public static void main(String[] args){
        int i1 = 123;
        byte b = (byte)i1;//强制类型转换为byte
        System.out.println("int强制类型转换为byte后的值等于"+b);
    }
   }
   

   结果：int强制类型转换为byte后的值等于123

变量类型

• 类变量：独立于方法外的变量，用static修饰

• 实例变量：独立于方法外的变量，没有static修饰

• 局部变量： 类方法中的变量

  public class one{
  static int old = 0;				\\类变量
  
  String str = "Hellow World  ?"	\\实例变量
  
  public void method(){
    int i = 0;					\\局部变量
  }
  }
  

局部变量

+++++

• 局部变量声明在方法、构造方法或者语句块中；
• 局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
• 访问修饰符不能用于局部变量；
• 局部变量只在声明它的方法、构造方法或者语句块中可见；
• 局部变量是在栈上分配的。
• 局部变量被声明后，必须经过初始化，才可以使用。

实例变量

++++++++

• 实例变量声明在一个类中，在方法、构造方法和语句块之外；
• 当一个对象被实例化之后，每个实例变量的值就跟着确定；
• 实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
• 实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
• 实例变量可以声明在使用前或者使用后；
• 访问修饰符可以修饰实例变量；
• 实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
• 实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
• 实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。

类变量

++++++++++++

• 类中以 static 关键字声明，但必须在方法之外；
• 无论一个类创建了多少个对象，类只拥有类变量的一份拷贝；
• 静态变量除了被声明为常量外很少使用，静态变量是指声明为 public/private，final 和 static 类型的变量。静态变量初始化后不可改变；
• 静态变量储存在静态存储区。经常被声明为常量，很少单独使用 static 声明变量。
• 静态变量在第一次被访问时创建，在程序结束时销毁。
• 与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为 public 类型。
• 默认值和实例变量相似。数值型变量默认值是 0，布尔型默认值是 false，引用类型默认值是 null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
• 静态变量可以通过：ClassName.VariableName的方式访问。
• 类变量被声明为 public static final 类型时，类变量名称一般建议使用大写字母。如果静态变量不是 public 和 final 类型，其命名方式与实例变量以及局部变量的命名方式一致。

---

修饰符

• 修饰符用来定义类、方法或者变量，通常放在语句的最前端。

---

数组

• 一维数组： 数组类型 数组名字 [ ]

  ​ 数组类型 [ ] 数组名字

  • 二维数组 数组类型 数组名字 [ ] [ ]

    ​ 数组类型 [ ] [ ] 数组名字

public class one{
    public static viod main (String[] args){
        int size = 3;			//数组大小
        int[] a = new int[size];
        a[0] = 2;
        a[1] = 3;
        a[2] = 4;
        int b = 1;
        for (int i = 0;i<3;i++){
            b += a;
        }
        System.out.println("总和为： " + b);
    ]
}

• For - Each循环

  for(type element: array)
  {
  System.out.println(element);
  }
  

  该命令打印array元素 type: 类型 array:数组名

• Arrays 类

java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。

具有以下功能：

• 给数组赋值：通过 fill 方法。
• 对数组排序：通过 sort 方法,按升序。
• 比较数组：通过 equals 方法比较数组中元素值是否相等。
• 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

具体说明请查看下表：

序号	方法和说明
1	public static int binarySearch(double[ ] a, double key) 用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
2	public static boolean equals(long[ ] a, long[ ] a2) 如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
3	public static void fill(int[ ] a, int val) 将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
4	public static void sort(int[ ] a) 对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。

---

运算符

• 算术混合运算德精度：byte，short，char，int，long，float，double
  • ​ 低----------------------------------------------->高

instanceof：

( Object reference variable ) instanceof  (class/interface type)

如果运算符左侧变量所指的对象，是操作符右侧类或接口(class/interface)的一个对象，那么结果为真。

下面是一个例子：

String name = "James";
boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真

算数运算符	描述	例子
+	加法 - 相加运算符两侧的值	A + B 等于 30
-	减法 - 左操作数减去右操作数	A – B 等于 -10
*	乘法 - 相乘操作符两侧的值	A * B等于200
/	除法 - 左操作数除以右操作数	B / A等于2
％	取余 - 左操作数除以右操作数的余数	B%A等于0
++	自增: 操作数的值增加1	B++ 或 ++B 等于 21
–	自减: 操作数的值减少1	B-- 或 --B 等于 19

关系运算符		例子
==		（A == B）为假。
!=		(A != B) 为真。
>		（A> B）为假。
<		（A <B）为真。
>=		（A> = B）为假。
<=		（A <= B）为真。

位运算符	描述	例子
＆	与	（A＆B），得到12，即0000 1100
|	或	（A | B）得到61，即 0011 1101
^	如果相对应位值相同，则结果为0，否则为1	（A ^ B）得到49，即 0011 0001
〜	非	（〜A）得到-61，即1100 0011
<<	按位左移运算符。左操作数按位左移右操作数指定的位数。	A << 2得到240，即 1111 0000
>>	按位右移运算符。左操作数按位右移右操作数指定的位数。	A >> 2得到15即 1111
>>>	按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。	A>>>2得到15即0000 1111

逻辑运算符	描述	例子
&&	逻辑与。两个操作数都为真，条件真。	（A && B）为假。
| |	逻辑或。两个操作数任何一个为真，条件为真。	（A | | B）为真。
！	称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。	！（A && B）为真。

操作符	描述	例子
=	简单的赋值运算符，将右操作数的值赋给左侧操作数	C = A + B将把A + B得到的值赋给C
+ =	加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数	C + = A等价于C = C + A
- =	减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数	C - = A等价于C = C - A
* =	乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数	C * = A等价于C = C * A
/ =	除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数	C / = A，C 与 A 同类型时等价于 C = C / A
（％）=	取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数	C％= A等价于C = C％A
<< =	左移位赋值运算符	C << = 2等价于C = C << 2
>> =	右移位赋值运算符	C >> = 2等价于C = C >> 2
＆=	按位与赋值运算符	C＆= 2等价于C = C＆2
^ =	按位异或赋值操作符	C ^ = 2等价于C = C ^ 2
| =	按位或赋值操作符	C | = 2等价于C = C | 2

运算符的优先级（由高到低）

类别	操作符	关联性
后缀	() [] . (点操作符)	左到右
一元	expr++ expr–	从左到右
一元	++expr --expr + - ～ ！	从右到左
乘性	* /％	左到右
加性	+ -	左到右
移位	>> >>> <<	左到右
关系	> >= < <=	左到右
相等	== !=	左到右
按位与	＆	左到右
按位异或	^	左到右
按位或	|	左到右
逻辑与	&&	左到右
逻辑或	| |	左到右
条件	？：	从右到左
赋值	= + = - = * = / =％= >> = << =＆= ^ = | =	从右到左
逗号	，	左到右

---

循环语句

• while 循环
• do…while 循环
• for 循环

注意：do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。

• 增强 for 循环 (用于数组 )

for(声明语句：表达式)
{
	//代码句子
}

**声明语句：**声明新的局部变量，变量的类型必须和数组元素的类型匹配。作用域限定在循环语句块，值与此时数组元素的值相等。

**表达式：**表达式是要访问的数组名，或者是返回值为数组的方法。

实例 ：

public class Test {
public static void main(String[] args){
int [] numbers = {10, 20, 30, 40, 50};

for(int x : numbers ){
   System.out.print( x );
   System.out.print("?");
}
System.out.print("\n");
String [] names ={"James", "Larry", "Tom", "Lacy"};
for( String name : names ) {
   System.out.print( name );
   System.out.print("&");
}
}
}

以上实例编译运行结果如下：

10?20?30?40?50?
James&Larry&Tom&Lacy&

• 枚举类型

  • enum WeekDay{
    sun,mon,tue,wed,thu,fri,sat
    }
    

    访问返回常量

    WeekDay day = WeekDay.mon;
    

    访问返回数组

    WeekDay a[] = WeekDay.values()
    

    • 则 a[0] ~ a[6]的值依次为sun,mon,tue,wed,thu,fri 和 sat

+++++

Java方法

• System . out . println ( )

• println() 是一个方法。
• System 是系统类。
• out 是标准输出对象。

• 调用系统类 System 中标准输出对象 out 中的方法 println()。

• 命名规则

  • 单个单词首字母小写
  • 多个单词第二个词首字母大写

• ‘一般情况下，定义一个方法包含以下语法：

修饰符 返回值类型 方法名(参数类型 参数名){
...
方法体
...
return 返回值;
}

注意： 在一些其它语言中方法指过程和函数。一个返回非void类型返回值的方法称为函数；一个返回void类型返回值的方法叫做过程。

• 变量作用域

（1）方法类定义的变量为局部变量

（2）局部变量的作用范围从声明开始，直到包含它的块结束，且必须声明才可以使用。

• 方法的重载

  一个类的两个方法拥有相同的名字，但是拥有不同的参数列表

  重载的方法必须拥有不同的参数列表，不能仅仅依据修饰符或者返回类型的不同来重载方法

• 构造方法

(1). 构造方法的名字必须与所在类的名字相同，并且没有类型

(2). 当类创建对象时，使用构造方法

class Add {
int x;
Add (){				//构造方法
x = 100;
}
Add(int a){			//构造方法
x = a;
	}
}

• 类方法与实例方法

  实例方法只能通过对象来调用

  1 . 加关键词 static 修饰的是类方法（静态），不加则为实例方法

  class A {
  int a;
  float max(float x,float y){			//实例方法
  .
  .
  .
  }
  static float jerry(){				//类方法
  .
  .
  .    
  }
  static void speak (String s){		//类方法
  .
  .
  .
  }
  }
  

---

static关键字

• 修饰类变量、类方法（静态方法）
• 实例方法不能通过类名调用
• 当static成员变量出现在实例变量中时：类名. 成员变量
• ​ a.他们之间最大的区别在于它们 [生命周期] 的不同，静态方法属于全局方法，当静态方法第一次被访问的时候，就将常驻内存直到整个系统被销毁；

​ b.而非静态方法则与类有关，只有该方法所在的类被实例化之后，该方法才能被访问，类被销毁的同时方法也被销毁。

​ c.生命周期的不同决定了它们的调用方式的不同，静态方法使用（类名.方法名）来调用，而非静态方法则需要（new 类名().方法名）来调用。
​ d.同时与之相关的就是，静态方法不能调用非静态方法和属性。在了解了它们生命周期的不同后，这一点也比较好理解，因为静态方法生命周期比非静态方法和属性长，当调用非静态方法和属性时就会产生非静态方法和属性已经被销毁的情况导致程序出错。

​ e.同时 静态方法会存在并发问题，非静态方法是针对对象的，不会存在线程安全问题。静态方法不能滥用

this关键字

• this可以出现在 实例方法 和 构造方法 中，但 不能出现在 类方法 中（被static修饰的方法）
• 构造方法 的名称类名相同
• 创建对象时至少调用一个构造方法
• this .成员变量
• 在实例方法中时，代表正在调用该方法的当前对象

class A{
    int x;
    static int y;
    void f(){
        this.x = 120;			//this.成员变量
        A.y = 110;				//类名.成员变量
    }
}
//this 代表使用 f 的当前对象。
/*   this.x 表示当前对象的变量x，	当对象调用方法f时，将120赋给该对象的变量x

---

package包

• （1）. 常用小写的字母来命名

• （2）.创建格式：

• ​ package 包名

在包中加入接口

package  one
    
interface two{		//接口interface    接口two
    public void eat();
    public viod sing(); 
}

常用的包：

• java . long 包含所有的基础语言类
• javax . swing 包含抽象窗口工具集中的图形、文本和窗口类GUI类
• java . io 包含所有的输入和输出类
• java . until 包含数据结构类
• java . sql 包含操作数据库的类
• java . net 包含所有实现网络功能的类
• java . applet 包好所有实现 Java Applet的类

import语句

• 可以引入包中的类

引入包中所有的类用通配符“*”

import java.util.*;

---

​

访问权限

• 访问权限由高到低：public > protected > private

友好变量 和 友好方法：不用访问权限修饰符修饰的成员变量和方法

访问权限修饰符：private、protected、public

• private 修饰的成员变量和方法称为私有变量 和 私有方法
• （只有在本类中创建该类的对象时，这个对象才能访问自己的私有成员变量和类中的私有方法）
• public 修饰的成员变量和方法被称为公有变量 和 公有方法
• protected 修饰的成员变量和方法被称为 受保护的成员变量和方法
• （几个类在同一个包中，其创建的对象才可以访问protected修饰的变量和方法）

---

继承

子类与父类

• 一个子类只能有一个父类

• 关键字 extends （继承）

  • 格式：

  • class 子类名 extends 父类名{           //继承
        .........
    }
    

重写

• 子类通过重写（Override）可以隐藏已继承的实例方法

（重写方法的名字、参数个数、参数的类型和父类的方法必须完全一样）

• final修饰的方法不能被重写

• static修饰的方法不能被重写，但能被再次声明

• 子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法

• 构造方法不能被重写。

（构造方法的名字必须与所在类的名字相同，并且没有类型）

重载

• 重载（Overloading）指在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同

• 被重载的方法必须改变参数列表(参数个数或类型不一样)；

• 被重载的方法可以改变返回类型和访问修饰符；

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lo4ltMQK-1668752538166)(C:\Users\yuxinrun\Downloads\uTools_1646920324658.png)]

（1）子类与父类在同一包中

子类继承了父类中除 private 和 final的成员变量和方法

（2）子类和父类不在同一包中

子类只继承了父类中 protected 和 public 修饰的变量和方法

1、父类中staitic修饰的静态方法，不能覆盖、能继承。

2、父类中staitic修饰的变量或常量，能覆盖、不能继承。

    static 修饰的变量和方法，只属于类本身，不属于对象；当声明一个对象时，并不产生 static 变量和方法的拷贝。也就是说，用 static 修饰的变量和方法在类加载的时候，会分配一块存储空间，所有此类的对象都可以操控此块存储空间；

    注意：当子类没有与父类同名的 static 变量（或方法时），子类的对象也可操控这块内存空间。但是，子类并没有继承父类中static修饰的变量和方法。这是因为 static 修饰的变量和方法是属于父类本身的。

3、父类中final修饰的方法，不能覆盖，但可继承。

public class Two {
private String name;
private int id;
public Two(String myName,int myId){
  name = myName;
  id = myId;
}
public void eat(){
  System.out.println(name+":I can eat more,hahahaha.");
}
public void comgperhensive(){
  System.out.println("大家好! 我是"+name+"       "+"我的编号"+id);
}
}

public class Three extends Two {

public Three(String myName, int myId) {
  super(myName, myId);
}
public static void main (String[] args){
  Three three = new Three("YXR",1008611);
  three.comgperhensive();
  three.eat();
}
}

结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-W06jrBja-1668752538167)(C:\Users\yuxinrun\Downloads\uTools_1646790759719.png)]

super关键字

• 在子类中使用被子类隐藏的成员变量和方法
• super 必须是子类构造方法中的头一条语句

public class Student{
int number;
String name;
Student(int number,String name){					//构造方法（名称与类名相同）
  this.name = name;
  this.number = number;
}
}

public class UniverStudent extends Student{
boolean Marriage;						//子类新增的结婚属性
	UniverStudent(int number,String name,boolean m){
	super(number,name);		//调用父类的方法，即Student（int number，String name）
}
public Boolean getMarriage(){
}
}

final关键字

• 可以修饰类、成员变量、和方法中的局部变量

• final 类不能被继承，也不能有子类（不允许被重写）

• final class A{
      .......
  }
  

• 注意： final在修饰常量时必须指定该常量的值，而且不能发生变化

对象的上转型对象

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-speai7H7-1668752538167)(C:\Users\yuxinrun\Downloads\uTools_1647093256958.png)]

---

对象上转型对象 ：若A类是B类的父类，B类创建一个对象，并把这个对象的引用放到A类的对象中。

A a;
a = new B();

A a;
B b = new B();
a = b;

则 a 是 b 的上转型对象

---

public class ONE {
    double m = 12.58;
    void crySpeak(String s){
        System.out.println(s);
    }
}

public class TWO extends ONE {
    char m = 'A';
    int n = 60;
    void computer(int a,int b){
        int c = a + b;
        System.out.println(a+"加"+b+"等于"+c);
    }
    void crySpeak(String s){
        System.out.println(m+"**"+s+"**"+m);
    }
}

public class demo {
    public static void main(String[] args){
        TWO son = new TWO();
        ONE father = son;                           //father是son对象的上转型对象
        father.crySpeak("杰哥不要啊！");          //等于TWO类调用重写的crySpeak（）方法

    //  father.n = 25;                  //非法：n是子类TWO新加的变量
    //  father.computer(1,2);           //非法：computer（）是子类TWO新增的方法

        System.out.println(father.m);   //操作隐藏的m不等于son.m
        System.out.println(son.m);      //操作子类TWO的m
        TWO other = (TWO)father;        //将子类对象的上转型对象强制转换成子类的对象
        System.out.println(other.m);    //等同于操作子类TWO的m
        other.crySpeak("卫生me不要");   //子类TWO对象other调用自己类的方法crySpeak（）
        other.computer(49,51);
        other.m = 'n';                  //子类对象操作自己的m
        System.out.println(other.m);
    }
}

运行结果[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XWKW0SS9-1668752538168)(D:\screenshot\uTools_1647142340880.png)]

继承与多态

• 多态性：指父类的某个方法被其子类重写时，可以各自产生自己的功能行为

抽象类的特点：

特别关心方法名字 、类型和参数，但不关心这些操作具体实现的细节，即不关心方法体

abstract （抽象类）类和方法

• abstract 方法 ：

• public abstract double max();      //抽象方法名后面直接跟一个分号，而不是花括号
  

  • 不能用 final 和 abstract 同时修饰一个方法
    • final 能继承，不能重写
    • abstract 能继承，可以重写 （父子类都是abstract 类）
  • 类包含抽象方法，那么该类必须是抽象类
  • 任何子类必须重写父类的抽象方法，或者声明自身为抽象类。

• abstract 类 ：

  • abstract 类不能用 new 运算符创建对象
  • 父类为 abstract 类，子类为非 abstract 类，则子类必须重写父类的 abstract 方法，即去掉 abstract

---

接口 interface

• 声明创建格式：

interface   接口名字{			//接口声明
 	 //接口体
}          

• 接口体中包含 static 常量和 方法 定义两部分

• 不可以用 static 和 abstract 或者 default 修饰同一个方法

• 修饰方法体用 static 或者 default

接口的使用： （1）接口名 . 接口中的常量

​ （2）接口名 . 接口中的 static 方法

类使用接口：implements 关键字

class	A	implements	B,C{		// B ,C 为接口名
}

*注： （1） 类实现接口后，若要重写接口中的 default 方法 ，需要去掉 default 关键字

​ （2）非 abstract 类实现接口后，必须重写abstract方法，即去掉abstract关键字

​ （3）类实现某接口，但类不拥有接口的 static 方法

​ （4）友好接口（不加public修饰的接口）可以被与该接口在同一包中的类声明实现

​ （5）接口可以被继承，通过关键字 extends 声明一个接口是另一个接口的子接口

---

内部类

public class RedCowFarm {
static String farmName;
RedCow cow;                 //内部类声明对象
RedCowFarm(String s) {
   cow = new RedCow(150, 112, 5000);
   farmName = s;
}

public void showCowMess(){
  cow.speak();
}

class RedCow{                       //创建内部类RedCow
  String cowName = "红牛";
  int height,weight,price;
  RedCow(int h,int w,int p){      //创建内部类 的 类方法RedCow
      height = h;
      weight = w;
      price = p;
  }
  void speak(){
      System.out.println("红牛挑战极限");
      System.out.println("我是"+cowName+",体高"+height+",体重"+weight+"价格"+price+"元"+"生活在"+farmName);
  }
}   							//内部类结束

}                                       //外嵌类结束

public class Boss {
public static void main(String[] args){
  RedCowFarm farm = new RedCowFarm("天堂");
  farm.showCowMess();
  farm.cow.speak();
}
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rHbHFt1F-1668752538168)(D:\桌面\screenshot\27.png)]

• 内部类可以被修饰为 static 类，但是 static 内部类不能操作外嵌类的实例成员变量

匿名类( 特殊的内部类 )

格式：

​ 若 People 是类，则以下代码为用People类的一个子类（匿名类）穿创建象：

new People(){
匿名类的类体					//不可以声明static成员变量和static方法
};

abstract class Speak{
public abstract void speakHello();
}
class Student {
void f(Speak sp){
sp.speakHello();
}
}
public class niminglei {
public static void main(String[] args){
Speak speak = new Speak(){
 public void speakHello(){
     System.out.println("虎年吉祥");
 }
};
speak.speakHello();
Student st = new Student();
st.f(new Speak(){
 public void speakHello(){
     System.out.println("疫情早点结束");
 }
});
}
}

异常类

​ 使用 try…catch 语句处理异常

• 所有的异常类是从 java.lang.Exception 类继承的子类

（1）. 检查性异常

（2）. 运行性异常

（3）. 错误

Java 的非检查性异常：

异常	描述
ArithmeticException	当出现异常的运算条件时，抛出此异常。例如，一个整数"除以零"时，抛出此类的一个实例。
ArrayIndexOutOfBoundsException	用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小，则该索引为非法索引。
ArrayStoreException	试图将错误类型的对象存储到一个对象数组时抛出的异常。
ClassCastException	当试图将对象强制转换为不是实例的子类时，抛出该异常。
IllegalArgumentException	抛出的异常表明向方法传递了一个不合法或不正确的参数。
IllegalMonitorStateException	抛出的异常表明某一线程已经试图等待对象的监视器，或者试图通知其他正在等待对象的监视器而本身没有指定监视器的线程。
IllegalStateException	在非法或不适当的时间调用方法时产生的信号。换句话说，即 Java 环境或 Java 应用程序没有处于请求操作所要求的适当状态下。
IllegalThreadStateException	线程没有处于请求操作所要求的适当状态时抛出的异常。
IndexOutOfBoundsException	指示某排序索引（例如对数组、字符串或向量的排序）超出范围时抛出。
NegativeArraySizeException	如果应用程序试图创建大小为负的数组，则抛出该异常。
NullPointerException	当应用程序试图在需要对象的地方使用 null 时，抛出该异常
NumberFormatException	当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常。
SecurityException	由安全管理器抛出的异常，指示存在安全侵犯。
StringIndexOutOfBoundsException	此异常由 String 方法抛出，指示索引或者为负，或者超出字符串的大小。
UnsupportedOperationException	当不支持请求的操作时，抛出该异常。

在 java.lang 包中的检查性异常类。

异常	描述
ClassNotFoundException	应用程序试图加载类时，找不到相应的类，抛出该异常。
CloneNotSupportedException	当调用 Object 类中的 clone 方法克隆对象，但该对象的类无法实现 Cloneable 接口时，抛出该异常。
IllegalAccessException	拒绝访问一个类的时候，抛出该异常。
InstantiationException	当试图使用 Class 类中的 newInstance 方法创建一个类的实例，而指定的类对象因为是一个接口或是一个抽象类而无法实例化时，抛出该异常。
InterruptedException	一个线程被另一个线程中断，抛出该异常。
NoSuchFieldException	请求的变量不存在
NoSuchMethodException	请求的方法不存在

Throwable 类的主要方法:

序号	方法及说明
1	public String getMessage() 返回关于发生的异常的详细信息。这个消息在Throwable 类的构造函数中初始化了。
2	public Throwable getCause() 返回一个 Throwable 对象代表异常原因。
3	public String toString() 返回此 Throwable 的简短描述。
4	public void printStackTrace() 将此 Throwable 及其回溯打印到标准错误流。。
5	public StackTraceElement [] getStackTrace() 返回一个包含堆栈层次的数组。下标为0的元素代表栈顶，最后一个元素代表方法调用堆栈的栈底。
6	public Throwable fillInStackTrace() 用当前的调用栈层次填充Throwable 对象栈层次，添加到栈层次任何先前信息中。

try…catch…

try{
//程序代码
}catch(ExceptionName  e1)			//括号内为异常类的名字
{
//catch 块
}  

多重捕获

try{
// 程序代码
}catch(异常类型1 异常的变量名1){
// 程序代码
}catch(异常类型2 异常的变量名2){
// 程序代码
}catch(异常类型3 异常的变量名3){
// 程序代码
}

thorws / throw 关键字

（若一个方法没有捕获到一个检查性异常，则该方法必须使用 throws 关键字来声明 【throws 关键字放在方法签名的尾部】）

（也可以使用 throw 关键字抛出一个异常，无论它是新实例化的还是刚捕获到的）

---

IntegerException . java 类

public class IntegerException extends Throwable {
String message;
public IntegerException(int m){
  message = "年龄"+m+"不合理";
}
public String toString(){
  return message;
}
}

People . java 类

public class People {
private int age = 1;            //定义私有变量
public void setAge(int age) throws IntegerException{        //抛出异常（整数异常）
  if (age >= 160||age < 3){
      throw new IntegerException(age);          //方法抛出异常，导致方法结束
  }
  else{
      this.age = age;
  }
}
public int getAge(){
  System.out.println("年龄"+age+"合理");
  return age;
}
}

Main . java 类

public class Main {
public static void main(String[] args) {
  People Zhangsan = new People(),
          Lisi = new People();
  try {
      Zhangsan.setAge(250);
      System.out.println(Zhangsan.getAge());
  } catch (IntegerException e) {
      System.out.println(e.toString());
  }

try {
Lisi.setAge(22);
System.out.println(Lisi.getAge());
} catch (IntegerException e) {
System.out.println(e.toString());
		}
	}
}

结果输出

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aaRDt57V-1668752538169)(D:\桌面\screenshot\uTools_1647508301820.png)]

---

fianlly 关键字

格式：

try{
//程序代码
}catch(异常类型 1   异常的变量名 1){
//程序代码
}catch(异常类型 2   异常的变量名 2){
//程序代码
}finally{
//程序代码
}

public class Main {
  public static class DangerException extends Exception{
      final String message = "危险，已超重！！！！！！";
      public String warnMess(){           //返回警告的信息
          return message;
      }
  }

  public static class CargoBoat {            //创建货船类
      int realContend;            //实际装载的重量
      int maxContend;             //最大的装载量
      public void setMaxContend(int max){
          maxContend = max;
      }
      public void loading(int m)throws DangerException {   //相当于loading方法继承一个异常类
          realContend += m;
          if(realContend > maxContend){
              throw new DangerException();                //抛出异常，方法结束(新的错误类，即new了个新对象)
          }
          System.out.println("目前装载的"+realContend+"吨货物");
      }
  }

  public static void main(String[] args){
      CargoBoat ship = new CargoBoat();
      ship.setMaxContend(1000);
      int m = 900;

      try {
          ship.loading(m);
          m = 100;

          ship.loading(m);
          m = 520;

          ship.loading(m);
          m = 13;
      } catch (DangerException mistake) {
          System.out.println(mistake.warnMess());
          System.out.println("无法再装载"+m+"吨货物");
      }
      finally {
          System.out.println("货船即将起航");
      }
  }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vwY2dwvg-1668752538170)(D:\桌面\screenshot\uTools_1647584640777.png)]

---

Java 反射

Class 类

(1) . Class 是 java.lang 包中的类

(2) . 任何类都有默认的一个public 的静态( static )的 Class 对象 ，且对象的名字为 class

(3) . 调用 getClass ( ) 方法 返回Class 对象 ：class

Class 对象调用如下的方法可获取当前类的相关信息：

• String getName ( ) 返回类的名字
• Constructor [ ] getDeclaredConstructors ( ) 返回类的全部构造方法
• Field [ ] getDeclaredFields ( ) 返回类的全部成员变量
• Method [ ] getDeclaredMethods ( ) 返回类的全部方法

public class GetClass {
   public static void main(String[] args) throws ClassNotFoundException {


/** 方式一：
*              （1）前提：已知该类的全类名，且在类路径下。
*              （2）方法：通过Class类的静态方法'foeName()'获取，抛出ClassNotFoundException
*              （3）例子：Class aclass = Class.forName('com.nice.Car')
*              （4）应用场景：多用于配置文件，读取类的全路径，加载类。
*/
       Class<?> aClass = Class.forName("com.nice.Car");
       System.out.println(aClass);

/** 方式二：
*              （1）前提：已知具体的类
*              （2）方法：通过类的class获取
*              （3）例子：Class aClass = Cat.class
*              （4）4应用场景：该方式最为安全可靠，且程序性能最高；多用于参数传递，如：通过放射得到对应的构造器对象。
*/
       Class bClass = Cat.class;
       System.out.println(bClass);

/** 方式三：
*              （1）前提：已知某个类的对象实例
*              （2）方法：调用该实例对象的‘getClass()’方法获取Class对象
*              （3）实例：Class cClass = O.getClass();
*              （4）应用场景：通过建好的对象，获取Class对象
 */
       Car  car = new Car();
       Class xClass = car.getClass();
       System.out.println(xClass);
   }
}

类加载

---

• 加载 Laoding
• 将字节码从不同的数据源转换为二进制字节流加载到内存中（方法区），并生成一个代表该类的 ‘ java.lang.Class ’ 对象
• 链接 Linking
• 验证 Verification：
  • 1. 确保 Class 文件的字节流中包含的信息符合当前的虚拟机的要求，并且不危害虚拟机的自身安全
    2. 包括：文件格式验证（是否以 魔数 oxcafebabe 开头）、元数据验证、字节验证码、符号引用验证
    3. 大项目时可以使用：-Xverify:none 参数关闭大部分的类验证措施，缩短虚拟机类加载时间。
• 准备 Preparation：
  • JVM 会在该阶段对 静态变量，分配内存并默认初始化。这些变量所使用的内存都将在 方法区 中进行分配。
• 解析 Resolution：
  • 1. JVM虚拟机将常量池中的符号引用替换为直接引用
• 初始化 Initialization：
• 1. 到初始化阶段，才真正开始执行类中定义的 java 程序代码，此阶段是执行 **( )**方法的过程。
  2. ( ) 方法是由编译器按语句在源文件中出现的顺序，依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句，并进行合并。
  3. 虚拟机会保证一个类的 ( ) 方法再多线程环境中被正确的加锁、同步，如果多个线程同时初始化一个类，则只会在一个线程中去执行这个类的 ( ) 方法，其他线程都需阻塞等待，直到活动线程执行 ( ) 方法完毕。

---

String 类

java . lang 包中的String 类为 final 类 （ 不能有子类）

创建字符串：

String s1 = "Runood";
String s2 = "Runood";
String s3 = s1;
String s4 = new String("Runood");
String s5 = new String("Runoob")

String 类的常用方法：

**（1）**public int length ( )

​ 返回字符串的长度

String str = "name";
int L = str.length();					//得到 4

**（2）**public boolean equals ( String )

​ 比较两字符串是否一致

String 对象 A，B中存放的是引用，固 A != B

String A = new String ("I LOVE YOU");
String B = new String ("YOU LOVE HE");
Sysatem.out.println(A.equals(B))		//得到 false

**（3）**public boolean startsWith (String s）

​ public boolean endsWith (String s)

​ 比较两字符序列前列或者后列是否一致

String A = "1008611"  ,B = "1008600";
System.out.println( A.endsWith("11") );    //得到 true
System.out.println( B.startsWith("11"))		//得到  false

**（4）**public boolean regionMatches ( int firstStart , String other, int otherStart , int length )

​ A字符序列firstStart位置开始取length长度

​ B（other）字符序列otherStart位置开始取相同长度

​ 相比较，相同则取true

​ public boolean regionMatches ( boolean b , int firstStart , String other , )

​ 参数 b 取 true 则忽略大小写

**（5）**public int compareTo ( String s )

​ 按字典序与参数序列 s 比较大小

​ 序列相同返回 0 ，大于s则返回正常值，小于s则返回负数

String str = "abcdefg";
System.out.println( str.compareTo("	boy"))			//返回负数

**（6）**public boolean contains ( String s )

​ 判断当前字符序列是否含有 s 的字符序列

String str = "laearn";
System.out.println( str.contains("aea"));        //返回true

**（7）**public int indexOf ( String s )

​ 从索引位置 0 开始索引对象的字符序列，并返回首次出现字符序列 s 的位置，否则为 -1

String  str = "abcdefgfedcba";
System.out.println( str.indexOf( "fgf"))			//返回 5+3 = 8

**（8）**public int indexOf ( string s , int startpoint )

​ 从 startpoint 位置开始索引

String str = "I am good man";
System.out.println( str.indexOf("good"，2));			//返回值为7

**（9）**public String substring ( int stratpoint )

​ 截取字符：从startpoint位置开始

​ public String substring ( int start , int end )

​ 截取字符：从 start 到 end

String str = "I love you!";
System.out.println( str.substring(1,6));		//返回 ：I love

**（10）**public String trim ( )

​ 返回去掉前后空格后得到的字符序列

---

对象的String表示： 创建对象的类的名字 @ 对象的引用的字符序列表示

• 一个对象调用 toString ( ) 方法返回 String 对象的字符序列

下面是 String 类支持的方法，更多详细，参看 Java String API 文档:

SN(序号)	方法描述
1	char charAt(int index) 返回指定索引处的 char 值。
2	int compareTo(Object o) 把这个字符串和另一个对象比较。
3	int compareTo(String anotherString) 按字典顺序比较两个字符串。
4	int compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写。
5	String concat(String str) 将指定字符串连接到此字符串的结尾。
6	boolean contentEquals(StringBuffer sb) 当且仅当字符串与指定的StringBuffer有相同顺序的字符时候返回真。
7	[static String copyValueOf(char] data) 返回指定数组中表示该字符序列的 String。
8	[static String copyValueOf(char] data, int offset, int count) 返回指定数组中表示该字符序列的 String。
9	boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束。
10	boolean equals(Object anObject) 将此字符串与指定的对象比较。
11	boolean equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较，不考虑大小写。
12	[byte] getBytes() 使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
13	[byte] getBytes(String charsetName) 使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
14	[void getChars(int srcBegin, int srcEnd, char] dst, int dstBegin) 将字符从此字符串复制到目标字符数组。
15	int hashCode() 返回此字符串的哈希码。
16	int indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。
17	int indexOf(int ch, int fromIndex) 返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
18	int indexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引。
19	int indexOf(String str, int fromIndex) 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
20	String intern() 返回字符串对象的规范化表示形式。
21	int lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。
22	int lastIndexOf(int ch, int fromIndex) 返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。
23	int lastIndexOf(String str) 返回指定子字符串在此字符串中最右边出现处的索引。
24	int lastIndexOf(String str, int fromIndex) 返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
25	int length() 返回此字符串的长度。
26	boolean matches(String regex) 告知此字符串是否匹配给定的正则表达式。
27	boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) 测试两个字符串区域是否相等。
28	boolean regionMatches(int toffset, String other, int ooffset, int len) 测试两个字符串区域是否相等。
29	String replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
30	String replaceAll(String regex, String replacement) 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
31	String replaceFirst(String regex, String replacement) 使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
32	[String] split(String regex) 根据给定正则表达式的匹配拆分此字符串。
33	[String] split(String regex, int limit) 根据匹配给定的正则表达式来拆分此字符串。
34	boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开始。
35	boolean startsWith(String prefix, int toffset) 测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
36	CharSequence subSequence(int beginIndex, int endIndex) 返回一个新的字符序列，它是此序列的一个子序列。
37	String substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。
38	String substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串。
39	[char] toCharArray() 将此字符串转换为一个新的字符数组。
40	String toLowerCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
41	String toLowerCase(Locale locale) 使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。
42	String toString() 返回此对象本身（它已经是一个字符串！）。
43	String toUpperCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
44	String toUpperCase(Locale locale) 使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。
45	String trim() 返回字符串的副本，忽略前导空白和尾部空白。
46	static String valueOf(primitive data type x) 返回给定data type类型x参数的字符串表示形式。
47	contains(CharSequence chars) 判断是否包含指定的字符系列。
48	isEmpty() 判断字符串是否为空。

---

**（1）**public void getChars ( int start , int end , char c [ ] , int offset)

​ 将String 对象字符序列存放到数组中

---

正则表达式

(1)

元字符	正则表达式写法	意义
.	“ . ”	代表任何一个字符
\d	" \d "	代表0~9的任何一个数字
\D	" \D "	代表任何一个非数字字符
\s	" \s "	代表空格类字符，‘ \ t ’ ，‘ \ n ’ ，‘ \x0B ’ ，‘ \ f ’ ，‘ \ r ’
\S	" \S "	代表非空格类字符
\w	" \\w "	代表可用于标识符的字符 （不包括美元符号）
\W	" \\W "	代表不能用于标识符的字符
\p{Lower}	" \\p{Lower} "	小写字母 [ a ~ z ]
\p{Upper}	" \\p{Upper} "	大写字母 [ A~Z ]
\p{ASCII}	" \\p{ASCII} "	ASCII 字符
\p{Alpha}	" \\p{Alpha} "	字母
\p{Dight}	" \\p{Dight} "	数字字符 [ 0 ~ 9 ]
\p{Alunm}	" \\p{Alunm} "	字母或数字
\p{punct}	" \\p{punct} "	标点符号 ！、#、$、%、&、“”、‘’、()、*、+、-、,、.、/、;、:、<、>、=、?、@、[ \ ]、^、_、{ | }、~、
\p{Gragh}	" \\p{Gragh} "	可视字符: \p{ Alnum }\ p{ Punct }
\p{Print}	" \\p{Print} "	可打印字符：\p{ Graph }
\p{Blank}	" \\p{Blank} "	空格或制表符 [ \ t ]
\p{Cntrl}	" \\p{Cntrl} "	控制字符：[ \x00-\x1F\x7F ]

[ . ] : 代表任何一个字符

[ abc ] : 代表 a,b,c中的任意一个；

[ ^abc ] : 代表除了a,b,c之外的任意字符；

[ a-zA-Z ] : 代表英文字母中的任意一个；

[ a - d ] : 代表a ~ d中的任意一个；

[ a - d[ m - p ] ] : 代表a ~ b或者 m ~ p中的任意一个；

[ a - z && [ def ] ] : 代表 d,e 或 f 中的任意一个 ( 交 )：

[ a - f && [ ^bc ] ] : 代表 a,d,e,f（差）

带限定符号的模式	意义	带限定符号的模式	意义
X ？	X出现0次或1次	X { n, }	X至少出现 n 次
**X ***	X出现0次或多次	X { n ,m }	X出现 n ~ m此
**X + **	X出现1次或多次	X Y	X的后缀是Y
X { n }	X 恰好出现 n次	X | Y	X或 Y

---

//判断str字符串是否符合regex的格式
//调用matches（）方法
public class E{
public static void main(String[] args){
String regex = "[^0-9]?hello";
String str = "chello";
System.out.println(str.matches(regex));		//输出true
} 
}

---

//字符序列的替换与分解		调用方法  replaceAll()
public class A {
public static void main (String[] args){
  String regex  = "-?[0-9][0-9]*[.]?[0-9]*";
  String str1 = "-6.18";
  String str2 = "899大家好，-45567.48545我再见了大家";
  if(str1.matches(regex)){
      System.out.println(str1+"可以表示数字");
  }
  else{
      System.out.println(str1+"不可以表示数字");
  }
  String result = str2.replaceAll(regex,"*");	     //将字符中符合regex的字符替换为*号
  System.out.println("去掉\""+str2+"\"中的数字，\n得到的字符序列是：");
  System.out.println(result);
}
}

---

public String [] split(String regex)

String对象调用该方法，使参数指定的正则表达式 regex 作为分隔符

Scanner reader = new Scanner(System.in); //指向键盘（键盘输入的内容）
String str = reader.nextLine(); //将键盘输入的内容赋给str

**键盘输入**

*****



##### StringTokenizer 类：

*  创建的对象不使用正则表达式做分隔标记

构造方法

* (1) . **StringTokenizer ( String s )**  : 构造StringTokenizer对象，默认以（空格符，换行符，回车符，Tab，进纸符）为分隔符，分解参数 s 中的字符序列
* (2) . **StringTokenizer ( String s , String delim)**  : 用参数 dilim  字符序列的字符做分隔符，分解参数 s 的字符序列 

```java
StringTokenizer A  = new StringTokenizer("We love you!")

A 对象调用 Srting nextToken( ) 方法逐个获取A中的单词，

A 对象调用 boolean hasMoreTokens( ) 方法判断A中是否还有单词，

A 对象调用 count Tokens( ) 方法返回A中的单词数

---

Scanner 类

​ ( 通过Scanner 类获取用户的输入)

String s = "I am 3 head?";
Scanner B = new Scanner(s);

（1）对象 B 调用 next ( ) 方法返回s序列中的单词，返回完毕则调用 hasNext ( ) 方法得到 true，

（2）对象 B 调用 nextInt ( )或者 nextDouble ( ) 方法将数字型单词转换为 int 或者 double 型数据返回

注意 ：若单词不是数字型单词 ，B 调用(2)时则会发生 InputMismatchException 异常

• next ( ) 与 nextline ( ) 的区别：
• next ( ) :
  • （1）读到有效字符后才结束输入
  • （2）对输入有效字符前的空白，会自动将其去掉
  • （3）输入有效字符后其后输入的空白作为结束符或分隔符
  • （4）不能得到带有空格的字符串
• nextline ( ) :
  • （1）以 Enter 作为结束符
  • （2）可以得到空白

---

Pattern (模式) 与 Matcher (匹配) 类

String input = "悟空的邮箱：sunkukong@163.com,八戒的email是：bajie@haose.com.cn "

(1) Pattern 对象

String regex =  "\\w+@\\w+\\.[a-z]+(\\.[a-z]+)? ";
Pattern pattern = Pattern.compile(regex); 		//初始化模式对象

调用类方法 compile(String regex , int flags) 返回 Pattern 对象

​ 参数 flags 可以取值：（Pattern . CASE_INSENSITIVE）匹配时忽略大小写,

​ （Pattern . MULTILINE）,( Pattern . DOTALL) ,( Pattern . UNICODE_CASE)

​ （ Pattern . CANON_EQ）,

（2）Matcher 对象

Matcher 类的对象直接检索出和 Pattern 类的对象匹配的 String 对象

Matcher matcher = pattern.matcher(input);		//初始化 匹配对象
//Matcher 类的对象直接检索出和 Pattern 类的对象匹配的 String 对象

• 模式对象 pattern 调用 matcher ( CharSequence input ) 方法，返回Matcher 匹配对象：matcher
• input 为matcher 要检索的 String 对象

---

• （1）public boolean matches ( ) : matcher 调用该方法判断 input 字符是否完全和 regex 匹配

• （2）public boolean find ( ) :

• （3）public boolean lookingAt ( ) ：判断从 input 的字符序列开始位置是否有和 regex 匹配的子序列

• （4）public boolean find ( int start )：判断 input 的字符序列从 start 位置开始是否有和 regex 匹配的子序列

• （5）public String replaceAll ( String replacement ) : 返回一个将 input 中符合 regex 的字符序列替换为参数 (replacement)的String对象

• （6）public String replaceFirst ( String replacement ) : 返回一个将 input 中符合 regex 的第一个字符序列替换为参数 (replacement)的String对象

• （7）public String group ( ) : 返回一个字符序列是 find 方法在 input 的序列中找到的符合 regex 的子序列String 对象

---

---

StringBuffer 类

StringBuffer buffer = new StringBuffer(“我喜欢学习”);

调用 append ( str ) 方法：可以追加一个字符序列

• StringBuffer 类有三个构造方法：

• （1）StringBuffer ( ) //初始容量为16个字符

• （2）StringBuffer ( int size ) //设置初始容量大小为size

• （3）StringBuffer ( String s ) //分配给对象实体的初始容量为参数 String 对象 s 字符的长度再加16个字符

常用方法：

（1）append 方法

• StringBuffer append ( String s )：将 s 的字符序列追加到当前 StringBuffer 对象中，并返回当前StringBuffer的引用。
• StringBuffer append ( int n )：将 n 作为字符列尾加到当前 StringBuffer 对象的字符序列中，并返回StringBuffer的引用。
• StringBuffer ( Object o )：将一个 Object 对象的字符表示尾加到当前StringBuffer 对象的字符序列中，并返回StringBuffer的引用

（2）public char charAt ( int n ) 和 public void setCharAt ( int n , char ch) 方法

• char charAt ( int n )：得到参数 n 指定位置上的单个字符。
• setCharAt ( int n , char ch )：将StringBuffer 对象实体的序列 n 位置处的字符用 ch 替换

（3）StringBuffer insert ( int index , String str )：将参数字符 str 插入到 index 指定的位置中，返回当前对象的引用

（4）public StringBuffer reverse ( )：将对象实体中的序列翻转，返回其对象引用

（5）StringBuffer delete ( int index , int endIndex )：删除选中的字符序列，返回当前对象的引用

（6）StringBuffer repalce ( int startIndex , int endIndex , String str )：选中替换的字符序列，返回对象的引用

序号	方法描述
1	public StringBuffer append(String s) 将指定的字符串追加到此字符序列。
2	public StringBuffer reverse() 将此字符序列用其反转形式取代。
3	public delete(int start, int end) 移除此序列的子字符串中的字符。
4	public insert(int offset, int i) 将 int 参数的字符串表示形式插入此序列中。
5	insert(int offset, String str) 将 str 参数的字符串插入此序列中。
6	replace(int start, int end, String str) 使用给定 String 中的字符替换此序列的子字符串中的字符。

以下列表列出了 StringBuffer 类的其他常用方法：

序号	方法描述
1	int capacity() 返回当前容量。
2	char charAt(int index) 返回此序列中指定索引处的 char 值。
3	void ensureCapacity(int minimumCapacity) 确保容量至少等于指定的最小值。
4	void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此序列复制到目标字符数组 dst。
5	int indexOf(String str) 返回第一次出现的指定子字符串在该字符串中的索引。
6	int indexOf(String str, int fromIndex) 从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。
7	int lastIndexOf(String str) 返回最右边出现的指定子字符串在此字符串中的索引。
8	int lastIndexOf(String str, int fromIndex) 返回 String 对象中子字符串最后出现的位置。
9	int length() 返回长度（字符数）。
10	void setCharAt(int index, char ch) 将给定索引处的字符设置为 ch。
11	void setLength(int newLength) 设置字符序列的长度。
12	CharSequence subSequence(int start, int end) 返回一个新的字符序列，该字符序列是此序列的子序列。
13	String substring(int start) 返回一个新的 String，它包含此字符序列当前所包含的字符子序列。
14	String substring(int start, int end) 返回一个新的 String，它包含此序列当前所包含的字符子序列。
15	String toString() 返回此序列中数据的字符串表示形式。

---

日期与时间

• LocalDate 类

---

1. ​ 调用 now ( ) 方法：返回当地时间

2. ​ 调用 **int getDayOfMonth ( ) **方法：返回当前的日

3. ​ int getMonthValue ( ) 方法 ：返回当前的月

4. ​ Month getMonth ( ) 方法 ：返回月的枚举类型

5. ​ **int getDayOfYear ( ) **方法 ： 返回当前时间为当前年的第几天

6. ​ DayOfWeek getDayOfeek ( ) :返回星期的枚举类型

7. ​ int getYear ( ) : 返回当前年的值

8. ​ **int lengthOfYear ( ) **: 返回当前年的天数

9. ​ **boolean isLeapYear ( ) **: 判断是否为闰年

10. LocalDate plusMonths ( long MonthToAdd ) : 返回新对象（对象中的日期是date对象的日期增加monthsToAdd月之后的日期）

11. ​ LocalDate of ( int year , int month , int dayOfMonth )：返回新对象（括号内指定的日期）

---

• LocalDateTime 类

---

1. ​ int getHour ( ) : 返回时
2. ​ int getMinute ( ) : 返回分
3. ​ int getSecond ( ) : 返回秒
4. ​ int getNano ( ) : 返回纳秒

---

• LocalTime 类

只封装时，分，秒和纳秒的数据

---

常用方法：

序号	方法和描述
1	boolean after(Date date) 若当调用此方法的Date对象在指定日期之后返回true,否则返回false。
2	boolean before(Date date) 若当调用此方法的Date对象在指定日期之前返回true,否则返回false。
3	Object clone( ) 返回此对象的副本。
4	int compareTo(Date date) 比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。
5	int compareTo(Object obj) 若obj是Date类型则操作等同于compareTo(Date) 。否则它抛出ClassCastException。
6	boolean equals(Object date) 当调用此方法的Date对象和指定日期相等时候返回true,否则返回false。
7	long getTime( ) 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
8	int hashCode( ) 返回此对象的哈希码值。
9	void setTime(long time) 用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。
10	String toString( ) 把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)。
11	plusYears( -year ) : 调用该方法对象日期加上参数年-year

---

---

---

日期，时间差：

long until ( Temporal endExclusive , TemporalUnit unit ) : 计算两时间差

dateStart.until (dateEnd,ChronoUnit.DAYS) //返回两时间相差的天数

---

日期格式化

• format（）方法

public class dateTime{
public static void main(String[] args){
    LocalDate date = LocalDate.now();
    String s = String.format(" %tY 年 %tm 月 %td 日",date,date,date);
    System.out.println(s);			//输出结果为 2022 年 03 月 24 日
    String str = String.format(" %ty - %<tm - %<td "，date);
    System.out.println(str);          //输出结果为  22 - 03 - 24  
}
}

• ​ 使用含有 < 的格式符与其前面的格式符一同格式同一日期

• SimpleDateFormat ( ) 方法

public class dateTime{
public static void mian(String[] args){
    Date dayNow = new Date();
	SimpleDateFormat F = new SimpleDateFormat("yyyy-MM-dd  HH:mm:ss");

    System.out.println(dayNow);   //输出  Thu Mar 24 17:47:20 CST 2022
    System.out.println("当地时间："+F.formart(dayNow))	//输出  当地时间：2022/03/24  17:50:44
}
}

---

日期和时间的格式化编码

时间模式字符串用来指定时间格式。在此模式中，所有的 ASCII 字母被保留为模式字母，定义如下：

字母	描述	示例
G	纪元标记	AD
y	四位年份	2001
M	月份	July or 07
d	一个月的日期	10
h	A.M./P.M. (1~12)格式小时	12
H	一天中的小时 (0~23)	22
m	分钟数	30
s	秒数	55
S	毫秒数	234
E	星期几	Tuesday
D	一年中的日子	360
F	一个月中第几周的周几	2 (second Wed. in July)
w	一年中第几周	40
W	一个月中第几周	1
a	A.M./P.M. 标记	PM
k	一天中的小时(1~24)	24
K	A.M./P.M. (0~11)格式小时	10
z	时区	Eastern Standard Time
’	文字定界符	Delimiter
"	单引号

使用printf格式化日期

printf 方法可以很轻松地格式化时间和日期。使用两个字母格式，它以 %t 开头并且以下面表格中的一个字母结尾。

转 换 符	说 明	示 例
c	包括全部日期和时间信息	星期六 十月 27 14:21:20 CST 2007
F	"年-月-日"格式	2007-10-27
D	"月/日/年"格式	10/27/07
r	"HH:MM:SS PM"格式（12时制）	02:25:51 下午
T	"HH:MM:SS"格式（24时制）	14:28:16
R	"HH:MM"格式（24时制）	14:28

printf 方法可以很轻松地格式化时间和日期。使用两个字母格式，它以 %t 开头并且以下面表格中的一个字母结尾。

转 换 符	说 明
%tY	将年格式化为 4 位形式
%ty	将年格式化位 2 位形式
%tm	将月格式化 2 位形式
%td	将日格式化 2 位形式
%tB	将月格式化为当前的全称
%tb	将月格式化为当前的简称
%tA	将星期格式化为当前的全称
%ta	将星期格式化为当前的简称
%tH	将时格式化为 2 位形式（24小时）
%tI	将时格式化为 2 位形式（12小时）
%tM	将分格式化为 2 位形式
%tS	将秒格式化为 2位形式
%tN	将纳秒格式化为 2 位形式
%tR	%tH : %tM
%tT	%tH : %tM : %S
%tr	%tI : %tH : %tM : %S : %tp (%tp上午或下午)
%tD	%tm / %td / %ty
%tF	%tY - %tm - %td
%tc	%ta %tb %td %tT %tZ %tY

不同区域的星期格式：format （Local local，格式化模式，日期列表）

---

(1) Calendar类

​ Calendar 的 getInstance（）方法返回一个默认用当前的语言环境和时区初始化的 GregorianCalendar 对象

Calendar类中用以下这些常量表示不同的意义

常量	描述
Calendar.YEAR	年份
Calendar.MONTH	月份
Calendar.DATE	日期
Calendar.DAY_OF_MONTH	日期，和上面的字段意义完全相同
Calendar.HOUR	12小时制的小时
Calendar.HOUR_OF_DAY	24小时制的小时
Calendar.MINUTE	分钟
Calendar.SECOND	秒
Calendar.DAY_OF_WEEK	星期几

(2) GregorianCalendar类

下面列出GregorianCalendar对象的几个构造方法：

序号	构造函数和说明
1	GregorianCalendar() 在具有默认语言环境的默认时区内使用当前时间构造一个默认的 GregorianCalendar。
2	GregorianCalendar(int year, int month, int date) 在具有默认语言环境的默认时区内构造一个带有给定日期设置的 GregorianCalendar
3	GregorianCalendar(int year, int month, int date, int hour, int minute) 为具有默认语言环境的默认时区构造一个具有给定日期和时间设置的 GregorianCalendar。
4	GregorianCalendar(int year, int month, int date, int hour, int minute, int second) 为具有默认语言环境的默认时区构造一个具有给定日期和时间设置的 GregorianCalendar。
5	GregorianCalendar(Locale aLocale) 在具有给定语言环境的默认时区内构造一个基于当前时间的 GregorianCalendar。
6	GregorianCalendar(TimeZone zone) 在具有默认语言环境的给定时区内构造一个基于当前时间的 GregorianCalendar。
7	GregorianCalendar(TimeZone zone, Locale aLocale) 在具有给定语言环境的给定时区内构造一个基于当前时间的 GregorianCalendar。

这里是GregorianCalendar 类提供的一些有用的方法列表：

序号	方法和说明
1	void add(int field, int amount) 根据日历规则，将指定的（有符号的）时间量添加到给定的日历字段中。
2	protected void computeFields() 转换UTC毫秒值为时间域值
3	protected void computeTime() 覆盖Calendar ，转换时间域值为UTC毫秒值
4	boolean equals(Object obj) 比较此 GregorianCalendar 与指定的 Object。
5	int get(int field) 获取指定字段的时间值
6	int getActualMaximum(int field) 返回当前日期，给定字段的最大值
7	int getActualMinimum(int field) 返回当前日期，给定字段的最小值
8	int getGreatestMinimum(int field) 返回此 GregorianCalendar 实例给定日历字段的最高的最小值。
9	Date getGregorianChange() 获得格里高利历的更改日期。
10	int getLeastMaximum(int field) 返回此 GregorianCalendar 实例给定日历字段的最低的最大值
11	int getMaximum(int field) 返回此 GregorianCalendar 实例的给定日历字段的最大值。
12	Date getTime() 获取日历当前时间。
13	long getTimeInMillis() 获取用长整型表示的日历的当前时间
14	TimeZone getTimeZone() 获取时区。
15	int getMinimum(int field) 返回给定字段的最小值。
16	int hashCode() 重写hashCode.
17	boolean isLeapYear(int year) 确定给定的年份是否为闰年。
18	void roll(int field, boolean up) 在给定的时间字段上添加或减去（上/下）单个时间单元，不更改更大的字段。
19	void set(int field, int value) 用给定的值设置时间字段。
20	void set(int year, int month, int date) 设置年、月、日的值。
21	void set(int year, int month, int date, int hour, int minute) 设置年、月、日、小时、分钟的值。
22	void set(int year, int month, int date, int hour, int minute, int second) 设置年、月、日、小时、分钟、秒的值。
23	void setGregorianChange(Date date) 设置 GregorianCalendar 的更改日期。
24	void setTime(Date date) 用给定的日期设置Calendar的当前时间。
25	void setTimeInMillis(long millis) 用给定的long型毫秒数设置Calendar的当前时间。
26	void setTimeZone(TimeZone value) 用给定时区值设置当前时区。
27	String toString() 返回代表日历的字符串

import java.util.Calendar;
import java.util.GregorianCalendar;
public class calender {                 //calender 日历，日程表
    public static void main(String[] args) {
        String months[] = {
                "Jan", "Feb", "Mar", "Apr",
                "May", "Jun", "Jul", "Aug",
                "Sep", "Oct", "Nov", "Dec"};

        int year;
        // 初始化 Gregorian 日历
        // 使用当前时间和日期
        // 默认为本地时间和时区
        GregorianCalendar gcalendar = new GregorianCalendar();
        // 显示当前时间和日期的信息
        System.out.print("Date: ");
        System.out.print(months[gcalendar.get(Calendar.MONTH)]);        //Mar
        System.out.print(" " + gcalendar.get(Calendar.DATE) + " ");     // 24
        System.out.println(year = gcalendar.get(Calendar.YEAR));        //2022
        System.out.print("Time: ");
        System.out.print(gcalendar.get(Calendar.HOUR) + ":");           //8:
        System.out.print(gcalendar.get(Calendar.MINUTE) + ":");         //48:
        System.out.println(gcalendar.get(Calendar.SECOND));             //16

        // 测试当前年份是否为闰年
        if(gcalendar.isLeapYear(year)) {
            System.out.println("当前年份是闰年");
        }
        else {
            System.out.println("当前年份不是闰年");
        }
    }
}

---

Math 类

所有的包装类**（Integer、Long、Byte、Double、Float、Short）**都是抽象类 Number 的子类。

包装类	基本数据类型
Boolean	boolean
Byte	byte
Short	short
Integer	int
Long	long
Character	char
Float	float
Double	double

Number & Math 类常用的一些方法：

序号	方法与描述
1	xxxValue()	将 Number 对象转换为xxx数据类型的值并返回。
2	compareTo()	将number对象与参数比较。
3	equals()	判断number对象是否与参数相等
4	valueOf()	返回一个 Number 对象指定的内置数据类型
5	toString()	以字符串形式返回值。
6	parseInt()	将字符串解析为int类型。
7	abs()	返回参数的绝对值。
8	ceil()	返回大于等于( >= )给定参数的的最小整数，类型为双精度浮点型。
9	floor()	返回小于等于（<=）给定参数的最大整数 。
10	rint()	返回与参数最接近的整数。返回类型为double。
11	round()	它表示四舍五入，算法为 Math.floor(x+0.5)，即将原来的数字加上 0.5 后再向下取整，所以，Math.round(11.5) 的结果为12，Math.round(-11.5) 的结果为-11。
12	min()	返回两个参数中的最小值。
13	max()	返回两个参数中的最大值。
14	exp()	返回自然数底数e的参数次方。
15	log()	返回参数的自然数底数的对数值。
16	pow()	返回第一个参数的第二个参数次方。
17	sqrt()	求参数的算术平方根。
18	sin()	求指定double类型参数的正弦值
19	cos()	求指定double类型参数的余弦值。
20	tan()	求指定double类型参数的正切值。
21	asin()	求指定double类型参数的反正弦值。
22	acos()	求指定double类型参数的反余弦值。
23	atan()	求指定double类型参数的反正切值。
24	atan2()	将笛卡尔坐标转换为极坐标，并返回极坐标的角度值。
25	toDegrees()	将参数转化为角度。
26	toRadians()	将角度转换为弧度。
27	random()	返回一个随机数

28. public static double random ( ) : 产生一个 [ 0,1 ) 的随机数。

29. public static double pow ( double a , double b ) : 返回 a 的 b 次冥

30. public static double sqrt ( double a ) ： 返回 a 的平方根

31. public static double ceil ( double a )： 返回大于 a 的最小整数，并将该整数转化为 double 型

32. public static double floor ( double a ) : 返回小于 a 的最大整数，并将该整数转化为 double 型

33. public static long round ( double a ) : 返回四舍五入的整数（小数大于5则入）

---

Random 类

• (int)(Math.random()*100)+1;			//得到 [ 1 , 100 ] 之间的随机整数
  

• Random random = new Random();
  random.nextInt();	//random对象调用不带参数的 nextInt() 方法，返回随机整数
  random.nextInt(50);	//调用 nextInt( 50 ) 方法，返回 [0 , 50) 之间的随机整数
  

• random.nextBoolean();		//调用 nextBoolean()方法 随机放回 true 或 false
  

  注意：

  Random random1 = new Random(20);
  Random random2 = new Random(20);
  randon1.nextInt(10);
  random2.nextInt(10);
  //random1 与 random2 中的参数种子都为 20
  //则他们得到的随机整数为一致的
  

• 从 [0,10]中随机选择3个数组成数组输出

• public class Example {
      public static void main(String[] args){
          getRandom shu = new getRandom();
          int []a = shu.GetRandom(10,3);      //从 [0,10]中随机选择3个数组成数组输出
          System.out.println(Arrays.toString(a));
      }
  }
  

• public class getRandom {
      public static int[] GetRandom(int max,int amount){
          int [] result = new int[amount];        //存放得到的 amount 随机数
          int [] a = new int[max];            //存放 max 个整数
          Random random = new Random();
          for(int i = 0;i < a.length; i++){       //将 1至 max放入数组 a中
              a[i] = i+1;
          }
          for(int i = 0;i < amount; i++){         //得到 amount 随机数
              int index = random.nextInt(a.length);       //随机返回 a数组中的一个索引值 （即随机数）
              result[i] = a[index];                       //取出该随机数
              int []b = Arrays.copyOfRange(a,0,index);        //数组 b 存放的是 a[0]到 a[index-1]
              int []c = Arrays.copyOfRange(a,index+1,a.length);   //数组 c 存放的是 a[index] 到 a[a.length]
              a = new int[b.length+c.length];             //新的数组 a 中去掉了抽到的数组
              for(int k = 0;k < a.length;k++){
                  if (k<b.length)
                      a[k] = b[k];
                  else
                      a[k] = c[k - b.length];
              }
          }
          return result;                      //返回结果的是一个数组
      }
  }
  

  ---

---

Java Swing

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z2ZtkmEN-1668752538172)(D:\桌面\screenshot\微信图片_20220325144958.jpg)]

注：其他组件必须被添加到底层容器中，以便借助这个底层容器和操作系统进行信息交互

（1）容器调用 removeAll ( ) 方法： 移除容器中的全部组件

（2）容器调用 remove ( Component c) : 移除容器中参数 c 指定的组件

（3）容器调用 add ( ) : 将组件添加到容器中

（4）容器添加或移除组件时调用 validate ( ) 方法： 保证容器中的组件正常显示

---

窗口 面板 JFrame

序号	方法	描述
1	JFrame（String s）	创建标题为 s 的窗口
2	public void setBounds ( int a , int b , int width , int height )	设置窗口在屏幕上的初始位置大小
3	public void setSize ( int width , int height )	窗口的大小
4	public void setLocation ( int x , int y )	窗口的位置
5	public void setVisible ( boolean b )	窗口的可见性
6	public void setResizable ( boolean b )	窗口大小是否可调
7	public void dispose ( )	撤销当前窗口，并释放其使用的资源
8	public void ExtendedState ( int state )	【MAXIMIZED_HORIZ 水平方向最大化】【 MAXIMIZED_VERT 垂直方向最大化 】 【MAXIMIZED_BOTH 水平、垂直方向都最大化】

9 . public void setDefaultCloseOperation ( int operation )

​ 点击窗口关闭图标后

​ (1) DO_NOTHING_ON_CLOSE 什么也不做

​ (2) HIDE_ON_CLOSE 隐藏当前窗口

​ (3) DISPOSE_ON_CLOSE 隐藏当前窗口，并释放其占用的资源

​ (4) EXIT_ON_CLOSE 关闭当前程序

public class A {
public static void main(String[] args){
  JFrame L = new JFrame("第一个窗口");         //创建一个面板
  Container com = L.getContentPane();         //调用方法的将得到的内容面板引用给对象 com
  com.setBackground(Color.BLUE);              //设置背景颜色
  L.setBounds(800,500,500,200);   //设置窗口面板的位置大小
  L.setVisible(true);                 //设置窗口是否可见
  L.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);   //设置关闭窗口的模式

}
}

菜单

setJMenuBar (JMenuBar bar) // 将菜单放置到窗口中

• JComponent 类的子类 JMenu 负责创建菜单，子类 JMenuItem 负责创建菜单项
• 嵌入式子菜单：JMenu 为 JMenuItem 类的子类
• 菜单上的图标：1. 图表类 Icon 声明一个图标 2. 其子类 ImageIcon 创建一个图标
  • ​ Icon icon = new ImageIcon("pecture.gif") //添加图标 pecture .gif

public class BBB extends JFrame {
    JMenuBar menuBar;        //声明一个菜单条对象
    JMenu menu,subMenu;         //声明菜单对象
    JMenuItem item1,item2;          //声明菜单项对象
    public BBB(){}              //创建一个空的构造方法
    public BBB(String s,int x,int y,int w,int h){           //重写构造方法
        init(s);
        setLocation(x,y);
        setSize(w,h);
        setVisible(true);
        setDefaultCloseOperation(DISPOSE_ON_CLOSE);
    }

    private void init(String s) {
        setTitel(s);
        menuBar = new JMenuBar();
        menu = new JMenu("菜单");
        subMenu = new JMenu("子菜单");
        item1 = new JMenuItem("菜单项1");
        item2 = new JMenuItem("菜单项2");
        item1.setAccelerator(KeyStroke.getKeyStroke('A'));
        item2.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, InputEvent.CTRL_DOWN_MASK));
        menu.add(item1);
        menu.addSeparator();
        menu.add(item2);
        menu.add(subMenu);
        subMenu.add(new JMenuItem("子菜单里的菜单项"));
        menuBar.add(menu);
        setJMenuBar(menuBar);

    }

    private void setTitel(String s) {}
}

---

常用组件、容器与布局

常用组件

• （1）JTextFeild 类创建文本框

• （2）JTextArea 类创建文本区

• （3）JButton 类创建按钮

• （4）JLabel 类创建标签

• （5）JCheckBox 类创建复选框

• （6）JRadioButton 类创建单选按钮

ButtonGroup fruit = new ButtonGroup(); //创建单选框
JRadioButton button1 = new JRadioButton(“香蕉”)，

  	button2 = new JRadioButton("苹果");//创建单选按钮

fruit.add(button1);
fruit.add(button2); //将按钮集合添加进盒子

* （7）**JComboBox**  类创建下拉列表

* ```java
JComboBox <String> comBox;
comBox = new JComboBox <String>();			//创建下拉列表 comBox

• （8）JPasswordFeild 类创建密码框

• 调用 setEchoChar ( char c ) 设置回显字符

• 调用 char [ ] getPassword ( ) 返回用户输入的密码

---

常用容器

​ 中间容器必须加到底层容器中

• （1）JPanel 面板：( 默认 FliowLayxout 布局 )

​ 使用JPanel创建面板对象，再向面板添加组件，将面板添加到其他容器中

• （2）滚动窗格

​ **JScrollPane scroll = new JScrollPane( new JTextArea ( ) ) ** //将文本区放到窗格 scroll 中

• （3）拆分窗格 ( 将容器分为俩部分 )

• JSplitPane( int a , Component b , Conponent c ) 构造方法

• HORIZONTAL_SPLIT 水平拆分（参数a）

• VERTICAL_SPLIT 垂直拆分（参数a）

• JSplitPane( int a , boolean b , Component c , Conponent d ) 构造方法

• 参数 b 决定当拆分线移动时，组件是否发生连续变化

• （4）分层窗格

• add ( Jcomponent com , int layer )

• 添加组件 com ，并指定其所在的层 layer

• layer 可取：

  • DEFAULT_LAYER （默认层）最底层
  • PALETTE_LAYER （调色层）第四层
  • MODAL_LAYER （模态层）第三层
  • POPUP_LAYER （弹出层）第二层
  • DRAG_LAYER （拖动层）最高层

• public void setLayer ( Component c , int layer ) 重新设置组件 c 所在的层

• public int getLayer ( Component c ) 获取组件 c 所在的层数

• （5）选项卡窗格

• JTabbedPane 为中间容器

• add ( String text , Component c ) 选项卡调用方法将组件 c 添加到窗格中

• **public JTabbedPane ( int tabPlacement ) ** 创建选项卡窗格 ( 选项卡的位置有参数决定 )

• 参数 tabPlacement可取：

  • JTabbedPane
  • TOP
  • JTabbedPane . BOTTOM
  • JTabbedPane . LEFT
  • JTabbedPane . RIGHT

---

常用布局

• （1）FlowLayout 布局 （流水布局）面板默认布局
• （2）BorderLyout 布局 （环绕布局）窗口默认布局
• （3）CardLayout 布局 （卡片布局）选项卡窗格默认布局
• （4）GridLayout 布局 （网格布局）
• （5）BoxLayout 布局 （盒式布局）
• （6）null 布局 （空布局）

---

public Pass(){
    init();
    setVisible(true);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
void init(){
    setLayout(new FlowLayout());                      //设置流水布局：排版根据窗口的大小
    label = new JLabel("文本框：");              //标签
    add(label);
    text = new JTextField(10);               //文本框
    add(text);
    button = new JButton("确定");                //按钮
    add(button);
    checkbox1 = new JCheckBox("唱");             //复选框
    checkbox2 = new JCheckBox("跳");
    checkbox3 = new JCheckBox("Rap");
    checkbox4 = new JCheckBox("篮球");
    add(checkbox1);
    add(checkbox2);
    add(checkbox3);
    add(checkbox4);
    group = new ButtonGroup();                        //单选框
    radio1 = new JRadioButton("男");             //单选按钮
    radio2 = new JRadioButton("女");
    comBox = new JComboBox<>();                      //下拉列表
    comBox.addItem("110");
    comBox.addItem("120");
    comBox.addItem("119");
    comBox.addItem("123");
    add(comBox);
    area = new JTextArea(6,12);        //文本区
    JScrollPane scroll = new JScrollPane(area);       //将文本区放入滚动窗格中
    add(scroll);
}
}

/*主函数*/
public class main {
public static void main(String[] args){
    Pass pass = new Pass();
    pass.setBounds(800,500,300,260);
    pass.setTitle("常用组件");
}
}   

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a5fSlpRS-1668752538172)(D:\桌面\screenshot\uTools_1648276837690.png)]

---

处理事件

• 事件源
• 监视器
• 处理事件的接口

---

ActionEvent 事件

• ActionEvent 事件源

文本框，密码框，按钮，单选按钮，菜单项

• 注册监视器

触发 ActionEvent 事件的组件使用方法：

​ addActionListener (ActionListener listen)

• ActionListener 接口

该接口只有一个方法：

public void actionPerformed(ActionEvent e)		//实现该接口时，必须重写该方法

事件源触发ActionEvent事件后，监视器调用接口中的方法

actionPerformed(ActionEvent e)

之后ActionEvent类事先创建的事件对象会传递给该方法的参数 e

• ActionEvent 类中的方法

(1) public Object getSource()方法

ActionEvent事件对象调用该方法获取发生ActionEvent事件的事件源对象的引用

(2) public String getActionCommand() 方法

ActionEvent事件对象调用该方法获取发生ActionEvent事件时和该事件相关的一个“命令”字符串

public class A extends JFrame {
JTextField text;                                //创建文本框
ActionListener listener;                        //创建监听器
public A(){
init();
setBounds(100,100,200,200);//设置窗口的位置与大小
setVisible(true);                           //设置窗口可见性
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);                  //设置默认关闭操作
}
void init(){
setLayout(new FlowLayout());
text = new JTextField(10);          //设置文本框事件源
listener = new PoliceListen();               //创建监听器
text.addActionListener(listener);            //将监视器与事件源关联绑定
add(text);
}
}

public class PoliceListen implements ActionListener {
public void actionPerformed(ActionEvent e){			//监听器触发后所要执行的操作方法
int n = 0,m = 0;
String str = e.getActionCommand();               //调用方法，返回发生ActionEvent事件的命令字符串
try {
    n = Integer.parseInt(str);
    m = n * n;
    System.out.println(n+"的平方是"+m);
} catch (NumberFormatException ex) {
    ex.printStackTrace();
    System.out.println(ex.toString());
}
}
}

public class example {
public static void main(String[] args){
A a = new A();

}
}

---

---

---

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jEroRfD6-1668752538173)(D:\桌面\screenshot\1.jpg)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-puPkvMxA-1668752538173)(D:\桌面\screenshot\2.jpg)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TfYzSWhC-1668752538174)(D:\桌面\screenshot\3.jpg)]

---

---

---

ItemEvent 事件

• ItemEvent 事件源

复选框，下拉列表

• 注册监视器

触发 ItemEvent 事件的组件使用方法：

addItemListener(ItemListener listen)

• ItemListener 接口

该接口只有一个方法：

public void itemStateChanged(ItemEvent e); 		//项目状态更改

当监视器调用该方法，ItemEvent类事先创建的对象就会传递给该方法的参数 e

• ItemEvent 类中的方法

(1) getSource() 和 getItemSelectable()

返回发生项目事件的事件源

---

DocumentEvent 事件

• DocumentEvent 事件源

文本区

• 注册监视器

触发 DocumentEvent 事件的组件的使用方法：

addDocumentListener(DocumentListener listen)

• DocumenListener 接口

(1) 更改

public void changedUpdate(DocumentEvent e)		

(2) 删除

public void removeUpdate(DocumentEvent e)

(3) 插入

public void insertUpdate(DocumentEvent e)

事件源触发DocumentEcent事件后，监视器将发现触发的DocumentEvent事件，然后调用接口中的·相应2方法对发生的事件进行处理

• DocumentEvent 类中的方法

(1) getDocumen ()

返回所维护的文档

---

MouseEvent 事件

• MouseEvent 事件源

任何组件

• 注册监视器

addMouseListener(MouseListener listener)

• MouseListener 接口

（1）在组件上按下鼠标键

public void mousePressed(MouseEvent);

（2）在组件上释放鼠标键

public void mouseReleased(MouseEvent);

（3）鼠标进入组件

public void mouseEntered(MouseEvent);

（4）鼠标离开组件

public void mouseExited(MouseEvent);

（5）在组件上点击鼠标

public void mouseClicked(MouseEvent);

• MouseMotionListener 接口（鼠标运动监听器）

addMouseMotionListener(MouseMotionListener listener)	//添加该鼠标监听器

（1）拖动鼠标

public void mouseDragged(MouseEvent)

（2）移动鼠标

public void mouseMoved(MouseEvent)

• MouseEvent 类中的方法

（1）getX () 和 getY ()

获取鼠标在事件源中的 x, y坐标

（2）getButton ()

获取鼠标的左键或者右键

（3）getClickCount ()

获取鼠标被点击的次数

（4）getSource ()

获取发生鼠标事件的事件源

---

焦点事件

• addFocusListener(FocusListener listener) 注册焦点事件监视器
• FocusListener 接口中的方法

（1）组件从 无 输入焦点到 有 输入焦点

public void focusGained(FocusEvent e);		//获取焦点

（2）组件从 有 输入焦点到 无 输入焦点

public void focusLost(FocusEvent e);			//丢失焦点

• 其他方法

public void boolean requsetInWindow(); //调用该方法获取输入焦点

*******************

###### 键盘事件

| **按键类型** | **按键动作类型** | **键盘事件类型** |
| ------------ | ---------------- | ---------------- |
| 操作键       | 按住不放         | keyPressed       |
| 操作键       | 按一下松开       | keyReleased      |
| 字符键       | 按住不放         | keyTyped         |
| 字符键       | 按一下松开       | keyReleased      |
| 辅助键       | 按住不放         | keyPressed       |
| 辅助键       | 按一下松开       | keyReleased      |

###  

* 事件源

>键盘按键

* 注册监视器

>`addKeyListener(KeyListener listener)`

* KeyListener  接口

>（1）按键按下

>```java
>public void keyPressed(KeyEvent e)
>```

>（2）键入键 ( 敲击 )

>```java
>public void keyTyped(KeyEvent e)
>```

>（3）按键释放

>```java
>public void KeyReleased(KeyEvent e)
>```

* KeyEvent  类中的方法

>* 判断哪个键被使用，并返回一个建码值

>```java
>public void getKeyCode()
>```

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ilPb3fV2-1668752538174)(D:\桌面\screenshot\4.jpg)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eeor1V6K-1668752538174)(D:\桌面\screenshot\6.jpg)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hTTkQpgq-1668752538175)(D:\桌面\screenshot\5.jpg)]

-----------------

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qCvAkuyM-1668752538175)(D:\桌面\screenshot\8.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IMo1RSA0-1668752538176)(D:\桌面\screenshot\9.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AE9LRpWz-1668752538177)(D:\桌面\screenshot\10.png)]

*****************

*******************

###### 窗口事件

 注意：若要处理窗口事件，需先设置窗口的默认关闭方式为  DO_NOTHING_ON_CLOSE

* WindowsEvent  事件源

>**JFrame**  为  **Windows**  的子类，【Windows 子类创建的对象都可以发生窗口事件】

>WindowsEvent 创建的事件对象调用 **getWindows ( )**   :  获取发生窗口事件的窗口

* 注册监听器

>`addWindowListener(WindowListener Listener)`

* WindowListener  接口

>（1）非激活~激活

>```java
>public void windowActivated(WindowsEvent e)
>```

>（2）激活~非激活

>```java
>public void windowDeactivated(WindowsEvent e)
>```

>（3）正在关闭

>```java
>public void windowClosing(WindowsEvent e)
>```

>调用该方法时，若在该方法中使用  **System . exit (  )**  退出程序运行，则监视器将没办法调用（正在关闭方法）

>（4）关闭后

>```java
>public void windowClosed(WindowsEvent e )
>```

>（5）最小化

>```java
>public void windowIconified(WindowsEvent e)
>```

>（6）撤销最小化


>```java
>public void windowDeactivated(WindowsEvent e)
>```

>（7）打开窗口

>```java
>public void windowOpened(WindowsEvent e)
>```

* **WindowAdapter  适配器类**

>作用：（1）处理事件的接口中方法很多时使用适配器类

>[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kG9WsYRf-1668752538178)(D:\桌面\screenshot\11.png)]

>`继承适配器类，监听器用到接口的哪个方法就重写哪个方法`

*****************

*****************

##### 树组件			（JTree类的对象）

* （1）DefaultMutableTreeNode  结点    （默认可变树结点）

>1. `DefaultMutableTreeNode` 类为实现了 `MultableTreeNode` 接口

>   构造方法：

>   （1）

>   ```java
>   DefaultMubtableTreeNode(Object userObject);//默认可以有子结点
>   ```

>   创建树结点

>   ```java
>   DefaultMutableTreeNode node = new DefaultMutableTreeNode("这是一个结点");
>   ```

>   （2）

>   ```java
>   DefaultMutableTreeNode(Object userObject,boolean allowChildren);
>   ```

>2. 结点对象  调用该方法设置是否可有  子结点

>   ```java
>   setAllowChildren(boolean h)
>   ```

>3. 结点对象  调用该方法   得到结点中存放的数据

>   ```java
>   getUserObject()
>   ```

>>   				4.向根结点添加节点*（确定结点之间的关系）

>>   ```java
>>   根结点。add（子结点）
>>   ```

>>   ********************************

>>   创建结点，并作为树的根节点

>>   ```java
>>   //创建树结点对象 root
>>   DefaultMutableTreeNode root = new DefaultMutableTreeNode("根结点");
>>   //创建树组件  tree
>>   JTree tree;
>>   //将结点对象 root 定义为树组件 tree 的根结点
>>   tree = new JTree(root)
>>   ```





* （2）TreeSelectionEvent  事件

`注册监视器` **:**        `addTreeSelectListener(TreeSelectionListener listener)`

`创建监视器的类必须实现接口`   **TreeSelectionListener**

`接口方法`    **：**    `public void valueChanged（TreeSelectionEvent  e）`

tree  使用  `getLastSelectionPathComponent（）` 获取选中的组件

*************************

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OKNjECe8-1668752538178)(D:\桌面\screenshot\13.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nvRjWr8g-1668752538178)(D:\桌面\screenshot\12.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-E75dWvKN-1668752538179)(D:\桌面\screenshot\14.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0GrfP0d1-1668752538179)(D:\桌面\screenshot\15.png)]

************************

******************

##### 表格组件      JTable

>* (1)	创建默认表格模型

>>  ```java
>>  JTable()
>>  ```

> ```
> 
> ```

>>* (2)    创建 a 行，b 列的表格

>>  ```java
>>  JTable(int a,int b)
>>  ```

> ```
> 
> ```

>>* (3)     创建表格

>>  ```java
>>  //指定显示 date【】【】二维数组的值
>>  //列名由数组 columnName 指定
>>  JTable(Object data[][],Object columnName[])
>>  ```

> ```
> 
> ```

>>* **repaint（ ）** ：刷新显示当前数据

---

将按钮绑定到键盘

• AbstractAction 类

创建监视器的类必须实现 ActionListener 接口的子接口 Action（ AbstractAction 类符合该条件）

所以继承AbstractAction 类即可

只需重写 public void actionPerformed（ActionEvent e） 方法即可

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mGH27OnI-1668752538179)(D:\桌面\screenshot\16.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QQTd57Hp-1668752538180)(D:\桌面\screenshot\17.png)]

---

设 listener 为 AbstractAction 的子类。按钮对象为 button

• (1) 获取输入映射

按钮调用方法 public final InputMap getInputMap(int condition)

​

状态 condition 的取值：	描述（何时调用该操作）
WHEN_FOCUSED	击键发生，且组件具有焦点
WHEN_IN_FOCUSED_WINDOW	1. 击键发生，且组件具有焦点。 2.组件处于具有焦点的窗口中时
WHEN_ANCESTOR_OF_FOCUSED_COMPONENT	1. 击键发生，且组件具有焦点。 2.组件是具有焦点的组建的祖先时

InputMap inputmap = button.getInpuMap(JComponent.WHEN_IN_FOCUSED)
//调用 getInputMap() 返回InputMap对象

• （2）绑定按钮的键盘操作

按钮的 InputMap 型对象调用方法 public void put(KeyStroke keyStork,Object actionMapKey)

inputmap.put(KeyStorke.getKeyStorke("A"),"love");
//将敲击键盘上的 "A" 键指定为imputmap对象即button 的操作
//“love” 为指定的 映射为该操作的关键字

• （3）为按钮的键盘操作指定监视器

按钮调用方法 public final ActionMap getActionMap()

ActionMap actionmap = button.getActionMap();
//调用该方法：返回一个 ActionMap 型对象  

actionmap 对象调用方法：public void put(Object key,Action action)

actionmap.put("love",listener);
//将监视器与映射关键字绑定

---

---

输入流与输出流

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HDZWgtId-1668752538180)(D:\桌面\screenshot\18.png)]

文件字节输入流

1. 设定输入源
2. 创建指向源的输入流
3. 输入流调用 read ( ) 方法读取源中的数据
4. 关闭输入流

---

File f = new File("pathname");		//创建输入流的源 f
//  pathname 为文件的路径

FileInputStream IN = new FileInputString(f);    //创建指向源的输入流

​ int read(byte b[])

从文件中读取 b**.** length 个字节，存放进数组 b 中

​ int read(byte b[],int off,int len)

从文件中读取 len 个字节，存放进数组 b 中，off 是首字节在数组 b 中存放的位置

IN.read(byte b[],0,18)
//调用 read（）方法读取源中的数据

IN.close();
//关闭输入流

---

文件字节输出流

1. 设置目的地
2. 创建指向目的地的输出流
3. 输出流调用 write ( ) 方法将数据写入到目的地
4. 关闭输出流

---

File f = new File("pathname");	//设置目的地
//pathname  : 目的地文件的路径

FileOutputStream OUT = new FileOutputStream(f)
//创建指向目的地的输出流

​ public void write(byte b[])

将数组以字节为单位向文件写入数据

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

从字节数组的 off 起始位置处写 len 长度字节到文件

OUT.write(byte b[],0,b.length)

OUT.close();

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-46atFGxr-1668752538181)(D:\桌面\screenshot\19.jpg)]

文件字符输入流

FileReader 的父类 Reader

FileWriter 的父类 Writer

1. 设置源

File f = new File("pathname");		//创建输入流的源 f
//  pathname 为文件的路径

2. 设置指向源的输入流

FileReader In = new FileRader(f);
//创建指向源f 的输入流In

3. 输入流调用方法 read () 从源中读取数据

返回实际读取的字符数目

int read(char b[])

从文件中读取 b**.** length 个字符，存放进数组 b 中

​ int read(char b[],int off,int len)

从文件中读取 len 个字节，存放进数组 b 中，off 是首字符在数组 b 中存放的位置

IN.read(char b[],0,18)
//调用 read（）方法读取源中的数据

4. 关闭流

In.close();

文件字符输出流

1. 创建目的地

File f = new File("pathname");//  pathname 为文件的路径

2. 创建指向目的地的输出流

FileWriter OUT = new FileWriter(f);
//创建输入流 OUT对象 并指向目的地 f

3. 输出流调用 writer () 向目的地写入数据

​ write (char b[])

写入一个数组

​ write (char b[],int off,int length)

将字符数组从 off 位置开始取 length 长度的字符写入到文件

OUT.write(char b[],0,b.length);

4. 关闭流

OUT.close();

缓冲流

• BufferedWriter 缓冲输出流
• BufferedReader 缓冲输入流 （可以按行读取文件）

BufferedReader 缓冲输入流

1. 创建源

File f = new File("pathname");		//创建输入流的源 f

1. 创建指向源的缓冲输入流对象

FileReader In001 = new FileReader("pathname");
//创建指向源f 的输入流In001
BufferedReader In002 = new BufferedReader(In001);
//向 BufferedReader 传递一个 Reader 子类的对象来创建 缓冲输入流对象

3. 缓冲输入流对象调用 readLine ( ) 方法读取源

String strLine = inTwo.readLine();

4. 关闭流

In001.close();
In002.close();

---

BufferedWriter 缓冲输出流

3. 缓冲输出流对象调用 writer（）方法写入数据到目的地

writer(String s,int off,int len)
// off 为s的开始位置，len为写入的字符数量

newLine();
//调用该方法表示回行

---

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2U07PwJM-1668752538181)(D:\桌面\screenshot\20.png)]

---

RandomAccessFile 随机流

（ 随机流的指向即可作为源，也可作为目的地 ）

• RandomAccessFile 类的构造方法

RandomAccessFile(String name,String mode);
// name 为确定文件名（patnname）；给出创建的源或目的地
// mode 取r（只读），rw（可读/写）

RandomAccessFile(File file,String mode);
//file 为一个File对象；给出创建的源或目的地
// mode 取r（只读），rw（可读/写）

方法：

​ 用来定位 随机访问文件流（RandomAccessFile）的读写位置

seek(long a);
// a 为读写位置距离文件开头的字节个数

​ 获取当前流的读写位置

getFilePointer();

---

数组流

​ 流的源除了是文件外，还可以是计算机类内存

• 字节数组输入流 ByteArrayInputStream 使用字节数组作为流的源

• 字节数组输出流 ByteArrayOutputStream 使用字节数组作为流的目标

• 字符数组输入流 CharArrayInputStream 使用字符数组作为流的源

• 字符数组输出流 CharArrayOutputStream 使用字符数组作为流的目标

---

​ ByeArrayInputStream

ByteArrayInputStream(byte[] buf);
//构造的输入流的源是参数 buf 指定的数组的全部字节单元
/******************************************************************************************/
ByteArrayInputString(byte[] buf,int offset,int length);
//构造的输入流的源是 buf 指定的数组从 offset 处读取 length 个字节单元

调用方法：

1. public int read();
2. public int raed(byte[] b,int off,int len) 从源中读取数据存放到指定的数组中

---

​ ByteArraayOutputStream

ByteArrayOutputStream();
//构造的输出流指向一个默认大小32字节的缓冲区
/*******************************************************************************************/
ByteArrayOutputStream(int size);
构造的输出流指向一个默认大小为 size 字节的缓冲区

调用方法：

1. public void write(int b)
2. public void write(byte[] b,int off,int len) 将 b 中的字节写入到缓冲区中

---

数据流

特点：读取数据时不必关心这个数据应当是多少字节

• DataInputStream 数据输入流

DataInputStream(InputStream in);
//创建的（数据输入流）指向一个由参数 in 指定的（底层输入流）

• DataOutputStream 数据输出流

DataOutputStream(OutputStraem out);
//创建的（数据输出流）指向一个由参数 out 指定的（底层输出流）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AzwpzEg8-1668752538181)(D:\桌面\screenshot\21.jpg)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FMn0a0fU-1668752538182)(D:\桌面\screenshot\22.jpg)]

对象流

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tGjDWguz-1668752538182)(D:\桌面\screenshot\23.jpg)]

为了将对象写入文件，并能在把对象正常的读回到程序中。使用对象流写入或读入对象时需保证对象时序列化对象

• 类实现 Serializable 接口，该类创建的对象为序列化对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-G4rUXh4D-1668752538182)(D:\桌面\screenshot\25.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aYD4dJ10-1668752538183)(D:\桌面\screenshot\24.png)]

序列化与对象克隆

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0tViLXNT-1668752538184)(D:\桌面\screenshot\26.jpg)]

public class WindowClone002 extends JFrame implements ActionListener {
JTextArea text = null;          //创建文本区
JButton button;                 //创建按钮
WindowClone002(){
  setLayout(new FlowLayout());        //设置窗口布局
  text = new JTextArea(5,8);     //设置文本区的行数与列数
  button = new JButton("按下即可复制");
  button.addActionListener(this);             //向按钮绑定监视器
  setVisible(true);                             //设置窗口可见性
  add(new JScrollPane(text));                   //设置滚动窗格，并将其添加到窗口面板
  add(button);                                  //将按钮添加到窗口面板上
  setSize(580,300);               //设置窗口面板的大小
  setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置窗口关闭模式
}
/**************************************监听器监听动作****************************************/
public void actionPerformed(ActionEvent e){
  try {
 /********************************输出流（写入）*********************************/
      ByteArrayOutputStream OutOne = new ByteArrayOutputStream(); //创建输出流对象
      ObjectOutputStream OutTwo = new ObjectOutputStream(OutOne); //创建指向输出流的对象流
      OutTwo.writeObject(text);       //将文本区内容写入到对象流指定的目的地

 /********************************输入流（读入）********************************/
      ByteArrayInputStream InOne = new ByteArrayInputStream(OutOne.toByteArray());
      //toByteArray一个字节流转换为一个 byte数组
      ObjectInputStream InTwo = new ObjectInputStream(InOne);

 /**********************************克隆***********************************/
      JTextArea cloneText = (JTextArea) InTwo.readObject();
      cloneText.setBackground(Color.CYAN);
      this.add(new JScrollPane(cloneText));
      this.validate();

  } catch (Exception ex) {
      ex.printStackTrace();
  }

}
}

public class Example002 {
public static void main (String[] args){
  WindowClone002 win = new WindowClone002();
}
}

泛型与集合框架

泛型

泛型类

class 名称 <泛型列表>{
类体
}

<泛型列表> 给出的泛型可作为：1.类的成员变量的类型 2.方法的类型 3.局部变量的类型

使用泛型类声明对象：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9utcDvA0-1668752538184)(D:\桌面\screenshot\27.jpg)]

public class Student<E>{
E SEX;		//用泛型类 E 声明变量对象
}

1. 泛型变量只能调用从 Object 类继承或重写的方法

泛型接口

//声明泛型接口
public interface 接口名称 <泛型列表>{
接口体
}

1.未传入泛型实参时

class FruitGenerator<T> implements Generator<T>{
   @Override
   public T next() {
      	return null;
   }
}

2.传入泛型实参时

public class FruitGenerator implements Generator<String> {

	private String[] fruits = new String[]{"Apple", "Banana", "Pear"};

	@Override
	public String next() {
  		Random rand = new Random();
  		return fruits[rand.nextInt(3)];
	}
}

泛型方法

/*
* 泛型方法的基本介绍
* param tClass 传入的泛型实参
* return T 返回值为T类型
* 说明：
*     1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
*     2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
*     3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
*     4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
*/
public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,
IllegalAccessException{
      T instance = tClass.newInstance();
      return instance;
}

泛型类的泛型方法

//设GenerateTest 为泛型类 则有：

class GenerateTest<T>{
  public void show_1(T t){
      System.out.println(t.toString());
  }

  //在泛型类中声明了一个泛型方法，使用泛型E，这种泛型E可以为任意类型。可以类型与T相同，也可以不同。
  //由于泛型方法在声明的时候会声明泛型<E>，因此即使在泛型类中并未声明泛型，编译器也能够正确识别泛型方法中识别的泛型。
  public <E> void show_2(E t){
      System.out.println(t.toString());
  }

  //在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型。
  public <T> void show_3(T t){
      System.out.println(t.toString());
  }
}

泛型数组

LinkedList < E > 泛型类

• 声明和创建链表对象时，必须指定 E 的具体类
• 该类创建的对象以链表结构储存数据（链表对象）

LinkedList <String> mylist = new LinkedList <String> ();	//普通创建链表对象 mylist

LinkedList <String> mylist = new LinkedList (Collection <? extends String> C);
//使用集合创建链表

• mylist 调用 add（E obj） 向链表增加结点、

mylist.add("结点");

LiinkedList 泛型类实现List 接口常用方法	方法描述
1.public boolean add(E element)	链表尾添加结点，element指定结点中的数据
2.public void add(int index,E element)	链表指定位置添加结点，element指定结点中的数据
3.public void clear()	删除链表中的所有结点
4.public E remove(int index)	删除指定位置上的结点
5.public boolean remove(E element)	删除首次出现含有数据 element 出现的结点
6.public E get(int index)	得到链表中指定位置处结点中的数据
7.public int indexOf(E element)	返回首次出现含有数据 element 出现的结点的位置，无则返回-1
8.public int lastIndexOf(E element)	返回最后出现含有数据 element 出现的结点的位置，无则返回-1
9.public E set(int index,E element)	将链表 index 位置结点中的数据，替换为 element
10.public int size()	返回链表的长度（结点的个数）
11.public boolean contains(Object element)	判断链表中是否有结点含有数据 element
LinkedList 泛型类本身的方法	描述
12.public void addFirst(E element)	链表头添加结点，element 为指定结点中的数据
13.public void addLast(E element)	链表尾添加结点，element 为指定结点中的数据
14.public E getFirst()	得到链表第一个结点中的数据
15.public E getLast()	得到链表最后结点中的数据
16.public E removeFirst()	删除第一个结点，并返回结点中的数据
17.public E removeLast()	删除最后的结点，并返回结点中的数据
18.public Object clone()	得到一个克隆链表

常用方法（没整理）

方法	描述
public boolean add(E e)	链表末尾添加元素，返回是否成功，成功为 true，失败为 false。
public void add(int index, E element)	向指定位置插入元素。
public boolean addAll(Collection c)	将一个集合的所有元素添加到链表后面，返回是否成功，成功为 true，失败为 false。
public boolean addAll(int index, Collection c)	将一个集合的所有元素添加到链表的指定位置后面，返回是否成功，成功为 true，失败为 false。
public void addFirst(E e)	元素添加到头部。
public void addLast(E e)	元素添加到尾部。
public boolean offer(E e)	向链表末尾添加元素，返回是否成功，成功为 true，失败为 false。
public boolean offerFirst(E e)	头部插入元素，返回是否成功，成功为 true，失败为 false。
public boolean offerLast(E e)	尾部插入元素，返回是否成功，成功为 true，失败为 false。
public void clear()	清空链表。
public E removeFirst()	删除并返回第一个元素。
public E removeLast()	删除并返回最后一个元素。
public boolean remove(Object o)	删除某一元素，返回是否成功，成功为 true，失败为 false。
public E remove(int index)	删除指定位置的元素。
public E poll()	删除并返回第一个元素。
public E remove()	删除并返回第一个元素。
public boolean contains(Object o)	判断是否含有某一元素。
public E get(int index)	返回指定位置的元素。
public E getFirst()	返回第一个元素。
public E getLast()	返回最后一个元素。
public int indexOf(Object o)	查找指定元素从前往后第一次出现的索引。
public int lastIndexOf(Object o)	查找指定元素最后一次出现的索引。
public E peek()	返回第一个元素。
public E element()	返回第一个元素。
public E peekFirst()	返回头部元素。
public E peekLast()	返回尾部元素。
public E set(int index, E element)	设置指定位置的元素。
public Object clone()	克隆该列表。
public Iterator descendingIterator()	返回倒序迭代器。
public int size()	返回链表元素个数。
public ListIterator listIterator(int index)	返回从指定位置开始到末尾的迭代器。
public Object[] toArray()	返回一个由链表元素组成的数组。
public T[] toArray(T[] a)	返回一个由链表元素转换类型而成的数组。

---

遍历链表

• 链表对象调用 iterator（） 获取一个 itereator （迭代）对象，（该对象就是针对当前链表的迭代器）

public class example003 {
  public static void main(String []args){
      LinkedList<String> list = new LinkedList<String>();     //创建链表
      for(int i = 0;i <= 60096;i++){
          list.add("speed"+i);                                //添加结点
      }
/*******************************************************************************************/        
      Iterator<String>  iter = list.iterator();               //获得一个迭代对象iter
      long startTime = System.currentTimeMillis();		   //标记开始的时间位置
      while(iter.hasNext()){								 //使用该迭代器 iter
          String str = iter.next();
      }
      long endTime = System.currentTimeMillis();			    //标记结束时间的位置
      long result = endTime - startTime;					   //计算迭代器所用时间
      System.out.println("迭代器遍历集合："+result+"毫秒");
/*******************************************************************************************/
      startTime = System.currentTimeMillis();
      for(int i = 0;i < list.size();i++){
          String te = list.get(i);
      }
      endTime = System.currentTimeMillis();
      result = endTime - startTime;
      System.out.println("get()方法遍历集合所用时间："+result+"毫秒");
  }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EFt85QdE-1668752538184)(D:\桌面\screenshot\29.png)]

---

---

LinkedList 类（续）

（连接的列表---------链表）

• 可以在任何位置高效插入和删除的一个有序序列

1. Iterator 接口中没有 add ( ) 方法，子接口 ListIterator 中包含 add () 方法

2. ListIterator 接口中有两个方法（ 实现反向遍历链表 ）：

3. E previous ()

4. boolean hasPrevious () //返回越过的对象

5. 迭代器（ Iterator ( ) ）： { 迭代器的侧重指向为上一个最近的元素对象 }

6. LinkedList<String> staff = new LinkedList<String>();//创建链表 staff
   var staff = new LinkedList<String>();			   //创建链表 staff
                                                                                           
   ListIterator<String> iter = staff.listIterator();
   //调用listIterator()方法 
   //返回实现了 listIterator 接口的迭代器对象
   

7. 迭代器对象调用 add() 方法： 在迭代器位置之前添加一个新对象

   1. var staff = new LinkedList<String>();	//创建链表
      staff.add("Dog");	//添加结点
      staff.add("Pig");
      staff.add("Cat");
      ListIterator<String> iter = staff.listIterator();	//创建迭代器对象
      iter.next();	//迭代器位置下移{由（第一个与第二个结点之间的位置）到（第二个与第三个结点之间的位置）}
      //    注：第一个结点为指向第二个结点的空结点
      iter.add("Me");			//在此位置添加新结点
      

8. 迭代器调用 set()方法： 修改迭代器的侧重指向对象

   1. ListIterator<String> iter = staff.listIterator();		//创建链表
      String oldValue = iter.next();		//返回第二个结点的数据对象
      iter.set("newValue");			   //更改该节结的数据
      

public class linkedList {
  public static void main(String[] args){
      var a = new LinkedList<String>();   //创建链表a
      a.add("Wuxiaolong");                //添加结点
      a.add("yudongrong");
      a.add("ducongjiang");

      var b = new LinkedList<String>();   //创建链表b
      b.add("zhangsan");                  //添加结点
      b.add("lisi");
      b.add("hanmeimei");
      b.add("wangdachui");

  /**************merge the words from b into a******************/
      ListIterator<String> iterA = a.listIterator();      //创建链表a的迭代器
      ListIterator<String> iterB = b.listIterator();      //创建链表b的迭代器
      while(iterB.hasNext()){                             //判断迭代对象iterB的指向是否存在
          if(iterA.hasNext())
              iterA.next();                        //迭代器iterA指向下一个位置
          iterA.add(iterB.next());                 //添加iterB的侧重指向对象到iterA当前的位置中（左侧重）
      }
      System.out.println(a);
      System.out.println(b);
      System.out.println("****************");
  /**************remove every first word from b**************/
      while(iterB.hasPrevious()){			  //反向迭代列表
          iterB.previous();                   //（右侧重）
          iterB.previous();
          iterB.remove();
      }
      System.out.println(b);
      System.out.println("******************");
  /***************remove every second word from a***************/
      iterA = a.listIterator();
      while(iterA.hasNext()){
          iterA.next();
          if(iterA.hasNext()){
              iterA.next();
              iterA.remove();
          }
      }
      System.out.println(a);
      System.out.println("******************");
  }
}

ArrayList 类

( 有类型参数的泛型类 )

ArrayList<E> staff = new ArrayList<E>();  	//创建一个数组列表
ArrayList<E> staff = new ArrayList<>();	    //创建一个数组列表
var staff = new ArrayList<E>();			   //创建一个数组列表

1. staff.ensuraCapacity(100) 创建容量为100的内部数组
2. staff.size() 返回数组列表中实际元素的个数
3. staff.trimToSize() 回收多余的储存空间（固定大小）

**java . util . ArrayList **

ArrayList<E>	创建空的数组列表
ArrayList<E>(int initialCapacity)	创建指定容量大小的数组列表
boolean add(E obj)	在数组列表尾追加一个元素
int size()	返回数组列表中的元素个数
void ensureCapacity ( int capacity )	确保数组列表在不重新分配内部储存数组的情况下，有足够的容量储存给定数量的元素
void trimToSize	回收多余的储存空间
E set(int index,E obj)	将值obj放到数组列表的指定位置，返回之前的内容
E get(int index)	得到指定位置储存的值
E remove(int index)	返回指定位置的元素，返回指定的元素
void add(int index,E obj)	将值obj插入到指定位置
subList(int A,int B)	截取A到B部分的元素
toArray()	将 arraylist 转换为数组
sort()	对 arraylist 元素进行排序
forEach()	遍历 arraylist 中每一个元素并执行特定操作
trimToSize()	将 arraylist 中的容量调整为数组中的元素个数
lastIndexOf()	返回指定元素在 arraylist 中最后一次出现的位置
removeRange()	删除 arraylist 中指定索引之间存在的元素

HashSet 散列集

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JsHhB0X0-1668752538185)(D:\桌面\screenshot\2022-4-13-1.png)]

• 集是没有重复元素的元素集合

• HashSet 中的元素实际上为对象

• 基本类型对应的包装类表如下：

  基本类型	引用类型
  boolean	Boolean
  byte	Byte
  short	Short
  int	Integer
  long	Long
  float	Float
  double	Double
  char	Character

• 散列表在JAVA中用链表数组的形式实现
• 每个列表被称为 桶

HashSet<String> hashSet = new HashSet<String>();		
//创建 保存String 字符串类型的 HashSet 对象 hashSet

方法	描述
add（）	添加元素
boolean contanins()	判断元素在集合中是否存在
remove()	删除元素
clear()	删除集合中所有元素
public boolean isEmpty()	判断集合是否为空
public Object clone()	克隆

集合的 交集、并集和差集：

交集：boolean retainAll(HashSet set)

并集：boolean addAll(HashSet set)

差集：boolean removeAll(HashSet set)

---

java.util.HashSet

HashSet()	创建一个空的散列表
HashSet( Collection <? extends E> elements)	创建一个散列表，将集合中的所有元素添加到其中
HashSet(int initialCapacity)	创建指定初始容量(桶数)的散列表
HashSet(int initialCapacity,float loadFactor)	创建指定容量与装填因子(0.0~1.0)的散列表

java.lang.Objct

int hashCode()	返回对象的散列码

TreeSet 树集

• 有序集合
• 使用树集，必须能够比较元素：即元素必须实现 Comparable 接口
• 其迭代：按照有序顺序进行访问元素

TreeSet <String> tSet = new TreeSet <String> ();		//创建树集对象
var tSet = new TreeSet <String> ();				//创建树集对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iiG2ec8z-1668752538185)(D:\桌面\screenshot\2022-4-15-01.png)]

java.util.TreeSet

TreeSet()
TreeSet(Comparator <? super E> comparator)	构建一个空树集
TreeSet(Collection<? extends E elements)
TreeSet(SortedSet <E> s)	构建一个树集，并增加一个集合或有序集中的所有元素

java.util.SortedSet

Comparator<? super E> comparator()	返回对元素进行排序的比较器，若元素用Comparable接口的compareTo方法进行比较则返回null
E first() ; E last()	返回有序集中的最小元素或者最大元素

java.util.NavigableSet

E heiger (E value) ; E lower (E value)	返回大于value的最小元素 或 小于value的最大元素 ，否则返回null
E ceiling(E value) ; E floor(E value)	返回大于等于value的最小元素 或 小于等于value的最大元素 ，否则返回null
E pollFirst() ; E pollLast()	删除并返回这个集中的最大元素或最小元素，集为空时返回null
Iterator<E> descendingIterator()	返回一个按递减顺序遍历集中的元素的迭代器

TreeSet 类的常用方法

public boolean add(E obj)	向树集添加结点，节点数据为obj。
public void clear()	删除树集中的所有结点
public void contains(Object obj)	判断树集中是否含有参数指定的对象
public E first()	返回树集最小结点中的数据
public E last()	返回树集最大结点中的数据
public isEmpty()	判断是否为空树集
public boolean remove(Object obj)	删除树集中储存参数指定的对象的最小结点
public int size()	返回树集中结点的数目

Heap 堆

1. Heap 堆也可叫 Priority Queue 优先队列
2. 从堆取出的元素是按照元素的优先级大小
3. **

---

创建堆

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kQH9zMVA-1668752538186)(D:\桌面\screenshot\2022-4-15-02.png)]

date = (T[]) new Object[capacity+1] //创建储存capacity+1个元素的数组

---

堆的 Shift Up 操作 : 向最大堆添加元素

（ 最大堆 ：根结点最大 ）

public class HeapExample<T extends Comparable> {			//继承比较类

protected T[] data;         //堆的元素
protected int count;        //下标记数
protected int capacity;     //堆的容量

// 构造函数, 构造一个空堆, 可容纳capacity个元素
public HeapExample(int capacity){
    data = (T[])new Comparable[capacity+1];
    count = 0;
    this.capacity = capacity;
}
// 返回堆中的元素个数
public int size(){
    return count;
}

// 返回一个布尔值, 表示堆中是否为空
public boolean isEmpty(){
    return count == 0;
}
// 像最大堆中插入一个新的元素 item
public void insert(T item){
    assert count + 1 <= capacity;           //判断：当该语句为True时，执行之后的代码语句
    data[count+1] = item;               //将数据依次赋值给堆的结点
    count ++;                       //对接点下标的记数
    shiftUp(count);                   //调用“shiftUp（）”依次进行升堆操作
}
// 交换堆中索引为i和j的两个结点中的元素
private void swap(int i, int j){
    T t = data[i];
    data[i] = data[j];
    data[j] = t;
}

//********************
//* 最大堆核心辅助函数
//********************
private void shiftUp(int k){
   while( k > 1 && data[k/2].compareTo(data[k]) < 0 ){//判断该位置结点与其父节点的大小比较
        swap(k, k/2);               //交换对应子，父结点的元素
        k /= 2;
   }
}

// 测试 HeapShiftUp
public static void main(String[] args) {
    HeapExample<Integer> heapShiftUp = new HeapExample<Integer>(100);
    int N = 50; // 堆中元素个数
    int M = 100; // 堆中元素取值范围[0, M)
    for( int i = 0 ; i < N ; i ++ )
        heapShiftUp.insert( new Integer((int)(Math.random() * M)) );
    System.out.println(heapShiftUp.size());

}
}

---

堆的 Shift down 操作 ： 取出最大堆的元素

只能取出最大优先级的元素

public class ShiftDownExample<T extends Comparable> {

 protected T[] data;          //储存数据的数组
 protected int count;         //记录数据的下标
 protected int capacity;      //设置堆的容量

 // 构造函数, 构造一个空堆, 可容纳capacity个元素
 public ShiftDownExample(int capacity){
 //这里加1是指原来能装的元素个数，那去掉0位，只能装capacity个元素
     data = (T[])new Comparable[capacity+1];      //创建T[]类型的Comparable可比较的数据数组,这个数组的大小为capacity+1
     count = 0;                              
     this.capacity = capacity;
 }
 // 返回堆中的元素个数
 public int size(){
     return count;
 }

 // 返回一个布尔值, 表示堆中是否为空
 public boolean isEmpty(){
     return count == 0;
 }

 // 获取最大堆中的堆顶元素
 public T getMax(){
     assert( count > 0 );
     return data[1];
 }

 // 像最大堆中插入一个新的T类型的元素 item
 public void insert(T item){

     assert count + 1 <= capacity;       //判断<=是否成立，相当于if
     data[count+1] = item;
     count ++;
     shiftUp(count);
 }

 // 交换堆中索引为i和j的两个元素
 private void swap(int i, int j){
     T t = data[i];
     data[i] = data[j];
     data[j] = t;
 }

 // 从最大堆中取出堆顶元素, 即堆中所存储的最大数据
 public T extractMax(){                  //提取最大元素
     assert count > 0;
     T ret = data[1];
     swap( 1 , count );
     count --;
     shiftDown(1);
     return ret;
 }

 //********************
 //* 最大堆核心辅助函数
 //********************
 private void shiftUp(int k){

     while( k > 1 && data[k/2].compareTo(data[k]) < 0 ){
         swap(k, k/2);
         k /= 2;
     }
 }

 //shiftDown操作
 private void shiftDown(int k){
     while( 2*k <= count ){
         int j = 2*k; // 在此轮循环中,data[k]和data[j]交换位置
         if( j+1 <= count && data[j+1].compareTo(data[j]) > 0 )
             j ++;
         // data[j] 是 data[2*k]和data[2*k+1]中的最大值
         if( data[k].compareTo(data[j]) >= 0 ) break;
         swap(k, j);
         k = j;
     }
     System.out.println("shiftDown结束");
 }

 // 测试 HeapShiftDown
 public static void main(String[] args) {
     ShiftDownExample<Integer> heapShiftDown = new ShiftDownExample<Integer>(10);
     // 堆中元素个数
     int N = 10;
     // 堆中元素取值范围[0, M)
     int M = 10;
     for( int i = 0 ; i < N ; i ++ )
         heapShiftDown.insert( (int)(Math.random() * M));
     Integer[] arr = new Integer[N];
     // 将最大堆中的数据逐渐使用extractMax取出来
     // 取出来的顺序应该是按照从大到小的顺序取出来的
     for( int i = 0 ; i < N ; i ++ ){
         arr[i] = heapShiftDown.extractMax();
         System.out.print(arr[i] + " ");
     }
     // 确保arr数组是从大到小排列的
     for( int i = 1 ; i < N ; i ++ )
         assert arr[i-1] >= arr[i];
 }
}

---

Heapfiy 排序法

• 对于完全二叉树：从第一个非叶子节点开始进行排序

public class HeapfiyExample<T extends Comparable>{
  protected T[] data;			//存储数据的堆数组
  protected int count;		//堆实际元素的个数
  protected int capacity;		//堆的容量

  //通过给定数组创建一个最大堆，时间复杂度为O(n)
  public HeapfiyExample(T array[]){
      int n = array.length;
      data = (T[])new Comparable[n+1];
      capacity = n;
      for(int i = 0 ; i < n ; i ++){
          data[i+1] = array[i];
      }
      count = n;
      //从第一个不是叶节点的位置开始
      for(int i = count/2 ; i >= 1 ; i --){
          ShiftDown(i);
      }
  }
  /*************************************************/
  //返回堆中的元素个数
  public int Size(){
      return count;
  }
  //判断堆是否为空
  public boolean isEmpty(){
      return count == 0;
  }
  /***************************************************/

  //获取最大堆的堆顶元素
  public T getMax(){
      assert(count > 0);
      return data[1];
  }
  //交换堆中的两个元素
  public void Swap(int i,int j){
      T t = data[i];
      data[i] = data[j];
      data[j] = t;
  }
  //最大堆元素进行排序  (第一次建立的排序)
  public void ShiftUp(int k){
      while(k > 1&&data[k].compareTo(data[k/2]) > 0){
          Swap(k,k/2);
          k/=2;
      }
  }
  //向最大堆插入元素   (创建有内容的最大堆)
  public void insert(T item){
      assert count + 1 <= capacity;
      data[count+1] = item;
      count ++;
      ShiftUp(count);
  }
  /*****************************************************************************/
  //取出最大元素后，堆的排序操作
  public void ShiftDown(int k){
      while( 2*k <=  count){
          int j = 2*k; // 在此轮循环中,data[k]和data[j]交换位置
          if( j+1 <= count && data[j+1].compareTo(data[j]) > 0 )
              j ++;
          // data[j] 是 data[2*k]和data[2*k+1]中的最大值
          if( data[k].compareTo(data[j]) >= 0 ) break;
          Swap(k, j);
          k = j;
      }
  }

  //取出堆中的元素（最大优先）
  public T extractMax(){
      assert count > 0;
      T ret = data[1];
      Swap(1,count);
      count--;
      ShiftDown(1);
      return  ret;
  }
  /******************************************************************************/
  public static void main(String[] args){
      Integer []array = {45,4,1,2,5,7,12,2,5,4};
      HeapfiyExample<Integer> heapfiy = new HeapfiyExample<>(array);
      for(int i = 0; i < 9; i++ ){
          array[i] = heapfiy.extractMax();
          System.out.println(array[i]+" ");
      }
  }
}

---

HeapSort 优化堆排序

进行优化，使用原地堆排序

public class HeapSortExample<T extends Comparable> {


   public static void sort(Comparable[] arr) {

       int n = arr.length;

       // 注意，此时我们的堆是从0开始索引的
       // 从(最后一个元素的索引-1)/2开始
       // 最后一个元素的索引 = n-1
       for (int i = (n - 1 - 1) / 2; i >= 0; i--)
           shiftDown(arr, n, i);

       for (int i = n - 1; i > 0; i--) {
           swap(arr, 0, i);
           shiftDown(arr, i, 0);
       }
   }

   // 交换堆中索引为i和j的两个元素
   private static void swap(Object[] arr, int i, int j) {
       Object t = arr[i];
       arr[i] = arr[j];
       arr[j] = t;
   }

   // 原始的shiftDown过程
   private static void shiftDown(Comparable[] arr, int n, int k) {

       while (2 * k + 1 < n) {
           //左孩子节点
           int j = 2 * k + 1;
           //右孩子节点比左孩子节点大
           if (j + 1 < n && arr[j + 1].compareTo(arr[j]) > 0)
               j += 1;
           //比两孩子节点都大
           if (arr[k].compareTo(arr[j]) >= 0) break;
           //交换原节点和孩子节点的值
           swap(arr, k, j);
           k = j;
       }
   }

   // 测试 HeapSort
   public static void main(String[] args) {
       Integer []array = {45,4,1,2,5,7,12,2,5,4};
       sort(array);
       // 将heapify中的数据逐渐使用extractMax取出来
       // 取出来的顺序应该是按照从大到小的顺序取出来的
       for (int i = 0; i < 9; i++) {
           System.out.print(array[i] + " ");
       }
       // 确保arr数组是从大到小排列的
       for (int i = 1; i < 10; i++)
           assert array[i - 1] >= array[i];
   }
}

---

IndexMaxHeap 索引堆

• 索引堆使用了一个新的 int 类型的数组，用于存放索引信息
• 优点：加入的数据位置固定，方便寻找。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nG2wRBA9-1668752538186)(D:\桌面\screenshot\2022-4-18-02.png)]

如果堆中存储的元素较大，可以用索引堆的数据结构进行替代，堆中存储的是数组的索引，我们相应操作的是索引。

---

Queue 队列 与 Deque 双端队列 与 PriorityQueue 优先队列

双端队列（deque）：允许在头部和尾部添加删除元素

ArrayDeque 和 LinkedList 实现了 Deque 接口

java.util.Queue 队列

boolean add(E elelment)	若队列未满，添加元素至队尾并返回 true；若队列已满，抛出 IllegalStateException 非法状态异常
boolean offer(E elelment)	若队列未满，添加元素至队尾并返回 true；若队列已满，返回 false
E remove()	若队列不为空，删除并返回队列的队头元素；若队列为空，抛出 NoSuchElementException 无此元素异常
E poll()	若队列不为空，删除并返回队列的队头元素；若队列为空，返回 null
E element()	若队列不为空，返回队列对头的元素；若队列为空，抛出 NoSuchElementException 无此元素异常
E peek()	若队列不为空，返回队列对头的元素；若队列为空，返回 null

java.util.Deque 双端队列

void addFirst(E element)
void addLast(E element)	将对象添加到双端队列的 队头或队尾；若队列已满，抛出 IllegaStateException 非法状态异常
boolean offerFirst(E element)
boolean offerLast(E element)	将对象添加到双端队列的 队头或队尾；若队列已满，返回 false
E removeFrist(E element)
E removeLsat(E element)	删除并返回 队头或队尾 的元素；若队列为空，抛出 NoSuchElementException 无此元素异常
E pollFirst()
E pollLast()	删除并返回 队头或队尾 的元素；若队列为空，返回 null
E peekFirst()
E peekLast()	返回 队头或队尾 的元素；若队列为空，抛出 NoSuchElementException 无此元素异常

java.util.ArrayDuque 数组双端队列

ArrayDeque()	用初始容量 16 创建一个无限定双端队列
ArrayDeque(int initialCapacity)	自定义初始容量，创建一个无限定双端队列

java.util.PriorityQueue 优先队列

• 1. 可以按照任意顺序插入

2. 按照有序顺序进行检索
3. （使用了堆结构）

• 典型用法：任务调度

  1. 一个任务对应一个优先级
  2. 任务以随机顺序添加到队列中
  3. 当启动一个新的任务时，都删除优先级最高的任务（删除（小-->大））

PriorityQueue()	创建一个存放Comparable类型对象的优先队列
PriorityQueue(int initialCapacity)	创建一个存放Comparable类型对象的容量为initialCapacity的优先队列
priorityQueue(int initialCapacity,Comparator<? super E> c)	创建优先队列，并使用指定的比较器对元素进行排序

public class PriorityQueueExample {
  public static void main(String [] args){
      var PQ = new PriorityQueue<LocalDate>();
      PQ.add(LocalDate.of(1000,8,9));
      PQ.add(LocalDate.of(1200,2,13));
      PQ.add(LocalDate.of(230,10,23));
      PQ.add(LocalDate.of(2200,4,16));
      PQ.add(LocalDate.of(9300,11,6));

      System.out.println(PQ);         //随机排序（插入）
      for (LocalDate date:PQ)
          System.out.println(date);

      System.out.println("*********************");

      while (!PQ.isEmpty())		  //删除操作（排序删除：小到大）	
          System.out.println(PQ.remove());
  }
}

---

映射 Map

• 映射用来存放键值对
• 1. HashMap 散列映射：对键进行散列
• 2. TreeMap 树映射：根据键的顺序将元素组织为搜索树
• 散列和比较函数只应用于 键

java.util.Map<K,V>

V get(Object key)	获取键的值（对象），若映射中没有该键的对象，返回 null
default V getOrDeafault(Object key,V defaultValue)	获取键的值（对象），若映射中没有找到该建，返回 defaultValue
V put(K key,V value)	将关联的键值对添加到映射中，若键存在则取代旧对象，返回旧对象；若键不存在则返回 null
void putAll(Map <? extends K,? extends V> entries)	将给定映射中的所有映射条目添加到这个映射中
boolean containsKey(Object key)	判断映射中是否存在该键，存在返回true
boolean containsValue(Object value)	判断映射中是否存在该值，存在返回true
default void forEach(BiConsumer<? super K,? super V> action)	对映射中所有的键值对应用这个动作

HashMap 散列映射

java.util.HashMap<K,V>

HashMap()
HashMap(int initailCapacity)
HashMap(int initailCapacity)
用给定容量和装填因子创建一个空的散列映射； 默认装填因子 = 0.75

HashMap 常用方法列表如下：

方法	描述
public void clear()	删除 hashMap 中的所有键/值对
public Object clone()	复制一份 hashMap
isEmpty()	判断 hashMap 是否为空
size()	计算 hashMap 中键/值对的数量
put()	将键/值对添加到 hashMap 中
putAll()	将所有键/值对添加到 hashMap 中
putIfAbsent()	如果 hashMap 中不存在指定的键，则将指定的键/值对插入到 hashMap 中。
public V remove(Object key)	删除 hashMap 中指定键 key 的映射关系，并返回删除的值
containsKey()	检查 hashMap 中是否存在指定的 key 对应的映射关系。
containsValue()	检查 hashMap 中是否存在指定的 value 对应的映射关系。
replace()	替换 hashMap 中是指定的 key 对应的 value。
replaceAll()	将 hashMap 中的所有映射关系替换成给定的函数所执行的结果。
public V get(Object Key)	获取指定 key 对应对 value
getOrDefault()	获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值
forEach()	对 hashMap 中的每个映射执行指定的操作。
entrySet()	返回 hashMap 中所有映射项的集合视图。
keySet()	返回 hashMap 中所有 key 组成的集合视图。
values()	返回 hashMap 中存在的所有 value 值。
merge()	添加键值对到 hashMap 中
compute()	对 hashMap 中指定 key 的值进行重新计算
computeIfAbsent()	对 hashMap 中指定 key 的值进行重新计算，如果不存在这个 key，则添加到 hasMap 中
computeIfPresent()	对 hashMap 中指定 key 的值进行重新计算，前提是该 key 存在于 hashMap 中。

TreeMap 树映射

树映射保证结点是按照结点中的关键字（键）key，升序排列。

java.util.TreeMap<K,V>

方法	描述
TreeMap （）	为实现Comparator的键，创建一个空的树映射
TreeMap（Comparator <? super K> V）	创建一个树映射，并使用指定的比较器对键进行升序排列
TreeMap（Map <? extends K,?extends V> entries）	创建一个树映射，并将某个映射中的所有映射条目添加到树映射中
TreeMap（SortedMap <? extends k,? extends V> entries）	创建一个树映射，将某个有序映射的所有映射条目添加到树映射中，并使用该有序映射相同的比较器

SortedMap 有序映射

java.util.SortedMap<K,V>

方法	描述
Comparator <? super K> comparator()	返回对键进行排序的比较器，若键是用Comparator接口的compareTo方法进行比较，则返回null
K firstKey（）
K lasiKey（）	返回映射中最小的键 或 最大的键

---

映射视图

1. 视图：键集，值集，键/值对集

Set <K> keySet;			//返回 键集视图
Collection <V> values;		//返回 值集视图
Set <Map.Entry<K,V>> entrySet;	//返回 键/值对视图

注：不能向键集添加元素

java.util.Map<K,V>

方法	描述
Set <Map.Entry < K,V >> entrySet()	返回Map.Entry对象 (键值对)的一个集视图， 能进行删除操作
Set <K> keySet()	返回映射中的键集视图 能进行删除操作
Collection <V> values()	返回映射中的值集视图 能进行删除操作

java.util.Map.Entry<K,V>

方法	描述
K getkey()	返回映射条目的 键
V getvalue()	返回映射条目的 值
V setValue(V newValue)	修改映射中的值，并返回旧值

链接散列集LinkedHashSet 与链接散列映射 LinkedHashMap（类）

• 会记住插入元素项的顺序

枚举集 EunmSet 与映射 EnumMap

---

集合框架

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XaF0QR6g-1668752538187)(D:\桌面\screenshot\2022-04-19-01.gif)]

1. 集合接口

序号	接口描述
1	**Collection **接口 Collection 是最基本的集合接口，一个 Collection 代表一组 Object，即 Collection 的元素, Java不提供直接继承自Collection的类，只提供继承于的子接口(如List和set)。Collection 接口存储一组不唯一，无序的对象。
2	**List **接口 List接口是一个有序的 Collection，使用此接口能够精确的控制每个元素插入的位置，能够通过索引(元素在List中位置，类似于数组的下标)来访问List中的元素，第一个元素的索引为 0，而且允许有相同的元素。List 接口存储一组不唯一，有序（插入顺序）的对象。
3	**Set **具有与 Collection 完全一样的接口，只是行为上不同，Set 不保存重复的元素。Set 接口存储一组唯一，无序的对象。
4	**SortedSet **继承于Set保存有序的集合。
5	Map 接口存储一组键值对象，提供key（键）到value（值）的映射。
6	Map.Entry 描述在一个Map中的一个元素（键/值对）。是一个 Map 的内部接口。
7	**SortedMap **继承于 Map，使 Key 保持在升序排列。
8	**Enumeration **这是一个传统的接口和定义的方法，通过它可以枚举（一次获得一个）对象集合中的元素。这个传统接口已被迭代器取代。Set和List的区别

Set和List的区别

• 1. Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。
• 2. Set 检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。
• 3. List 和数组类似，可以动态增长，根据实际存储的数据的长度自动增长 List 的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。

---

2. 集合实现（集合类）

序号	类描述
1	AbstractCollection 实现了大部分的集合接口。
2	AbstractList 继承于AbstractCollection 并且实现了大部分List接口。
3	AbstractSequentialList 继承于 **AbstractList **，提供了对数据元素的链式访问而不是随机访问。
4	LinkedList 该类实现了List接口，允许有null（空）元素。主要用于创建链表数据结构，该类没有同步方法，如果多个线程同时访问一个List，则必须自己实现访问同步，解决方法就是在创建List时候构造一个同步的List。例如：List list=Collections.synchronizedList(newLinkedList(...));LinkedList 查找效率低。
5	ArrayList 该类也是实现了List的接口，实现了可变大小的数组，随机访问和遍历元素时，提供更好的性能。该类是非同步的,在多线程下不要使用。ArrayList 增长当前长度的50%，插入删除效率低。
6	AbstractSet 继承于AbstractCollection 并且实现了大部分Set接口。
7	HashSet该类实现了Set接口，不允许出现重复元素，不保证集合中元素的顺序，允许包含值为null的元素，但最多只能一个。
8	**LinkedHashSet **具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。
9	TreeSet 该类实现了Set接口，可以实现排序等功能。
10	AbstractMap 实现了大部分的Map接口。
11	HashMap是一个散列表，它存储的内容是键值对(key-value)映射。 该类实现了Map接口，根据键的HashCode值存储数据，具有很快的访问速度，最多允许一条记录的键为null，不支持线程同步。
12	TreeMap 继承了AbstractMap，并且使用一颗树。
13	WeakHashMap 继承AbstractMap类，使用弱密钥的哈希表。
14	LinkedHashMap 继承于HashMap，使用元素的自然顺序对元素进行排序.
15	IdentityHashMap 继承AbstractMap类，比较文档时使用引用相等。

java.util包中定义的类，如下所示：

序号	类描述
1	Vector 该类和ArrayList非常相似，但是该类是同步的，可以用在多线程的情况，该类允许设置默认的增长长度，默认扩容方式为原来的2倍。
2	Stack 栈是Vector的一个子类，它实现了一个标准的 后进先出的栈。
3	Dictionary 字典 类是一个抽象类，用来存储键/值对，作用和Map类相似。
4	**Hashtable **是 Dictionary(字典) 类的子类，位于 java.util 包中。
5	**Properties ** 继承于 Hashtable，表示一个持久的属性集，属性列表中每个键及其对应值都是一个字符串。
6	BitSet 一个Bitset类创建一种特殊类型的数组来保存位值。BitSet中数组大小会随需要增加。

---

3. 集合算法

• 集合框架定义了集合类的静态方法，可用于集合(set)和映射(map);
• 迭代器 （Iterator）：通过循环遍历来得到或删除集合的元素
• 比较器 （Comparator）

---

映射遍历

public class mapIteratorExample {
   public static void main(String[] args){
       var map = new HashMap<Integer,String>();
       map.put(1,"杜甫");
       map.put(2,"李白");
       map.put(3,"白居易");
       map.put(4,"王羲之");
   //第一种遍历方法：普遍使用，二次取值
       for (Integer key:map.keySet()) {
           System.out.println(map.get(key));
       }

   //第二种遍历方法：Iterator 迭代器
       var iter= map.entrySet().iterator();
       while(iter.hasNext()){
           Map.Entry<Integer, String> entry = iter.next();
           System.out.println(entry.getValue());
       }

   //第三种遍历方法：（大容量时适用）推荐
       for (Map.Entry<Integer,String> entry :map.entrySet()) {
           System.out.println(entry.getValue());
       }
   }
}

数组遍历

public class traversalArrayList {
   public static void main(String [] args){
       var arrayList = new ArrayList<String>();
       arrayList.add("李白");
       arrayList.add("杜甫");
       arrayList.add("杜牧");
   //第一种遍历方法：For-Each 遍历，二次取值
       for (String str: arrayList){
       System.out.println(str);
       }
   //第二种遍历方法：将链表变为数组相关的内容进行遍历
       String[] stringArray = new String[arrayList.size()];
       arrayList.toArray(stringArray);
       for (int i = 0;i < arrayList.size();i ++){
           System.out.println(stringArray[i]);
       }
   //第三种遍历方法：使用Iterator迭代器
       Iterator iter = arrayList.iterator();
       while(iter.hasNext()){
           System.out.println(iter.next());
       }
   }
}

---

---

算法

• 简单实用的算法

算法
static <T extends Comparable<? super T>> T min(Collection<T> elements)
static <T extends Comparable<? super T>> T max(Collection<T> elements)
static <T> min(Collection<T> elements, Coamparable<? super T> c)
static <T> max(Collection<T> elements, Coamparable<? super T> c)	返回集合中最小或者最小的元素
static <T> void copy(List<? super T>to,List<T> from)	将原列表的所有元素复制到目标列表的相应位置上
static <T> void fill(List<? super T>L,T,value)	将列表所有位置设置为相同的值
static <T> boolean replaceAll(List<T> L,T oldValue,T newValue)	用newValue 替换所有 oldValue
static <T> boolean addAll(Colleaction<? super T>c, T...values)	将所有的值添加到集合 c 中。若集合改变了，返回true
static int indexOfSubList(List <?> L, List <?> S)
static int LastindexOfSubList(List <?> L, List <?> S)	返回 L中第一个或最后一个等于 S 的子列表的索引。【例：L为[ a,b,c ]，S为 [ b,c ] 则返回索引 1】
static void swap(List <?> L, int i, int j)	交换给定偏移位置的两个元素
static void reverse(List <?> L)	逆置列表 L 中元素的顺序
static void rotate(List <?> L, int d)	旋转列表 L 中的元素。将索引为 i 的元素移动到位置 （i+d）%L.size()
sattic int frequency(Collection <?> C, Object O)	返回 C 中与对象 O 相等的元素的个数
static disjoint(Collection <?> C,Collection <?> D)	若两个集合没有共同元素，则返回 true

返回值	描述
static <T> boolean	addAll(Collection<? super T> c, T... elements)将所有指定的元素添加到指定的集合。
static <T> Queue<T>	asLifoQueue(Deque<T> deque)返回Deque作为先进先出（ Lifo ） Queue的视图 。
static <T> int	binarySearch(List<? extends Comparable<? super T>> list, T key)使用二叉搜索算法搜索指定对象的指定列表。
static <T> int	binarySearch(List<? extends T> list, T key, Comparator<? super T> c)使用二叉搜索算法搜索指定对象的指定列表。
static <E> Collection<E>	checkedCollection(Collection<E> c, 类<E> type)返回指定集合的动态类型安全视图。
static <E> List<E>	checkedList(List<E> list, 类<E> type)返回指定列表的动态类型安全视图。
static <K,V> Map<K,V>	checkedMap(Map<K,V> m, 类<K> keyType, 类<V> valueType)返回指定地图的动态类型安全视图。
static <K,V> NavigableMap<K,V>	checkedNavigableMap(NavigableMap<K,V> m, 类<K> keyType, 类<V> valueType)返回指定可导航地图的动态类型安全视图。
static <E> NavigableSet<E>	checkedNavigableSet(NavigableSet<E> s, 类<E> type)返回指定的可导航集的动态类型安全视图。
static <E> Queue<E>	checkedQueue(Queue<E> queue, 类<E> type)返回指定队列的动态类型安全视图。
static <E> Set<E>	checkedSet(Set<E> s, 类<E> type)返回指定集合的动态类型安全视图。
static <K,V> SortedMap<K,V>	checkedSortedMap(SortedMap<K,V> m, 类<K> keyType, 类<V> valueType)返回指定排序映射的动态类型安全视图。
static <E> SortedSet<E>	checkedSortedSet(SortedSet<E> s, 类<E> type)返回指定排序集的动态类型安全视图。
******************************************************************	**********************************************************************************************************************************************************************************************************************************************************************************
static <T> void	copy(List<? super T> dest, List<? extends T> src)将所有元素从一个列表复制到另一个列表中。
static boolean	disjoint(Collection<?> c1, Collection<?> c2)如果两个指定的集合没有共同的元素，则返回 true 。
static <T> Enumeration<T>	emptyEnumeration()返回没有元素的枚举。
static <T> Iterator<T>	emptyIterator()返回没有元素的迭代器。
static <T> List<T>	emptyList()返回空列表（immutable）。
static <T> ListIterator<T>	emptyListIterator()返回没有元素的列表迭代器。
static <K,V> Map<K,V>	emptyMap()返回空的地图（不可变）。
static <K,V> NavigableMap<K,V>	emptyNavigableMap()返回空导航地图（不可变）。
static <E> NavigableSet<E>	emptyNavigableSet()返回一个空导航集（immutable）。
static <T> Set<T>	emptySet()返回一个空集（immutable）。
static <K,V> SortedMap<K,V>	emptySortedMap()返回空的排序映射（immutable）。
static <E> SortedSet<E>	emptySortedSet()返回一个空的排序集（immutable）。
static <T> Enumeration<T>	enumeration(Collection<T> c)返回指定集合的枚举。
static <T> void	fill(List<? super T> list, T obj)用指定的元素代替指定列表的所有元素。
static int	frequency(Collection<?> c, Object o)返回指定集合中与指定对象相
static int	indexOfSubList(List<?> source, List<?> target)返回指定源列表中指定目标列表的第一次出现的起始位置，如果没有此类事件，则返回-1。
static int	lastIndexOfSubList(List<?> source, List<?> target)返回指定源列表中指定目标列表的最后一次出现的起始位置，如果没有此类事件则返回-1
static <T> ArrayList<T>	list(Enumeration<T> e)返回一个数组列表，其中包含由枚举返回的顺序由指定的枚举返回的元素。
static <T extends Object & Comparable<? super T>>T	max(Collection<? extends T> coll)根据其元素的 自然顺序返回给定集合的最大元素。
static <T> T	max(Collection<? extends T> coll, Comparator<? super T> comp)根据指定的比较器引发的顺序返回给定集合的最大元素。
static <T extends Object & Comparable<? super T>>T	min(Collection<? extends T> coll)根据其元素的 自然顺序返回给定集合的最小元素。
static <T> T	min(Collection<? extends T> coll, Comparator<? super T> comp)根据指定的比较器引发的顺序返回给定集合的最小元素。
static <T> List<T>	nCopies(int n, T o)返回由指定对象的 n副本组成的不可变列表。
static <E> Set<E>	newSetFromMap(Map<E,Boolean> map)返回由指定地图支持的集合。
static <T> boolean	replaceAll(List<T> list, T oldVal, T newVal)将列表中一个指定值的所有出现替换为另一个。
static void	reverse(List<?> list)反转指定列表中元素的顺序。
static <T> Comparator<T>	reverseOrder()返回一个比较器，它对实现 Comparable接口的对象集合施加了 自然排序的相反。
static <T> Comparator<T>	reverseOrder(Comparator<T> cmp)返回一个比较器，它强制指定比较器的反向排序。
static void	rotate(List<?> list, int distance)将指定列表中的元素旋转指定的距离。
static void	shuffle(List<?> list)使用默认的随机源随机排列指定的列表。
static void	shuffle(List<?> list, Random rnd)使用指定的随机源随机排列指定的列表。
static <T> Set<T>	singleton(T o)返回一个只包含指定对象的不可变集。
static <T> List<T>	singletonList(T o)返回一个只包含指定对象的不可变列表。
static <K,V> Map<K,V>	singletonMap(K key, V value)返回一个不可变的地图，只将指定的键映射到指定的值。
static <T extends Comparable<? super T>>void	sort(List<T> list)根据其元素的natural ordering对指定的列表进行排序。
static <T> void	sort(List<T> list, Comparator<? super T> c)根据指定的比较器引起的顺序对指定的列表进行排序。
static void	swap(List<?> list, int i, int j)交换指定列表中指定位置的元素
static <T> Collection<T>	synchronizedCollection(Collection<T> c)返回由指定集合支持的同步（线程安全）集合。
static <T> List<T>	synchronizedList(List<T> list)返回由指定列表支持的同步（线程安全）列表。
static <K,V> Map<K,V>	synchronizedMap(Map<K,V> m)返回由指定地图支持的同步（线程安全）映射。
static <K,V> NavigableMap<K,V>	synchronizedNavigableMap(NavigableMap<K,V> m)返回由指定的可导航地图支持的同步（线程安全）可导航地图。
static <T> NavigableSet<T>	synchronizedNavigableSet(NavigableSet<T> s)返回由指定的可导航集支持的同步（线程安全）可导航集。
static <T> Set<T>	synchronizedSet(Set<T> s)返回由指定集合支持的同步（线程安全）集。
static <K,V> SortedMap<K,V>	synchronizedSortedMap(SortedMap<K,V> m)返回由指定的排序映射支持的同步（线程安全）排序映射。
static <T> SortedSet<T>	synchronizedSortedSet(SortedSet<T> s)返回由指定的排序集支持的同步（线程安全）排序集。
static <T> Collection<T>	unmodifiableCollection(Collection<? extends T> c)返回指定集合的不可修改视图。
static <T> List<T>	unmodifiableList(List<? extends T> list)返回指定列表的不可修改视图。
static <K,V> Map<K,V>	unmodifiableMap(Map<? extends K,? extends V> m)返回指定地图的不可修改视图。
static <K,V> NavigableMap<K,V>	unmodifiableNavigableMap(NavigableMap<K,? extends V> m)返回指定可导航地图的不可修改视图。
static <T> NavigableSet<T>	unmodifiableNavigableSet(NavigableSet<T> s)返回指定的可导航集合的不可修改的视图。
static <T> Set<T>	unmodifiableSet(Set<? extends T> s)返回指定集合的不可修改视图。
static <K,V> SortedMap<K,V>	unmodifiableSortedMap(SortedMap<K,? extends V> m)返回指定排序映射的不可修改视图。
static <T> SortedSet<T>	unmodifiableSortedSet(SortedSet<T> s)返回指定排序集的不可修改视图。

1. 排序与混排

• Collections 类中的 sort（） 方法可以对实现了 List 接口的集合进行排序

• 集合类库的排序（归并排序）：将所有元素转入一个数组中；对数组进行排序；再将排序后的序列复制回列表。

---

java.util.Collections

算法	描述
static <T extends Comparable<? super T>> void sort(List<T> elements)	使用归并排序算法排序。时间复杂度为:O(nlogn),n为列表的长度
static void shuffle(List<?> elements)
static void shufle(List<?> elements,Random r)	混排列表中的元素。时间复杂度为：O(na(n)), n为列表长度，a(n)为访问元素的平均时间

---

java.util.List

算法	描述
default void sort（Comparator <? super T> Comparator）	使用给定的比较器对列表排序

---

java.util.Comparator

算法	描述
static <T extends Comparable<? super T>> Comparator<T> reverseOrder()	生成一个比较器，逆转Comparable接口提供的顺序
default Comparator <T> reversed()	生成一个比较器，逆转这个比较器提供的顺序

public class ShuffleExample {
  public static void main(String[] args){
      var num= new ArrayList<Integer>();
      for (int i = 0;i < 49;i ++){
          num.add(i);
      }
      Collections.shuffle(num);       //  随机打乱该数组
      System.out.println(num);

      var newNum = num.subList(0,10);      //截取数组
      Collections.sort(newNum);
      System.out.println(newNum);
  }
}

2. 二分查找

有序集合

java.util.Collections

方法	描述
binarySearch（集合对象，查找的元素）	返回元素的索引
static <T extends Comparable<? super T>> int binarySearch(List<T> elements, T key)	从有序列表中搜索键，若元素类型实现了RandomAccess 接口，则使用二分查找，否则线性查找 返回键在列表中的索引
static <T> int binarySearch(List<T> elements,T key,Comparable<? super T> c>

3. 批操作

---

二叉树

二叉搜索树

• 左子列为递减，右子列为递增

二分查找法（有序数组）

public class BinarySearch{
   public static int find(Comparable []arr,Comparable target){
       int L = arr.length() - 1;
       int T = 0; 
       int mid = L/2 + T/2;
       if(arr[mid].compareTo(target) == 0)				
           return mid;
       if(arr[mid].compareTo(target) > 0)
           return L = mid - 1;
       else	T = mid + 1 ;
   } 
}

二叉搜索树 插入操作

指定列表中指定位置的元素 |
| static <T> Collection<T> | synchronizedCollection(Collection<T> c)返回由指定集合支持的同步（线程安全）集合。 |
| static <T> List<T> | synchronizedList(List<T> list)返回由指定列表支持的同步（线程安全）列表。 |
| static <K,V> Map<K,V> | synchronizedMap(Map<K,V> m)返回由指定地图支持的同步（线程安全）映射。 |
| static <K,V> NavigableMap<K,V> | synchronizedNavigableMap(NavigableMap<K,V> m)返回由指定的可导航地图支持的同步（线程安全）可导航地图。 |
| static <T> NavigableSet<T> | synchronizedNavigableSet(NavigableSet<T> s)返回由指定的可导航集支持的同步（线程安全）可导航集。 |
| static <T> Set<T> | synchronizedSet(Set<T> s)返回由指定集合支持的同步（线程安全）集。 |
| static <K,V> SortedMap<K,V> | synchronizedSortedMap(SortedMap<K,V> m)返回由指定的排序映射支持的同步（线程安全）排序映射。 |
| static <T> SortedSet<T> | synchronizedSortedSet(SortedSet<T> s)返回由指定的排序集支持的同步（线程安全）排序集。 |
| static <T> Collection<T> | unmodifiableCollection(Collection<? extends T> c)返回指定集合的不可修改视图。 |
| static <T> List<T> | unmodifiableList(List<? extends T> list)返回指定列表的不可修改视图。 |
| static <K,V> Map<K,V> | unmodifiableMap(Map<? extends K,? extends V> m)返回指定地图的不可修改视图。 |
| static <K,V> NavigableMap<K,V> | unmodifiableNavigableMap(NavigableMap<K,? extends V> m)返回指定可导航地图的不可修改视图。 |
| static <T> NavigableSet<T> | unmodifiableNavigableSet(NavigableSet<T> s)返回指定的可导航集合的不可修改的视图。 |
| static <T> Set<T> | unmodifiableSet(Set<? extends T> s)返回指定集合的不可修改视图。 |
| static <K,V> SortedMap<K,V> | unmodifiableSortedMap(SortedMap<K,? extends V> m)返回指定排序映射的不可修改视图。 |
| static <T> SortedSet<T> | unmodifiableSortedSet(SortedSet<T> s)返回指定排序集的不可修改视图。 |

1. 排序与混排

• Collections 类中的 sort（） 方法可以对实现了 List 接口的集合进行排序

• 集合类库的排序（归并排序）：将所有元素转入一个数组中；对数组进行排序；再将排序后的序列复制回列表。

---

java.util.Collections

算法	描述
static <T extends Comparable<? super T>> void sort(List<T> elements)	使用归并排序算法排序。时间复杂度为:O(nlogn),n为列表的长度
static void shuffle(List<?> elements)
static void shufle(List<?> elements,Random r)	混排列表中的元素。时间复杂度为：O(na(n)), n为列表长度，a(n)为访问元素的平均时间

---

java.util.List

算法	描述
default void sort（Comparator <? super T> Comparator）	使用给定的比较器对列表排序

---

java.util.Comparator

算法	描述
static <T extends Comparable<? super T>> Comparator<T> reverseOrder()	生成一个比较器，逆转Comparable接口提供的顺序
default Comparator <T> reversed()	生成一个比较器，逆转这个比较器提供的顺序

public class ShuffleExample {
  public static void main(String[] args){
      var num= new ArrayList<Integer>();
      for (int i = 0;i < 49;i ++){
          num.add(i);
      }
      Collections.shuffle(num);       //  随机打乱该数组
      System.out.println(num);

      var newNum = num.subList(0,10);      //截取数组
      Collections.sort(newNum);
      System.out.println(newNum);
  }
}

2. 二分查找

有序集合

java.util.Collections

方法	描述
binarySearch（集合对象，查找的元素）	返回元素的索引
static <T extends Comparable<? super T>> int binarySearch(List<T> elements, T key)	从有序列表中搜索键，若元素类型实现了RandomAccess 接口，则使用二分查找，否则线性查找 返回键在列表中的索引
static <T> int binarySearch(List<T> elements,T key,Comparable<? super T> c>

3. 批操作

---

二叉树

二叉搜索树

• 左子列为递减，右子列为递增

二分查找法（有序数组）

public class BinarySearch{
   public static int find(Comparable []arr,Comparable target){
       int L = arr.length() - 1;
       int T = 0; 
       int mid = L/2 + T/2;
       if(arr[mid].compareTo(target) == 0)				
           return mid;
       if(arr[mid].compareTo(target) > 0)
           return L = mid - 1;
       else	T = mid + 1 ;
   } 
}

二叉搜索树 插入操作