Java基础知识（14）

包括Java语言特性，Java开发工具包，Java文件执行过程，类的声明与文件名的关系，标识符，变量与字面量，注释Javadoc，进制，字符编码，基本数据类型，运算符，控制语句，修饰符，数组

1.JAVA特性

特性	解释
简单性	Java语言继承了C++语言的优点，去掉了C++中学习起来比较难的多继承、指针等概念，所以Java语言学习起来更简单，使用起来也更方便。
面向对象	Java是一种面向对象的编程语言。
分布性	Java设计成支持在网络上应用，它是分布式语言。所以只要用Java编写了一个程序，就可以到处应用。可以节省大量人力物力。
编译和解释性	Java编译程序生成字节码，而不是通常的[机器码]，这使得Java开发程序比用其他语言开发程序快很多。
稳健性	Java刚开始被设计出来就是为了写高可靠和稳健的软件的。所以用Java写可靠的软件很容易。目前许多第三方交易系统、银行平台的前台和后台电子交易系统等都会用Java语言开发。
安全性	Java的存储分配模型是它防御恶意代码的主要方法之一。所以很多大型企业级项目开发都会选择用Java开发。
可移植性	Java并不依赖平台，用Java编写的程序可以运用到任何操作系统上。
高性能	Java是一种先编译后解释的语言，所以它不如全编译性语言快。但Java设计者制作了“及时”编译程序，这样就可以实现全编译了。
多线索性	Java是多线索语言，它可以同时执行多个程序，能处理不同任务。
动态性	Java语言设计成适应于变化的环境，它是一个动态的语言。

2.JDK 和 JRE 和 JVM

	全称	解释
JDK	Java Development Kit	JDK是Java开发工具包，提供了编译、运行、调试Java程序所需要的各种工具 ，包含JRE和开发Java程序所必须的命令工具。
JRE	Java Runtime Environment	Java运行环境主要包含两个部分：JVM和Java系统类库。所有的Java 程序都要在JRE下才能运行。JDK的工具也是Java程序，也需要JRE才能运行。为了保持JDK的独立性和完整性，在JDK的安装过程中，JRE也是安装的一部分在名为jre的目录中。普通用户只需要运行已开发好的Java程序，安装JRE即可。
JVM	Java Virtual Mechinal	JVM即Java虚拟机，负责加载、执行字节码文件(.class)，是Java实现跨平台的核心（一次编写，多处运行），有自己完善的硬件架构，如处理器、堆栈、寄存器等，还具有相应的指令系统。

JDK=JRE+编译、运行等命令工具
JRE=JVM+Java系统类库
运行Java程序的最小环境为JRE
开发Java程序的最小环境为JDK

JVM内存
JVM运行时内存主要分为：程序计数器、虚拟机栈、本地方法栈、堆、方法区五个部分。

左对齐	右对齐
程序计数器	一块较小的内存空间，记住下一条jvm指令的执行地址，记录当前线程执行到代码的具体某一行，此时若线程被挂起时，程序计数器用来记录代码已经执行的位置，当线程恢复执行后继续从记录位置开始执行。线程私有，每个线程都有一个独立的程序计数器，随着线程的创建而创建，随着线程的销毁而销毁，唯一一个在java虚拟机中不会OOM的区域。常见的异常处理、分支操作等都是通过通过程序计数器来完成的。
虚拟机栈
本地方法栈	本地方法栈与虚拟机栈基本相同，主要用来管理nattive方法，如在Android中使用JNI。占用的内存区大小是不固定的，可根据需要动态扩展。
堆	线程共享区域，是JAVA虚拟机管理的内存中最大的一块，在虚拟机启动时创建。存放对象实例，几乎所有的对象实例都在堆上分配，GC管理的主要区域。
方法区

3.java 和 javac

	解释
java	执行一个java文件的基本命令，通过参数配置可以以不同方式执行一个java程序或者是一个jar包。
javac	编译一个java文件的基本命令，通过不同参数可以完成各种配置，比如导入其他类，指定编译路径等可以将java源文件编译为class字节码文件。
javap	一个class文件的反编译程序，可以获取class文件的反编译结果，甚至是jvm执行程序的每一步代码实现。
	总结：Javac是编译、Java是执行。 编写Java代码后，使用Javac进行编译生成 .Class文件，.Class文件使用 Java命令执行代码；

例：
javac HelloWorld.java
运行javac命令后，如果成功编译没有错误的话，会出现一个 HelloWorld.class 的文件。
java 可以运行class字节码文件，如 java HelloWorld，注意 java 命令后面不要加 .class。

