java基础 - 教程

Java

1.java语法

Java区分大小写

Java文件名称必须与类名匹配

2.mian（）方法

必需，mian（）方法中任何代码都将被执行

可以用println()方法将一行文本打印到屏幕上，要结合文本和变量启用+字符

String name=”John”

System.out.println(“Hello ”+name);

也可以利用+字符将变量添加到另一个变量

String name1=”john”;

Sting name2=”mary”;

Sting name=name1+name2

3.{}表示代码的开始和结束

4.java注释

单行：//

多行注释：以/*开头 以*/结尾

5.java变量

变量是存储数据值的容器

声明同一个类型的变量用逗号分隔

Int x=6.y=8,i=9;

创建变量必须指定类型并为其赋值

Type variavle=value;

其中 type是Java的一种类型（如int 或 String），variable 是变量的名称（如 x 或 name）。 等号用于为变量赋值

若创建存储文本的变量

String name=”John”;

System.out.println(name);

若创建存储数字的变量：

Int mynum=9;

System.out.println(mynum);

若不赋值情况下声明变量随后再赋值(新值会覆盖旧值)

Int mynum;

Mynum=15;

System.out.println(mynum);

6.final变量

变量不可更改且只读

Final int munum=16;

Mysum=20;

7.其他类型

8.标识符

所有java变量必须用唯一的名称标识

9.变量名称命名规则

10.java数据类型

数据类型分为两组:

• 基本数据类型 - 包括 byte, short, int, long, float, double, boolean 和 char
• 非根本数据类型 - 例如String, Arrays 和 Classes

数字：

原始数字类型分为两组:

整数类型存储整数、正数或负数（例如 123 或 -456），没有小数。 有效类型为 byte, short, int 和 long。 您应该利用哪种类型，取决于数值。

浮点类型表示带有小数部分的数字，包含一个或多个小数。 有两种类型: float 和 double。

科学数字：

带有e表示10的幂

字符：

必须用单引号括起来

Char myGrade=’B’

或者使用ASCII值表示某些字符

字符串：必须用双引号括起来

String name=”Hello word”

否为真:就是布尔类型：利用比较运算符（如大于(>)运算符）来确定表达式（或变量）

Int x=10;

Int y=10;

System.out.println(x>10)；

比如:

System.out.println(10==16);//返回false

11.数据类型转换

• 隐式类型转换(自动) - 从小类型到大类型，不需要强制转换符
  byte -> short -> char -> int -> long -> float -> double
  
• 强制类型转换(手动) - 从大类型到小类型，需要强制转换符建立强制转换
  double -> float -> long -> int -> char -> short -> byte

比如：

隐式类型转换：

Int myInt=9;

Double mydouble=myInt;

强制类型转换：

double mydouble=9.78

int myInt=(int)mydouble;

12.运算符

++ 在变量前面和后面是有区别的：

• ++ 在前面叫做前自增（例如 ++a）。前自增先进行自增运算，再进行其他操作。
• ++ 在后面叫做后自增（例如 a++）。后自增先进行其他操作，再进行自增运算。

赋值运算符（=）：

Int x=10;

关系运算符：

13.获取字符串长度

Length()方法

String txt=”jshfkiwhjsm”

：”+txt.length());就是System.out.println(“字符串长度

其它字符串方法toUpperCase()、toLowerCase()

String txt = "Hello World";

System.out.println(txt.toUpperCase()); // 输出 "HELLO WORLD"

System.out.println(txt.toLowerCase()); // 输出 "hello world"

14.查找字符位置

indexOf()方式返回字符串包含空格中指定文本第一次出现的索引位置而且是从0开始计算位置，0是字符串中的第一个位置

String txt = "Please locate where 'locate' occurs!";

Systrm.out.println(txt.indexOf(“locate”));

15.字符串串联

1.使用+串联字符

String firstName = "John";

String lastName = "Doe";

System.out.println(firstName + " " + lastName);

上面的““是为了打印两个字符串之间创建一个空格

注意：

+：数字相加，字符相连

比如：

Int x=10;

Int y=10;

Int z=x+y;//z为20

比如：

String x=“10“;

int y=10;

String z=x+y//z为1020

比如：

String x=“10“;

String y=”10”;

String z=x+y//z为1020

2.也可以应用concat()方法

String firstName = "John";

String lastName = "Doe";

Sstem.out.println(firstName.concat(lastName))；

16.特殊字符必须写在引号内，避免此挑战可以使用反斜杠转义字符

比如：

String txt=”we are the so-called \”Vikings\” from the north”

17.java中的数学方法

Math.max(x,y)查找x,y的最大值

Math.min(x,y)查找x,y的最小值

Math.sqrt(x)返回x的平方根

Math.abs(x)返回x的绝对（正）值

Math.random()返回一个介于0.0（包括）和1.0（不包括）之间的随机数，若只需要一个介于0到100之间的随机数，可以用以下公式

Int randomNum=(int)(math.random()*101);

比如：

Math.max(-1,9)

Math.abs(-9.2)

18.if else语句

Java 支撑的常见逻辑条件:

• 小于: a < b
• 小于或等于: a <= b
• 大于: a > b
• 大于或等于: a >= b
• 等于 a == b
• 不等于: a != b

Java 有以下条件语句:

• if 假设指定的条件为真，则使用if指定要执行的代码块
• else 假如相同条件为false，则使用else指定要执行的代码块
• else if 假设第一个条件为false，则使用else if指定要测试的新条件
• switch 使用switch指定要执行的许多可选代码块

比如：

int time=10;

if(time<10){System.out.println(goodmorning)};

else if(time=10){ System.out.println(goodday)};

else{System.out.println(good)};

if else简写语句：

variable = (condition) ? expressionTrue : expressionFalse;

比如：

Int time=10;

String result=(time<19)?”goodday”:”goodevening”;

19.switch语句：从多个要执行的代码块选择一个执行

Switch(expression){

Cese x:

Break:

Case y:

Break:

Default:

}

工作原理:

• switch 表达式计算一次
• case 将表达式的值与每种情况的值进行比较
• 如果存在匹配项，则执行关联的代码块
• 可选的就是break 和 default 关键字

比如：

Int day=4;

Switch(day){

Case 1:

System.out.println(“monday”);

Break;

Case2:

System.out.println("Tuesday");

break;

case 3:

System.out.println("Wednesday");

break;

case 4:

System.out.println("Thursday");

break;

case 5:

System.out.println("Friday");

break;

case 6:

System.out.println("Saturday");

break;

case 7:

System.out.println("Sunday");

break;

}

// 输出 "Thursday" (day 4)

20.break关键字：中断

停止某块执行更多的代码和案例测试

21.default关键字

指定在没有大小写匹配默认要运行的一些代码

假设将default 语句用作 switch 中的最后一条语句，则不需 break 中断。

22.while循环语句

只要指定条件为真true,while循环就会遍历代码块

比如：

Int x=4;

While(i<6){

System.out.println(i);

I++

}

23.do while语句

do/while 循环是 while 循环的一个变体。在检查条件是否为真之前，这个循环将执行一次代码块，然后只要条件为真，它就会重复循环。

Int i=8;

Do{

System.out.println(i);

I++;

}

While(x<9);

上述即使条件为false，循环也将始终至少执行一次，因为代码块是在测试条件之前执行的:

24.for循环语句

得确切知道代码块循环次数，用foe循环而不是·while循环

比如：

For (int i=0;i<9;i++){

System.out.println(i);
}

打印0-10之间偶数值

For(i=0;i<=10;i=i+2){

System.out.println(i);}

25.for-each循环语句

专门用于循环数组array种的元素1

比如：

String[] cars={“volvo”,”bmw”,”ford”,”mazdf”}

For(string i:cars){

Systrm.out.println(“i”);
}

26.break语句也可以用于跳出循环

27.contiue语句

如果指定的条件发生时， continue 语句将中断一个迭代（在循环中），并继续循环中的下一次迭代。
for(i=0;i<10;i++){
if (i==4){

Continue;

}

System.out.println(i);

}

28.数组

用于在单个变量中存储多个值，而不是为美国值声明单独变量

要声明数组运用[]定义变量类型

String[] cars={“volob”,”hiws”,”sjdi”};

Int[] yint={2,26,10};

29.访问数组的元素：通过索引号来访问数组元素

String[] cars={“volob”,”hiws”,”sjdi”};

System.out.println(cars[0]);// 数组索引从0开始，[0]开头是第一个元素，[1] 是第二个元素。

30.更改数组元素的值

String[] cars={“volob”,”hiws”,”sjdi”};

Cars[0]=”biji”;

System.out.println(cars[0]);

31.获取数组元素的长度

Length属性

String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};

