一. Java 程序设计概述
1. Java 介绍
-
Java 是一个完整的平台，有一个庞大的库，库中包含大量可重用的代码，以及一个提供诸如安全行、跨操作系统可移植性以及自动垃圾回收功能的执行环境
-
Java 是一门解释性的语言，在执行 Java 代码时，将Java源码先编译成Java的字节码，也就是.class文件，这里有个编译的动作，然后将字节码装载到JVM中，逐条解释执行
2. Java 特性
-
简单性：剔除了 C++ 中很少使用、难以理解、容易混淆的特性
-
面向对象：Java 将重点放在对象和对象的接口上，并摒弃了多继承的结构
-
分布式：Java 应用程序能通过 URL 打开和访问网络上的对象
-
健壮性：强调进行早期的问题检测，后期的动态（运行时）检测
-
安全性：Java 代码不论来自哪里，都不能脱离沙箱
-
体系结构中立：Java 编译器生成一个体系结构中立的目标文件格式，可在多种处理器上运行
-
可移植性：指定数据类型的长度，屏蔽其它平台的 “依赖具体实现方法”
-
解释型：Java 解释器能在任何移植了解释器的机器上执行 Java 字节码
-
高性能：Java语言本身发展中通过虚拟机的优化提升了几十倍运行效率
-
多线程：多线程可以带来更好的交互响应和实时行为
-
动态性：Java 能够适应不断发展的环境库中可以自由地添加新方法和实例变量， 而对客户端却没有任何影响
二. Java 开发环境配置
1. JDK、JRE 和 JVM
-
JDK: Java Development ToolKit（Java开发工具包）。JDK是整个JAVA的核心，包括了Java运行环境（JRE），Java工具（javac/java/jdb等）和Java基础的类库（即Java API ） -
JRE：Java Runtime Environment（Java运行环境）。包含JVM标准实现及Java核心类库。 JRE中包含了Java virtual machine（JVM），runtime class libraries和Java application launcher，这些是运行Java程序的必要组件 -
JVM：Java Virtual Mechinal（Java 虚拟机）。是JRE的一部分。它是整个java实现跨平台的最核心的部分，负责解释执行字节码文件，是可运行java字节码文件的虚拟计算机
2. JDK 版本
| 版本名 | 缩写 | 介绍 |
|---|---|---|
| Server JRE（服务器 JRE） | -- | 在 Java 上运行 Java 程序的软件 |
| Standard Edition（标准版） | SE | 用于桌面或简单服务器应用的 Java 平台 |
| Enterprise Edition（企业版） | EE | 用于复杂服务器应用的 Java 平台 |
| Micro Edition（微型版） | ME | 用于小型设备的 Java 平台 |
| OpenJDK | -- | Java SE 的一个免费开源实现 |
| Update | u | Java 8 之前的 bug 修正版本 |
| NetBeans | -- | Oracle 公司而集成开发环境 |
在上面各版本中，我们通常使用的 JDK 版本是 SE 或者 OpenJDK，如果在进入公司的时候，就需要使用 EE 版本来进行开发
以上是 JDK 在不同用途上的版本，以下是 JDK 迭代的版本（以 SE 为例）
从 SE 1 开始，直到现在（2022.09），SE 已经迭代到 18 版，因为追求稳定性，学校老师一般使用的是 Java SE 8（有时也叫 Jdk-1.8），因为这是一个 LTS版本（长期稳定版），除 SE 8 外还有一个 LTS 版本，是 SE 11 (LTS)
虽然建议使用 SE8 或 SE11，但是也可以选择尝试其它版本 只要版本别低于 8，如果不是实际项目开发，差别不大
3. JDK 的安装及切换
这里只有 Linux 系统中关于 JDK 的操作
关于 Windows 下安装、切换 JDK 可以参考以下链接
在 Linux 下，可以选择 到官网下载安装 或者通过系统相关的包管理器安装，推荐第二种，方便
- 下载安装
JDK 下载链接：Java Archive Downloads - Java SE 11
# 在 /usr/share 中创建一个文件夹 java
mkdir /usr/share/java
# 根据自己电脑的 系统 和 CPU 核心架构 选择，这里以通用的 .tar.gz 为例
# 从上面的链接下载好安装包，建议下载 linux-x64_bin.tar.gz，放到这个 java 目录下
# 解压(可以解压到其它目录都行，后面相应的路径也要修改)
tar -xvf jdk-11.0.16_linux-x64_bin.tar.gz
# 编辑配置文件
vim /etc/profile
### 在文件末尾添加以下内容，上面的路径如果改变，下面的路径也要更改
# JAVE JDK 11
export JAVA_HOME=/usr/share/java/jdk-11.0.16
export PATH=$JAVA_HOME/bin:$PATH
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
# 重新载入配置文件，让配置生效
# Linux 中所有配置文件都是 Shell 脚本，source 命令可以重新编译并执行相应脚本文件
source /etc/profile
# 检查是否完成配置，如果显示出 JDK 的版本号，则表示完成配置
java -version
- 命令行安装
# 通过命令行安装很方便，也不用专门去官网下载软件包
# Linux 使用自己系统的包管理器安装就好
# 如果以下没有列出你所使用的包管理器，建议浏览器搜索词“Linux [包管理名] JDK”
# Arch Linux
yay -S jdk11-openjdk
# CentOS
yum -y install java-11-openjdk
# Ubuntu
apt install openjdk-11-jdk
4. 多版本 JDK
如果正在使用的 JDK 和需要使用的 JDK 版本不同，就需要切换 JDK 的版本
如果是自己到官网下载安装包进行安装，那就只需要在 /etc/profile文件中修改以下 JDK 的路径就行了
如果是使用系统的包管理器进行安装的，可以用命令进行切换
# 当前系统 Arch,其它系统建议搜索词“[系统名] 安装切换多版本jdk”
### Arch Linux
# 查看当前系统一共安装了几个 JDK，以下可见当前系统存在两个 JDK，11 作为 default
[guyan@DrangonBoat Desktop]$ archlinux-java status
Available Java environments:
java-11-openjdk (default)
java-8-openjdk
# 切换默认 JDK 版本
sudo archlinux-java set java-8-openjdk
# 再次使用 status 命令，可以看到 default JDK 已经更改为 8
其它系统 JDK 切换：
5. 集成开发环境（IDE）
IDE 有很多，推荐使用 Intellij IDEA、Visual code、Eclipse，也可以使用其它 IDE，甚至是用命令行当开发工具也可，这里推荐使用 IDEA 不是其它原因，只是因为我正在使用 IDEA
# 可以到官网下载安装 IDEA，但是可以简便地使用包管理器安装
# 使用包管理器(yay)查询软件包
yay -q intellij-idea
### 显示信息
...
2. community/intellij-idea-community-edition 4:2022.1.4-1 (408.2 MiB 1.8 GiB)
# 其它包管理器也可以进行相应的查询操作然后安装
在创建项目的时候，IDEA 会自动选用 JDK，如果有多个 JDK，其会自动选用最新的一个作为当前项目的 JDK
查看当前项目所使用的 JDK：IDEA -> Project Structure -> Project -> SDK
(注：当显示为 “No SDK“ 的时候，默认使用最新的 JDK )
- 在 IDEA 中添加已经安装的 JDK
进入 IDEA -> Project Structure -> SDKS
看右边可以发现已经列出了 JDK11 的路径
/usr/lib/jvm/java-11-openjdk这个路径是使用包管理器安装 JDK 时系统默认的安装路径可以点击 ’+‘ ，添加新的 JDK（自定义的安装位置，或这个/usr/lib/jvm 路径）
保存退出后再创建新的项目使就会自动使用众多 JDK 中最新的一个
- 更换当前项目使用的 JDK
进入 IDEA -> Project Structure -> Project
右方有 SDK 选项，可以在这里选择当前项目执行的 JDK 环境
三. 基本程序设计结构
1. 基本程序框架
package *; // 表示这个文件属于哪个包
import *; // 引入一些库，不必重复造轮子
/*
* name：Java 基本程序框架
* describe: NULL
*/
// public 称为访问修饰符，这部分会在后面详细说明，现在只需要知道它可以控制访问权限即可
// class，类，表明这是一个类，而不是方法或其它什么
// Basiframework 类名称，自定义，一般首字母大写，建议使用驼峰命名法
// 源代码文件的命名必须与公共类一致，即一个代码文件中只能有一个 public class
public class BasicFramework {
// Java 虚拟机总是从指定类中的 main 方法开始执行
// Java 项目中每个类都可以有一个 main 方法，但只有一个会被执行，其它的可用作单元测试
public static void main(String[] args) {
// 以下是程序的代码主体，在此编写程序的主要功能
// program statements
System.out.print("I wana see you at this time .");
}
// 可以在这里编写一些其它方法
}
-
Java 区分大小写，出现拼写错误时，程序将无法运行
-
每个语句以分号结束
2. 注释
注释有常规注释和文档注释两种，常规注释的内容在且只在源代码中，而文档注释在编写之后会自动由源文件生成一个HTML文档，类似于联机API文档（可以在控制台使用命令将文档注释抽取出来成为一个文档）
1. 常规注释
// 单行注释，直到本行结尾
/*
* 常规多行注释。注意，不要嵌套
*/
2. 文档注释
/**
* 文档注释
* @author guyan
* @param 元素注释
* @return
* @throws
*
* @version
* @since 引入版本特性的描述
* @deprecated 对类 方法或变量添加一个不再使用的注释,
* 给出取代或修改的意见
* @see 用到的时候再说
* @link
*/
// 注释抽取
javadoc -d 存放地址 fileName.java
3. 数据类型
Java 是一种强类型语言，这要求每个变量在声明的时候必须声明变量的类型。此外，Java 中的基本数据类型的取值范围不受系统的字长影响。
Java 有 8 种基本数据类型，以及多到不知道有多少种的引用数据类型。
8 种基本数据类型中，有 4 种整型，2 种浮点型，1 种字符型，和一种用于表示真值的 boolean 类型
-
整型：byte(1字节)，short(2字节)，int(4字节)，long(8字节)
-
浮点型：float(4字节)，double(8字节)
-
字符型：char(2字节)
-
Boolean值：Boolean(1 bit)
// 声明变量
byte a;
short b;
int c;
long d;
// 变量赋值
// 通常在书写代码的时候并不会十进制之外的进制，但要能看懂当前数字所使用的进制
// 长整形,后缀为 L ;十六进制前缀为 0X ;八进制前缀为 数字0 ;二进制前缀是0B
// 前缀都是数字 0
int n = 0B10011; // n=19
// 连续赋值
int a,b,c;
a = b = c = 4; //从右往左赋值
// 这种形式的赋值是可行的，但是不建议这样做
// 浮点数的其它进制的写法和整型是一样的
// 声明变量
float e;
double f;
// 浮点数除正常的浮点数之外还有 3 个表示溢出和出错的浮点数值
- 正无穷大
- 负无穷大
- NAN（不是一个数字）
// 字符类型除了表示一个字符的用法之外，还可以用于表示 Unicode 的编码
// 其中最有代表性的是转义字符，一个字符长度的 Unicode 编码可以将值赋给 char 变量
// 声明
char g = 'A';
// 布尔值，Boolean,只有两种取值：false true
// 声明
Boolean flag01 = false;
Boolean flag02 = true;
上面是八种基础数据类型的声明示例，尽量让变量的声明靠近第一次使用的地方
4. 变量与常量
与所有程序设计语言一样，Java 也使用变量来存储值，常量就是值不变的变量
1. 变量
int a ;
char c ;
...
// 如果可以从变量的初始值推断出它的类型，就不需要再声明其类型，而只需要用 var 关键字代替
var a = 10;
var s = "String";
2. 常量
// Java 中的常量需要使用关键字 final 明确指示
final int a = 10;
// 以上常量 a 在程序员想要再次修改它的值的时候会拒绝修改
// 常量名 通常使用全大写，请忽视这个示例的大小写问题
5. 运算符
算术运算符
加 减 乘 除
+ - * /
赋值运算符
// 赋值运算符除了‘=’，其它赋值运算符都偷偷加了私料
=
// 将运算符 左边的数值 [+,-,*,/,%] 右边的结果
+= -= *= /= %=
自增与自减运算符
// 自增与自减，通常用作在某次循环中对起到标志作用的变量进行操作
int a = 10;
--a; // 9
a--; // 8
++a; // 9
a++; // 10
// --a 与 a-- 的差异，如 int n = --a; 会先进行自减操作然后再赋值
// 而 int n = a--; 则是先进行赋值然后再自减
关系运算符
== != >= <= ? :
// 关系运算符通常与 Boolean 联系起来，因为关系运算的结果就是 布尔值
int a = 3;
int b = 4;
int c = 0;
Boolean flag ;
a == b; // 判定 a 与 b 是否相等，返回布尔值。此处返回 false
a != b; // 判定 a 与 b 是否不等，返回布尔值。此处返回 true
a >= b; // ...
a <= b; // ...
c = a>b ? a : b; // 判断 a 是否大于 b,如果为真，返回 a,如果为假，返回 b
//
flag = (a == b); // flag = false
// 虽然这里的括号有和没有对于计算机来说没什么区别，但对于人来说，明确的划分方便查看
逻辑运算符
且 与
&& ||
// 数学自行对号入座
位运算符
and or xor not
& | ^ ~
关于运算符的优先级：
尽量加括号
自增自减 的优先度最高（忽略括号）
赋值运算符 优先度最低
数学运算
// 当想要对某个数进行数学操作的时候，不需要自己再次重新编写
// Java 有一个 Math 函数库，大部分的数学运算的函数代码都在这个库中
// 如果想要在代码中调用这些库函数，则需要导入相应的库
import static java.lang.Math.*;
// Math 类中的静态常量
E // 自然数 e
PI // 圆周率 π
// 常用数学运算函数
abs(int a) // 返回 a 的绝对值，a 可以是所有数值类型
max(int x,int y) // 返回 x 和 y 中的最大值，x 和 y 可以是所有数值类型
min(int x,int y) // 返回 x 和 y 中的最小值，同上
ceil(double a) // 返回大于或等于 a 的最小整数
floor(double a) // 返回小于或等于 a 的最大整数
rint(double a) // 返回最接近 a 的整数值，如果有两个同样接近的整数，则结果取偶数
round(float a) // 将参数加上 1/2 后返回与参数最近的整数
exp(double a) // 返回 e 的 a 次幂
pow(double a,double b) // 返回以 a 为底数，以 b 为指数的幂值
sqrt(double a) // 返回 a 的平方根
cbrt(double a) // 返回 a 的立方根
log(double a) // 返回 a 的自然对数，即 lna 的值
log10(double a) // 返回以 10 为底 a 的对数
6. 数值类型转换
1. 自动转换数据类型
从低精度的数据类型转向高精度的数据类型是自动的，无需特别标明
但我们必须清楚，这里发生了数据类型转换
int a = 10;
float b = a;
// a 的值并不会发生实际的变化，只是在赋值过程中，先取出 a 的只
// 将其转化为 浮点数，然后将浮点数赋给变量 b
2. 强制转换数据类型
高精度的变量向低精度的变量进行转换时会丢失数据数据精度
Java 会对此发出警告，要想屏蔽这种警告需要进行强制类型转换
double x = 9.997;
int nx = (int)x; // nx = 9
7. 字符串
概念上，Java 的字符串就是 Unicode 字符序列。
实际上，Java 并没有内置的字符串类型，而是在标准的 Java 类库中提供了一个预定义类，很自然地叫做 “String”
String s = ""; // 一个空字符串
String greeting = "Hello";
在 Java 中字符串是不可变的，即一个字符串里不可以改变其中的字符，但是可以通过字符串拼接或其它操作，将新的字符串赋给字符串变量，实现字符串的变化。
关于效率问题，所有字符串都都存放在公共的存储池中，字符串变量指向存储池中相应的位置。
下面的例子将展示一个项目中源码文件书写格式 并在其中展示有关字符串的一些操作。
package chapter03;
import java.lang.String;
import java.util.Locale;
/*
* NO:02
* Name：字符串测试
* Describe：
* Java 共享池的基本性质
* 一些字符串处理函数
*/
public class StringTest {
public static void main(String[] args) {
// Java 字符串共享池 测试
// "==" 可用于检测两个字符串是否存放在同一个位置上，即检查引用是否相同
System.out.println("字符串共享池测试：");
String s1 = "share pool";
String s2 = s1;//"share pool";
String s3 = new String("share pool");
System.out.println("字符串 s1 为："+s1);
System.out.println("字符串 s2 为："+s2);
System.out.println("字符串 s3 用 new 方法创建为："+s3);
System.out.println("(s1 == s2) = " + (s1 == s2)); // true
System.out.println("(s1 == s3) = " + (s1 == s3)); // false
// 提取字符串字串
// 相同的字符串字面量共享地址，提取或拼接后的字符串不共享
System.out.println();
System.out.println("字符串提取字串测试：");
System.out.println("字符串 s3 为："+s3);
String s4 = s3.substring(0,5);
System.out.println("从字符串 s2 中提取字符串，" +
"字符串 s4 为："+s4); // s3="share"
System.out.println("(s3 == s4) = " + (s3 == s4));
// 字符串拼接
System.out.println();
System.out.println("字符串拼接测试：");
String s5 = " pool";
String s6;
s6 = s4 + s5;
System.out.println("字符串 s4 为："+s4);
System.out.println("字符串 s5 为："+s5);
System.out.println("拼接字符串 s4 与 s5,生成字符串 s6" +
"\n"+
"字符串 s6 为："+ s6);
// 字符串相等测试 equals
// “equals” 用于对比两个字符串中的字符，“==”用于检测引用是否相等
System.out.println();
System.out.println("字符串 equals() 测试：");
System.out.println("字符串 s2 为：" + s2 +
"\n" +
"字符串 s3 为：" + s3 +
"\n" +
"字符串 s4 为：" + s4 );
System.out.println("s2 equals s3 ? " + (s2.equals(s3)));
System.out.println("s3 equals s4 ? " + (s3.equals(s4)));
// 空字符串测试
System.out.println();
System.out.println("空字符串检测方式：");
String s7 = "";
System.out.println("空串 s7 长度为：" + s7.length());
Boolean flag = (s7.length() == 0); // flag = true
flag = (s7 == null); // flag = true
// 码点单元，码点是字符的 Unicode 编码
// 获取字符串中的字符数量，即字符串的长度
String greeting = "hello";
int n = greeting.length(); // is 5
// 获取字符串实际长度，即码点数量
int cpCount = greeting.codePointCount(0, greeting.length()); // 5
// charAt() 返回某个位置的码点单元
char first = greeting.charAt(0); // is 'h'
char last = greeting.charAt(4); // is 'o'
// 获取码点
int index = greeting.offsetByCodePoints(0,2);
// 返回从给定位置开始的码点
int cp = greeting.codePointAt(index);
System.out.println(index +" "+ cp);
// 字符串大小写转换
String name = "guyan";
name = name.toUpperCase(); // GUYAN
name = name.toLowerCase(); // guyan
// 删除字符串头或尾的空格
String space = " space ";
System.out.println(space.length()); // 9
space = space.strip();
System.out.println(space.length()); // 5
// 多字符串连接
// 返回一个字符串，用给定的定界符连接所有元素
String sencent = "q";
sencent.join(" ","a");
System.out.println(sencent);
// StringBuilder 字符串构建
// Stringbuilder 构建一个容器，在容器里的内容被转化为字符串前
// 可以任意对其中的内容进行修改
// 创建一个新的容器
StringBuilder builder = new StringBuilder();
// 追加一个字符串，并返回 this
builder.append("stabt"); // "stabt"
// 追加一个字符并返回 this
builder.append(" "); // "stabt "
// 追加一个码点
builder.append(118); // "stabt 118"
// 修改某个代码党员的值
builder.setCharAt(2, 'r'); // "start 118"
// 将字符串构建器中的内容转化为字符串
String s = builder.toString();
System.out.println(s);
}
}
8. 输入与输出
package chapter03;
import java.io.IOException; // 输入输出异常包，检测输入输出
import java.io.PrintWriter; // 用于创建一个文件并向文本写入数据
import java.nio.charset.StandardCharsets; // 标准Charsets的常量定义
import java.nio.file.Path; // 指向文件的路径
import java.util.Scanner; // 标准输入相关的包
/*
* NO：03
* Name：输入输出测试
* Describe：
* 输入输出
* 格式化输入输出
*/
public class IO {
public static void main(String[] args) throws IOException {
// 构造一个与标准输入流 System.in 相关联的Scanner 对象
// 其中，System.in 可以换成 字符串变量，读取的时候和i自动从字符串读取
Scanner input = new Scanner(System.in);
// 获取下一行输入
String line = input.nextLine();
// 获取下一个字符串（以空格作为分隔符）
String word = input.next();
// 获取下一个整数
int n = input.nextInt();
// 获取下一个浮点数,依次类推，double 类型的浮点数类似
float f = input.nextFloat();
// 检查键盘是否还有未使用的 单词、整数、浮点数
input.hasNext(); //返回 Boolean 值
input.hasNextInt(); // 可以将 Int 换成其它数据类型
input.hasNextFloat();
// 关闭输入流
input.close();
// 格式化输出
// Java 继承了 C 语言的 printf(),格式化输出数据
int a = 10;
f = (float) 12345.54;
// '%'是格式化输出的标志，后面的字母 'd' 表示整数
// 连起来的意思是将 a 替换到 %d 里
System.out.printf("%d \n",a);
// 常用的还有 %f %s %c %b
// 上面的字母通常只是用来表示数据类型
// 还可以在 '%' 与 'd' 之间添加其它参数来确认数据的打印格式
// emmmm, 不想写了，过
// 文件输入与输出
// 如果想要读取一个文件的内容，打开一个文件输入流
Scanner in =new Scanner(Path.of("myfile.txt"), StandardCharsets.UTF_8);
// 如果想要将内容写入文件，需要构造一个 PrintWriter 对象
PrintWriter out = new PrintWriter("myfile.txt", StandardCharsets.UTF_8);
}
}
9. 控制流程
// 块作用域
{}
// 条件语句
if(condition) {}
if(condition) {}
else {}
if(condition1) {}
else if(condition2){}
else{}
// 循环
while(){}
do{}while();
// 确定循环
// 在一个 for 循环中，“int i=10”只执行一次
// 在一个 for 循环中，“i>0” 每次循环前进行一次判断，如果为真，执行循环体
// 在一个 for 循环中，在执行完循环体之后，执行 “i--”
for( int i=10; i>0; i--) {}
// 多重选择
switch(choice) // 传入一个参数，匹配下面的case
{
// choice 可以为 char byte short int enum String，这例子里的是 int
// 当 choice = 1 时，执行 case 1 后面的块，其它 case 以此类推
case 1:{} // 最好每个 {} 里都有一个 break，否则就会在switch 里不断匹配
case 2:{}
case 3:
case 4:{}
//此时 3 和 4 将会执行同一块
default: {};
}
// 中断控制循环 break
// 当一个循环体执行到一条 break 语句的时候，会直接终止“当前“循环
break;
// 当在循环体中，执行到 continue 语句的时候
// 会跳过当前循环剩余未执行的语句，提前进入下一次循环
continue;
// for each
// for each 会遍历数组中的所有元素而不是固定的次数
for(int element : a)
System.out.print(element+" ");
10. 大数
当 long 或 double 的精度不足以满足使用的需求，可以使用大数，即 BigInteger 或 BigDecimal，这两个类可以处理任意长度的数字序列数值
package chapter03;
import java.math.BigInteger;
import java.util.Scanner;
/*
* NO：04
* Name：大数
* Describe：
* 大数声明
* 对大数操作
*/
public class BigIntegerTest {
public static void main(String[] args) {
BigInteger x = new BigInteger("1234567890123456789012345678901234567890");
BigInteger y = new BigInteger("1231231231231231231231231231212312312312");
BigInteger z = new BigInteger("0");
// +
System.out.println(x.add(y));
// -
System.out.println(x.subtract(y));
// *
System.out.println(x.multiply(y));
// /（除）
System.out.println(x.divide(y));
// 取余
System.out.println(x.mod(y));
// 平方根
System.out.println(x.sqrt());
// 比较
System.out.println(x.compareTo(y));
// 基本数据类型转大数
long n = 100;
z = BigInteger.valueOf(n);
System.out.println(z);
System.out.println(y);
}
}
11. 数组
package chapter03;
import java.util.Arrays;
import java.util.Scanner;
/*
* NO:05
* name：Java 数组
* describe: 测试数组基本操作
* 声明数组
* 访问数组元素
* for each 遍历数组
* 数组拷贝
* 数组排序
* 二维数组
*/
public class ArrayTest {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
// 声明数组
int[] a = new int[10];
int[] aExtra = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
a = new int[]{1, 11, 111}; // 匿名数组
// 可以使用上面这种声明匿名数组的语法
// 声明数组的时候，声明的是一个数组的引用，这个数组引用可以指向任意该类型的数组
// 访问数组元素
// 常规获取数组元素的方式是通过数组下标
System.out.println(a[1]);
// for each 遍历数组
// for功能更为强大，但 foreach 对遍历数组来说，更加方便
for(int element : a)
System.out.println(element);
// 数组拷贝 copyOf()
// 如果直接用 '=' 复制数组，那新数组的地址依旧为旧数组的地址
// 第一个参数是将要被复制的数组名
// 第二个参数是新数组的长度，只可以比原数组的长
int[] b = Arrays.copyOf(a, a.length+2);
for(int element : b)
System.out.print(element + " ");
System.out.println();
// 数组排序
// Java 库中有排序方法，当然，平时练还是要练的
a = new int[] {2, 6, 5, 9};
Arrays.sort(a); // sort() 是快速排序方法
for(int element : a)
System.out.print(element + " ");
System.out.println();
// 二维数组（平时使用的最多是二维，三维或者三维以上是很少的,也不建议使用）
int[][] square = new int[10][10];
// 声明使用方式和一维数组基本相同，过
}
}
参考：
-
Java 核心技术 11版 Cay S.Horstmann 著 林琪 等译
-
联机 API 文档Overview (Java SE 11 & JDK 11 )