4.public class和class

类声明	条件
public class	类名称必须与文件名称完全一致
class	类名称可以与文件名称不一致

文件名称为Hello.java，类名HelloDemo，文件名称与类名称不一致，但是因为使用了class声明，所以，此时编译不会产生任何错误，但是生成之后的*.class文件的名称是和class声明的类名称完全一致的: HelloDemo.class ，且执行的时候不能再执行 java Hello，而是应该执行 java HelloDemo。

注意：
1.一个 .java 的文件中，只能有一个 public class 的声明，但是允许有多个class的声明，定义了三个类class，那么此时程序编译之后会形成三个.class文件。
2.被public修饰的类可以被其他包访问。
如果现在的库名是com，可通过下面的声明访问Student：
import com.Student;
import com.*;

5.标识符

Java语言中，为各种变量、方法和类等起的名字称为标识符。
Java标识符的命名规则：

1.标识符由字母、数字、下划线“_”、美元符号“$”组成，第一个字符不能是数字。
2.不能把java关键字和保留字作为标识符。
3.标识符没有长度限制。
4.标识符对大小写敏感。
5.类名首字母大写，如果类名由多个单词组成，每个单词的首字母都要大写。
6.变量名、方法名首字母小写，如果名称由多个单词组成，每个单词的首字母都要大写。

6.变量，字面量

变量就是一个存数据盒子。（盒子大小由数据类型决定）在内存中的最基本的存储单元。存数据用的，而且这个数据是可变的，所以叫做变量。

1.变量的三要素：数据类型、变量名、值 （值就是数据，就是字面量。）
2.java中的变量必须先声明，再赋值才能访问（必须手动赋值。）
3.在方法体当中声明的变量叫做：局部变量。局部变量只在方法体当中有效，方法体执行结束该变量的内存就释放了。
4.在方法体外以及类体内声明的变量叫做：成员变量。不能直接访问，通过类的get方法访问。
5.字面量就是数据（或我们自己在源代码文件写下的值）

7.注释Javadoc

7.1 javadoc命令使用方式：(生成API文档)

1.使用命令行在目标文件所在目录输入 javadoc +文件名.java；
2.javadoc -d 文档存放目录 文件名.java；
3.javadoc -encoding UTF-8 -charset UTF-8 文件名.java。
4.通过IDEA生成Javadoc ： Tools -> Generate JavaDoc

7.2 Javadoc注释规范

左对齐	快捷键
注释一行://	CTRL+/
注释若干行: / * */	CTRL+shift+/
文本注释	/**+回车

注释若干行，写入Javadoc文档：

/**

• show 方法的简述.

• show 方法的详细说明第一行
  

• show 方法的详细说明第二行
• @param b true 表示显示，false 表示隐藏
• @return 没有返回值
  */

8.进制

X进制，就表示每一位上的数运算时都是逢X进一位。可使用数字符号的数目称为基数(en:radix)或底数，基数为n，即可称n进位制，简称n进制。

进制	后缀
二进制	尾部标志B或下标2
八进制	尾部标志O或下标8
十进制	尾部标志D
十六进制	尾部标志H或下标16,c语言中用添加前缀0x

二进制数的加法和乘法基本运算法则各有四条，如下：

0+0=0，0+1=1，1+0=1，1+1=10
0×0=0，0×1=0，1×0=0，1×1=1

位权

在数制中，各位数字所表示值的大小不仅与该数字本身的大小有关，还与该数字所在的位置有关，我们称这关系为数的位权。
十进制数的位权是以10为底的幂，二进制数的位权是以2为底的幂，十六进制数的位权是以16为底的幂。

进数转换
二，十六转十（按权求和）

把二进制数（或十六进制数）按 位权 形式展开多项式和的形式，求其最后的和，就是其对应的十进制数，简称“按权求和”。

十转二，十六（除2/16取余法）

一个十进制整数转换为二进制整数通常采用除二取余法，即用2连续除十进制数，直到商为0，逆序排列余数即可得到，简称除二取余法。同理，把十进制数转换为十六进制数时，将基数2转换成16。

二转十六

由于4位二进制数恰好有16个组合状态，即1位十六进制数与4位二进制数是一 一对应的。
二进制数转换为十六进制数，从左向右每四位一组，依次写出每组4位二进制数所对应的十六进制数，简称四位合一位。

数制转换的一般化