System.out.println(cars.length);

// 输出 4

String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};

for (int i = 0; i < cars.length; i++) {

System.out.println(cars[i]);

}

32.多维数组

含有一个或者多个的数组的数组

要创建二维数组，将每个数组都加到自己的花括号{}中

Int[][] mynumbers={{1,2,3,4}、{5，6，7，8}}

要访问myNumbers数组的元素，请指定两个索引:一个用于数组，另一个用于该数组内的元素。

int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };

int x = myNumbers[1][2];

System.out.println(x); // 输出 7

33.手段：

method一个代码块，只在运行时调用。就是方法

可能将数据（称为参数）传递到方法中。

方法用于执行某些操作，它们也称为函数。

为什么使用办法?代码复用:定义一次代码，然后多次使用。

用方法的名称定义的，后跟括号就是方法必须在类中声明。它()。

在MyClass内创建一个办法:

public class MyClass {

static void myMethod() {

// 要执行的代码

}

}

实例解析

• myMethod() 是方法的名称
• MyClass类的对象。在本教程的后面部分，您将了解有关对象以及如何借助对象访问方法的更多信息。就是static 意味着该方法属于MyClass类，而不
• void 表示此方法没有返回值。您将在本章后面了解有关返回值的更多信息

方法调用

要在Java中调用一个方法，请编写该方法的名称，后跟两个括号()和;

一个途径也可以被多次调用

在下面的示例中，调用 myMethod() 用于打印文本（操作）:

实例

在 main，调用myMethod()方法:

public class MyClass {

static void myMethod() {

System.out.println("I just got executed!");

}

public static void main(String[] args) {

myMethod();

myMethod();

}

}

// 输出 "I just got executed!"

34.方法里面的参数

信息可以作为参数传递给方法。参数在途径中充当变量。

通过它们在方法名称后的括号内指定。您能够添加多个参数，只需用逗号分隔即可。

public class MyClass {

static void myMethod(String fname) {

System.out.println(fname + " Refsnes");

}

public static void main(String[] args) {

myMethod("Liam");

myMethod("Jenny");

myMethod("Anja");

}

}

// Liam Refsnes

// Jenny Refsnes

// Anja Refsnes

该方式将名为fname的string字符串作为参数。 调用方法时，我们传递一个名字，该名字在方法内部用于打印全名: 当参数parameter被传递给技巧时，它被称为实参（argument）。因此，从上面的例子来看:fname是一个参数，而Liam, Jenny 和 Anja 是实参。

使用多个参数时，方法调用的参数数必须与参数数相同，并且参数的传递顺序必须相同。

void，并在手段内使用return关键字:就是使用的void关键字表示该方法不应返回值。如果希望方法返回值，可以使用基本数据类型（如int 或double）而不

public class MyClass {

staticintmyMethod(int x) {

return5 + x;

}

public static void main(String[] args) {

System.out.println(myMethod(3));

}

}

// 输出 8 (5 + 3)

通过您还能够将结果存储在变量中（推荐，因为这样更易于读取和维护）:

public class MyClass {

static int myMethod(int x, int y) {

return x + y;

}

public static void main(String[] args) {

int z = myMethod(5, 3);

System.out.println(z);

}

}

// 输出 8 (5 + 3)

35.方式重载

多个方法可以具有相同的名称和不同的参数

比如：

int myMethod(int x)

float myMethod(float x)

double myMethod(double x, double y)

比如：

static int plusMethodInt(int x, int y) {

return x + y;

}

static double plusMethodDouble(double x, double y) {

return x + y;

}

public static void main(String[] args) {

int myNum1 = plusMethodInt(8, 5);

double myNum2 = plusMethodDouble(4.3, 6.26);

System.out.println("int: " + myNum1);

System.out.println("double: " + myNum2);

}

与其定义两个做相同事情的方法，不如重载一个

注释:只要参数的数量或类型不同，多个办法就行具有相同的名称。

36.作用域

直接在方法中声明的变量在手段中的任何位置都可用，位于声明它们的代码行之后:

