Java入门基础

HTML文件以及markdown文件的链接

链接：https://pan.baidu.com/s/1NMznpqd-ES0jWV71wQFqKQ?pwd=cxlq
提取码：cxlq

百度网盘链接

前言

提示：这里可以添加本文要记录的大概内容：

Java是由美国Sun公司倡导和推出的一门面向对象编程语言，它最大的优点就是与平台无关，用Java语言开发的软件，编译后可以借助JRE直接运行于Windows 9x、Windows NT、Solaris、Linux、Mac OS以及其他平台上。Java的这一“一次编写，到处运行”的特点，使其被广泛应用于互联网应用程序的开发。

提示：以下是本篇文章正文内容，下面案例可供参考

一、如何运行Java文件：

首先创建java文件，然后打开命令提示符，cmd，进入到对应java文件的目录，执行javac 文件名.java生成class文件，命令java 文件名就可以运行了。

二、使用步骤

引入库

2.Java的命名规范

所有命名规则必须遵循以下规则：

1)名称只能由字母、数字、下划线、$符号组成2)命名时不能以数字开头 3)在命名是绝对不能出现Java关键字。4)绝对不允许在命名时出现中文及拼音命名。
Java中的名称命名规范（建议开发者遵守规范）：

①包名: 多单词组成时所有字母都小写:xxxyyyzzz

②类名、接口名: 多单词组成时，所有单词的首字母大写:XxxYyyZzz

③变量名、方法名: 多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写: xxxYyyZzz

④常量名:所有字母都大写。多单词时每个单词用下划线连接:XXX_YYY_ZZZ

三、 变量、常量与数据类型

1. 变量和常量

（1）变量：其值能够改变的量称为变量。变量代表程序的状态，程序可以通过改变变量值来改变程序的状态。为了能够方便地引用变量的值，在程序中需要为变量设定一个名称，这就是变量名。由于Java语言是一种强类型语言，所以变量在使用前必须首先声明。在程序中声明变量的语法格式如下：
数据类型 变量名称；
例如：int a;
（2）常量：常量代表程序运行过程中不能改变其值的量。在变量的语法格式前面添加关键字final即为常量的语法格式。此外，在Java编码规范中，要求常量名必须大写。常量的语法格式如下：
final 数据类型 常量名称 = 值；
例如：final double PI=3.14;

【实例2-1】本实例声明了两个变量number和ch，声明了一个常量SCORE。为它们赋值后，再将它们的值在控制台上输出。

public class Test1 {
public static void main(String[] args) {
	int number = 1;              //声明一整型变量number，为其赋初值1
	char ch = 'a';                //声明一字符型变量ch，为其赋初值'a'
	final double SCORE = 100.0;  //声明一双精度浮点型常量SCORE，其值为100.0
	System.out.println(number+"是整型");             //输出number
	System.out.println(ch+"是字符型");               //输出ch
	System.out.println(SCORE+"是双精度浮点型");    //输出SCORE
}
}

当声明一个变量时，编译程序会在内存里开辟一块足以容纳此变量的内存空间给它，无论变量的值如何改变，都将使用相同的内存空间。因此，善用变量将会帮助我们节省内存开销。所以要把变量定义在合适的位置。

2. 数据类型

（1）基本数据类型
在Java中规定了4类8种基本数据类型，这4类分别是整数、浮点数、字符和布尔值。其中，整数类型有byte，short，int，long，浮点数类型有单精度浮点数float和双精度浮点数double，字符型为char，布尔型为boolean

（2）String不是基本数据类型（混淆，面试的时候会问）

3、数据类型间的转换：

数据类型间的转换包括两种情况，自动类型转换和强制类型转换。为了规范简单数据类型的转换，系统基于各种简单数据类型容量的大小，为各种简单数据类型规定了不同的优先级（由低级到高级），具体如下：
byte → short → int（char） → long → float → double
低级数据类型向高级数据类型的转换称为自动类型转换，反之则称为强制类型转换。高
级数据类型转换为低级数据类型时，必须要加强制类型转换符。