R进制转换成十进制
任意R进制数据按权展开、相加即可得十进制数据。
十进制转换R
进制十进制数转换成R 进制数，须将整数部分和小数部分分别转换

整数转换
除R 取余法： 低位到高位
小数转换
乘R 取整法： 高位到底位；
整数退位法
0.321转成二进制数，保留7位
0.321*2^7=41.088,取整数41
41=32+8+1即100000+1000+1=101001
退位，因只有6位而要求保留7位，所以是0.0101001

9.字符编码unicode

在简体中文系统下，ANSI编码代表GB2312编码在日文操作系统下，ANSI编码代表 JIS 编码，可能最终显示的是中文，也可能显示的是日文。

在ANSI编码体系下，要想打开一个文本文件，不但要知道它的编码方式，还要安装有对应编码表，否则就可能无法读取或出现乱码。为什么电子邮件和网页都经常会出现乱码，就是因为信息的提供者可能是日文的ANSI编码体系和信息的读取者可能是中文的编码体系，他们对同一个二进制编码值进行显示，采用了不同的编码，导致乱码。这个问题促使了unicode码的诞生。

如果有一种编码，将世界上所有的符号都纳入其中，无论是英文、日文、还是中文等，大家都使用这个编码表，就不会出现编码不匹配现象。每个符号对应一个唯一的编码，乱码问题就不存在了。这就是Unicode编码。Unicode当然是一个很大的集合，现在的规模可以容纳100多万个符号。每个符号的编码都不一样，比如，U+0639表示阿拉伯字母Ain，U+0041表示英语的大写字母A，“汉”这个字的Unicode编码是U+6C49。Unicode固然统一了编码方式，但是它的效率不高，比如UCS-4(Unicode的标准之一)规定用4个字节存储一个符号，那么每个英文字母前都必然有三个字节是0，这对存储和传输来说都很耗资源。

10.基本数据类型

八种基本数据类型为：

byte、short、int、long、float、double、boolean、char。

基本数据类型	解释	最小值	最大值	默认值	包装类
byte	8位、有符号的以二进制补码表示的整数	-128（-2^7）	127(2^7-1)	0	Byte
short	16位、有符号的以二进制补码表示的整数	-32768（-2^15）	32767（2^15 - 1）	0	Short
int	32位、有符号的以二进制补码表示的整数	-2^31	2^31 - 1	0	Integer
long	64位、有符号的以二进制补码表示的整数	-2^63	2^63 -1	0	Long
float	单精度、32位、符合IEEE 754标准的浮点数	float 在储存大型浮点数组的时候可节省内存空间	浮点数不能用来表示精确的值，如货币	0.0f	Float
double	双精度、64位、符合IEEE 754标准的浮点数	浮点数的默认类型为double类型	double类型同样不能表示精确的值，如货币	0.0d	Double
char	char类型是一个单一的 16 位 Unicode 字符	\u0000（即为0）	\uffff（即为65,535）	char 数据类型可以储存任何字符	Character
boolean	boolean数据类型表示一位的信息	只有两个取值：true 和 false	单元格	单元格	Boolean

11.运算符

11.1 算术运算符

算术运算符即算术运算符号。是完成基本的算术运算 (arithmetic operators) 符号，就是用来处理四则运算的符号。
加法运算 减法运算 乘法运算 除法运算 求余运算 自增 自减

11.2 赋值运算符

赋值运算符用于给 JavaScript 变量赋值。
=
+=
-=
*=
/=
%=

11.3 比较运算符

比较运算符在逻辑语句中使用，以测定变量或值是否相等。
2个= 等于
3个=绝对等于（值和类型均相等）（Java非法）
!= 不等于
!== 不绝对等于(值和类型一个或两个都不相等)（Java非法）
大于
小于
大于或等于
小于或等于

11.4 逻辑运算符

逻辑运算符用于测定变量或值之间的逻辑。

&& and
|| or
! not

11.5 条件运算符

JavaScript 还包含了基于某些条件对变量进行赋值的条件运算符。
variablename=(condition)?value1:value2

11.6 用于字符串的 + 运算符

“abc”+12.6即abc12.6
“abc”+10+11即abc1011
“abc”+(10+11)即abc21

11.7 位运算符

按位 与 运算

按位与运算符"&"是双目运算符。 其功能是参与运算的两数各对应的二进位相与。
只有对应的两个二进位均为1时，结果位才为1 ，否则为0。

按位 或 运算

按位或运算符“|”是双目运算符。 其功能是参与运算的两数各对应的二进位相或。
只要对应的二个二进位有一个为1时，结果位就为1。

