JAVA基本语法

1. JAVA语言概述

1.1 java技术体系

• Java SE(Java Standard Edition)标准版
  • 支持面向桌面级应用（如Windows下的应用程序）的Java平台，即定位个人计算机的应用开发。
  • 包括用户界面接口AWT及Swing，网络功能与国际化、图像处理能力以及输入输出支持等。
  • 此版本以前称为J2SE
• Java EE(Java Enterprise Edition)企业版
  • 为开发企业环境下的应用程序提供的一套解决方案，即定位在服务器端的Web应用开发。
  • JavaEE是JavaSE的扩展，增加了用于服务器开发的类库。如：Servlet能够延伸服务器的功能，通过请求-响应的模式来处理客户端的请求；JSP是一种可以将Java程序代码内嵌在网页内的技术。
  • 版本以前称为J2EE
• Java ME(Java Micro Edition)小型版
  • 支持Java程序运行在移动终端（手机、机顶盒）上的平台，即定位在消费性电子产品的应用开发
  • JavaME是JavaSE的内伸，精简了JavaSE 的核心类库，同时也提供自己的扩展类。增加了适合微小装置的类库：javax.microedition.io.*等。
  • 此版本以前称为J2ME
    

1.2 java开发环境

• JVM (Java virtual Machine)：Java虚拟机，负责执行Java字节码（是一种与平台无关的指令集，可以在任何安装了JVM的平台上运行）
• JRE (Java Runtime Environment) ：Java运行时环境，包含JVM 和运行时所需要的核心类库。
• JDK (Java Development Kit, )：Java开发工具包，包含JRE 和开发人员使用的工具。

Java程序从开发到执行的流程：
通过JDK开发工具包开发Java程序后，通过JDK编译器检查Java程序错误并编译为.class文件，JRE中的JVM将class文件解释为机器语言，最终执行硬件，完成运行。

如下是Java 8.0 Platform：

1.3 JDK下载安装

JDK下载安装

1.4 HelloWorld

JDK安装完毕，我们就可以开发第一个Java程序了，习惯性的称为：HelloWorld。

• 开发步骤
  Java程序开发三步骤：编写、编译、运行。

  • 将 Java 代码编写到扩展名为 .java 的源文件中
  • 通过 javac.exe 命令对该 java 文件进行编译，生成一个或多个字节码文件
  • 通过 java.exe 命令对生成的 class 文件进行运行
    

• 编写
  （1）在D:\HelloTest 目录下新建文本文件，完整的文件名修改为Hello.java，其中文件名为Hello，后缀名必须为.java。
  
  （2）在文件中输入如下代码，并且保存：

  class Hello {
    	public static void main(String[] args) {
      	System.out.println("HelloWorld!!");
    	}
  }
  

• 编译
  在DOS命令行中，进入D:\HelloTest目录，使用javac 命令进行编译。
  
  编译成功后，命令行没有任何提示。打开D:\HelloTest目录，发现产生了一个新的文件 Hello.class，该文件就是编译后的文件，是Java的可运行文件，称为字节码文件，有了字节码文件，就可以运行程序了。

  

• 运行
  在DOS命令行中，在字节码文件目录下，使用java 命令进行运行。

• 修改成中文

  class Hello {
    	public static void main(String[] args) {
      	System.out.println("HelloWorld 你好世界!!");
    	}
  }
  

• 重新编译运行
  

• 修改编码集
  

• 再次编译运行
  

1.5 结构与格式

• Java程序的结构与格式

  • 结构：

    类{
        方法{
            语句;
        }
    }
    

  • 格式：

    （1）每一级缩进一个Tab键
    （2）{}的左半部分在行尾，右半部分单独一行，与和它成对的"{"的行首对齐

• 注意缩进!

  • 一定要有缩进。缩进就像人得体的衣着一样！
  • 只要遇到{}就缩进，缩进的快捷键tab键。

• 必要的空格

  • 变量类型、变量、赋值符号、变量值之间填充相应空格，更美观。比如： int num = 10;

• Java程序的入口
  Java程序的入口是main方法

  public static void main(String[] args){    
  
  }
  

• 两种常见的输出语句

  • 换行输出语句：输出内容，完毕后进行换行，格式如下：

    System.out.println(输出内容);
    

  • 直接输出语句：输出内容，完毕后不做任何处理，格式如下

    System.out.print(输出内容);
    

  注意事项：

  ​ 换行输出语句，括号内可以什么都不写，只做换行处理

  ​ 直接输出语句，括号内什么都不写的话，编译报错

1.6 源文件名与类名

（1）源文件名是否必须与类名一致？public呢？

如果这个类不是public，那么源文件名可以和类名不一致。但是不便于代码维护。

如果这个类是public，那么要求源文件名必须与类名一致。否则编译报错。

我们建议大家，不管是否是public，都与源文件名保持一致，而且一个源文件尽量只写一个类，目的是为了好维护。

（2）一个源文件中是否可以有多个类？public呢？

一个源文件中可以有多个类，编译后会生成多个.class字节码文件。

但是一个源文件只能有一个public的类。

1.7 注释

源文件中用于解释、说明程序的文字就是注释。

注释分类

• ​ 单行注释

//注释信息

• ​ 多行注释

/* 
注释文字1 
注释文字2
注释文字3
*/

• 文档注释

/**
  @author  指定java程序的作者
  @version  指定源文件的版本
*/ 

• 案例
  文档注释内容可以被JDK提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档。

/**
文档注释演示。这是我的第一个Java程序！^_^
@author songhk
@version 1.0
*/
public class HelloWorld{
    
	/**
	Java程序的入口
	@param args main方法的命令参数
	*/
    public static void main(String[] args){
        System.out.println("hello");
    }
}

操作方式。比如：

javadoc -d mydoc -author -version HelloWorld.java

1.8 Java API文档

• API （Application Programming Interface，应用程序编程接口）是 Java 提供的基本编程接口。
• Java语言提供了大量的基础类，因此 Oracle 也为这些基础类提供了相应的说明文档，用于告诉开发者如何使用这些类，以及这些类里包含的方法。大多数Java书籍中的类的介绍都要参照它来完成，它是编程者经常查阅的资料。
  下载API文档：
• 在线看：
  https://docs.oracle.com/javase/8/docs/api/index.html
  https://docs.oracle.com/en/java/javase/17/docs/api/index.html
• 离线下载：
  https://www.oracle.com/cn/java/technologies/javase-jdk8-doc-downloads.html
  https://www.oracle.com/java/technologies/javase-jdk17-doc-downloads.html

1.9 Java优缺点

优点

• 跨平台性： 这是Java的核心优势。Java在最初设计时就很注重移植和跨平台性。比如：Java的int永远都是32位。不像C++可能是16，32，可能是根据编译器厂商规定的变化。

• 通过Java语言编写的应用程序在不同的系统平台上都可以运行。“Write once , Run Anywhere”。

• 原理：只要在需要运行 java 应用程序的操作系统上，先安装一个Java虚拟机 (JVM ，Java Virtual Machine) 即可。由JVM来负责Java程序在该系统中的运行。

  
  