public class MyClass {

public static void main(String[] args) {

// 此处的代码不能使用 x

int x = 100;

// 这里的代码允许运用 x

System.out.println(x);

}

}

代码块可以单独存在，也能够属于 if, while 或 for 语句。 对于 for 语句，语句本身中声明的变量在块的作用域也可用。

37.递归

进行函数调用本身，将更复杂的问题分解为容易解决的问题

比如：运用递归所有数字相加到10

public class MyClass {

public static void main(String[] args) {

int result = sum(10);

System.out.println(result);

}

public static int sum(int k) {

if (k > 0) {

return k + sum(k - 1);

} else {

return 0;

}

}

}

指函数从不停止调用自身。每个递归函数都应该有一个停止条件，即函数停止调用自身的条件。就是正如循环会遇到无限循环的问题一样，递归函数也会遇到无限递归的问题。 无限递归

38.oop面向对象编程

过程编程是关于编写对材料执行操作的过程或函数，而面向对象编程是创建同时囊括信息和函数的对象。

与过程编程相比，面向对象编程有几个优点:

• OOP 更快更容易执行
• OOP 为软件提供了清晰的结构
• OOP 有助于保持C#代码"不重复自己"，并使代码更易于维护、修改和调试。
• OOP 使得用更少的代码和更短的编写时间创建完全可重用的应用程序成为可能

类是对象的模板，而对象是类的实例。

创建单个对象时，它们继承类中的所有变量和函数。

39.对象和类

Java是面向对象的编程语言

Java 中的一切都与类和对象及其属性和途径相关联

创建一个类，利用class关键字

Public class myclass{

Int x=10;

}

创建一个对象，对象是从类创建的，需要制定类名后跟对象名并启用new关键字

比如：

创建2个名为myobj的对象并打印x的值