按位 异或 运算

按位异或运算符“^”是双目运算符。 其功能是参与运算的两数各对应的二进位相异或。
当两对应的二进位相异时，结果为1。

求反运算

求反运算符～为单目运算符，具有右结合性。 其功能是对参与运算的数的各二进位按位求反。

左移运算

左移运算符,是双目运算符，“a << n"即” a << ( n % 32 ( int ) / 64 ( long ) )"。左移n位就是乘以2的n次方。
其功能把,左边的运算数的各二进位全部左移若干位，由右边的数指定移动的位数，高位丢弃，低位补0。

算数右移运算

右移运算符,是双目运算符,“a >>n"即” a >> ( n % 32 ( int ) / 64 ( long ) )"。右移n位就是除以2的n次方其功能是把,左边的运算数的各二进位全部右移若干位。

逻辑右移时

最高位补0，最低位丢失；

ps:
逻辑左移时，最高位丢失，最低位补0；
逻辑右移时，最高位补0，最低位丢失；
算术左移时，依次左移一位，尾部补0，最高的符号位保持不变。
算术右移时，依次右移一位，尾部丢失，符号位右移后，原位置上复制一个符号位
循环左移时，将最高位重新放置最低位
循环右移时，将最低位重新放置最高位

12.控制语句

控制语句分类: 选择(分支) 语句,循环语句,转向语句

12.1选择(分支)语句**

12.1.1 if语句

if(布尔表达式1){ // 分支1
java语句;
}else if(布尔表达式2){ // 分支2
java语句;
}else{
java语句; // 以上条件没有一个成立的。这个else就执行了。
}

注意：
int aa=10, bb = 10;
if (a = b){} //语法错误
if (1){} //c/c++可以,Java不行
if (aa){}  //c/c++可以,Java不行，Java要boolean变量才行

12.1.2 switch语句

支持int类型以及String类型。switch语句中“值”与“值1”、“值2”比较的时候会使用“==”进行比较。

switch(值){
case 值1:
java语句;…break;
case 值2:
java语句;…break;
default:
java语句;…
}

12.2循环语句

12.2.1 for循环

for(初始化表达式; 条件表达式; 更新表达式){
循环体；
}

12.2.2 while循环

while(布尔表达式){
循环体;
}

12.2.3 do…while；循环

do {
循环体;
}while(布尔表达式);

12.3 转向语句

break语句主要是用来终止离它最近的那个循环语句。
continue语句主要是用在循环语句中！终止当前"本次"循环，直接进入下一次循环继续执行。
return语句主要是用来退出本方法。

13.修饰符

13.1 类修饰符

public ：所有位置都可以访问该类
friendly（默认）：同一个包中的类可以访问，可以被继承（包括别的包中的类）
final：声明为最终类，不能被继承
abstract：抽象类，抽象类不能被实例化，只能被继承，且子类需要实现抽象类中所有的抽象方法

• 接口中所有的方法都是默认public abstract，所有的成员变量都默认是final static。
• 类声明为private是没有意义的。
• 类修饰符没有protected，因为没有必要，类的子类自然有对该类的“访问权限”，实际上权限的问题转移到了子类对父类中的成员变量以及方法有无访问权限，而这些由他们各自的成员变量、方法修饰符决定。

13.2 成员变量修饰符

public：所有类都可以访问
protected：同一个包中的类或者子类可以访问
默认：同一个包中的类可以访问（和类修饰符的friendly的意义不同）
private：只有该类本身可以访问
final：声明为最终变量，不可改变
static：静态变量

13.3 方法修饰符

public：同成员变量
protected：同成员变量
默认：同成员变量
private：同成员变量
final：方法不能被重写、可以被重载
static：静态方法
synchronize：同步修饰符，用于线程对方法的加锁

13.4 局部变量修饰符

局部变量只能够被两种修饰符修饰：默认和final

14.数组

14.1 数组的基本概念

什么是数组