• 面向对象性：

  面向对象是一种程序设计技术，非常适合大型软件的设计和开发。面向对象编程支持封装、继承、多态等特性，让程序更好达到高内聚，低耦合的标准。

• 健壮性：
  吸收了C/C++语言的优点，但去掉了其影响程序健壮性的部分（如指针、内存的申请与释放等），提供了一个相对安全的内存管理和访问机制。

• 安全性高：

  Java适合于网络/分布式环境，需要提供一个安全机制以防恶意代码的攻击。如：安全防范机制（ClassLoader类加载器），可以分配不同的命名空间以防替代本地的同名类、字节代码检查。

• 简单性：

  Java就是C++语法的简化版，我们也可以将Java称之为“C++--”。比如：头文件，指针运算，结构，联合，操作符重载，虚基类等。

• 高性能：

  • Java最初发展阶段，总是被人诟病“性能低”；客观上，高级语言运行效率总是低于低级语言的，这个无法避免。Java语言本身发展中通过虚拟机的优化提升了几十倍运行效率。比如，通过JIT(JUST IN TIME)即时编译技术提高运行效率。

  • Java低性能的短腿，已经被完全解决了。业界发展上，我们也看到很多C++应用转到Java开发，很多C++程序员转型为Java程序员。

缺点

• 语法过于复杂、严谨，对程序员的约束比较多，与python、php等相比入门较难。但是一旦学会了，就业岗位需求量大，而且薪资待遇节节攀升。
• 一般适用于大型网站开发，整个架构会比较重，对于初创公司开发和维护人员的成本比较高（即薪资高），选择用Java语言开发网站或应用系统的需要一定的经济实力。
• 并非适用于所有领域。比如，Objective C、Swift在iOS设备上就有着无可取代的地位。浏览器中的处理几乎完全由JavaScript掌控。Windows程序通常都用C++或C#编写。Java在服务器端编程和跨平台客户端应用领域则很有优势。

1.10 JVM功能说明

JVM（Java Virtual Machine ，Java虚拟机）：是一个虚拟的计算机，是Java程序的运行环境。JVM具有指令集并使用不同的存储区域，负责执行指令，管理数据、内存、寄存器。

• 实现Java程序的跨平台性
  我们编写的Java代码，都运行在JVM 之上。正是因为有了JVM，才使得Java程序具备了跨平台性。
  
  使用JVM前后对比：
  

• 自动内存管理(内存分配、内存回收)

  • Java程序在运行过程中，涉及到运算的数据的分配、存储等都由JVM来完成
  • Java消除了程序员回收无用内存空间的职责。提供了一种系统级线程跟踪存储空间的分配情况，在内存空间达到相应阈值时，检查并释放可被释放的存储器空间。
  • GC的自动回收，提高了内存空间的利用效率，也提高了编程人员的效率，很大程度上减少了因为没有释放空间而导致的内存泄漏。

  面试题：

  Java程序还会出现内存溢出和内存泄漏问题吗？ Yes!

2. JAVA语言基础

2.1 关键字

被Java语言赋予了特殊含义，用做专门用途的字符串（或单词）

 

2.2 标识符

Java中变量、方法、类等要素命名时使用的字符序列，称为标识符。

标识符的命名规则（必须遵守的硬性规定）：

> 由26个英文字母大小写，0-9 ，_或 $ 组成  
> 数字不可以开头。
> 不可以使用关键字和保留字，但能包含关键字和保留字。
> Java中严格区分大小写，长度无限制。
> 标识符不能包含空格。

标识符的命名规范（建议遵守的软性要求，否则工作时容易被鄙视）:

> 包名：多单词组成时所有字母都小写：xxxyyyzzz。
  例如：java.lang、com.atguigu.bean
  
> 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
  例如：HelloWorld，String，System等
  
> 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
  例如：age,name,bookName,main,binarySearch,getName
  
> 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
  例如：MAX_VALUE,PI,DEFAULT_CAPACITY

注意：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。

更多细节详见《代码整洁之道_关于标识符.txt》《阿里巴巴Java开发手册-1.7.1-黄山版》

 

2.3 常量

常量：在程序运行过程中，其值不可以发生改变的量。

常量分类：

常量类型	说明	举例
字符串常量	用双引号括起来的内容	“Hello World”
整数常量	不带小数的数字	666，888
小数常量	带小数的数字	3.14，-5.2
字符常量	用单引号括起来的内容	‘A’，‘0’，‘我’
布尔常量	布尔值，表示真假	true|false
空常量	一个特殊的值，空值	null

注意：空常量不能直接输出。
 

2.4 变量

变量是程序中不可或缺的组成单位，最基本的存储单元。

变量的概念：

• 内存中的一个存储区域，该区域的数据可以在同一类型范围内不断变化

• 变量的构成包含三个要素：数据类型、变量名、存储的值

• Java中变量声明的格式：数据类型 变量名 = 变量值
  

• 变量的作用：用于在内存中保存数据。

• 使用变量注意：

  • Java中每个变量必须先声明，后使用。
  • 使用变量名来访问这块区域的数据。
  • 变量的作用域：其定义所在的一对{ }内。
  • 变量只有在其作用域内才有效。出了作用域，变量不可以再被调用。
  • 同一个作用域内，不能定义重名的变量。

Java中变量的数据类型分为两大类：

• 基本数据类型：包括 整数类型、浮点数类型、字符类型、布尔类型。

• 引用数据类型：包括数组、 类、接口、枚举、注解、记录。

变量的声明

格式：数据类型  变量名;

//存储一个整数类型的年龄
int age; 

//存储一个小数类型的体重
double weight;

//存储一个单字符类型的性别 
char gender;

//存储一个布尔类型的婚姻状态
boolean marry;

//存储一个字符串类型的姓名
String name;

//声明多个同类型的变量
int a,b,c; //表示a,b,c三个变量都是int类型。

注意：变量的数据类型可以是基本数据类型，也可以是引用数据类型。

变量的赋值
给变量赋值，就是把“值”存到该变量代表的内存空间中。同时，给变量赋的值类型必须与变量声明的类型一致或兼容。

变量名 = 值;

//使用合适类型的`常量值`给已经声明的变量赋值
age = 18;
weight = 109;
gender = '女';

//使用其他`变量`或者`表达式`给变量赋值
int m = 1;
int n = m;
        
int x = 1;
int y = 2;
int z = 2 * x + y;

变量可以反复赋值

//先声明，后初始化
char gender;
gender = '女';

//给变量重新赋值，修改gender变量的值
gender = '男';
System.out.println("gender = " + gender);//gender = 男

也可以将变量的声明和赋值一并执行

boolean isBeauty = true;
String name = "迪丽热巴";

内存结构如图：

2.5 基本数据类型

计算机存储单位

• 字节（Byte）： 是计算机用于计量存储容量的基本单位，一个字节等于8 bit。

• 位（bit）： 是数据存储的最小单位。二进制数系统中，每个0或1就是一个位，叫做bit（比特），其中8 bit 就称为一个字节(Byte)。

• 转换关系：

  • 8 bit = 1 Byte
  • 1024 Byte = 1 KB
  • 1024 KB = 1 MB
  • 1024 MB = 1 GB
  • 1024 GB = 1 TB