Public classs myclasss{

Int x=8;

Public static void main (string[] args){

Myclass object1=new myclass();

Myclass object2=new myclass();

System.out.println(myobject2.x)

System.out.println(myobject1.x)

可以创建一个类的对象并在另一个类中访问它。这通常用于更好地组织类（一个类拥有所有属性和方法，而另一个类拥有main()方法

40.类属性：也就是字段

可以凭借创建类的对象和采用点语法（.）来访问属性

还行修改属性值

Public class Myclass(){

Int x=20;

}

Public static void main(string[] args){

Myclasss object=new Myclass();

Myobject.x=20;

System.out.println(myobj.x)

假如不希望覆盖该值，使用final

public class MyClass {

finalint x = 10;

public static void main(String[] args) {

MyClass myObj = new MyClass();

myObj.x = 25; // 将产生错误:无法为final 变量赋值

System.out.println(myObj.x);

}

}

点 (.) 用于访问对象的属性和方法。

要在Java中调用办法，请编写途径名称，后跟一组括号()，后跟分号(;)

41.构造函数

用于初始化对象的特殊途径，在创建类的对象时调用构造函数，可用于设置对象属性的初始值

// 创建一个 MyClass 类

public class MyClass {

int x; // 创建类属性

// 为 MyClass 类创建一个类构造函数

public MyClass() {

x = 5; // 设置类属性 x 的初始值

}

public static void main(String[] args) {

MyClass myObj = new MyClass(); // 创建一个 MyClass 类的对象（这将调用构造函数）

System.out.println(myObj.x); // 打印 x 的值

}

}

// 输出 5

请注意，构造函数名称必须与类名匹配，并且不能有返回类型(如 void).

还要注意，在创建对象时会调用构造函数。

默认情况下，所有类都有构造函数:如果您自己不创建类构造函数，Java会为您创建一个。但是，您无法设置对象属性的初始值。

构造函数还可以获取参数，用于初始化属性。

public class Car {

int modelYear;

String modelName;

public Car(int year, String name) {

modelYear = year;

modelName = name;

}

public static void main(String[] args) {

Car myCar = new Car(1969, "Mustang");

System.out.println(myCar.modelYear + " " + myCar.modelName);

}

}

// 输出 1969 Mustang

42. 修饰符：

访问修饰符和非访问修饰符

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

私有访问修饰符-private

私有访问修饰符是最严格的访问级别，所以被声明为private的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为private。

声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。

Private 访问修饰符的采用重要用来隐藏类的实现细节和保护类的数据。

static 静态方法意味着能够在不创建类对象的情况下访问它，这与public不同:

abstract 抽象途径属于abstract抽象类，它没有主体。主体由子类提供:

43.封装：

对用户隐藏敏感数据

为什么要封装?

• 更好地控制类属性和方法
• 类属性可以设置为只读（若是只使用get方法），也允许设置为只写（如果只使用set方法）
• 灵活:程序员可以在不影响其他部分的情况下更改代码的一部分
• 提高数据的安全性

完成这一点必须：

将类变量/属性声明为private

提供get和set方法来访问更细新private私有变量的值

Get技巧便会变量值，set方法设置值

两者的语法都是以get或者set开头，后跟变量，第一个字母大写

Public class person{

Private string name;

Public string getname(){

Return name;

}

Public string setname(){
this.name=newname;

Public class myclass{
public static void main(string[] args){
person object=new person();

Myboject.setname(“john”);

System.out.println(object.getname());}

44.java包

用于对相关类进行分组，软件包分为：

内置包（来自java api包）和用户自定义的包

内置的包：

使用库中的类或者包需使用import关键字

导入整个包在句子末尾加*，比如：import java.util;

用户自定义的包：

利用package关键字

Package mypack;

45.继承：

Java 中行将属性和方法从一个类继承到另一个类。我们将"继承概念"分为两类:

• 子类(Subclass) - 子，从另一个类继承的类
• 超类(Superclass) - 父，被继承的类

要从类继承，请使用 extends关键字。

Class vehicle{

Protected string brand=”ford”;

Public void honk(){

System.out.println(“true”);}

Class car extends vehicle{

Private string molename=”mustang”

Public static void main(string[] args){

Car mycar=new car();

Mycar.honk();

System.out,println(mycar.brand+mycar.molename);

}
我们将Vehicle中的brand属性设置为protected受保护的访问修饰符。 如果设置为private，则Car类将无法访问它。

46.多态

多态性启用这些方法来执行不同的任务得到不同的结果

Class animal{

Public void animal sound(){

System.out.println(“make sound”)}

Class pig extends animal{

Public void animalsound(){

System.out.println(“”);

Class dog extends animal{

Public void animalsound(){

System.out.println(“”);

Class mymainclass{

Public static void mian(string[] args){

Animal myanimal=new animal();

Animal pig=new pip();//创建一个pig对象

Animal dog =new dog;

Myanimal.animalsound();

Mypip.animalsound();

Mydog.animalsound();

为什么要利用"继承"和"多态性"?

- 因为它对于代码的可重用性很有用:在创建新类时可能重用现有类的属性和办法。

47.内部类

嵌套类的目的时将属于同一组类分组是代码更具可读性和易用性

访问内部类要先创建外部类在创建内部类对象

Class outercalss{

Int x=10;

Class innerclass{

Int y=5;

Public class mymainclass{

Public static void main(string[] args){

Outerclass outer=new outerclass();

Outerclasss.innerclass myinner=myouter.new innerclass();

System.out.println(myInner.y + myOuter.x);

与"常规"类不同，内部类行是private 私有的或 protected受保护的。 如果不希望外部对象访问内部类，请将该类声明为private:

Static内部类：

在不创建外部类的对象的情况下访问它

与static静态属性和方法一样，static静态内部类无权访问外部类的成员

内部类的一个优点就是：可以访问外部类的属性和方法

48.抽象类

隐藏某些细节并仅向用户显示基本信息的过程就是数据抽象

通过抽象能够通过abstract classes抽象类或interfaces接口来实现

Abstract关键字是非访问修饰符，用于类和办法

• 抽象类:是一个不能用于创建对象的受限类（要访问它，必须从另一个类继承）。
• 抽象方法:只能在抽象类中应用，并且它没有主体。主体由子类（继承自）提供。

抽象类可以有抽象办法和常规方法,要访问抽象类必须从另一个继承或者由接口实现

为什么以及何时启用抽象类和方式?

因为要实现安全性，要隐藏某些细节并仅显示对象的核心细节。

49.接口

Interface接口是一个完全抽象类，将相关方法和空实体分组

Interface animal{

Public void animalsound();//接口途径没有主体

Public void run();

要访问接口方法必须有另一个具有implements关键字而不是extend的类达成，接口的主体由implements提供

Interface animal{
public void animalsound();

Public void run();}

Class pig implements animal{

Public void animalsound(){}

Public void run(){}

关于接口的说明:

• 与抽象类一样，接口不能用于创建对象（在上面的示例中，不可能在MyMainClass中创建"Animal"对象）
• 接口方法没有主体-主体由"implement"类提供
• 在构建接口时，必须重写其所有手段
• abstract 抽象的和public公共的就是默认情况下，接口办法
• I接口属性默认为 public, static 和 final
• 接口不能包含构造函数（因为它不能用于创建对象）

为什么以及何时使用接口?

1) 为了实现安全性-隐藏某些细节，只显示对象（接口）的重要细节。

，它可以凭借接口实现，因为该类行实现多个接口。就是2) Java不支持"多重继承"（一个类只能从一个超类继承）。只

注释:要实现多个接口，请用逗号分隔它们（请参见下面的示例）。

50.枚举

enum枚举是一个特殊的类表示一组常量（不可更改的变量，茹finnal变量）

要创建enum，要使用enum关键字（而不是类或接口），并用逗号分隔，应为大写字母

Enum level{

Low,

Medium,

High}

可能使用.语法访问enum枚举常量

Level myvar=level.medium;

类中枚举

Switch语句中的枚举

枚举通常用于switch语句中检查相应的值

Enum level{

Low,

Medium,

High}

Public class myclass{

Public static void mian(string[] args){

Leverl myvar=leverl.medium;

Switch(myvar){

Case low:

Break;

Case medium:

Break;

Cese high:

Break;

循环遍历枚举

枚举通常有一个values（）方法，该方法返回所有枚举常量的数组

For(level myvar:level.values() ){

System.out.println(“”)}

枚举和类之间的差异

enum枚举可以像class类一样具有属性和方法。唯一的区别是枚举常量是public, static 和 final（不可更改-无法重写）。

通过enum 枚举不能用于创建对象，也不能扩展其他类（但能够实现接口）。

为什么以及何时使用枚举?

当您知道值不会更改时，如月日期、星期、颜色等，请利用枚举。

51.用户输入

Scanner类用于获取用户输入，位于java.util包中

要使用 Scanner 类，请创建该类的对象，并运用 Scanner 类文档中的任何可用办法。

Import java.util.Scanner;

Class myclass{

public static void main(String[] args) {

scanner myobj=new scanner(system.in);//创建scanner对象

system.out.println(“enter username”);

string username=myobj.nextline()//读取用户输入

system.out.println(“username is’+username);

如果输入错误（例如数字输入中的文本），将收到异常/错误消息 (如 "InputMismatchException").

52.日期

显示当前日期导入java.time.localdate类，并启用其now（）方式

Import java.time.localdate

Public class myclass{

Localdate myobj=localdate.nw();//创建日期对象

System.out.println(myobj);}//显示当前日期2025-08-05

显示当前时间导入java.time.localtime

Import java.time.localtime;

Public Class myclass{

Public static void mian(string[] args){

Localtime obiect=locltime.now();

System.out.println(myobj);}//输出为10;59:15.158007

显示当前日期和时间，青岛如java.time.localdatetiem类并使其用now()技巧

import java.time.LocalDateTime; // 导入 LocalDateTime 类

public class MyClass {

public static void main(String[] args) {

LocalDateTime myObj = LocalDateTime.now();

System.out.println(myObj);

}

}//输出为2025-08-05T10:59:15.159783

53. arraylist数组

Arraylist类是一个可调整大小的array数组，可能在java.util包中找到

通过Java 中内置数组和ArrayList的区别在于数组的大小不能修改（如果要向数组中添加或删除元素，必须创建一个新的数组）。 而能够随时从ArrayList中添加和删除元素。语法也略有不同:

比如创建名为cars的arrylist对向，将用于存储字符串

添加元素到aaaylist允许使用add()方法

访问arraylist的元素能够使用get（）方法

修改arraylist中的元素可以和启用set()方法

删除arraylist元素行使用remove()方法

通过删除arraylist所有元素能够使用clear()方法

计算arraylist中元素数量可以使用size方法

循环遍历数组arraylist元素，并且使用size方法指定循环次数

也可能使用for-each循环变量arraylist

Import java.util.arraylist;

Public class myclass{

public static void main(String[] args) {

Arraylist<string> cars=new Arraylist<string>();

Cars.add(“bolos”)

Cars.get(0);// 注意:数组索引从0开始，[0]开头是第一个元素，[1] 是第二个元素。

Cars.set(0，“open“);

Cars.remove(0)；

Cars.clear();

cars.size();

for(int i=0;i<cars.size();i++){

system.out.println(“cars.get(i)”);}

for(string i：cars){

system.out.println(i);

}

基元类型）。要使用其他类型，如int，必须指定一个等效的就是ArrayList 中的元素实际上是对象。在上面的示例中，我们创建了类型为"String"的元素（对象）。 请记住，Java中的字符串是对象（而不包装类:Integer。 对于其他基础类型，请利用:Boolean, Character, Double等等:

Java.util包中另一个有用的类是collections类，包括用于按字母和数字排序的sort()方式

Import java.util.collections;

Import java.util.arraylist;

Public class myclass{

Public static void main(string[] args){

Arraylist<string> cars=new arraylist<string>();

Cars.add(“volvo”);

Collections.sort(cars);

For(string i：cars){

System.out.println(i);

54.链表linkedlist

链表linkedlist和arraylist数组用法几乎相同

Import java.util.linkedlist;

Public class myclass{

Public static void main(string[] args){

Linkedlist<string> cars=new linkedlist<string>();

Cars.add(“sd”);

ArrayList 与 LinkedList

LinkedList 类是一个集合，可能包含许多相同类型的对象，就像 ArrayList 一样。

通过LinkedList 类具有与 ArrayList 类相同的所有方法，因为它们都实现了 List 接口。这意味着您能够以相同的方式添加项目、更改项目、删除项目和清除列表。

然而，虽然 ArrayList 类和 LinkedList 类行以相同的方式应用，但它们的构建方式却大不相同。

ArrayList 的工作原理

ArrayList 类内部有一个常规数组。添加元素时，会将其放入数组中。如果阵列不够大，则会创建一个更大的新阵列来替换旧阵列，并移除旧阵列。

LinkedList 的工作原理

LinkedList 将其项目存储在"容器"中。该列表有一个指向第一个容器的链接，每个容器都有一个指向列表中下一个容器的链接。要将元素添加到列表中，将该元素放入一个新容器中，并且该容器链接到列表中的其他容器之一。

何时使用

在以下情况下最好使用 ArrayList:

• 您想时常访问随机项目
• 您只需要在列表末尾添加或删除元素

在以下情况下最好利用 LinkedList:

• 您只能经过循环采用列表而不是访问随机任务
• 您经常需要从开头或中间添加和删除项目

55.hashmap

在 ArrayList一章中，您了解了数组将项目存储为有序集合，并且您必须使用索引号 (int 类型) 来访问它们。 然而， HashMap 将项目存储在 "key/value" 对中，您允许经过另一种类型的索引 (例如 String)访问它们。

一个对象用作另一个对象（值）的键（索引）。 它可以存储不同的类型: String 字符串键和 Integer 整数值，或者相同类型，例如: String 字符串键和 String 字符串值:

比如：创建一个名为capitalcities的hashmap对象，他将存储字符串键和字符串值

Import java.util.hashmap;

Hashmap<string,string>capitalcities=new hashmap<string,string>();

HashMap 类有很多有用的办法。例如，

要向其中添加项目，请使用 put() 方法:

访问hashmap的值使用get()

移除项目采用remove方法

删除所有项目用clear（）方法

要找出有多少项目运用size途径

运用fro-each循环遍历hashmap的工程

注释:只需要键，请使用 keySet() 方法，如果只需要值，请使用 values() 手段:就是若

Import java.util.hashmap;

Public class myclass{

Public static void main(string[] args){

Hashmap<string,string> cars=new hashmap<string,string>();

Cars.put(“hsi”,”hdk”);

Cars.get(“shdi”);

Cars.remove(“sdk”);

Car.clear(“sjdi”);

Car.size();

For(string i:cars.values()){//打印values

Systrm.out.println(“i’);

}

For(string i:cars.keyset()){//打印键和值

System.out.println(“i”)}

原始类型）。要使用其他类型，例如 int，您必须指定一个等效的就是HashMap 中的键和值实际上是对象。在上面的示例中，我们启用了"String"类型的对象。请记住，Java 中的 String 是一个对象（不包装类: Integer。对于其他原始类型，请使用: Boolean 用于 boolean, Character 用于 char, Double 用于 double 等:

56.hashset集合

是项目的集合，其中每个任务都是唯一的，允许在 java.util 包中找到:

比如：创建一个名为cars的hashset对象，该对象存储字符串

Import java.util.hashset;

Hashset<string> cars=new hashset<string>();

HashSet 类有很多有用的方法。 例如，

要向其中添加项目，请使用 add() 手段:

要检查某个项目是否存在于 HashSet 中，请使用 contains() 方法:

要删除项目，请使用 remove() 方法:

要删除所有项目，请使用 clear() 方法:

要找出有多少工程，请使用 size 途径:

运用 for-each 循环遍历 HashSet 的项目:

HashSet 中的项目实际上是对象。 在上面的示例中，我们创建了"String"类型的项目（对象）。 请记住，Java 中的 String 是一个对象（不是原始类型）。 要启用其他类型，例如 int，您必须指定一个等效的包装类: Integer。 对于其他原始类型，请使用: Boolean 用于 boolean, Character 用于 char, Double 用于 double 等:

57.迭代器interator

Iterator 是一个可用于循环遍历集合的对象，例如 ArrayList 和 HashSet。 它被称为"迭代器"，因为"迭代"是循环的技术术语。

要运用迭代器，您必须从 java.util 包中导入它。

获取迭代器

//导入arraylist类和interator类

Import java.util.arraylist;

Import java.util.intertator;

Public class myclass{

Public static void main(sting[] args){

Arrsylist<string> cars=new arraylist<string>();

Cars.add(“sd”);

//获取迭代器

Interator<string> it=cars.interator();

//打印第一项

System.out.println(it.next());

要遍历集合，请使用迭代器的 hasNext() 和 next() 方法:

While(it.hashnext()){

Systrm.out.print(it.next());}

从集合中删除方案

迭代器旨在轻松更改它们循环的集合。remove() 途径行在循环时从集合中删除项目。

注释: 尝试使用 for 循环或 for-each循环删除项目将无法正常工作，因为集合在代码尝试循环的同时改变大小。

58.包装类

包装类提供了一种将原始数据类型 (int, boolean, 等) 用作对象的方法。

处理对象，因此您能够使用某些方法来获取有关特定对象的信息。

例如，以下方法用于获取与对应包装对象关联的值: intValue(), byteValue(), shortValue(), longValue(), floatValue(), doubleValue(), charValue(), booleanValue().

另一个有用的技巧是 toString() 方法，它用于将包装对象转换为字符串。

在下面的例子中，大家将 Integer 转换为 String，并使用 String 类的 length() 方法输出"字符串"的长度:

public class MyClass {

public static void main(String[] args) {

Integer myInt = 100;

String myString = myInt.toString();

System.out.println(myString.length());

}

}

59.异常

在执行 Java 代码时，可能会出现不同的错误:程序员编写的编码错误、错误输入导致的错误或其他无法预料的事情。

发生错误时，Java 通常会停止并生成错误消息。对此的技术术语是:Java 将抛出异常（抛出错误）。

---

Java try 和 catch

try 语句允许您定义一个代码块，以便在执行时对其进行错误测试。

要是 try 块中发生错误， catch 语句允许您定义要执行的代码块。

try 和 catch 关键字成对出现:

try{

//要尝试的代码块

}

Catch（exception e）{

//处理错误的代码块

}

finally 语句允许您在 try...catch 之后执行代码，而不管结果如何:

pubic class myclass{

public static void main(string[] args){

try{

int [] mynumbers={1,2,3};

systrm.out.println(“mynunmbers[10]”);}

catch(exception e){

system.out.println(“went wrong”);

}

Finally{

System.out.println(“trysh”);}

Throw关键字

throw 语句允许您创建自定义错误。

throw 语句与异常类型一起使用。 Java 中有许多异常类型可用: ArithmeticException, FileNotFoundException, ArrayIndexOutOfBoundsException, SecurityException, etc:

60.正则表达式

正则表达式是形成搜索模式的字符序列。当您在文本中搜索数据时，您可以启用此搜索模式来描述您要搜索的内容。

更复杂的模式。就是正则表达式可能是单个字符，也可能

正则表达式可用于执行所有类型的文本搜索和文本替换操作。

Java 没有内置的正则表达式类，但我们可以导入 java.util.regex 包来使用正则表达式。该软件包包括以下类:

Pattern 类 - 定义模式（用于搜索）

Matcher 类 - 用于搜索模式

PatternSyntaxException 类 - 指示正则表达式模式中的语法错误

I在此示例中，正在一个句子中搜索单词 "w3schools" 。

首先，利用 Pattern.compile() 方法创建模式。第一个参数指示正在搜索的模式，第二个参数有一个标志来指示搜索应该不区分大小写。第二个参数是可选的。

matcher() 途径用于搜索字符串中的模式。它返回一个 Matcher 对象，其中包含有关已执行搜索的信息。

如果在字符串中找到模式，find() 方法返回 true，假如没有找到，则返回 false。

---

Flags 标志

compile() 方法中的标志改变了搜索的执行方式。这里有几个:

• Pattern.CASE_INSENSITIVE - 执行搜索时将忽略字母的大小写。
• Pattern.LITERAL - 模式中的特殊字符没有任何特殊含义，在执行搜索时将被视为普通字符。
• Pattern.UNICODE_CASE - 将它与 CASE_INSENSITIVE 标志一起使用，也可以忽略英文字母表之外的字母的大小写

61.线程

线程允许程序通过同时执行多项操作来更管用地运行。

线程可以用来在后台执行复杂的任务而不中断主程序。

创建线程

创建线程有两种手段。

它可以利用扩展 Thread 类并覆盖其 run() 方法来创建:

public class MyClass extends Thread {

public void run() {

System.out.println("This code is running in a thread");

}

}

另一种创建线程的方法是实现 Runnable 接口:

public class MyClass implements Runnable {

public void run() {

System.out.println("This code is running in a thread");

}

}

假如该类扩展了 Thread 类，则能够通过创建该类的实例并调用其 start() 方法来运行线程:

Public class myclass extends thread{

Public static void main(string[] args) {

Myclass thread=new myclass();

Thread.start();

Systrm.out.println(“hsjk”);}

Public void run(){

System.out.println(“hsjd”)}

假设类实现了 Runnable 接口，则行通过将类的实例传递给 Thread 对象的构造函数，然后调用线程的 start() 途径来运行线程:

public class MyClass implements Runnable {

public static void main(String[] args) {

MyClass obj = new MyClass();

Thread thread = new Thread(obj);

thread.start();

System.out.println("This code is outside of the thread");

}

public void run() {

System.out.println("This code is running in a thread");

}

}

"extending" 和 "implementing" 线程之间的区别

首要区别在于，当一个类扩展 Thread 类时，您不能扩展任何其他类，但通过实现 Runnable 接口，也行从另一个类扩展，例如: class MyClass extends OtherClass implements Runnable.

线程并发问题：

因为线程与程序的其他部分同时运行，所以无法知道代码将以何种顺序运行。当线程和主程序读取和写入相同的变量时，其值是不可预测的。由此产生的问题称为并发挑战。

通过为了避免并发障碍，最好在线程之间共享尽可能少的属性。如果得共享属性，一种可能的解决方案是在使用线程能够更改的任何属性之前，使用线程的 isAlive() 技巧检查线程是否已完成运行。

62.lamdba表达式

lambda 表达式是一小段代码，它接受参数并返回一个值。 Lambda 表达式类似于手段，但它们不得名称，并且可能直接在方法体中实现。

语法

最方便的 lambda 表达式包含一个参数和一个表达式:

parameter -> expression

要使用多个参数，请将它们括在括号中:

(parameter1, parameter2) -> expression

表达方式有限。它们必须立即返回一个值，并且它们不能包含变量、赋值或语句，例如 if 或 for。 为了进行更复杂的管理，许可使用带有花括号的代码块。如果 lambda 表达式需要返回一个值，那么代码块应该有一个 return 语句。

(parameter1, parameter2)-> {code block }

63.文档处理

创建、读取、更新、删除文件

java.io 包中的 File 文件类允许我们处理文件。

要使用 File 类，请创建该类的对象，并指定文件名或目录名:

Import java.io.File;//导入file类

File myobj=new file(“filename.txt”);//指定文件名

创建文件：

要在 Java 中创建文件，允许使用 createNewFile() 途径。 此方式返回一个布尔值:如果文件创建成功，则返回: true ，若是文件已经存在，则返回 false。 请注意，该方法包含在 try...catch 块中。 这是必要的，基于假如发生错误（假如由于某种原因无法创建文件），它会抛出 IOException:

要在特定目录中创建文件（需要权限），请指定文件的路径并采用双反斜杠转义 "\" 字符（对于 Windows）。 在 Mac 和 Linux 上，您可能只写路径，例如: /Users/name/filename.txt

写入文件

我们使用 FileWriter 类及其 write() 技巧将一些文本写入我们在上面示例中创建的材料。 请注意，当您结束对文件的写入后，您应该使用 close() 方法关闭它:

读取文件

运用 Scanner 类来读取我们在上一章中创建的文本文件的内容

import java.io.File; // 导入 File 文件类

import java.io.FileNotFoundException; // 导入这个类来处理错误

import java.util.Scanner; // 导入 Scanner 类以读取文本文件

public class ReadFile {

public static void main(String[] args) {

try {

File myObj = new File("filename.txt");

Scanner myReader = new Scanner(myObj);

while (myReader.hasNextLine()) {

String data = myReader.nextLine();

System.out.println(data);

}

myReader.close();

} catch (FileNotFoundException e) {

System.out.println("An error occurred.");

e.printStackTrace();

}

}

}

删除文件

使用 delete() 方法:

import java.io.File; // 导入 File 文档类

public class DeleteFile {

public static void main(String[] args) {

File myObj = new File("filename.txt");

if (myObj.delete()) {

System.out.println("Deleted the file: " + myObj.getName());

} else {

System.out.println("Failed to delete the file.");

}

}

}

64.object类

说 Java 的所有类都继承了 Object，子类可以使用 Object 的所有方法。就是Java Object 类是所有类的父类，也就

Object 类位于 java.lang 包中，编译时会自动导入，我们创建一个类时，如果没有明确继承一个父类，那么它就会自动继承 Object，成为 Object 的子类。

一样的：就是Object 类可以显式继承，也可以隐式继承，以下两种方式

显示继承：

Public class runoob extends object{

}

隐式继承：

Public class runoob{

}

65.NIO Files类

java.nio.file.Files 是 Java NIO (New I/O) 包中的一个实用工具类，位于 java.nio.file 包中。

java.nio.file.Files 供应了一系列静态方法来操作文件系统中的记录和目录，大大简化了档案 I/O 操作。

主要特点

• 静态方法：所有方法都是静态的，无需创建实例
• 功能丰富：给予文档读写、属性操作、目录遍历等多种功能
• 异常处理：统一使用 IOException 处理文件操作异常
• 与 Path 配合：核心与 java.nio.file.Path 接口一起使用

66.泛型：

泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。

泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

假定我们有这样一个需求：写一个排序方法，能够对整型数组、字符串数组甚至其他任何类型的数组进行排序，该如何实现？

答案是可以启用 Java 泛型。

通过使用 Java 泛型的概念，我们能够写一个泛型方法来对一个对象数组排序。然后，调用该泛型方法来对整型数组、浮点数数组、字符串数组等进行排序。

泛型方法

你可以写一个泛型方法，该方法在调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型，编译器适当地处理每一个方法调用。

下面是定义泛型方法的规则：

所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在办法返回类型之前（在下面例子中的 <E>）。

每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。

类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。

泛型方法体的声明和其他手段一样。注意类型参数只能代表引用型类型，不能是原始类型（像 int、double、char 等）。

java 中泛型标记符：

E - Element (在集合中使用，基于集合中存放的是元素)

T - Type（Java 类）

K - Key（键）

V - Value（值）

N - Number（数值类型）

？ - 表示不确定的 java 类型

有界的类型参数:

可能有时候，你会想限制那些被允许传递到一个类型参数的类型种类范围。例如，一个操作数字的方法可能只希望接受Number或者Number子类的实例。这就是有界类型参数的目的。

要声明一个有界的类型参数，首先列出类型参数的名称，后跟extends关键字，最后紧跟它的上界。

泛型类

泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分。

和泛型方法一样，泛型类的类型参数声明部分也包括一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。因为他们接受一个或多个参数，这些类被称为参数化的类或参数化的类型。

类型通配符

利用就是1、类型通配符一般?代替具体的类型参数。例如List<?> 在逻辑上是 List<String>,List<Integer> 等所有 List<具体类型实参> 的父类。

67.序列化

Java 序列化是一种将对象转换为字节流的过程，以便可能将对象保存到磁盘上，将其传输到网络上，或者将其存储在内存中，以后再进行反序列化，将字节流重新转换为对象。

序列化在 Java 中是通过java.io.Serializable接口来实现的，该接口没有任何方法，只是一个标记接口，用于标识类可以被序列化。

打开这个记录，读取序列化的内容，然后将其还原为对象，以便在程序中运用。就是当你序列化对象时，你把它包装成一个特殊文件，能够保存、传输或存储。反序列化则

序列化是一种用于保存、传输和还原对象的方法，它使得对象可以在不同的计算机之间移动和共享，这对于分布式系统、材料存储和跨平台通信很有用。

，一个类的对象要想序列化成功，必须满足两个条件：

该类必须实现 java.io.Serializable 接口。

该类的所有属性必须是可序列化的。倘若有一个属性不是可序列化的，则该属性必须注明是短暂的。

68.网络编程

网络编程是指编写运行在多个设备（计算机）的程序，这些设备都通过网络连接起来。

java.net 包中 J2SE 的 API 具备有类和接口，它们供应低层次的通信细节。你行直接使用这些类和接口，来专注于解决问题，而不用关注通信细节。

java.net 包中提供了两种常见的网络协议的支持：

• TCP：TCP（英语：Transmission Control Protocol，传输控制协议） 是一种面向连接的、可靠的、基于字节流的传输层通信协议，TCP 层是位于 IP 层之上，应用层之下的中间层。TCP 保障了两个应用程序之间的可靠通信。通常用于互联网协议，被称 TCP / IP。
• UDP：UDP （英语：User Datagram Protocol，用户数据报协议），位于 OSI 模型的传输层。一个无连接的协议。提供了应用程序之间要发送数据的数据报。由于UDP缺乏可靠性且属于无连接协议，所以应用程序通常必须容许一些丢失、错误或重复的数据包。

本教程主要讲解以下两个主题。

• Socket 编程：这是使用最广泛的网络概念，它已被解释地非常详细。
• URL 处理：这部分会在另外的篇幅里讲，点击这里更详细地了解在Java 语言中的 URL 处理。

---

Socket 编程

套接字使用TCP提供了两台计算机之间的通信机制。 客户端程序创建一个套接字，并尝试连接服务器的套接字。

当连接建立时，服务器会创建一个 Socket 对象。客户端和服务器现在可以利用对 Socket 对象的写入和读取来进行通信。

java.net.Socket 类代表一个套接字，并且 java.net.ServerSocket 类为服务器程序提供了一种来监听客户端，并与他们建立连接的机制。

以下步骤在两台计算机之间运用套接字建立TCP连接时会出现：

• 服务器实例化一个 ServerSocket 对象，表示通过服务器上的端口通信。
• 服务器调用 ServerSocket 类的 accept() 方法，该方法将一直等待，直到客户端连接到服务器上给定的端口。
• 服务器正在等待时，一个客户端实例化一个 Socket 对象，指定服务器名称和端口号来请求连接。
• Socket 类的构造函数试图将客户端连接到指定的服务器和端口号。如果通信被建立，则在客户端创建一个 Socket 对象能够与服务器进行通信。
• 在服务器端，accept() 方法返回服务器上一个新的 socket 引用，该 socket 连接到客户端的 socket。

连接建立后，通过使用 I/O 流在进行通信，每一个socket都有一个输出流和一个输入流，客户端的输出流连接到服务器端的输入流，而客户端的输入流连接到服务器端的输出流。

TCP 是一个双向的通信协议，因此数据许可通过两个数据流在同一时间发送。以下是一些类提供的一套完整的有用的途径来实现 socket。

同步和异步：同步和异步是针对应用程序和内核的交互而言的，同步指的是用户进程触发IO 操作并等待或者轮询的去查看IO 操作是否就绪，而异步是指用户进程触发IO 操作以后便开始做自己的事情，而当IO 操作已经完成的时候会得到IO 完毕的通知。

以银行取款为例：

同步 ： 自己亲自出马持银行卡到银行取钱（使用同步 IO 时，Java 自己处理IO 读写）；

异步 ： 委托一小弟拿银行卡到银行取钱，然后给你（利用异步IO 时，Java 将 IO 读写委托给OS 处理，需要将资料缓冲区地址和大小传给OS(银行卡和密码)，OS 需拥护异步IO操作API）；

阻塞和非阻塞：阻塞和非阻塞是针对于进程在访问数据的时候，根据IO操作的就绪状态来采取的不同方式，说白了是一种读取或者写入操作方法的实现方式，阻塞方式下读取或者写入函数将一直等待，而非阻塞方式下，读取或者写入方法会立即返回一个状态值。

以银行取款为例：

阻塞 ： ATM排队取款，你只能等待（使用阻塞IO时，Java调用会一直阻塞到读写完成才返回）；

非阻塞 ： 柜台取款，取个号，然后坐在椅子上做其它事，等号广播会通知你办理，没到号你就不能去，你可以不断问大堂经理排到了没有，大堂经理如果说还没到你就不能去（使用非阻塞IO时，如果不能读写Java调用会马上返回，当IO事件分发器通知可读写时再继续进行读写，不断循环直到读写完毕）

1.BIO 编程

Blocking IO： 同步阻塞的编程方式。

BIO编程方式通常是在JDK1.4版本之前常用的编程方式。编程搭建过程为：首先在服务端启动一个ServerSocket来监听网络请求，客户端启动Socket发起网络请求，默认情况下ServerSocket回建立一个线程来处理此请求，如果服务端没有线程可用，客户端则会阻塞等待或遭到拒绝。

且建立好的连接，在通讯过程中，是同步的。在并发处理效率上比较低。大致结构如下：

同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以借助线程池机制改善。

BIO方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，但工具直观简单易理解。

使用线程池机制改善后的BIO模型图如下:

2.NIO 编程：Unblocking IO（New IO）： 同步非阻塞的编程方式。

NIO本身是基于事件驱动思想来结束的，其主要想解决的是BIO的大并发问题，NIO基于Reactor，当socket有流可读或可写入socket时，操作系统会相应的通知引用工具进行处理，应用再将流读取到缓冲区或写入操作系统。也就是说，这个时候，已经不是一个连接就要对应一个处理线程了，而是实用的请求，对应一个线程，当连接没有数据时，是没有工作线程来处理的。

NIO的最重要的地方是当一个连接创建后，不应该对应一个线程，这个连接会被注册到多路复用器上面，因而所有的连接只需要一个线程就可能搞定，当这个线程中的多路复用器进行轮询的时候，发现连接上有请求的话，才开启一个线程进行处理，也就是一个请求一个线程模式。

在NIO的处理方式中，当一个请求来的话，开启线程进行处理，可能会等待后端应用的资源(JDBC连接等)，其实这个线程就被阻塞了，当并发上来的话，还是会有BIO一样的疑问

3.AIO编程：Asynchronous IO： 异步非阻塞的编程方式。

与NIO不同，当进行读写操作时，只须直接调用API的read或write办法即可。这两种方法均为异步的，对于读管理而言，当有流可读取时，操作系统会将可读的流传入read方法的缓冲区，并通知应用程序；对于写操控而言，当操作系统将write方法传递的流写入完毕时，操作系统主动通知应用程序。即行理解为，read/write途径都是异步的，完成后会主动调用回调函数。在JDK1.7中，这部分内容被称作NIO.2，关键在java.nio.channels包下增加了下面四个异步通道：AsynchronousSocketChannel、AsynchronousServerSocketChannel、AsynchronousFileChannel、AsynchronousDatagramChanne

69.发送邮件

最初你应该在你的机器上安装 JavaMail API 和Java Activation Framework (JAF) 。就是使用Java应用程序发送 E-mail 十分简单，但

如果你想发送一封e-mail给多个收件人，那么应用下面的方法来指定多个收件人ID：

void addRecipients(Message.RecipientType type,

Address[] addresses)

throws MessagingException

下面是对于参数的描述：

type:要被设置为 TO, CC 或者 BCC，这里 CC 代表抄送、BCC 代表秘密抄送。举例：Message.RecipientType.TO

addresses: 这是 email ID 的数组。在指定电子邮件 ID 时，你将需要启用 InternetAddress() 方法。