• 数组是相同类型元素的集合。
• 创建数组的时候，Java就会再内存中分配一段连续的空间来存放数组的内容。
• 每一个数组内容都有自己的编号，这个编号从0开始的，也就是数组的下标从0开始。
• 在Java中，数组[]里面的大小支持常量，变量和表达式。
• 数组是一段连续的内存空间，因此支持随机访问，即通过下标访问快速访问数组中任意位置的元素。
• 数组的下标从0开始，介于[0, N）之间不包含N，N为元素个数，不能越界，否则会报出下标越界异常。

14.2 一维数组

14.2.1 创建和初始化

创建一个数组：
T[] 数组名 = new T[N];
T：数组中元素的类型；
T[]：表示是数组类型。
N：创建数组要的长度。
比如：
int[] array1 = new int[10]; // 创建一个可以容纳10个int类型元素的数组
double[] array2 = new double[5]; // 创建一个可以容纳5个double类型元素的数组
String[] array3 = new String[3]; // 创建一个可以容纳3个字符串元素的数组

对数组进行初始化，有两种方式。
静态初始化：
知道数组的内容，就可以静态初始化。
int[] arr = { 1,2,3,4 }; //省略情况，注意省略格式不可以拆分, 否则编译失败
int[] arr = new int[] { 1,2,3,4 };//可以省略new int[]
动态初始化：
int[] arr = new int[10]; //定义10个int类型的数组
上面两种创建方式都可以分两步进行创建：
int[] array1;
array1 = new int[10];
int[] array2;
array2 = new int[]{10, 20, 30};// 注意省略格式不可以拆分, 否则编译失败
注意：
如果没有对数组进行初始化，数组中的元素有默认值。不同的数据类型有不同的默认值，如果是简单类型，大多是默认值为0。float是0.0f，double是0.0，char是/u0000，boolean是false。引用类型比如字符串类型则是null。

14.2.2 一维数组的使用

数组元素的访问：

数组在内存中是一段连续的空间，下标是从0开始的。
比如：
int[]array = new int[]{10, 20, 30, 40, 50};
System.out.println(array[0]);
System.out.println(array[1]);
System.out.println(array[2]);

数组的内容修改：

将上面的array[0]改为20：
array[0] = 20;

14.2.3 数组的遍历

在Java中，对数组的遍历有两种方式：
第一种是for，第二种是增强for（foreach）。

由于Java是面向对象的语言，在Java中，一切都是对象，比如数组。数组这个对象有它的属性，比如数组的长度等，基于这一点，我们可以不用刻意知道数组的长度，使用.length来获取数组的长度。
//for
int[]array = new int[]{10, 20, 30, 40, 50};
for(int i = 0; i < array.length; i++){
System.out.println(array[i]);
}
//foreach
int[] array = {1, 2, 3};
for (int x : array) {
System.out.println(x);
}
//foreach
double[] array = {1.0, 2.0, 3.0};
for (double x : array) {
System.out.println(x);
}
增强for循环是得不到数组的下标的，所以它一般用于数组的遍历，比如数组累加这样的操作。

14.2.4 数组在内存中的分布

JVM内存分布简介
Java经过编译后产生的.class文件被加载到JVM虚拟机里面的本地方法栈里面运行。为了高效管理内存，JVM对内存进行了划分。
JVM是一个软件，由C/C++编写的软件。这是因为系统之类的由C/C++代码编写比较高效。

说明：
Java虚拟机栈：
也是我们在Java中常说栈。一般用来存放局部变量。
本地方法栈：
运行由c/c++编写的代码。经过编译产生的.class文件被加载到这里运行。
堆：
是Java中最大的一块内存空间。只要是对象，都是在堆上开辟的。在堆里面的引用叫对象。堆上的内存是不需要进行手动释放的，Java有自己的垃圾回收机制。
程序计数器：
保存一些指令和信息等。
方法区：
存放常量，静态成员变量等。

这里重点关心堆和虚拟机栈。

14.2.5 引用类型变量

引用类型创建的变量，一般称为对象的引用。存储的是对象所在空间的地址。

如何理解数组的引用呢？比如写了这么一个代码：
int[] arr = new int[] {1,2,3};
在内存中发生了什么呢？

这里的arr是局部变量，运行代码后，java就会在栈上为arr分配空间。后面new了之后，就会在堆上开辟一块空间来保存这些内容。arr存的是后面对象的地址。这里要强调的是，引用变量存的是对象的地址。打印arr，打印出了这么一个地址（可以理解为数组首元素地址）。
这里的地址为了安全，经过了特殊的处理，是这个引用对象的哈希地址。@之后的是哈希地址，@前的I表示这是一个int型，[表示是一个数组。arr这个引用，引用（指向）了一个数组对象。

引用不一定在栈上。还有可能在堆上，比如成员变量。引用赋值为null表示不指向任何对象。

14.3 二维数组

14.3.1 定义：

二维数组本质上也就是一维数组，只不过每个元素又是一个一维数组。
数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };

int[][] arr1 = { {1,2,3},{4,5,6} };
int[][] arr2 = new int[][] { {1,2,3},{4,5,6} };
int[][] arr3 = new int[2][3];
int[][] arr4 = new int[2][];

在Java中，如果是前两种定义的方式，必须要手动加括号。同时，行是必须要指定的，列可以不用指定。

14.3.2 遍历

和一维数组类似，二维数组有for循环和foreach循环来进行遍历。
int[][] arr1 = { {1,2,3},{4,5,6} };

//for
for (int i = 0; i < arr1.length; i++) {
  for (int j = 0; j < arr1[i].length; j++) {
    System.out.print(arr1[i][j] + " ");
  }
  System.out.println();
}
//foreach
for (int[] x : arr1) {
  for (int y : x) {
    System.out.print(y + " ");
  }
  System.out.println();
}

14.4 Arrays数组常用的方法

Java中的Arrays工具类包括了数组常用的一些方法，比如数组的排序，数组的拷贝等方法。

在使用之前需要导入：import java.util.Arrays;

这些方法是重构的，这里拿int类型的数组简单介绍一下，其他的原理是相同的。

14.4.1 Arrays.toString方法：

将一维数组变成字符串。

public static void main(String[] args) {
  int[] array = new int[] { 1,2,3,4 };
  System.out.println(Arrays.toString(array));//[1,2,3,4]
}

14.4.2 Arrays.copfOf方法

从0下标复制指定长度数组的内容到新的数组中。

public static int[] copyOf(int[] original, int newLength)
参数：original:要复制的数组;
          newLength - 要返回的副本的长度

public static void main(String[] args) {
  int[] array = new int[] { 1,2,3,4 };
  int[] ret = Arrays.copyOf(array,2);
  System.out.println(Arrays.toString(ret));//[1,2]
}

14.4.3 Arrays.copyOfRange方法

和Arrays.copfOf方法类似，这个是指定范围的拷贝。范围是左闭右开区间。
public static int[] copyOfRange(int[] original, int from, int to)

参数
original - 要从中复制范围的数组
from - 要复制的范围的初始索引（包括）
to - 要复制的范围的最终索引，除了它本身。 （该索引可能位于数组之外）

public static void main(String[] args) {
  int[] array = new int[] { 1,2,3,4 };
  int[] ret = Arrays.copyOfRange(array,2,4);
  System.out.println(Arrays.toString(ret));//[3,4]
}

14.4.4 Arrays.sort方法

对数组进行升序排序。

public static void sort(int[] a)
public static void main(String[] args) {
  int[] array = new int[] { 4,3,2,1 };
  Arrays.sort(array);
  System.out.println(Arrays.toString(array));//[1,2,3,4]
}

14.4.5 Arrays.fill方法

对数组内容进行指定填充。

public static void fill(int[] a, int val)//全部填充
参数：
a - 要填充的数组
val - 要存储在数组的所有元素中的值

public static void fill(int[] a, int fromIndex, int toIndex, int val)//指定范围填充
参数
a - 要填充的数组
fromIndex - 要用指定值填充的第一个元素（包括）的索引
toIndex - 要用指定值填充的最后一个元素（排除）的索引
val - 要存储在数组的所有元素中的值

public static void main(String[] args) {
  int[] array = new int[10];
  Arrays.fill(array,10);
  Arrays.fill(array,2,8,20);
  System.out.println(Arrays.toString(array));
}

14.4.6 Arrays.equal方法

判断两个数组的内容是否相同

public static boolean equals(int[] a, int[] a2)
参数
a - 要测试相等的一个数组
a2 - 要测试的其他数组是否相等

public static void main(String[] args) {
  int[] arr1 = new int[] { 4,3,2,1 };
  int[] arr2 = new int[] { 1,2,3,4 };
  int[] arr3 = new int[] { 1,2,3,4 };
  System.out.println(Arrays.equals(arr1, arr2));//false
  System.out.println(Arrays.equals(arr2, arr3));//true
}

14.4.7 Arrays.binarySearch方法

二分查找数组内容，使用前先sort排序数组。

public static int binarySearch(int[] a, int fromIndex, int toIndex, int key)
参数
a - 要搜索的数组
fromIndex - 要搜索的第一个元素（包括）的索引
toIndex - 要搜索的最后一个元素（排他）的索引
key - 要搜索的值

public static void main(String[] args) {
  int[] arr1 = new int[] { 4,3,2,1 };
  System.out.println(Arrays.binarySearch(arr1, 3));//下标是1
}