整数类型：byte、short、int、long

定义long类型的变量，赋值时需要以"l"或"L"作为后缀。
Java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long。
Java的整型常量默认为 int 型。

浮点类型：float、double

• 与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作系统的影响
  
• 浮点型常量有两种表示形式：
  • 十进制数形式。如：5.12 512.0f .512 (必须有小数点）
  • 科学计数法形式。如：5.12e2 512E2 100E-2
• float：单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。
• double：双精度，精度是float的两倍。通常采用此类型。
• 定义float类型的变量，赋值时需要以"f"或"F"作为后缀。
• Java 的浮点型常量默认为double型。

关于浮点型精度的说明

• 并不是所有的小数都能可以精确的用二进制浮点数表示。二进制浮点数不能精确的表示0.1、0.01、0.001这样10的负次幂。

• 浮点类型float、double的数据不适合在不容许舍入误差的金融计算领域。如果需要精确数字计算或保留指定位数的精度，需要使用BigDecimal类。

字符类型：char

• char 型数据用来表示通常意义上“字符”（占2字节）

• Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。

• 字符型变量的三种表现形式：

  • **形式1：**使用单引号(’ ')括起来的单个字符。

    例如：char c1 = ‘a’; char c2 = ‘中’; char c3 = ‘9’;

  • **形式2：**直接使用 Unicode值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。

    例如：\u0023 表示 ‘#’。

  • **形式3：**Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。

    例如：char c3 = ‘\n’; // '\n’表示换行符

• char类型是可以进行运算的。因为它都对应有Unicode码，可以看做是一个数值。

布尔类型：boolean

• boolean 类型用来判断逻辑条件，一般用于流程控制语句中：

  • if条件控制语句；
  • while循环控制语句；
  • for循环控制语句；
  • do-while循环控制语句；

• boolean类型数据只有两个值：true、false，无其它。

  • 不可以使用0或非 0 的整数替代false和true，这点和C语言不同。
  • 拓展：Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达所操作的boolean值，在编译之后都使用java虚拟机中的int数据类型来代替：true用1表示，false用0表示。——《java虚拟机规范 8版》

2.6 类型转换

在Java程序中，不同的基本数据类型（只有7种，不包含boolean类型）变量的值经常需要进行相互转换。
转换的方式有两种：自动类型提升和强制类型转换。

自动类型提升

规则：将取值范围小（或容量小）的类型自动提升为取值范围大（或容量大）的类型 。

基本数据类型的转换规则如图所示：

（1）当把存储范围小的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围大的变量时

int i = 'A';//char自动升级为int，其实就是把字符的编码值赋值给i变量了
double d = 10;//int自动升级为double
long num = 1234567; //右边的整数常量值如果在int范围呢，编译和运行都可以通过，这里涉及到数据类型转换

//byte bigB = 130;//错误，右边的整数常量值超过byte范围
long bigNum = 12345678912L;//右边的整数常量值如果超过int范围，必须加L，显式表示long类型。否则编译不通过

（2）当存储范围小的数据类型与存储范围大的数据类型变量一起混合运算时，会按照其中最大的类型运算。

int i = 1;
byte b = 1;
double d = 1.0;

double sum = i + b + d;//混合运算，升级为double

（3）当byte,short,char数据类型的变量进行算术运算时，按照int类型处理。

byte b1 = 1;
byte b2 = 2;
byte b3 = b1 + b2;//编译报错，b1 + b2自动升级为int

char c1 = '0';
char c2 = 'A';
int i = c1 + c2;//至少需要使用int类型来接收
System.out.println(c1 + c2);//113 

强制类型转换

规则：将取值范围大（或容量大）的类型强制转换成取值范围小（或容量小）的类型。

自动类型提升是Java自动执行的，而强制类型转换是自动类型提升的逆运算，需要我们自己手动执行。

转换格式：
数据类型1 变量名 = (数据类型1)被强转数据值; //()中的数据类型必须<=变量值的数据类型

1）当把存储范围大的值（常量值、变量的值、表达式计算的结果值）强制转换为存储范围小的变量时，可能会损失精度或溢出。

int i = (int)3.14;//损失精度

double d = 1.2;
int num = (int)d;//损失精度

int i = 200;
byte b = (byte)i;//溢出

（2）当某个值想要提升数据类型时，也可以使用强制类型转换。这种情况的强制类型转换是没有风险的，通常省略。

int i = 1;
int j = 2;
double bigger = (double)(i/j);

（3）声明long类型变量时，可以出现省略后缀的情况。float则不同。

long l1 = 123L;
long l2 = 123;//如何理解呢？ 此时可以看做是int类型的123自动类型提升为long类型

//long l3 = 123123123123; //报错，因为123123123123超出了int的范围。
long l4 = 123123123123L;


//float f1 = 12.3; //报错，因为12.3看做是double，不能自动转换为float类型
float f2 = 12.3F;
float f3 = (float)12.3;

问答：为什么标识符的声明规则里要求不能数字开头？

//如果允许数字开头，则如下的声明编译就可以通过：
int 123L = 12;
//进而，如下的声明中l的值到底是123？还是变量123L对应的取值12呢？ 出现歧义了。
long l = 123L;

 

2.7 String字符串类型

• String不是基本数据类型，属于引用数据类型
• 使用一对""来表示一个字符串，内部可以包含0个、1个或多个字符。
• 声明方式与基本数据类型类似。例如：String str = “尚硅谷”;

运算规则

1、任意八种基本数据类型的数据与String类型只能进行连接“+”运算，且结果一定也是String类型

System.out.println("" + 1 + 2);//12

int num = 10;
boolean b1 = true;
String s1 = "abc";

String s2 = s1 + num + b1;
System.out.println(s2);//abc10true

//String s3 = num + b1 + s1;//编译不通过，因为int类型不能与boolean运算
String s4 = num + (b1 + s1);//编译通过

2、String类型不能通过强制类型()转换，转为其他的类型

String str = "123";
int num = (int)str;//错误的

int num = Integer.parseInt(str);//正确的，后面才能讲到，借助包装类的方法才能转

2.7 运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较。

运算符的分类：

• 按照功能分为：算术运算符、赋值运算符、比较(或关系)运算符、逻辑运算符、位运算符、条件运算符、Lambda运算符

分类	运算符
算术运算符（7个）	+、-、*、/、%、++、–
赋值运算符（12个）	=、+=、-=、*=、/=、%=、>>=、<<=、>>>=、&=、|=、^=等
比较(或关系)运算符（6个）	>、>=、<、<=、==、!=
逻辑运算符（6个）	&、|、^、!、&&、||
位运算符（7个）	&、|、^、~、<<、>>、>>>
条件运算符（1个）	(条件表达式)?结果1:结果2
Lambda运算符（1个）	->

• 按照操作数个数分为：一元运算符（单目运算符）、二元运算符（双目运算符）、三元运算符 （三目运算符）

分类	运算符
一元运算符（单目运算符）	正号（+）、负号（-）、++、–、!、~
二元运算符（双目运算符）	除了一元和三元运算符剩下的都是二元运算符
三元运算符 （三目运算符）	(条件表达式)?结果1:结果2

算数运算符

赋值运算符

• 符号：=

  • 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
  • 支持连续赋值。
    int a2,b2; a2 = b2 = 10;

• 扩展赋值运算符： +=、 -=、*=、 /=、%=

  赋值运算符	符号解释
  +=	将符号左边的值和右边的值进行相加操作，最后将结果赋值给左边的变量
  -=	将符号左边的值和右边的值进行相减操作，最后将结果赋值给左边的变量
  *=	将符号左边的值和右边的值进行相乘操作，最后将结果赋值给左边的变量
  /=	将符号左边的值和右边的值进行相除操作，最后将结果赋值给左边的变量
  %=	将符号左边的值和右边的值进行取余操作，最后将结果赋值给左边的变量

比较（关系）运算符

• 比较运算符的结果都是boolean型，也就是要么是true，要么是false。

• > < >= <= ：只适用于基本数据类型（除boolean类型之外）

  == != ：适用于基本数据类型和引用数据类型

• 比较运算符“==”不能误写成“=”

逻辑运算符

• 逻辑运算符，操作的都是boolean类型的变量或常量，而且运算得结果也是boolean类型的值。

• 运算符说明：

  • & 和 &&：表示"且"关系，当符号左右两边布尔值都是true时，结果才能为true。否则，为false。
  • | 和 || ：表示"或"关系，当符号两边布尔值有一边为true时，结果为true。当两边都为false时，结果为false
  • ! ：表示"非"关系，当变量布尔值为true时，结果为false。当变量布尔值为false时，结果为true。
  • ^ ：当符号左右两边布尔值不同时，结果为true。当两边布尔值相同时，结果为false。
    • 理解：异或，追求的是“异”！

• 逻辑运算符用于连接布尔型表达式，在Java中不可以写成 3 < x < 6，应该写成x > 3 & x < 6 。

• 区分“&”和“&&”：

  • 相同点：如果符号左边是true，则二者都执行符号右边的操作

  • 不同点：& ： 如果符号左边是false,则继续执行符号右边的操作

  ​ && ：如果符号左边是false,则不再继续执行符号右边的操作

  • 建议：开发中，推荐使用 &&

• 区分“|”和“||”：

  • 相同点：如果符号左边是false，则二者都执行符号右边的操作

  • 不同点：| ： 如果符号左边是true，则继续执行符号右边的操作

    ​ || ：如果符号左边是true，则不再继续执行符号右边的操作

  • 建议：开发中，推荐使用 ||

位运算符

• 位运算符的运算过程都是基于二进制的补码运算

（1）左移：<<

运算规则：在一定范围内，数据每向左移动一位，相当于原数据*2。（正数、负数都适用）

【注意】当左移的位数n超过该数据类型的总位数时，相当于左移（n-总位数）位

3<<4  类似于  3*2的4次幂 => 3*16 => 48

-3<<4  类似于  -3*2的4次幂 => -3*16 => -48

（2）右移：>>

运算规则：在一定范围内，数据每向右移动一位，相当于原数据/2。（正数、负数都适用）

【注意】如果不能整除，向下取整。

69>>4  类似于  69/2的4次 = 69/16 =4

-69>>4  类似于  -69/2的4次 = -69/16 = -5

（3）无符号右移：>>>

运算规则：往右移动后，左边空出来的位直接补0。（正数、负数都适用）

69>>>4  类似于  69/2的4次 = 69/16 =4

-69>>>4   结果：268435451

（4）按位与：&

运算规则：对应位都是1才为1，否则为0。

• 1 & 1 结果为1

• 1 & 0 结果为0

• 0 & 1 结果为0

• 0 & 0 结果为0

9 & 7 = 1

-9 & 7 = 7

（5）按位或：|

运算规则：对应位只要有1即为1，否则为0。

• 1 | 1 结果为1

• 1 | 0 结果为1

• 0 | 1 结果为1

• 0 & 0 结果为0

9 | 7  //结果： 15

-9 | 7 //结果： -9

（6）按位异或：^

运算规则：对应位一个为1一个为0，才为1，否则为0。

• 1 ^ 1 结果为0

• 1 ^ 0 结果为1

• 0 ^ 1 结果为1

• 0 ^ 0 结果为0

9 ^ 7  //结果为14

-9 ^ 7 //结果为-16

（7）按位取反：~

运算规则：对应位为1，则结果为0；对应位为0，则结果为1。

• ~0就是1

• ~1就是0

~9  //结果：-10

~-9  //结果：8

条件运算符
条件运算符格式：

(条件表达式)? 表达式1:表达式2

说明：条件表达式是boolean类型的结果，根据boolean的值选择表达式1或表达式2

如果运算后的结果赋给新的变量，要求表达式1和表达式2为同种或兼容的类型

运算符优先级

运算符有不同的优先级，所谓优先级就是在表达式运算中的运算符顺序。

上一行中的运算符总是优先于下一行的。

优先级	运算符说明	Java运算符
1	括号	()、[]、{}
2	正负号	+、-
3	单元运算符	++、--、~、！
4	乘法、除法、求余	*、/、%
5	加法、减法	+、-
6	移位运算符	<<、>>、>>>
7	关系运算符	<、<=、>=、>、instanceof
8	等价运算符	==、!=
9	按位与	&
10	按位异或	^
11	按位或	`
12	条件与	&&
13	条件或	`
14	三元运算符	? :
15	赋值运算符	=、+=、-=、*=、/=、%=
16	位赋值运算符	&=、`

3. 流程控制语句

• 流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。

• 程序设计中规定的三种流程结构，即：

  • 顺序结构
    • 程序从上到下逐行地执行，中间没有任何判断和跳转。
  • 分支结构
    • 根据条件，选择性地执行某段代码。
    • 有if…else和switch-case两种分支语句。
  • 循环结构
    • 根据循环条件，重复性的执行某段代码。
    • 有for、while、do-while三种循环语句。
    • 补充：JDK5.0 提供了foreach循环，方便的遍历集合、数组元素。

3.1 顺序结构

顺序结构就是程序从上到下逐行地执行。表达式语句都是顺序执行的。并且上一行对某个变量的修改对下一行会产生影响。

3.2 分支语句

3.2.1 if-else条件判断结构

结构1：单分支条件判断：if

if(条件表达式)｛
  	语句块;
｝

说明：条件表达式必须是布尔表达式（关系表达式或逻辑表达式）或 布尔变量。

执行流程：

1. 首先判断条件表达式看其结果是true还是false
2. 如果是true就执行语句块
3. 如果是false就不执行语句块
   

结构2：双分支条件判断：if…else

if(条件表达式) { 
  	语句块1;
}else {
  	语句块2;
}

执行流程：

1. 首先判断条件表达式看其结果是true还是false
2. 如果是true就执行语句块1
3. 如果是false就执行语句块2

结构3：多分支条件判断：if…else if…else

if (条件表达式1) {
  	语句块1;
} else if (条件表达式2) {
  	语句块2;
}
...
}else if (条件表达式n) {
 	语句块n;
} else {
  	语句块n+1;
}

执行流程：

1. 首先判断关系表达式1看其结果是true还是false
2. 如果是true就执行语句块1，然后结束当前多分支
3. 如果是false就继续判断关系表达式2看其结果是true还是false
4. 如果是true就执行语句块2，然后结束当前多分支
5. 如果是false就继续判断关系表达式…看其结果是true还是false

​ …

n. 如果没有任何关系表达式为true，就执行语句块n+1，然后结束当前多分支。

if…else嵌套

在 if 的语句块中，或者是在else语句块中，又包含了另外一个条件判断（可以是单分支、双分支、多分支），就构成了嵌套结构。

执行的特点：
（1）如果是嵌套在if语句块中的，只有当外部的if条件满足，才会去判断内部的条件
（2）如果是嵌套在else语句块中的，只有当外部的if条件不满足，进入else后，才会去判断内部的条件

3.2.2 switch-case选择结构

语法格式：

switch(表达式){
    case 常量值1:
        语句块1;
        //break;
    case 常量值2:
        语句块2;
        //break; 
    // ...
   [default:
        语句块n+1;
        break;
   ]
}

执行流程图：

执行过程：

第1步：根据switch中表达式的值，依次匹配各个case。如果表达式的值等于某个case中的常量值，则执行对应case中的执行语句。

第2步：执行完此case的执行语句以后，
​ 情况1：如果遇到break,则执行break并跳出当前的switch-case结构
​ 情况2：如果没有遇到break，则会继续执行当前case之后的其它case中的执行语句。—>case穿透
​ …
​ 直到遇到break关键字或执行完所有的case及default的执行语句，跳出当前的switch-case结构

使用注意点：

• switch(表达式)中表达式的值必须是下述几种类型之一：byte，short，char，int，枚举 (jdk 5.0)，String (jdk 7.0)；

• case子句中的值必须是常量，不能是变量名或不确定的表达式值或范围；

• 同一个switch语句，所有case子句中的常量值互不相同；

• break语句用来在执行完一个case分支后使程序跳出switch语句块；

  如果没有break，程序会顺序执行到switch结尾；

• default子句是可选的。同时，位置也是灵活的。当没有匹配的case时，执行default语句。

3.2.3 if-else语句与switch-case语句比较

• 结论：凡是使用switch-case的结构都可以转换为if-else结构。反之，不成立。

• 开发经验：如果既可以使用switch-case，又可以使用if-else，建议使用switch-case。因为效率稍高。

• 细节对比：

  • if-else语句优势
    • if语句的条件是一个布尔类型值，if条件表达式为true则进入分支，可以用于范围的判断，也可以用于等值的判断，使用范围更广。
    • switch语句的条件是一个常量值（byte,short,int,char,枚举,String），只能判断某个变量或表达式的结果是否等于某个常量值，使用场景较狭窄。
  • switch语句优势
    • 当条件是判断某个变量或表达式是否等于某个固定的常量值时，使用if和switch都可以，习惯上使用switch更多。因为效率稍高。当条件是区间范围的判断时，只能使用if语句。
    • 使用switch可以利用穿透性，同时执行多个分支，而if…else没有穿透性。

3.3 循环语句

• 理解：循环语句具有在某些条件满足的情况下，反复执行特定代码的功能。

• 循环结构分类：

  • for 循环
  • while 循环
  • do-while 循环

• 循环结构四要素：

  • 初始化部分
  • 循环条件部分
  • 循环体部分
  • 迭代部分

3.3.1 for循环

for (①初始化部分; ②循环条件部分; ④迭代部分)｛
         	③循环体部分;
｝

**执行过程：**①-②-③-④-②-③-④-②-③-④-…-②

说明：

• for(;;)中的两个；不能多也不能少
• ①初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
• ②循环条件部分为boolean类型表达式，当值为false时，退出循环
• ④可以有多个变量更新，用逗号分隔

3.3.2 while循环

①初始化部分
while(②循环条件部分)｛
    ③循环体部分;
    ④迭代部分;
}

**执行过程：**①-②-③-④-②-③-④-②-③-④-…-②

说明：

• while(循环条件)中循环条件必须是boolean类型。
• 注意不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环。
• for循环和while循环可以相互转换。二者没有性能上的差别。实际开发中，根据具体结构的情况，选择哪个格式更合适、美观。
• for循环与while循环的区别：初始化条件部分的作用域不同。

3.3.3 do-while循环

①初始化部分;
do{
	③循环体部分
	④迭代部分
}while(②循环条件部分);

**执行过程：**①-③-④-②-③-④-②-③-④-…-②

说明：

• 结尾while(循环条件)中循环条件必须是boolean类型
• do{}while();最后有一个分号
• do-while结构的循环体语句是至少会执行一次，这个和for和while是不一样的
• 循环的三个结构for、while、do-while三者是可以相互转换的。

3.3.4 对比三种循环结构

• 三种循环结构都具有四个要素：
  • 循环变量的初始化条件
  • 循环条件
  • 循环体语句块
  • 循环变量的修改的迭代表达式

• 从循环次数角度分析
  • do-while循环至少执行一次循环体语句。
  • for和while循环先判断循环条件语句是否成立，然后决定是否执行循环体。
• 如何选择
  • 遍历有明显的循环次数（范围）的需求，选择for循环
  • 遍历没有明显的循环次数（范围）的需求，选择while循环
  • 如果循环体语句块至少执行一次，可以考虑使用do-while循环
  • 本质上：三种循环之间完全可以互相转换，都能实现循环的功能

3.3.5 嵌套循环

• 所谓嵌套循环，是指一个循环结构A的循环体是另一个循环结构B。比如，for循环里面还有一个for循环，就是嵌套循环。其中，for ,while ,do-while均可以作为外层循环或内层循环。
  • 外层循环：循环结构A
  • 内层循环：循环结构B
• 实质上，嵌套循环就是把内层循环当成外层循环的循环体。只有当内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的外层循环。
• 设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。
• **技巧：**从二维图形的角度看，外层循环控制行数，内层循环控制列数。
• **开发经验：**实际开发中，我们最多见到的嵌套循环是两层。一般不会出现超过三层的嵌套循环。如果将要出现，一定要停下来重新梳理业务逻辑，重新思考算法的实现，控制在三层以内。否则，可读性会很差。

for(初始化语句①; 循环条件语句②; 迭代语句⑦) {
    for(初始化语句③; 循环条件语句④; 迭代语句⑥) {
      	循环体语句⑤;
    }
}

//执行过程：① - ② - ③ - ④ - ⑤ - ⑥ - ④ - ⑤ - ⑥ - ... - ④ - ⑦ - ② - ③ - ④ - ⑤ - ⑥ - ④..

**执行特点：**外层循环执行一次，内层循环执行一轮。

3.3.6 break和continue

	        适用范围			在循环结构中使用的作用						相同点

break		switch-case
			循环结构			一旦执行，就结束(或跳出)当前循环结构		    此关键字的后面，不能声明语句

continue	循环结构			一旦执行，就结束(或跳出)当次循环结构		    此关键字的后面，不能声明语句

3.3.7 Scanner键盘输入

• 如何从键盘获取不同类型（基本数据类型、String类型）的变量：使用Scanner类。

• 键盘输入代码的四个步骤：

  1. 导包：import java.util.Scanner;
  2. 创建Scanner类型的对象：Scanner scan = new Scanner(System.in);
  3. 调用Scanner类的相关方法（next() / nextXxx()），来获取指定类型的变量
  4. 释放资源：scan.close();

• 注意：需要根据相应的方法，来输入指定类型的值。如果输入的数据类型与要求的类型不匹配时，会报异常 导致程序终止。

**案例：**小明注册某交友网站，要求录入个人相关信息。如下：

请输入你的网名、你的年龄、你的体重、你是否单身、你的性别等情况。

//① 导包
import java.util.Scanner;

public class ScannerTest1 {

    public static void main(String[] args) {
        //② 创建Scanner的对象
        //Scanner是一个引用数据类型，它的全名称是java.util.Scanner
        //scanner就是一个引用数据类型的变量了，赋给它的值是一个对象（对象的概念我们后面学习，暂时先这么叫）
        //new Scanner(System.in)是一个new表达式，该表达式的结果是一个对象
        //引用数据类型  变量 = 对象;
        //这个等式的意思可以理解为用一个引用数据类型的变量代表一个对象，所以这个变量的名称又称为对象名
        //我们也把scanner变量叫做scanner对象
        Scanner scanner = new Scanner(System.in);//System.in默认代表键盘输入
        
        //③根据提示，调用Scanner的方法，获取不同类型的变量
        System.out.println("欢迎光临你好我好交友网站！");
        System.out.print("请输入你的网名：");
        String name = scanner.next();

        System.out.print("请输入你的年龄：");
        int age = scanner.nextInt();

        System.out.print("请输入你的体重：");
        double weight = scanner.nextDouble();

        System.out.print("你是否单身（true/false)：");
        boolean isSingle = scanner.nextBoolean();

        System.out.print("请输入你的性别：");
        char gender = scanner.next().charAt(0);//先按照字符串接收，然后再取字符串的第一个字符（下标为0）

        System.out.println("你的基本情况如下：");
        System.out.println("网名：" + name + "\n年龄：" + age + "\n体重：" + weight + 
                           "\n单身：" + isSingle + "\n性别：" + gender);
        
        //④ 关闭资源
        scanner.close();
    }
}

3.3.8 获取随机数

如何产生一个指定范围的随机整数？

1、Math类的random()的调用，会返回一个[0,1)范围的一个double型值

2、Math.random() * 100 —> [0,100)
(int)(Math.random() * 100) —> [0,99]
(int)(Math.random() * 100) + 5 ----> [5,104]

3、如何获取[a,b]范围内的随机整数呢？(int)(Math.random() * (b - a + 1)) + a

4、举例

class MathRandomTest {
	public static void main(String[] args) {
		double value = Math.random();
		System.out.println(value);

		//[1,6]
		int number = (int)(Math.random() * 6) + 1; //
		System.out.println(number);
	}
}

 
 

4. 数组

• 数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

• 数组中的概念

  • 数组名
  • 下标（或索引）
  • 元素
  • 数组的长度

 

• 数组的特点：

  • 数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
  • 创建数组对象会在内存中开辟一整块连续的空间。占据的空间的大小，取决于数组的长度和数组中元素的类型。
  • 数组中的元素在内存中是依次紧密排列的，有序的。
  • 数组，一旦初始化完成，其长度就是确定的。数组的长度一旦确定，就不能修改。
  • 我们可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快。
  • 数组名中引用的是这块连续空间的首地址。

 

4.1 数组的分类

• 按照元素类型分：

  • 基本数据类型元素的数组：每个元素位置存储基本数据类型的值
  • 引用数据类型元素的数组：每个元素位置存储对象（本质是存储对象的首地址）（在面向对象部分讲解）

• 按照维度分：

  • 一维数组：存储一组数据
  • 二维数组：存储多组数据，相当于二维表，一行代表一组数据，只是这里的二维表每一行长度不要求一样。
    

 

4.2 一维数组的操作

 

4.2.1 一维数组的声明

格式：

//推荐
元素的数据类型[] 一维数组的名称;

//不推荐
元素的数据类型  一维数组名[];

举例：

int[] arr;
int arr1[];
double[] arr2;
String[] arr3;  //引用类型变量数组

数组的声明，需要明确：

（1）数组的维度：在Java中数组的符号是[]，[]表示一维，[][]表示二维。

（2）数组的元素类型：即创建的数组容器可以存储什么数据类型的数据。元素的类型可以是任意的Java的数据类型。例如：int、String、Student等。

（3）数组名：就是代表某个数组的标识符，数组名其实也是变量名，按照变量的命名规范来命名。数组名是个引用数据类型的变量，因为它代表一组数据。

注意：Java语言中声明数组时不能指定其长度(数组中元素的个数)。 例如： int a[5]; //非法

 
 

4.2.2 一维数组的初始化

 

静态初始化

• 如果数组变量的初始化和数组元素的赋值操作同时进行，那就称为静态初始化 。

• 静态初始化，本质是用静态数据（编译时已知）为数组初始化。此时数组的长度由静态数据的个数决定。

• 一维数组声明和静态初始化格式1：

  数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3,...};
  
  或
      
  数据类型[] 数组名;
  数组名 = new 数据类型[]{元素1,元素2,元素3,...};
  

  new：关键字，创建数组使用的关键字。因为数组本身是引用数据类型，所以要用new创建数组实体。

  例如，定义存储1，2，3，4，5整数的数组容器。

  int[] arr = new int[]{1,2,3,4,5};//正确
  System.out.println(arr);//[I@14ae5a5
  //或
  int[] arr;
  arr = new int[]{1,2,3,4,5};//正确
  

• 一维数组声明和静态初始化格式2：

  数据类型[] 数组名 = {元素1,元素2,元素3...};
  //必须在一个语句中完成，不能分成两个语句写
  

  例如，定义存储1，2，3，4，5整数的数组容器

  int[] arr = {1,2,3,4,5};//正确
  
  int[] arr;
  arr = {1,2,3,4,5};//错误
  

 

动态初始化

• 数组变量的初始化和数组元素的赋值操作分开进行，即为动态初始化。

• 动态初始化中，只确定了元素的个数（即数组的长度），而元素值此时只是默认值，还并未真正赋自己期望的值。真正期望的数据需要后续单独一个一个赋值。

• 格式：

  数组存储的元素的数据类型[] 数组名字 = new 数组存储的元素的数据类型[长度];
  
  或
  
  数组存储的数据类型[] 数组名字;
  数组名字 = new 数组存储的数据类型[长度];
  

• 长度： 数组的长度，表示数组容器中可以最多存储多少个元素。

• 注意： 数组有定长特性，长度一旦指定，不可更改。

• 举例1：正确写法

  int[] arr = new int[5];
  
  int[] arr;
  arr = new int[5];
  

• 举例2：错误写法

  int[] arr = new int[5]{1,2,3,4,5};//错误的，后面有{}指定元素列表，就不需要在[]中指定元素个数了。
  

 

4.2.3 一维数组的使用

 

数组的长度

• 数组的元素总个数，即数组的长度
• 每个数组都有一个属性length指明它的长度，例如：arr.length 指明数组arr的长度(即元素个数)
• 每个数组都具有长度，而且一旦初始化，其长度就是确定，且是不可变的。

数组元素的引用

• 如何表示数组中的一个元素？
  每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个自动编号称为数组索引(index)或下标，可以通过数组的索引/下标访问到数组中的元素。

  数组名[索引/下标]
  

• 数组的下标范围？
  Java中数组的下标从[0]开始，下标范围是[0, 数组的长度-1]，即[0, 数组名.length-1]
  数组元素下标可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i];

 

4.2.4 一维数组的遍历

将数组中的每个元素分别获取出来，就是遍历。for循环与数组的遍历是绝配。

举例

        int[] arr = new int[]{1,2,3,4,5};
        //打印数组的属性，输出结果是5
        System.out.println("数组的长度：" + arr.length);

        //遍历输出数组中的元素
        System.out.println("数组的元素有：");
        for(int i=0; i<arr.length; i++){
            System.out.println(arr[i]);
        }

 

4.2.5 一维数组的内存

 

Java虚拟机的内存划分
为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

区域名称	作用
虚拟机栈	用于存储正在执行的每个Java方法的局部变量表等。局部变量表存放了编译期可知长度 的各种基本数据类型、对象引用，方法执行完，自动释放。
堆内存	存储对象（包括数组对象），new来创建的，都存储在堆内存。
方法区	存储已被虚拟机加载的类信息、常量、（静态变量）、即时编译器编译后的代码等数据。
本地方法栈	当程序中调用了native的本地方法时，本地方法执行期间的内存区域
程序计数器	程序计数器是CPU中的寄存器，它包含每一个线程下一条要执行的指令的地址

 

一维数组在内存中的存储

• 一个一维数组内存图

    	int[] arr = new int[3];
    	System.out.println(arr);//[I@5f150435
  

  

• 数组下标为什么是0开始
  因为第一个元素距离数组首地址间隔0个单元格。

• 两个一维数组内存图
  两个数组独立

      int[] arr = new int[3];
      int[] arr2 = new int[2];
      System.out.println(arr);
      System.out.println(arr2);
  

  

• 两个变量指向一个一维数组

      // 定义数组，存储3个元素
      int[] arr = new int[3];
      //数组索引进行赋值
      arr[0] = 5;
      arr[1] = 6;
      arr[2] = 7;
      //输出3个索引上的元素值
      System.out.println(arr[0]);
      System.out.println(arr[1]);
      System.out.println(arr[2]);
      //定义数组变量arr2，将arr的地址赋值给arr2
      int[] arr2 = arr;
      arr2[1] = 9;
      System.out.println(arr[1]);
  

  

 

4.3 数组元素的默认值

数组是引用类型，当我们使用动态初始化方式创建数组时，元素值只是默认值。

例如：

		int a[]= new int[5]; 
		System.out.println(a[3]); //a[3]的默认值为0

对于基本数据类型而言，默认初始化值各有不同。

对于引用数据类型而言，默认初始化值为null（注意null与0不同！)

 

4.4 多维数组

• 如果说可以把一维数组当成几何中的线性图形，那么二维数组就相当于是一个表格，像Excel中的表格、围棋棋盘一样。
  

4.4.1 多维数组的声明

语法格式：

//推荐
元素的数据类型[][] 二维数组的名称;

//不推荐
元素的数据类型  二维数组名[][];
//不推荐
元素的数据类型[]  二维数组名[];

举例：

//存储多组成绩
int[][] grades;

//存储多组姓名
String[][] names;

面试：

int[] x, y[];
//x是一维数组，y是二维数组

 

4.4.2 多维数组的初始化

 
静态初始化

• 格式：

  int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};
  或
  int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};
  

  定义一个名称为arr的二维数组，二维数组中有三个一维数组

  • 每一个一维数组中具体元素也都已初始化
    • 第一个一维数组 arr[0] = {3,8,2};
    • 第二个一维数组 arr[1] = {2,7};
    • 第三个一维数组 arr[2] = {9,0,1,6};
  • 第三个一维数组的长度表示方式：arr[2].length;

  • 注意特殊写法情况：int[] x,y[]; x是一维数组，y是二维数组。

• 举例1：

  int[][] arr = {{1,2,3},{4,5,6},{7,8,9,10}};//声明与初始化必须在一句完成
  
  int[][] arr = new int[][]{{1,2,3},{4,5,6},{7,8,9,10}};
  
  int[][] arr;
  arr = new int[][]{{1,2,3},{4,5,6},{7,8,9,10}};
  
  arr = new int[3][3]{{1,2,3},{4,5,6},{7,8,9,10}};//错误，静态初始化右边new 数据类型[][]中不能写数字
  

• 举例2：

          //存储多组成绩
          int[][] grades = {
                      {89,75,99,100},
                      {88,96,78,63,100,86},
                      {56,63,58},
                      {99,66,77,88}
                  };
  
          //存储多组姓名
          String[][] names = {
              {"张三","李四", "王五", "赵六"},
              {"刘备","关羽","张飞","诸葛亮","赵云","马超"},
              {"曹丕","曹植","曹冲"},
              {"孙权","周瑜","鲁肃","黄盖"}
          };
  

 

动态初始化

如果二维数组的每一个数据，甚至是每一行的列数，需要后期单独确定，那么就只能使用动态初始化方式了。
动态初始化方式分为两种格式：

• 格式1：规则二维表：每一行的列数是相同的

  //（1）确定行数和列数
  元素的数据类型[][] 二维数组名 = new 元素的数据类型[m][n];
  	//其中，m:表示这个二维数组有多少个一维数组。或者说一共二维表有几行
  	//其中，n:表示每一个一维数组的元素有多少个。或者说每一行共有一个单元格
  
  //此时创建完数组，行数、列数确定，而且元素也都有默认值
  
  //（2）再为元素赋新值
  二维数组名[行下标][列下标] = 值;
  

  举例：

  int[][] arr = new int[3][2];
  

  • 定义了名称为arr的二维数组

  • 二维数组中有3个一维数组

  • 每一个一维数组中有2个元素

  • 一维数组的名称分别为arr[0], arr[1], arr[2]

  • 给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;

 

• 格式2：不规则：每一行的列数不一样

  //（1）先确定总行数
  元素的数据类型[][] 二维数组名 = new 元素的数据类型[总行数][];
  
  //此时只是确定了总行数，每一行里面现在是null
  
  //（2）再确定每一行的列数，创建每一行的一维数组
  二维数组名[行下标] = new 元素的数据类型[该行的总列数];
  
  //此时已经new完的行的元素就有默认值了，没有new的行还是null
  
  //(3)再为元素赋值
  二维数组名[行下标][列下标] = 值;
  

  举例：

  int[][] arr = new int[3][];
  

  • 二维数组中有3个一维数组。
  • 每个一维数组都是默认初始化值null (注意：区别于格式1）
  • 可以对这个三个一维数组分别进行初始化：arr[0] = new int[3]; arr[1] = new int[1]; arr[2] = new int[2];
  • 注：int[][]arr = new int[][3]; //非法

 

• 对于二维数组的理解，可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。
• 其实，从数组底层的运行机制来看，其实没有多维数组。

 

4.4.3 多维数组的长度和角标

• 二维数组的长度/行数：二维数组名.length
• 二维数组的某一行：二维数组名[行下标]，此时相当于获取其中一组数据。它本质上是一个一维数组。行下标的范围：[0, 二维数组名.length-1]。此时把二维数组看成一维数组的话，元素是行对象。
• 某一行的列数：二维数组名[行下标].length，因为二维数组的每一行是一个一维数组。
• 某一个元素：二维数组名[行下标][列下标]，即先确定行/组，再确定列。

 

4.4.4 多维数组的遍历

格式：

for(int i=0; i<二维数组名.length; i++){ //二维数组对象.length
    for(int j=0; j<二维数组名[i].length; j++){//二维数组行对象.length
        System.out.print(二维数组名[i][j]);
    }
    System.out.println();
}

举例：

       //存储3个小组的学员的成绩，分开存储，使用二维数组。
        int[][] scores = {
                {85,96,85,75},
                {99,96,74,72,75},
                {52,42,56,75}
        };

        System.out.println("一共有" + scores.length +"组成绩.");
        for (int i = 0; i < scores.length; i++) {
            System.out.print("第" + (i+1) +"组有" + scores[i].length + "个学员，成绩如下：\t");
            for (int j = 0; j < scores[i].length; j++) {
                System.out.print(scores[i][j]+"\t");
            }
            System.out.println();
        }

 

4.4.5 内存解析

二维数组本质上是元素类型是一维数组的一维数组。

int[][] arr = {
    {1},
    {2,2},
    {3,3,3},
    {4,4,4,4},
    {5,5,5,5,5}
};

 

//1、声明二维数组，并确定行数和列数
int[][] arr = new int[4][5];

//2、确定元素的值
for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr.length; j++) {
        arr[i][j] = i + 1;
    }
}

 

//1、声明一个二维数组，并且确定行数
//因为每一行的列数不同，这里无法直接确定列数
int[][]  arr = new int[5][];

//2、确定每一行的列数
for(int i=0; i<arr.length; i++){
    /*
			arr[0] 的列数是1
			arr[1] 的列数是2
			arr[2] 的列数是3
			arr[3] 的列数是4
			arr[4] 的列数是5
			*/
    arr[i] = new int[i+1];
}

//3、确定元素的值
for(int i=0; i<arr.length; i++){
    for(int j=0; j<arr[i].length; j++){
        arr[i][j] = i+1;
    }
}

 

4.5 Arrays工具类的使用

java.util.Arrays类即为操作数组的工具类，包含了用来操作数组（比如排序和搜索）的各种方法。

比如：

• 数组元素拼接
  • static String toString(int[] a) ：字符串表示形式由数组的元素列表组成，括在方括号（“[]”）中。相邻元素用字符 ", "（逗号加空格）分隔。形式为：[元素1，元素2，元素3。。。]
  • static String toString(Object[] a) ：字符串表示形式由数组的元素列表组成，括在方括号（“[]”）中。相邻元素用字符 ", "（逗号加空格）分隔。元素将自动调用自己从Object继承的toString方法将对象转为字符串进行拼接，如果没有重写，则返回类型@hash值，如果重写则按重写返回的字符串进行拼接。
• 数组排序
  • static void sort(int[] a) ：将a数组按照从小到大进行排序
  • static void sort(int[] a, int fromIndex, int toIndex) ：将a数组的[fromIndex, toIndex)部分按照升序排列
  • static void sort(Object[] a) ：根据元素的自然顺序对指定对象数组按升序进行排序。
  • static void sort(T[] a, Comparator<? super T> c) ：根据指定比较器产生的顺序对指定对象数组进行排序。
• 数组元素的二分查找
  • static int binarySearch(int[] a, int key) 、static int binarySearch(Object[] a, Object key) ：要求数组有序，在数组中查找key是否存在，如果存在返回第一次找到的下标，不存在返回负数。
• 数组的复制
  • static int[] copyOf(int[] original, int newLength) ：根据original原数组复制一个长度为newLength的新数组，并返回新数组
  • static T[] copyOf(T[] original,int newLength)：根据original原数组复制一个长度为newLength的新数组，并返回新数组
  • static int[] copyOfRange(int[] original, int from, int to) ：复制original原数组的[from,to)构成新数组，并返回新数组
  • static T[] copyOfRange(T[] original,int from,int to)：复制original原数组的[from,to)构成新数组，并返回新数组
• 比较两个数组是否相等
  • static boolean equals(int[] a, int[] a2) ：比较两个数组的长度、元素是否完全相同
  • static boolean equals(Object[] a,Object[] a2)：比较两个数组的长度、元素是否完全相同
• 填充数组
  • static void fill(int[] a, int val) ：用val值填充整个a数组
  • static void fill(Object[] a,Object val)：用val对象填充整个a数组
  • static void fill(int[] a, int fromIndex, int toIndex, int val)：将a数组[fromIndex,toIndex)部分填充为val值
  • static void fill(Object[] a, int fromIndex, int toIndex, Object val) ：将a数组[fromIndex,toIndex)部分填充为val对象

举例：java.util.Arrays类的sort()方法提供了数组元素排序功能：

import java.util.Arrays;
public class SortTest {
	public static void main(String[] args) {
		int[] arr = {3, 2, 5, 1, 6};
        System.out.println("排序前" + Arrays.toString(arr));
        Arrays.sort(arr);
        System.out.println("排序后" + Arrays.toString(arr));
	}
}

 

4.6 数组中的常见异常

• 数组角标越界异常
  当访问数组元素时，下标指定超出[0, 数组名.length-1]的范围时，就会报数组下标越界异常：ArrayIndexOutOfBoundsException。

  public class TestArrayIndexOutOfBoundsException {
      public static void main(String[] args) {
          int[] arr = {1,2,3};
         // System.out.println("最后一个元素：" + arr[3]);//错误，下标越界
        //  System.out.println("最后一个元素：" + arr[arr.length]);//错误，下标越界
          System.out.println("最后一个元素：" + arr[arr.length-1]);//对
      }
  }
  

  创建数组，赋值3个元素，数组的索引就是0，1，2，没有3索引，因此我们不能访问数组中不存在的索引，程序运行后，将会抛出 ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。

  
   

• 空指针异常

  观察一下代码，运行后会出现什么结果。

  public class TestNullPointerException {
      public static void main(String[] args) {
          //定义数组
          int[][] arr = new int[3][];
  
          System.out.println(arr[0][0]);//NullPointerException
      }
  }
  

  因为此时数组的每一行还未分配具体存储元素的空间，此时arr[0]是null，此时访问arr[0][0]会抛出NullPointerException 空指针异常。

  

  空指针异常在内存图中的表现

  

  小结：空指针异常情况

  		//举例一：
   		int[] arr1 = new int[10];
   		arr1 = null;
   		System.out.println(arr1[9]);
  		
  		//举例二：
   		int[][] arr2 = new int[5][];
   		//arr2[3] = new int[10];
   		System.out.println(arr2[3][3]);
  		
  		//举例三：
  		String[] arr3 = new String[10];
  		System.out.println(arr3[2].toString());