Java 基础
Java基础与高级
第一章 开发前言
1.1 Java语言概述
什么是Java语言：
Java语言是美国Sun（Stranford Unniversity Newwork）公司，在1995年推出的高级编程语言
1.2 计算机基础知识
1.2.1 二进制
二进制（binary）在数学和数字电路中指以2为基数的记数系统，以2为基数代表系统是二进位制的。这一系统中，通常用两个不同的符号0（代表零）和1（代表一）来表示 。数字电子电路中，逻辑门的实现直接应用了二进制，因此现代的计算机和依赖计算机的设备里都用到二进制。每个数字称为一个比特（Bit，Binary digit的缩写）
1.2.2 八进制
八进制，Octal，缩写OCT或O，一种以8为基数的计数法，采用0，1，2，3，4，5，6，7八个数字，逢八进1。一些编程语言中常常以数字0开始表明该数字是八进制。八进制的数和二进制数可以按位对应（八进制一位对应二进制三位），因此常应用在计算机语言中。
1.2.3 十进制
600，3/5，-7.99……看着这些耳熟能详的数字，你有没有想太多呢？其实这都是全世界通用的十进制，即1.满十进一，满二十进二，以此类推……2.按权展开，第一位权为100，第二位101……以此类推，第N位10^（N-1），该数的数值等于每位位的数值*该位对应的权值之和。
1.2.4 十六进制
十六进制（简写为hex或下标16）在数学中是一种逢16进1的进位制。一般用数字0到9和字母A到F（或af）表示，其中:AF表示10~15，这些称作十六进制数字。
1.3 进制的转换
1.3.1 二进制与八进制、十进制的转换
二进制转八进制
方法为：3位二进制数按权展开相加得到1位八进制数。（注意事项，3位二进制转成八进制是从右到左开始转换，不足时补0）。
二进制转十进制
方法为： 把二进制数按权展开、相加即得十进制数。
二进制转十六进制
方法为：与二进制转八进制方法近似，八进制是取三合一，十六进制是取四合一。（注意事项，4位二进制转成十六进制是从右到左开始转换，不足时补0）
1.3.2 十进制转二进制、八进制、十六、进制
十进制转二进制：
方法为：十进制数除2取余法，即十进制数除2，余数为权位上的数，得到的商值继续除2，依此步骤继续向下运算直到商为0为止。
转八进制和十六进制类同
1.4 计算机存储单元
位（bit)：一个数字0或一个数字1代表一位，一个汉字占两位
字节（Byte）:每逢8位是一个字节，这是数据存储的最小单位
1Byte = 8bit
1 KB = 1024 Byte
1 MB = 1024 KB
1GB = 1024 MB
1 TP = 1024 GB
1 PB = 1024 TB
1 EB = 1024 TB
1 ZB = 1024 EB
1.5 命令提示符（Windows）
MS-DOS(Microsoft Disk Operating System)
命令提示符（cmd)
启动 win + r
1.5.1 常用命令
大小写不区分
cd :切换路径（相对路径，绝对路径）
Table:自动补齐 （多次使用可以切换）
cls:清屏
exit：退出
第二章 Java语言开发环境搭建
2.1 Java虚拟机–VM
JVM：（Java Vritual Machine）:Java虚拟机。简称JVM。是运行所有Java程序的假想计算机，是Java程序的运行环境，是Java最具吸引力的特性之一。
跨平台：任何软件的运行，都必须要运行在操作系统之上，而我们用Java编写的软件可以运行在任何的操作系统上，这个特性称为Java语言的跨平台型特性，该特性是由JVM实现的，我们编写的程序运行在JVM上，而JVM运行在操作系统上
2.1.1 JVM的组成部分
-
类加载器：在JVM启动时或者类运行时将需要的class加载到JVM中
类加载器（class loader）用来加载Java类到Java虚拟机中一般来说，Java虚拟机使用Java类的方式如下：java源程序（.class）在经过Java编译器编译后就被转换成Java字节代码（.class文件）
-
类执行器：执行引擎的任务是负责执行class文件中包含的字节码指令，相当于实际机器上的CPU
-
内存区：将内存划分若干个区以模拟实际机器上的存储，记录和调度功能模块，如实际机器上的各种功能的寄存器或者PC指针的记录器等
-
本地调用方法，调用C或C++实现本地方法的代码返回结构
2.2 JRE和JDK
JRE(Java Runtime Environment)：是Java程序的运行时环境，包含JVM和运行时所需要的核心类库
JDK（Java Development）:是Java程序开发工具，包含JRE和开发人员使用的工具
第三章 Java 常用规范
3.1 注释
//:单行注释
/* */ :多行注释
3.2 关键字
概念： Java关键字是电脑语言里事先定义的，有特别意义的标识符，有时又叫保留字，还有特别意义的变量。Java的关键字对Java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名和参数。
常用的关键字：
| 关键字 | 含义 |
|---|---|
| abstract | 表明类或者成员方法具有抽象属性 |
| assert | 断言，用来进行程序调试 |
| boolean | 基本数据类型之一，声明布尔类型的关键字 |
| break | 提前跳出一个块 |
| byte | 基本数据类型之一，字节类型 |
| case | 用在switch语句之中，表示其中的一个分支 |
| catch | 用在异常处理中，用来捕捉异常 |
| char | 基本数据类型之一，字符类型 |
| class | 声明一个类 |
| const | 保留关键字，没有具体含义 |
| continue | 回到一个块的开始处 |
| default | 默认，例如，用在switch语句中，表明一个默认的分支。Java8 中也作用于声明接口函数的默认实现 |
| do | 用在do-while循环结构中 |
| double | 基本数据类型之一，双精度浮点数类型 |
| else | 用在条件语句中，表明当条件不成立时的分支 |
| enum | 枚举 |
| extends | 表明一个类型是另一个类型的子类型。对于类，可以是另一个类或者抽象类；对于接口，可以是另一个接口 |
| final | 用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变，用来定义常量 |
| finally | 用于处理异常情况，用来声明一个基本肯定会被执行到的语句块 |
| float | 基本数据类型之一，单精度浮点数类型 |
| for | 一种循环结构的引导词 |
| goto | 保留关键字，没有具体含义 |
| if | 条件语句的引导词 |
| implements | 表明一个类实现了给定的接口 |
| import | 表明要访问指定的类或包 |
| instanceof | 用来测试一个对象是否是指定类型的实例对象 |
| int | 基本数据类型之一，整数类型 |
| interface | 接口 |
| long | 基本数据类型之一，长整数类型 |
| native | 用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的 |
| new | 用来创建新实例对象 |
| package | 包 |
| private | 一种访问控制方式：私用模式 |
| protected | 一种访问控制方式：保护模式 |
| public | 一种访问控制方式：共用模式 |
| return | 从成员方法中返回数据 |
| short | 基本数据类型之一,短整数类型 |
| static | 表明具有静态属性 |
| strictfp | 用来声明FP_strict（单精度或双精度浮点数）表达式遵循[IEEE 754](https://baike.baidu.com/item/IEEE 754)算术规范 |
| super | 表明当前对象的父类型的引用或者父类型的构造方法 |
| switch | 分支语句结构的引导词 |
| synchronized | 表明一段代码需要同步执行 |
| this | 指向当前实例对象的引用 |
| throw | 抛出一个异常 |
| throws | 声明在当前定义的成员方法中所有需要抛出的异常 |
| transient | 声明不用序列化的成员域 |
| try | 尝试一个可能抛出异常的程序块 |
| void | 声明当前成员方法没有返回值 |
| volatile | 表明两个或者多个变量必须同步地发生变化 |
| while | 用在循环结构中 |
3.3 标识符
- 标识符：是指在程序中，我们自己定义内容，比如类的名字、方法的名字和变量的名字等
- 命名规则：硬性要求
- 标识符可以包含英文字母26（区分大小写），0-9数字、$ 、_(下划线)
- 标识符不能已数字开头
- 标识符不能是关键字
- 命名规范
- 类名规范：首字母大写，后面每个单词首字母大写（大驼峰式）
- 变量名规范：首字符小写，后面每个单词字母大写（小驼峰式）
- 方法名规范：小驼峰式
第四章 变量和常量
4.1 常量
4.1.1 常量概述
- 常量：是指在Java程序运行期间固定不变的数据
4.1.2 分类
| 类型 | 含义 | 数据举例 |
|---|---|---|
| 整数常量 | 所有的整数 | 1，2，5 |
| 小数常量 | 所有的小数 | 1.2，2.3342 |
| 字符常量 | 单引号引起来，只能写一个字符，必须有内容 | ‘a’ ,’ ’ , '哈’ |
| 字符串常量 | 双引号引起来，可以写多个字符也可以不写 | ”Afasf“，””， |
| 布尔常量 | 只有两个值 | true,false |
| 空常量 | 只有一个值 | null |
4.2变量
- 变量：常量是固定不变的数据，那么在程序中可以变化的量称为变量
4.2.1 变量类型
语法：type idenfifier [=value] [,identifier[= value] …]
格式说明：type为变量的数据类型，identifier变量名，可以使用逗号隔开来声明多个同类型变量
int a, b, c; // 声明三个int型整数：a、 b、c
int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
byte z = 22; // 声明并初始化 z
String s = "runoob"; // 声明并初始化字符串 s
double pi = 3.14159; // 声明了双精度浮点型变量 pi
char x = 'x'; // 声明变量 x 的值是字符 'x'。
4.2.2 Java 语言支持的变量类型
- 类变量：独立于方法之外的变量。用Static修饰
- 实例变量：独立于方法之外的变量，不过没有static修饰
- 局部变量：类的方法中的变量
public class Variable{
static int allClicks=0; // 类变量
String str="hello world"; // 实例变量
public void method(){
int i =0; // 局部变量
}
}
4.2.2.1 Java 局部变量
- 局部变量声明在方法，构造方法或者语句块中
- 局部变量在方法、构造方法、或者语句块被执行的时候创键，当他们执行完成后，变量就会被销毁
- 访问修饰符不能用于局部变量
- 局部变量只能声明它的方法，构造方法或者语句块中可见
- 局部变量是在栈上分配的
- 局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用
在以下实例中age是一个局部变量。定义在pupAge()方法中，它的作用域就限制在这个方法中。
public class Test{
public void pupAge(){
int age = 0;
age = age + 7;
System.out.println("小狗的年龄是: " + age);
}
public static void main(String[] args){
Test test = new Test();
test.pupAge();
}
4.2.2.2 Java 实例变量
- 实例变量声明在一个类中，但在方法、构造方法和语句块之外；
- 当一个对象被实例化之后，每个实例变量的值就跟着确定
- 实例变量在对象创键的时候创键，在对象被销毁的时候销毁
- 实例变量的值应该至少被一个方法，构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息
- 实例变量可以声明在使用前或者使用后；
- 访问修饰符可以修饰实例变量；
- 实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
- 实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
- 实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。
实例：
public class Employee{
// 这个实例变量对子类可见
public String name;
// 私有变量，仅在该类可见
private double salary;
//在构造器中对name赋值
public Employee (String empName){
name = empName;
}
//设定salary的值
public void setSalary(double empSal){
salary = empSal;
}
// 打印信息
public void printEmp(){
System.out.println("名字 : " + name );
System.out.println("薪水 : " + salary);
}
public static void main(String[] args){
Employee empOne = new Employee("RUNOOB");
empOne.setSalary(1000);
empOne.printEmp();
}
}
4.2.2.3 类变量（静态变量）
- 类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法之外。
- 无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
- 静态变量除了被声明为常量外很少使用。常量是指声明为public/private，final和static类型的变量。常量初始化后不可改变。
- 静态变量储存在静态存储区。经常被声明为常量，很少单独使用static声明变量。
- 静态变量在第一次被访问时创建，在程序结束时销毁。
- 与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。
- 默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
- 静态变量可以通过：ClassName.VariableName的方式访问。
- 类变量被声明为public static final类型时，类变量名称一般建议使用大写字母。如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。
实例：
Employee.java 文件代码：
import java.io.*;
public class Employee {
//salary是静态的私有变量
private static double salary;
// DEPARTMENT是一个常量
public static final String DEPARTMENT = "开发人员";
public static void main(String[] args){
salary = 10000;
System.out.println(DEPARTMENT+"平均工资:"+salary);
} }
以上实例编译运行结果如下:
开发人员平均工资:10000.0
**注意：**如果其他类想要访问该变量，可以这样访问：Employee.DEPARTMENT。
第五章 Java的 数据类型
5.1 基本数据类型
整数型 ：byte short int long
浮点型：float double
字符型：char
布尔型：bolean
| 数据类型 | 关键字 | 内存占用 | 取值范围 |
|---|---|---|---|
| 短字节 | byte | 1 byte | -128~127 |
| 短整型 | short | 2 byte | -32768~32767 |
| 整型 | int(默认) | 4 byte | -231~231-1 |
| 长整型 | long | 8 byte | -263~263-1 |
| 单精度浮点型 | float | 4 byte | 1.4013E-45 ~3.4028E+38 |
| 双精度浮点型 | double(默认) | 8 byte | 4.9E-324~1.7977E+308 |
| 字符型 | char | 2 byte | 0~65535 |
| 布尔类型 | boolean | 1 byte | true,false |
注意事项：
- 字符串不是基本的数据类型，而是引用类型
- 浮点型可能只是一个近似值，并非精确的值
- 数据范围与字节孰不一定相关，例如float数据范围比long更加广泛，但是float是4byte long 8byte
- 浮点数当中默认类型shidouble，如果一定要使用long类型，需要加上一个后缀L
5.2 引用数据类型
java中除了八种基本数据类型外，其他数据类型全都是引用（reference)数据类型，引用数据类型用来表示复杂数据类型，例如 类，接口，数组
Java中的引用类型，相当于C等语言中指针（pointer)类型，引用事实上就是指针，是指向一个对象的内存地址，引用类型变量中保持的指向对象的内存地址
5.3 数据类型的转换
5.3.1 自动转换（隐式）
- 自动转换（隐式）：将取值小的范围自动提升到取值范围大的类型
特点：
- 代码不需要进行特殊处理，自动完成
- 数据范围从小到大
代码实例：
class Hello
{
public static void main(String[] args)
{
//自动转换
int a = 5;
byte b = 6;
int c = a + b;
System.out.println(c);
}
}
5.3.2 强制转换（显示）
-
强制类型转换（显示）：将取值范围大的类型强制转换成取值范围小的类型
特点：
- 代码需要经行特殊处理，需手动完成
- 格式： 数据类型 变量名 = （数据类型）被转换的值
代码实例：
int a = (int)8.8;
注意事项：
- 强制类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出
- byte/short/char这三种类型都可以发生数学运算
- byte/short/char这三种类型在运算的时候，都会被首先提升称为int类型，在计算
- boolean类型不能发生数据类型转换
第六章 Java的运算符
6.1 ACISS 表
记住：
48 ：0
65 ：A
97 : a
6.2 算术运算符
| 运算符标识 | 说明 |
|---|---|
| + | 加法运算，字符串连接运算 |
| - | 减法运算 |
| * | 乘法运算 |
| / | 除法运算 |
| % | 取模运算，两个数相除取余数 |
| ++，– | 自增减运算+1 |
6.3 赋值运算符
| 运算标识符 | 说明 |
|---|---|
| = | 等于 |
| += | 加等于 |
| -= | 减等于 |
| *= | 乘等于 |
| /= | 除等于 |
| %= | 取模等 |
6.4 比较运算符
| 运算标识符 | 说明 |
|---|---|
| == | 比较两边是否相等 |
| < | 比较符号左边的数据是否大于右边的数据，如果小于结果是true |
| > | 比较符号左边的数据是否大于右边的数据，如果大于结构是true |
| <= | 比较符号左边的数据是否大于等于右边的数据，如果小于结果是true |
| >= | 比较符号左边的数据是否大于等于右边的数据，如果大于结构是true |
| != | 不等于符号，如果两边的数据不相等，结果是ttue |
6.5 逻辑运算符
| 符号 | 说明 | 解释 | 例子 |
|---|---|---|---|
| & | 逻辑与 | 符号左右两边都是true,则返回true，否则都是false | a&b |
| | | 逻辑或 | 只要有一边是true则返回的都是true，全部是falses，才会返回false | a|b |
| && | 短路与 | 符号左右两边都是true,则返回true，否则都是false(如果a为false,则不计算b) | a&&b |
| || | 短路或 | 只要有一边是true则返回的都是true，全部是falses，才会返回false(如果a为true,则不计算b) | a||b |
| ！ | 逻辑非 | a为true，值为false:a为false，值为true | !a |
6.6 其他运算符
三元运算符：
格式：数据类型 变量名称 = 条件判断？ 表达式A:表达式B;
执行流程：
判断条件是否成立：
如果条件成立 ，返回A ,否则返回B
int a =10,b = 20 ;
System.out.println(a>b?a:b);
//a大于b吗？如果大于输出a，否则输出b
小括号：起到改变表达式运算顺序的作用，他的优先级最高
中括号：数组下标
引用号：（.）对象调用实例变量或实例方法的操作符，也是类调用静态变量或静态方法的操作符
复值号：（=) 赋值是用等号运算符实现的
instanceof ： 判断某个对象是否属于某个类
new : 对象内存分配运算符
箭头（->）:java 8 新增的，用来声明Lamba表达式
双冒号(:：用于Lambda表达式中方法的引用
第七章 控制语句
7.1 分支语句
7.1.1 if语句
由if语句引导的选择结构有if结构、if-else 结构和 else-if结构
-
if结构
如果条件表达式为true就执行语句组，否则就执行if结构后面的语句，如果语句组只有一条语句，就可以省略大括号，但从编程规范角度来说不要省略大括号，否则会影响程序的可读性变差
语法格式：
if(条件表达式){ 语句组; } int score =90; if(score >87) { System.out.println("优秀"); } -
if-else结构
语法格式：
if(条件表达式){ 语句组; }else{ 语句组; } -
if-else if -else
语法结构：
if(条件表达式1){ 语句组1; }else if(条件表达式2){ 语句组2; }else if（...）{ 语句最...; }else{ 语句组; }
7.1.2 switch语句
switch提供多分支程序结构语句
语法格式：
switch(表达式){
case 值1：
语句组1;
case 值2：
语句组2；
...
default：
语句组n;
}
注意事项：
- 语句中”表达式“计算结果只能是int,byte,short,char和String类型，枚举类型，不能是其他类型。
- 每个case后面只能跟一个 数据类型
- default语句可省略
实例：
int Score = 75;
char grade;
switch(Score /10){
case 9:
grade = '优';
break;
case 8:
grade = '良';
break;
case 7:
grade = '中';
break;
default:
grade = '差';
break;
}
7.2 循环语句
7.2.1 while语句
while语句是一种先判断的循环结构
语法：
while(循环条件){
语句体；
}
while循环没有初始化语句，循环次数不可知，只要循环条件满足就会一直执行
实例;
int i = 0;
while (i*i < 100000){
i++;
}
System.out.println("i="+i);
System.out.println("i*i="+(i*i))
7.2.2 do-while语句
do-while语句的使用与while语句相似，不过do-while语句是先执行在判断
语法：
do{
语句组
}while（条件表达式）
do-while循环没有初始化语句，循环次数不可知，无论条件是否满足，都会执行一次循环体，然后在判断循环条件，如果满足则执行，不满足则停止
实例
int i = 0;
do {
i++;
}while (i*i < 100000)
System.out.println("i="+i);
System.out.println("i*i="+(i*i))
7.3 for语句
7.3.1 For循环
for语句使用最广泛、功能最强的一种循环体
语法格式：
for（初始化循环条件；迭代){
语句组；
}
实例
System.out.println("--------------");
for(int i = 1;i<10;i++){
System.out.printf("%dx%d=%d",i,i,i*i)
}
7.3.2 增强型for循环
java 5后一种专门用于遍历集合的for循环–增强for循环
实例：
//声明并初始化int数组
int[] number ={1,2,3,4,5,7,8};
System.out.println("-------for------------");
for(int i:number){
System.out.println(a)
}
7.4 跳转语句
7.4.1 break
break作用：强制退出循环体。不在执行循环体中剩余的语句
- break:不带标签的break语句使程序跳出所在层的循环体
- break label:带标签的break语句使程序跳出标签指示的循环体
带标签的实例：
lable1:for(int x =0;x<5;x++){
for(int y=5;y>0;y--){
if(y==x){
break label1; //跳转到lable1指向的循环体
}
System.out.printf("(x,y)=(%d,%d)",x,y);
System.out.println(); //仅作为换行
}
}
7.4.2 continue
continue语句用来结束本次循环，跳过循环体中尚未执行的语句，接着进行终止条件的判断
与break语句类似，可带标签，默认情况下continue只会跳出最近的内循环
第八章 Java方法
7.1 方法的概述
方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能
当我们需要这个功能的时候，就可以去调用，实现代码的复用性，也解决了代码冗余的现象
7.2 方法的定义
-
定义格式：
修饰符 返回值类型 方法名（参数列表）{ 代码块； return; //返回值 } -
定义格式解释：
- 修饰符：目前固定写法 public static
- 返回值类型 ： 目前固定写法void
- 方法名：为我们定义的方法起名，满足标识符的规范，用来调用方法
-
注意事项
- 方法定义的先后顺序无所谓
- 方法的定义不能产生嵌套包含关系
- 方法定义好后，需要调用
-
方法调用格式：
- 方法名称（）；
第九章 数组
9.1 一维数组
**定义：**当数组中每个元素都只带一个下标时，这种数组就是“一维数组”。数组是引用数据类型，引用数据类型在使用之前一定要做两件事：声明和初始化
9.1.1 数组声明
元素数据类型[] 数组变量名；
元素数据类型 数组变量名[];
注意：数组声明完成后，数组长度还不能确定，JVM（java虚拟机）还没有给元素分配内存空间
提示：从面相对象角度看，Java更推荐采用第一种声明方式，因为他把“元素数据类型[ ]”看成一个整体,即数组类型
数组声明示例：
int intArray[];
float[] floatArray;
9.1.2 数组初始化
声明数组完成后就要对数组进行初始化，数组初始化的过程就是为数组的每一个元素分配内存，并未每一个元素提供一个初始值，初始化之后的数组长度不能变化。
提示：
有些计算机提供了可变类型数组，即数组长度可变，这种数组本质上是创建了一个新的数组对象，并非原始数组的长度发生了变化
数组初始化分为静态初始化和动态初始化：
-
静态初始化
静态初始化就是将数组的元素放到大括号中，元素之间用（,)分隔
int[] intArray; //静态初始化int数组 intArray = {12,34,643,7}; //声明的同时初始化数组 int[] intarray = {1,2,4,67,78} -
动态初始化
动态初始化使用New运算符分配指定长度的内存空间
new 元素数据类型[数组长度]; //示例代码如下 int[] intArray; //动态初始化数组 intArray = new int[4]; intArray[0] = 1; intArray[1] = 23; intArray[2] = 2342; intArray[3] = 234; -
数组的合并案例
public class javaDebug { public static void main(String[] args) { //两个待合并的数组 int[] intArray = {12,34,6,7}; int[] int2Array = {234,5345,7457}; //动态初始化数组，设置数组的长度为两个待合并的数组长度之和 int[] array = new int[intArray.length+int2Array.length]; //for循环添加数组内容 for(int i =0;i< array.length;i++){ if(i < int2Array.length){ array[i] = int2Array[i]; System.out.println(array[i]); }else{ array[i] = intArray[i-int2Array.length]; System.out.println(array[i]); } } System.out.println("合并后:"); for(int i:array) { System.out.println(i); } } }
9.2 多维数组
9.2.1 二维数组声明
语法格式：
元素数据类型[][] 数组变量名;
元素数据类型 数组变量名[][];
元素数据类型[] 数组变量名[];
9.2.2 二维数初始化
二维数组的初始化也可以分为静态初始化和动态初始化
-
静态初始化
int intArray[] [] = { {1,2,3,4,5}, {2,3,4,5,6}, {234,45,645,65} } -
动态初始化
动态初始化语法结构：
new 元素数据类型[高维数组长度][低维数组长度];代码是咧：动态创键并初始化一个4x3的二维数组示例
int[] [] intArray = new int[4] [3]案例：
/** * 多维数组 */ //静态创键多维数组 int [] [] intArrays = { {1,2,3}, {11,22,33}, {111,222,333} }; //动态创键多维数组 double[][] doubleArrays = new double[3][3]; //计算数组 intArray元素的平方根，结果保存到doubleArray for(int i=0;i<intArrays.length;i++) { for(int j=0;j<intArrays.length;j++) { //计算平方根 doubleArrays[i][j] = Math.sqrt(intArrays[i][j]); System.out.println(doubleArrays[i][j]); }
9.2.3 不规则数组
代码示例：
int[] [] intArray = {
{1231,243,534},
{12313},
{1,3,4,51234,45,4365}
}
不规则数组初始化较为麻烦不能使用**new int[[4] [3]**语句
代码示例
int[] [] intArray = new int[4][];
//先初始化高维数组为4，然后逐一初始化低维数组
intArray[0] = new int[2];
intArray[1] = new int[5];
...;
提示：
下标越界异常（ArrayIndexOutOfBoundsException)是试图访问不存在的下标引发的。例如，一个一维数组如果有10个元素，那么表达式array[10]就会发生下标越界异常，这是因为数组下标是从0开始的，最后一个元素下标是数组长度减一，所以[10]访问元素是不存在的。
第十章 字符串
10.1 Java中的字符串
-
Java中的字符串是由双引号括号起来的多个字符。
-
Java中的字符采用Unicode编码，所以Java字符串可以包含中文等亚洲字符
-
Java SE提供了三个字符串String、StringBuffer和StringBuilder
-
String是不可变字符串，StringBuffer和StringBuilder是可变字符串
-
注意:字符串中还有一个极端情况，就是“”代表空字符串，双引号中没有任何内容，空字符串不是null,空字符串是分配内存空间，而null是没有分配空间8吗iiiiiiiiiii
10.2 不可变字符串
- Java中不可变字符串是String，属于Java.lang包
创键String对象可以通过构造方法实现，常用的构造方法如下：
| 语法 | 说明 |
|---|---|
| String() | 使用空字符串创键并初始化一个新的String对象 |
| String(String original) | 使用另外一个字符串创键并初始化一个新的String对象 |
| String(StringBuffer buffer) | 使用可变字符串对象（StringBuffer)创键并初始化一个新的String对象 |
| String(StringBuilder) | 使用可变字符串（StringBuilder)创键并初始化一个新的String对象 |
| String(byte[] bytes) | 使用平台的默认字符集解码指定的byte数组，并通过byte数组创键并初始化一个新的String对象 |
| String(char[] value) | 通过字符串数组创键并初始化一个新的String对象 |
| String(char[]value,int offset,int count) | 通过字符数组的子数组创键并初始化一个新的String对象；offset参数是子数组第一个字符的索引，count参数指定子数组的长度 |
实例：
public class stringDemo {
public static void main(String[] args) {
//创键字符串对象
String s1 = new String();
String s2 = new String("hello word!");
String s3 = new String("\u0048\u0065\u006c\u006f\u0020\u0057\u006f\u0072\u006c\u0064");
System.out.println("s2 ="+s2);
System.out.println("s3 = "+s3);
char chars[] = {'a','b','c','e','f'};
//通过字符串数组创键字符串对象
String s4 = new String(chars);
//通过子字符数组创键字符串对象
String s5 = new String(chars,1,4);
System.out.println("s4="+s4);
System.out.println("s5="+s5);
}
}
输出结果：
s2 =hello word!
s3 = Helo World
s4=abcef
s5=bcef
10.2.1 字符串池
使用new 关键字与字符串常量都能获得字符串对象，但他们之间有一些区别
public class stringdemo2 {
public static void main(String[] args) {
String s1 = new String("hello");
String s2 = new String("hello");
String s3 = "hello";
String s4 = "hello";
System.out.println("s1==s2"+":"+(s1==s2));
System.out.println("s3==s4"+":"+(s3==s4));
System.out.printf("s1==s3:%b%n",s1==s3);
}
}
输出结果：
s1==s2:false
s3==s4:true
s1==s3:false
- ==运算符比较的是两个引用是否指向相同的对象
Java中的不可变字符串String常量采用字符串池（String Pool）管理技术，字符串池是一种字符串驻留技术。
采用字符串常量赋值时会在字符串池中查找“hello”字符串常量，如果已经存在。则会引用赋值，否则会创键字符串对象，并放入池中。但是此原理不适用于new所创键的字符串对象，new 会重新创键一个内存指向。
10.2.2 字符串拼接
String字符串虽然是不可变字符串，但是也可以拼接，只是会产生一个新的对象，String 字符串拼接可以使用+运算符或String的concat（String str）方法。
“+”运算符的优势是可以连接任何类型数据拼接成字符串，而concat方法只能拼接String类型字符串
代码示例：
public class stringconcat {
public static void main(String[] args) {
String s1 = "hello";
//使用+运算符
String s2 = s1+"";
String s3 = s2+"\t"+s1;
System.out.println(s3);
//使用+运算符连接，支持+=赋值运算符
String s4 = "hello";
s4 += "";
s4 +=s3;
System.out.println(s4);
//使用concat方法连接
String s5 = "hello";
s5 = s5.concat(" ").concat("Word");
System.out.println(s5);
}
}
10.2.3字符串查找
- 在给定的字符串中查找字母或字符串是比较常见的操作。
- 在String类中提供了indexOf或lastIndexOf方法用于查找字符或字符串，返回值是查找的字符或字符串所在的位置，-1表示没有找到，这两个方法有多个重载版本
| 语法 | 说明 |
|---|---|
| int indexOf(int ch) | 从前往后搜索字符ch，返回第一次找到字符ch所在的索引 |
| int indexOf(int ch,inf fromIndex) | 从指定的索引开始从前往后搜索字符ch,返回第一次找到字符ch所在的索引 |
| int indexOf(String str) | 从前往后搜索字符str，返回第一次找到字符ch所在的索引 |
| int indexOf(String str ,inf fromIndex) | 从指定的索引开始从前往后搜索字符str,返回第一次找到字符ch所在的索引 |
| int lastindexOf(int ch) | 从后往前搜索字符ch，返回第一次找到字符ch所在的索引 |
| int lastindex(int ch,inf fromIndex) | 从指定的索引开始从后往前搜索字符ch,返回第一次找到字符ch所在的索引 |
| int lastindexOf(String str) | 从后往前搜索字符str，返回第一次找到字符ch所在的索引 |
| int lastindex(Stringch,inf fromIndex) | 从指定的索引开始从后往前搜索字符str,返回第一次找到字符ch所在的索引 |
提示：
字符串本质上是字符数组，因此他也有索引，索引从0开始，
String charAt(int index)方法可以返回索引index所在位置的字符
代码示例：
package eclipseDeBug;
public class stringOfdemo {
public static void main(String[] args) {
String sourcetStr = "There is a string accessing example.";
//获取字符串长度
int len = sourcetStr.length();
//获取索引位置16的字符
char ch = sourcetStr.charAt(16);
//查找字符串和子字符串
int fisrtChar1 = sourcetStr.indexOf('r');
int lastChar1 = sourcetStr.lastIndexOf('r');
int firstStr1 = sourcetStr.indexOf("ing");
int lastStr1 = sourcetStr.lastIndexOf("ing");
int firstChar2 = sourcetStr.indexOf('e',15);
System.out.println("原始字符串长度"+len);
System.out.println("原始字符串"+sourcetStr);
System.out.println("索引16的字符"+ch);
System.out.println("从前往后搜索r字符"+fisrtChar1);
System.out.println("从后往前搜索r字符"+lastChar1);
System.out.println("从前往后搜索ing字符产"+firstStr1);
System.out.println("从后忘前搜索ing字符串"+lastStr1);
System.out.println("从索引15开始，从前往后搜索字符e"+firstChar2);
}
}
输出结果：
原始字符串长度36
原始字符串There is a string accessing example.
索引16的字符g
从前往后搜索r字符3
从后往前搜索r字符13
从前往后搜索ing字符产14
从后忘前搜索ing字符串24
从索引15开始，从前往后搜索字符e21
10.2.4 字符串的比较
-
比较相等
方法 说明 boolean equals(Object anObject) 比较两个字符串中的内容是否相等 boolean equalsIgnoreCase(String anotherString) 类似equals方法，只是忽略大小写 -
比较大小
方法 说明 int compareTo(String anotherString) 按字典顺序比较两个字符串，相等返回0，不相等返回差值 int compareToIgnoreCase(String str) 类似compareTo,只是忽略大小写 -
比较前缀和后缀
方法 说明 boolean endsWith(String suffix) 测试此字符是否以指定的后缀的后缀结束 boolean starts(String prefix) 测试此字符串是否以指定的前缀结束
10.3.5 字符串的截取
Java中字符串截取的主要方法如下：
| 方法 | 说明 |
|---|---|
| String substring(int beginIndex) | 从指定索引开始截取一直到字符串结束的子字符串 |
| String substring(int beginIndex,int endIndex) | 从指定索引开始到指定索引结束 |
10.3 可变字符串
- 可变字符串再追加、删除、修改、插入和拼接等操作过程中不会产生新的对象
10.3.1 StringBuffer 和 StringBuilder
- Java提供了两个可变字符串类StringBuffer和StringBuiler，中文翻译为“字符串缓冲区”
- StringBuffer是线程安全的，他的方法是支持线程同步，线程同步会操作会串行顺序执行的，在单线程环境下会影响效率
- StringBuilder是StringBuffer的单线程版本，他不是线程安全的，但它的执行效率很高
- StringBuffer 和StringBuilder具有完全相同的API，即构造方法和普通方法等内容一样
| 方法 | 说明 |
|---|---|
| StringBuilder（） | 创键字符串内容是空的Stringbuiler对象，初始容量默认16 |
| Stringbuilder(CharSequence seq) | 指定CharSequence字符串创键StringBuiler对象，CharSequence接口类型，他的实现类有String、StringBuffer和StringBuilder等，所以参数可以是String,StringBuffer，StringBuilder |
| StringBuilder(int capacity) | 创键字符串内容是空的StringBuilder对象，初始容量由参数capacity指定 |
| StringBuilder(String str) | 指定String字符串创键StringBuiler对象，上述构造方法同样适合StringBuffer |
提示：
- 字符串长度和字符串缓冲区容量有别，字符串长度是掐在字符串缓冲区中目前所包含的字符串长度，通过length()获取
- 字符串缓冲区容量是缓冲区中所能容纳的最大字符数，通过capacity()获得，当所容纳的字符超过这个长度时，字符串缓冲区启动扩充容量，但是会牺牲性能
代码示例：
package eclipseDeBug;
public class stringBufferdemo {
public static void main(String[] args) {
//字符串长度和字符串缓冲区容量capacity
StringBuilder sbuilder1 =new StringBuilder();
System.out.println("包含的字符长度:"+sbuilder1.length());
System.out.println("字符串缓冲区容量:"+sbuilder1.capacity());
for(int i=0;i<18;i++) {
sbuilder1.append(i);
}
System.out.println(sbuilder1.length());
System.out.println(sbuilder1.capacity());
}
}
输出结果：
包含的字符长度:0
字符串缓冲区容量:16
26
34
10.3.2 字符串追加
- StringBuilder提供了很多修改字符串缓冲区的方法，如追加、插入、修改、删除
- 字符串追加方法是append，append有很多重载方法，可以追加很多类型数据他的返回值还是StringBuilder
代码示例：
for(int i=0;i<18;i++) {
sbuilder1.append(i);
}
10.3.3 字符串的插入、删除、替换
| 方法 | 说明 |
|---|---|
| StringBuilder insert(int offset,string str) | 在字符串缓冲区中索引围为offset的字符位置之前插入str,insert有很多重载方法，可以插入多种数据 |
| StringBuffer delete(int stat,int end) | 在字符串缓冲区中删除子字符串，要删除的子字符串从指定索引开始直到索引end-1出的字符 |
| StringBuffer replace(int start,int end,String str) | 在字符缓冲区中用str替换子字符串，子字符串从指定索引start开始直到索引end-1处的字符 |
代码示例：
//删、改、插入
//原始不可变的字符串
String str1 ="Java c";
StringBuilder mstr = new StringBuilder(str1);
//输入字符串
mstr.insert(4,"hello");
System.out.println(mstr);
mstr.replace(0, 5, "Hadoop");
System.out.println(mstr);
输出结果：
Javahello c
Hadoopello c
builder1.append(i);
}
System.out.println(sbuilder1.length());
System.out.println(sbuilder1.capacity());
}
}
输出结果：
~~~java
包含的字符长度:0
字符串缓冲区容量:16
26
34
10.3.2 字符串追加
- StringBuilder提供了很多修改字符串缓冲区的方法，如追加、插入、修改、删除
- 字符串追加方法是append，append有很多重载方法，可以追加很多类型数据他的返回值还是StringBuilder
代码示例：
for(int i=0;i<18;i++) {
sbuilder1.append(i);
}
10.3.3 字符串的插入、删除、替换
| 方法 | 说明 |
|---|---|
| StringBuilder insert(int offset,string str) | 在字符串缓冲区中索引围为offset的字符位置之前插入str,insert有很多重载方法，可以插入多种数据 |
| StringBuffer delete(int stat,int end) | 在字符串缓冲区中删除子字符串，要删除的子字符串从指定索引开始直到索引end-1出的字符 |
| StringBuffer replace(int start,int end,String str) | 在字符缓冲区中用str替换子字符串，子字符串从指定索引start开始直到索引end-1处的字符 |
代码示例：
//删、改、插入
//原始不可变的字符串
String str1 ="Java c";
StringBuilder mstr = new StringBuilder(str1);
//输入字符串
mstr.insert(4,"hello");
System.out.println(mstr);
mstr.replace(0, 5, "Hadoop");
System.out.println(mstr);
输出结果：
Javahello c
Hadoopello c