byte by=1;
		int in=by;
		System.out.println(in);
Long l=1000000000000000000L;
    	float f=l;
     	System.out.println(f);
		double dou = 10.0;
		float flo;
		flo = (float) dou;                  //此处加入强制类型转换
		System.out.println(flo);
注意：char和int在同一范围内可以相互转换，无需强制
char c1 = 97;
System.out.println(c1);
int num1 = 'a';
System.out.println(num1);
甚至，我们可以将一个数字与一个字符在一个表达式中进行计算：
char c2 = 'a' + 1;
int num2 = 'a' + 1;
System.out.println("c2:          " + c2); 
System.out.println("num2:        " + num2);
System.out.println("(char) num2: " + (char) num2);

可能出现的错误:int是比char范围更大的，因此，这些错误主要便是会出现在从int转到char的过程中。
由于char是一个16位的无符号的数据类型，所以其大小范围是：0 至 2 ^ 16 -1，即 0 - 65535，用十六进制码来看，则为：’\u0000’ - ‘\uffff’。
虽然我们可以直接以一个数字赋给一个char型的变量，但是，若我们赋的值的大小大于了65536，则会报出错误来，
如下代码：

char c3 = 65535;
System.out.println(c3);
char c4 = 65536;
System.out.println(c4);

【实例2-2】 通过类型转换实现数据的累加。在实际开发过程中，经常会遇到传递的参数与所需的参数类型不一致，或者参数的类型不能够进行我们想要的操作等情况，此时就需要进行数据类型转换。
本实例通过将字符串类型转换成整型，并对转换后的数据进行累加，来了解数据类型转换的应用。

String a = "10";
	String b = "15";
	String c = "20";
	String d = "25";
	int a1 = Integer.parseInt(a);               //将字符串转换成整型
	int a2 = Integer.parseInt(b);               //将字符串转换成整型
	int a3 = Integer.parseInt(c);               //将字符串转换成整型
	int a4 = Integer.parseInt(d);               //将字符串转换成整型
	int sum = a1+a2+a3+a4;
	System.out.println("sum="+sum);

补充：Java的注释
JAVA的注释共有三种形式：单行注释、多行注释、文档注释
（1） 单行注释： //这是一个单行注释
（2） 多行注释:
/*
这是一个多行注释
/
(3) 文档注释:
/*
@author a_hasaigei
@version 1.0
这是一个文档注释。文档注释，是一种特殊的多行注释
/
4、 运算符、表达式与语句
程序由许多语句组成，而语句的基本单位是表达式与运算符。在Java中，使用+、-、、/来表示加、减、乘、除运算，使用%表示求余操作，使用=是赋值操作，使用==和！=表示关系运算，使用? :表示条件运算。
? :也称为“三元运算符”，其格式为“(条件)？表达式1：表达式2”，其意义为：如果条件表达式的值为true，则返回表达式1的值，否则返回表达式2的值。

例如，(68>60)? “及格”:“不及格”；，此条件语句的输出结果为“及格”。

public class Test2 {
	public static void main(String[] args) {
		int num1 = 100;                                //定义整型变量num1
		int num2 = 80;                                 //定义整型变量num2
		int max = compareNumForMax(num1,num2);        //调用方法得出较大值
		int min = compareNumForMin(num1,num2);        //调用方法得出较小值
		System.out.println("max="+max+","+"min="+min);  //打印较大值和较小值	
	}
public static int compareNumForMax(int a,int b){
		int c = 0;                      		     	//定义整型变量c
		c = (a>b)?a:b;  			            //通过条件运算符来比较大小
     return c;      		                        //返回较大值
	}	
public static int compareNumForMin(int a,int b){
		int c = 0;      					//定义整型变量c
		c = (a>b)?b:a;  					//通过条件运算符来比较大小
		return c;       					//返回较小值	
	}	
}

四、 流程控制语句

1、 条件控制语句

（1） 单if语句：if是条件判断，如果满足条件的话，直接执行后续语句；
注意：如果有多个if则每一个都会判断是否满足，若满足则会执行if内的代码。
例如：

int a=1；
if(a>-1){
System.out.println(“a>-1”);
}
if(a>0){
System.out.println(“a>0”);
}

（2） if…else语句:
if是条件判断，如果满足条件的话，直接执行后续语句；如果不满足条件的话，则执行else后面的语句。
格式：

if（条件）{
}else{
}

（3） if…else if…else语句: 如果满足条件的话，直接执行后续语句；如果不满足
条件的话，才判断else if的条件，若有一个满足就不再判断后边的条件。
格式：

if（条件）{
}else if（条件）{
}else{
}

（4） switch语句（不常用）
switch语句用于基于不同的条件来执行不同的动作。在switch（变量）语句里，变量只能是整型或字符型。程序先读出变量的值，然后在各个case里查找哪个值和这个变量相等，如果相等，就算条件成立，程序执行相应的分支，直到碰上break或者switch语句结束。
格式：

switch（值）{
		case 值1:break;
case 值2:break;
case 值3:break;
default:break;
}

例如：

int params=1；
switch(params){
case 0:
			System.out.println("红");
			break;
case 1:
			System.out.println("黄色");
			break;	
		case 2:
			System.out.println("蓝色");
			break;
		default:
		    System.out.println("白色");
		    break;	
		}

2、循环控制语句

（1） for循环，
格式：

for(赋初值；判断条件；赋值加减){
       执行语句
}

在该语句中，根据判断条件，检查是否要继续执行循环，当判断条件为真（true）时，继续执行循环主体内的语句；判断条件为假（false）时，则跳出循环，执行其他语句。
执行完循环主体内的语句后，循环控制变量会根据增减量的要求更改循环控制变量的值，然后再回到初始位置重新判断是否继续执行循环。
【实例2-4】 利用for语句求1+2!+3!+…+20!的和。本例通过双重for循环来达到求1到20阶乘和的目的。其中，通过外层for循环让sum和临时变量temp相加20次，通过内层for循环求出阶乘值，并赋值给temp变量。
（1） for循环，格式

public class Test3 {
     public static void main(String[] args) {
	            //通过双重for循环实现
		long sum=0;
for(int i=1;i<=20;i++)    	//用于遍历1~20
		 {   long temp=1;        	 //定义长整型变量temp
		     for(int j=1;j<=i;j++)   	//用于求i!
		       {   temp=temp*j;   }
		     sum+=temp;       		  //将i!相加
		} 
		System.out.println(sum);
	}

（2） while循环，格式

while（判断条件）{
   执行语句
}

例子：

int a=5;
		while(a>1) {
			System.out.println(a);
			a--;
		}

【实例2-5】 本例通过if…else语句和正则表达式统计一个字符串中汉字、英文字母、特殊字符、空格和数字的个数。它声明了4个变量，当符合判断条件时，令对应的变量自加1。

public class Test4 {
	public static void main(String[] args) {
		String str = "a12中国3@b&4语*言 3c";	//需要被统计的字符串                                                  		String E1 = "[\u4e00-\u9fa5]";		//汉字的正则表达式
		String E2 = "[a-zA-Z]";				//英文字母的正则表达式
		String E3 = "[0-9]";				//数字的正则表达式
     String E4 = "\\s+";			     //空格的正则表达式
		int chineseCount = 0;			//初始化统计汉字的变量
		int englishCount = 0;			//初始化统计英文字母的变量
		int numberCount = 0;			//初始化统计数字的变量
		int spaceCount = 0;			//初始化统计空格的变量
		String temp;				//定义临时变量temp
		for (int i = 0; i < str.length(); i++)	//遍历字符串中的字符
		{    
			//取出字符串中的单一字符并转成字符串
			temp=String.valueOf(str.charAt(i));
			//通过if…else语句统计不同字符的数量
			if (temp.matches(E1)){  
chineseCount++;  
}else if (temp.matches(E2)) {
  englishCount++;  
}else if (temp.matches(E3)) {  
numberCount++;  
}else if(temp.matches(E4)){  
spaceCount++;  
}
		}    
		System.out.println("汉字数:" + chineseCount);
		System.out.println("英文数:" + englishCount);
		System.out.println("数字数:" + numberCount);
		System.out.println("特殊字符:" + (str.length()- (chineseCount + englishCount + numberCount+spaceCount))); 
		System.out.println("空格:"+spaceCount);
	}
}

提示：（1）String.valueOf（）方法是一个静态方法，作用是将其他数据类型的数据转换成字符串类型。
例：String numberStr= String.ValueOf(90);
(2) str.charAt(i)方法，作用是获取字符串某一下标的字符，类型是char。
例：char ch=“abcdef”.charAt(1);
System.out.println(ch); //结果ch的值为b
（3）正则表达式是一种可用于模式匹配和替换的规范，它是由普通字符和特殊字符组成的文字模式。正则表达式作为一个模板，可将某个字符模式与所搜索的字符串进行匹配。（一般用于校验格式是否正确，例如密码格式校验）。
代码为：字符串对象.matches(正则表达式)，返回值为true或false
boolean boo=“a”.matches("[a-zA-Z]"); //boo的值为true。
练习：使用while循环的完成人机猜拳小游戏，一局定胜负。

五、 数组的创建

Java中数组的创建，包括声明数组和分配内存。

1、数组的三种声明方式如下：

方式一 数组类型[] 数组名={数值0,数值1,数值2,数值3,…};
例如：

String[] test1={"a","b","c","…"};

方式二 数组类型[] 数组名;数组名=new 数组类型[]{数值0,数值1,数值2,…};
例如：

String[] test2; test2=new String[]{"a","b","c","…"};

方式三 数组类型[] 数组名;数组名=new 数组类型[数组长度];
例如：

String[] test3; test3=new String[6];

这三种方式的区别是，方式一和方式二的数组大小由系统分配，我们只为数组中每个位置赋初值；方式三只指定数组大小，初始化工作由系统完成，即系统为数组的每个位置赋初始值。由于String类型为引用类型，所以默认初始值为null。
在声明数组时，也可以将[]放在数组名后面，其格式如下：数据类型 数组名[]； //声明数组 (不建议放后边)

2、数组中元素的表示方法

数组中元素的获取是由索引来完成的，数组索引由0开始。比如，有一个长度为10的数组arr，那么它的索引是从0到9，如果想要取第十个元素，就可以通过arr[9]来获取。

3、数组的赋值

数组的赋值除了可以直接用大括号来完成，比如int []arr = {1,2,3}，还可以通过指定元素赋值，比如arr[0]=1，arr[1]=2，arr[2]=3，其效果和第一种赋值方式一样。

数组的相关方法

(1) 获取数组长度（length是属性，不是方法。Java面试会问）
其格式为：数组名.length。
(2)数组的拷贝：Java数组的复制操作可以分为深拷贝和浅拷贝，简单来说深拷贝，可以将对象的值和对象的内容复制（相当于每拷贝一个都是一个独立的个体）;浅拷贝是指对对象引用的复制（相当于共用一个对象）。

①浅拷贝举例：

int [] a= {1,2,3,4};
     int [] b=a;
     System.out.println(a[1]);//值为2
     System.out.println(b[1]);//值为2
     b[1]=3;
     System.out.println(b[1]);//值为2
     System.out.println(a[1]); //值为3,将a的引用拷贝给了b，b的值改变，a的值跟着变，也就是浅拷贝

②深拷贝举例：System.arrcopy（）方法为数组的深拷贝
其格式为：System.arrcopy(源数组名，起始索引，目标数组名，起始索引，拷贝数组元素个数)。比如，有两个数组，int A[] = {1，2，3}和int B[] = {4，5，6}，则System.arrcopy(A，0，B，0，2)方法的作用是：复制A数组中从下标0开始的2个元素到目标数组B，从目标数组B的下标0所对应的位置开始存储（若已有数据会被覆盖）。这样拷贝后，B数组的元素从头到尾依次是1，2，6。
例如：

	 int[] A = {1,2,3};
 	 int[] B = {4,5,6};
 	 System.arraycopy(A,0,B,0,2);
 	 for(int i=0;i<B.length;i++){
 		 System.out.print(B[i]+","); // 1,2,6,
 	 }
 	 B[0]=9;
System.out.println(B[0]); //结果为9
 	 System.out.println(A[0]); //结果为1，并未被B的元素值改变而改变

(3) 数组的排序
Arrays.sort(数组名)，使用该方法可让数组元素按从小到大的顺序排列。
一般来讲，Java数组初始化需要声明数组和分配内存，但在许多情况下，数组需要动态扩容以满足实际开发的需要。数组的扩容在本质上并没有增加原数组的容量，只是将原数组内容拷贝到新的大数组。(在不知道所需要长度的情况下我们一般不使用数组而是使用集合)
【实例2-7】 数组的拷贝和排序。为方便比较原始数组和扩容后新数组的内容差异，本例通过数组的排序方法对内容进行了排序，并将数组内容在控制台上输出。

package test;
import java.util.Arrays;
public class test {
	public static void main(String[] args) {
		int[] a = {0,36,66,5,13,28,1};                 //初始化a数组
		Arrays.sort(a);                             //对a数组进行排序
		System.out.println("a数组的元素是：");
		 for (int i = 0; i < a.length; i++) {            //对数组中的元素进行遍历输出
				System.out.print(a[i]+" ");
			}
			int increase = 3;          //容量增加量
			int[] b = new int[a.length+increase];         //初始化b数组
			System.arraycopy(a, 0, b, 0, a.length);     //将a数组拷贝到b数组
          	int num = 100;                            //定义整型变量并赋100
	for (int i = a.length; i < b.length; i++) {          //对b数组的剩余元素赋值
		b[i] = num;
		num = num+1;
	}
	System.out.println();
	Arrays.sort(b);                              //对b数组进行排序
	System.out.println("扩容后b数组的元素是：");
	for (int i = 0; i < b.length; i++) {
		System.out.print(b[i]+" ");
	}
}
}

四、 面向对象程序设计

1、面向对象

面向对象是一种程序设计思想，计算机程序设计的实质，就是将现实中一些事物的特征抽离出来，描述成一些计算机事件的过程。在这种抽象的过程中，我们把具体的事物封装成一个一个的整体进行描述，使被描述的对象具备一些系统性、整体性的行为和特征，我们把这种设计思想称为面向对象。
面向对象的程序设计有三大特征，它们分别是封装、继承和多态。其意义如下：
封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式。
继承：子类通过一种方式接受父类所有的公有的、受保护的成员变量和成员方法。
多态：程序在运行过程中，同一种类型在不同条件下表现不同的结果，这种不定状态的表现形式被称为多态。

2、类与对象

类是抽象的概念集合，表示的是一个共性的产物，类中定义的是属性和方法。对象是共性产物的一个独立个体，是类的实例。
（1）类
① 类的声明：需要定义类的名称、对该类的访问权限、该类与其他类的关系等。类的
明的格式如下：

[修饰符] class <类名> [extends 父类名] [implements 接口列表]{
     类体
 }
②	类体主要由以下两部分构成：成员变量的定义和成员方法的定义
方法的格式：
[修饰符] <方法返回值的类型> <方法名>( [参数列表]) {
        [方法体]
}

例如：

public class Student {
	//类的成员变量(属性)有学号、姓名、性别等，
	int id;
	String name;
	//类的成员方法(方法)有学习、选课等
	public void study(){
		System.out.println("学生在学习");
	}
}

（2）对象
①每个对象都是某个类（class）的一个实例（instance），在创建对象时需要用到new关键字。例如，有一个Person类，实例化Person类（即创建对象）的代码如下：

  Person person = new Person();

对象.属性：表示调用对象的属性。
当实例化对象后，可以按照如下方式操作对象：
对象.方法()：表示调用对象的方法。
构造方法：构造器用于构造该类的实例（对象）。Java通过new关键字来调用构造器，从而返回该类的实例。
构造方法是一种特殊的方法，其格式如下：

[修饰符] 类名(形参列表){
	    ……
}

构造方法的要点：
(1)构造器的方法名必须和类名一致。
(2)通过new关键字调用。
(3)构造方法虽然有返回值，但是不能定义返回类型(返回值的类型肯定是本类)，不能在构造器里调用return。
(4)如果我们没有定义构造器，则系统会自动定义一个无参的构造函数。如果已定义则编译器不会添加！

3、Java中的访问修饰符

private：用private修饰的类、类属变量及方法，只有本类可以访问，包内包外的任何类均不能访问。
default：如果一个类、类属变量及方法没有用任何修饰符，则其访问权限为default（默认）。对于默认访问权限的类、类属变量及方法，包内的任何类（包括继承了此类的子类）都可以访问它，而包外的任何类都不能访问它（包括包外继承了此类的子类）。
protected：用protected修饰的类、类属变量及方法，包内的任何类及包外那些继承了该类的子类均能访问，protected重点突出继承。
public：用public修饰的类、类属变量及方法，包内及包外的任何类（包括子类和普通类）都可以访问。

4、 方法

Java方法是语句的集合，多个语句结合在一起执行一个功能。方法定义包括方法头和方法体，如下所示：

public static int compareNumForMax(int a,int b){ 		//方法头
		int c = 0;										//方法体
		if(a>b){							//方法体
		  c = a;}							//方法体
		else{							//方法体
		  c = b;}							//方法体
		return c;						//方法体
	}

访问修饰符：该方法中的访问修饰符为public，访问修饰符是可选的，其功能是告知编译器如何调用该方法。
修饰符：该方法中的修饰符为static，被static修饰的成员称为静态成员，被所有对象共享，并且可以直接通过“类名.静态成员”格式调用。static成员优先于对象存在，因为static成员随着类的加载就已经存在了。
方法体：该方法的方法体即为{}中的全部语句。
返回类型：该方法的返回类型为int（整型），方法可以返回一个值，也可以没有返回值。无返回值时，返回类型的关键字为void。
方法名称：该方法的方法名称为compareNumForMax。
参数：该方法的参数为a和b，当调用一个方法时，可以传递值给参数。

补充：static
在类中，用static声明的成员变量为静态成员变量。它为该类的公用变量，属于类，被该类的所有实例共享，在类被载入时被显式初始化，对于该类的所有对象来说，static成员变量只有一份。被该类的所有对象共享！一般都是用“类名.类属性”使用。
用static声明的方法为静态方法，不需要对象，就可以调用(类名.方法名)，在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可访问非static的成员。可以通过对象引用或类名（不需要实例化）访问静态成员，一般是通过类来访问静态成员。
【实例2-8】 输出水果属性。本例定义一个名为Test7的类。我们可以利用其中的setProperties方法设置水果属性，而利用printProperties方法输出水果属性。
//类声明，每个Java程序中只能有一个类被声明为Public类
//与此同时，Java程序名必须与该类名称相同

public class Test7 {
	private boolean seedes; 			           //成员变量声明
	private boolean seasonal;
	private float price;
	// 成员方法，设置水果属性
	public void setProperties(boolean seed, boolean season, float cost) {
		seedes = seed;
		seasonal = season;
		price = cost;
	}
	// 成员方法，输出水果属性
	public void printProperties() {
		if (seedes) {
			System.out.println("Fruit is seedes");
		} else {
			System.out.println("Fruit is seedless");
		}
		if (seasonal) {
			System.out.println("Fruit is seasonal");
		} else {
			System.out.println("Fruit is not seasonal");
		}
		System.out.println("Price is " + price);
	}
	// 类中包含了main方法，说明该类为Java程序的主类，即可以被运行的类
	// 这是Java Application应用程序的入口
public static void main(String[] args) {
		boolean myseed, myseason;	  		//声明局部变量
		float mycost;
		myseed = true;			   	//为局部变量赋值
		myseason = true;
		mycost = 25.86F;
		Test7 MyFruit = new Test7();			//基于类创建对象
		// 调用setProperties方法，为成员变量赋值
		MyFruit.setProperties(myseed, myseason, mycost);
		MyFruit.printProperties();    // 调用printProperties方法，输出水果属性
	}
}

五、 集合类的应用

集合类：集合类存放于java.util包中。集合类存放的都是对象的引用，而非对象本身。通俗地说，集合就是一个存放数据对象引用的容器。

1、集合类的分类

集合类型主要有3种：set（集）、list（列表）和map（映射）。
常用的集合类实现了在系统中定义的三大接口，分别为：java.util.Set接口、java.util.List接口和java.util.Map接口。其中List和Set接口继承自Collection接口。它们的关系如下所示。
Collection（接口）
–List：（接口）
–ArrayList / LinkedList / Vector（类）
–Set ：（接口）
–HashSet / TreeSet（类）
Map（接口）
–HashMap（类）
–HashTable（类）
–TreeMap（类）
在Java程序设计语言中，接口不是类，而是对类的一组需求描述，实现接口的类要按接口描述的统一格式进行定义，定义接口的关键字是interface。
Set集合中的对象不按特定方式排序，只是简单地把对象加入集合中。同时，Set集合中不能有重复对象，List集合的主要特征是其对象以线性方式存储，集合中可以存放重复对象，Map是一种把键对象和值对象映射的集合，它的每一个元素都包含一对键对象和值对象。

2、常用集合类

接下来介绍两种常用的集合类ArrayList和HashMap。
（1）ArrayList集合类实现了List接口，每个ArrayList实例都有一个容量，当元素添加到ArrayList集合，它的容量自动增加。ArrayList集合允许添加所有类型，包括null。下面介绍一下ArrayList类的常用方法。
public int size()：返回此列表中元素的数目。
public boolean isEmpty()：如果此列表不包含元素，返回true。
public E get(int index)：返回此列表中指定位置的元素。
public E set(int index,E element)：用指定元素替换此列表中指定位置的元素。
public boolean add(E e)：将指定的元素插入到列表的末尾。
public E remove(int index)：移除此列表中指定位置的元素，所有后续元素左移（下标减1）。
例如：

     ArrayList<String> list=new ArrayList<>();
	 list.add("小明");
	 list.add("小红");
	 System.out.println(list);
	 list.remove(0);
	 System.out.println(list);

错误示范：

 List<String> list1=new List<>();

因为List是一个接口，不是一个类，所以不能直接创建对象。但是可以向上转型。

List<String> list1=new ArrayList<>();  

【实例2-9】 使用集合对数据进行增删改查。本例通过ArrayList集合实现了数据的增删改查，首先在主函数中创建一个集合，然后定义增、删、改、查方法，将创建的集合对象作为参数传入方法，在方法里面通过集合自身的增、删、改、查方法来对数据进行处理。

import java.util.ArrayList;
import java.util.List;
public class Test8 {
     private static ArrayList<String> list;
     public static void main(String[] args) {	
		list = new ArrayList<>();     //实例化一个ArrayList集合对象
		add(list,"小明");            //调用add(List<String> list,String name)方法
		add(list,"小红");            //调用add(List<String> list,String name)方法
		System.out.println("添加完之后查询输出:");
        System.out.println(select(0));  //调用select(int index)方法，并输出此方法的返回值
	   System.out.println(select(1));  //调用select(int index)方法，并输出此方法的返回值
	   update(1,"小华");                      //调用update(int index,String name)方法
	   System.out.println("修改之后输出:");
	   for(String n:list){                        //遍历集合中的字符串
		 System.out.println(n);
	   }
		delete(1);                       //调用delete(int index)方法
		System.out.println("删除之后输出:");
		for(String n:list){           //遍历集合中的字符串
			System.out.println(n);
		}
	}
public static void add(List<String> list,String name){
		list.add(name);             //通过集合对象添加数据
	}
	public static void delete(int index){
		list.remove(index);          //通过集合对象删除数据
	}
public static void update(int index,String name){
		list.remove(index);          //通过集合对象删除数据
		list.add(index, name);        //通过集合对象添加数据
	}
	public static String select(int index){
		return list.get(index);         //通过集合对象查询数据
	}
}

注意：静态方法能够直接调用静态方法，但不能直接调用普通方法，必须实例化后才可调用。
【实例2-10】 利用Collections对集合进行排序。java.util.Collections是一个包装类，它包含有各种有关集合操作的静态多态方法，这些方法的参数和返回值都是集合。此类不能实例化，就像一个工具类，服务于Java的Collection框架。
本例通过Collections包装类的sort(List list)方法对ArrayList集合进行升序排序。

import java.util.ArrayList;
import java.util.Collections;
public class Test9 {
	public static void main(String[] args) {
		ArrayList<Integer> list = new ArrayList<>();  //实例化一个集合对象
		list.add(33);       					  //添加数据
		list.add(29);       					  //添加数据
		list.add(10);        					  //添加数据
		list.add(14);       					  //添加数据
		list.add(77);       					  //添加数据
		Collections.sort(list);					  //对集合进行升序排序
		for(int num:list){   					  //遍历集合
			System.out.print(num+" ");
		}
	}
}

补充foreach用法。
（2）HashMap集合类是基于哈希表的Map接口的实现，这种实现提供了所有可选的Map操作，并允许null值和null键。下面介绍一下HashMap类的常用方法。
public int size()：返回HashMap集合中的键值映射的数目。
public boolean isEmpty()：如果这个HashMap不包含键值映射则返回true，否则返回false。
public V get(Object key)：返回指定的键映射的值，如果这个HashMap不包含此键，则返回null。
public V put(K key,V value)：将指定值与此映射中的指定键关联。如果映射以前包含一个键的映射，旧值将被替换。
public V remove(Object key)：从HashMap集合中移除指定的键映射。
例如：

HashMap<String,String> hash=new HashMap<>();
		hash.put("a", "a");
		hash.put("b", "b");
		String a=hash.get("a");
		System.out.println(a);
		System.out.println(hash.size());

六、 异常处理语句

异常是在程序运行过程中发生的、会打断程序正常执行的事件，下面是几种常见的异常。

1、 NullPointerException：没有给对象开辟内存空间时会出现空指针异常。
2、 ArithmeticException：算数异常。
3、 ClassCastException：类型转换异常。
异常处理语句是由try、catch与finally三个关键字所组成的程序块，其语法如下：

try{
     要检查的语句；
}catch(异常类 对象名称){
  异常发生时的处理语句；
}finally{
  一定会运行到的程序代码；
}

除了用try，catch和finally处理异常，还可以在方法体上抛出异常，如果方法内的程序代码有可能发生异常，且方法内又没有使用任何代码块来捕捉这些异常，则必须在声明方法时一并指明所有可能发生的异常，以便让调用此方法的程序得以做好准备来捕捉异常。
如果要由方法抛出异常，则方法必须以下面的语法来声明：
方法名称（参数…） throws 异常类 1，异常类 2，…
例：

public class te {
	public static void main(String[] args) {
		try {
			exceptionTest();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public static void exceptionTest() throws Exception {
		try {
			int a=0;
			int b=10;
			System.out.println(b/a);
		}catch(Exception e) {
			System.out.println("异常处理:"+e); //捕获到异常才会执行的代码
			throw e;
		}finally{
			System.out.println("关闭"); //一定能够执行到的代码
		}
	}
}