Java安装

JDK下载

https://www.oracle.com/cn/java/technologies/downloads/archive/

环境变量配置

（系统变量所有windows用户都可以用，用户变量只针对该用户生效）

1.Path中新建

%JAVA_HOME%\jre\bin

%JAVA_HOME%\bin

2.新建变量

变量名：JAVA_HOME

变量值：jdk安装目录，例如：E:\environment\java\JDK8_202

补充：

1.也可以直接在Path新建：

jdk安装目录\jre\bin

jdk安装目录\bin

但好像会影响maven关于java_home一些设置

2.win7直接把：

;%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin

复制在Path后面

3.关于CLASSPATH

其作用是：

指定类搜索路径，要使用已经编写好的类，前提当然是能够找到它们了，JVM就是通过CLASSPTH来寻找类的。我们需要把jdk安装目录下的lib子目录中的dt.jar和tools.jar设置到CLASSPATH中，当然，当前目录“.”也必须加入到该变量中。

在jdk1.5以后，可以完全不用配置，如果非要配置的话：

变量名：CLASSPATH

变量值：.;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar

基础语法

类、对象、方法的概念

一个 Java 程序可以认为是一系列对象的集合，而这些对象通过调用彼此的方法来协同工作。下面简要介绍下类、对象、方法的概念

类：自定义数据类型，就像一个猫类（int也是数据类型），有属性，行为，描述对象的行为和状态。

对象：类的一个实例，简单理解为具体的猫（我的猫，你的猫），就像int 100 、200、 300 ，其中100 200 300都是对象

创建一个对象、实例化一个对象都是一个意思。在内存里，就是创建一个真真实实对象，若是赋值，那么这个变量只是指向他（内存中的对象）而已

总结：类是抽象的，代表一类人或事物，即：它是数据类型

对象是具体的，实际的，代表一个具体事物，也可以叫实例

类是对象的模板，对象是类的一个个体，对应一个实例

方法：就是行为，一个类可以有很多方法，也可以理解为类有哪些功能

基本语法和注意事项

基本语法

先看一个psvm（主方法）

什么是主方法

所有的 Java 程序由 public static void main(String[] args) 方法开始执行

访问修饰符（控制访问范围）

下面按照权限从小到大的顺序对4种访问权限分别介绍：

1.私有权限(private)

只有类本身可以访问

2.默认权限(default)

类，成员变量，构造方法，方法都能够使用默认权限，即无需写任何关键字。默认权限即同包权限，同包权限只能由本类中以及同包的类中访问。

3.受保护权限(protected)

受保护级别，对子类和同一个包中的类公开

4.公共权限(public)

表示对外公开的

关键字

Java中有特殊用途的词称为关键字。关键字对Java编译器有特殊意义，像刚刚的访问修饰符也属于关键字。这里的static关键字表示静态方法，关于静态方法的调用只需要类名.方法名即可，其他内容这里不做了解

返回类型

void表示空，即没有返回类型

注意事项

1.大小写敏感：Java 是大小写敏感的，这就意味着标识符 Hello 与 hello 是不同的。

2.源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记 Java 是大小写敏感的），文件名的后缀为 .java。（如果文件名和类名不相同则会导致编译错误）。

3.主方法入口：所有的 Java 程序由 public static void main(String[] args) 方法开始执行。

4.标识符的命名规则（必须遵守）和规范（这样更好）：

什么是标识符：

Java对各种变量、方法和类等命名时使用的字符序列称为标识符（凡是自己起名的都是标识符）

1.规则

数字不可以开头

不可以使用关键字

不能包含空格

2.规范

包名：所有字母小写，例如：aaa.bbb.ccc

类名和接口：首字母大写（大驼峰），例如：SchoolUser

变量名、方法：小驼峰

常量名：所有字母大写，多个单词用下划线隔开

数据类型

Java 是一种强制类型的语言，所有的变量都必须先明确定义其数据类型，然后才能使用。Java 中所有的变量、表达式和值都必须有自己的类型，没有“无类型”变量这样的概念

数据类型：简单理解为传值还是传引用

基本数据类型就是简单的值传递，引用数据类型就是

基本数据类型

所有的类型在内存中都会分配一定的存储空间。基本的变量类型只有一块存储空间(分配在堆中)

整数类型

byte\short\int\long

这四个用来表示整数

byte往右包括byte分别是：

8位、16为、32位、64位

浮点类型

float\double

前者有效8位（含非小数点）

后者有效16位（含非小数点）

（这里说的有效位和大小位是不一样的）

商业计算中我们要使用java.math.BigDecimal，通过使用BigDecimal类我们可以解决高精度计算问题

注意事项：

CPU处理单精度速度比处理双精度快

如果不声明，默认小数为double类型，所以如果要用float的话，必须进行强转

字符型

char

用法：

char c=‘c’; //字符，可以是汉字，因为是Unicode编码。需要加单引号。

char c=十进制数，八进制数，十六进制数都可以; //可以用整数赋值【整数范围：0~65535】。输出字符编码表中对应的字符。

char c=‘\u数字’; //用字符的编码值来初始化，如：char=‘\0’,表示结束符，它的ascll码是0，这句话的意思和 char c=0 是一个意思。

布尔型

boolean

引用数据类型

简单来说，引用是对象的名字(别名)

引用类型有两块存储空间(一块在stack中,一块在heap栈中)

然后把他们连线（指向内存）

或者这么理解：

一个对象在内存中会请求一块空间来保存数据，根据对象的大小，它可能需要占用的空间大小也不等。访问对象的时候，我们不会直接是访问对象在内存中的数据，而是通过引用去访问。引用也是一种数据类型

数组引用

只需要知道数组是引用数据类型就行（这句话本身没有意义，当作思维导图框架来记"数据类型"即可）

这里主要介绍数组（稍微了解一下，多为数组和Arrays类将放到进阶笔记和集合一起介绍）

数组的初始化

所谓的静态和动态是相对于程序运行是而言的，静态是在程序编译时就初始化好了的，动态初始化是在程序运行是才动态分配内存空间。对于代码而言，其实都可以。唯一不一样的地方，就是动态的初始值都是0,静态的是直接给定值了。

动态初始化

数据类型[] 数组名 = new 数据类型[大小];

例如：

lint[] Array = new int[5];

↑表示名为Array的数组，存放int型数据，长度是5

↑语句亦可分开：

int[] Array;

new int[5];

这两步在内存的逻辑就是：现在内存当中声明了Array变量，此时是null，在new的时候才分配空间

静态初始化

int[] Array = {1,2,3,23,23,2,1,12};

数组的默认值

数组创建后，如果没赋值，会自动赋值（默认值）
int 0
short 0
byte 0
long 0
float 0.0
double 0.0
char \u0000
boolean fasle
string null

数组的应用

创建一个含有A-Z字母的26位数组

public static char[] method03(){//创建一个含有A-Z字母的26位数组//char类型数据运算存在'A'+1='B'char[] Array = new char[26];for (int i = 0; i < Array.length; i++) {//强转↓Array[i]= (char)('A'+i);}return Array;
}

找出数组int[]中的最大值和对应下标

public static void method04(int[] Array){int index = 0;int max = 0;for (int i = 0; i <Array.length ; i++) {if (Array[i]>max){max = Array[i];index = i;}}System.out.println("当前数组最大值是："+max);System.out.println("当前数组最大值对应的下标是："+index);
}

数组拷贝

值传递和引用传递的区别https://www.bilibili.com/video/BV1fh411y7R8?p=165&spm_id_from=pageDriver&vd_source=0bac303dcbad5605f81b566bb72718dd
概括：值传递就是复制生成新的，而引用传递（地址拷贝）是根据地址来生成，也就是拷贝地址

int[] arr1 = {1,3,3,3,6};
int[] arr2 = new int [arr1.length];//拷贝的新数组arr2，先开辟新的数组空间，大小保证和arr1一样
for(int i = 0;i<arr1.length;i++){arr2[i]=arr1[i];
}

接口引用

只需要知道接口是引用数据类型就行（这句话本身没有意义，当作思维导图框架来记"数据类型"即可）

这里主要介绍接口（稍微了解一下，后面基础OOP将会对接口进行补充）

接口的引入

当想要从很多类抽取一个相同特征，而这些类仅仅只是这些特征相同，例如：鼠标键盘耳机手机都有usb

接口的概述定义

接口是引用数据类型，可以定义常量、抽象方法 (jdk7及其以前)、默认方法和静态方法(jdk8额外增加)、私有方法(jdk9额外增加) 接口也会被编译成.class文件。

接口的使用，它不能创建对象，但是可以被实现。一个实现接口的类，需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类

接口是一种规范，定义了一组规则，可以简单理解为：“如果你是…则必须…”

代码理解接口：

package com.atguigu.java2;
/** 接口的使用：* 1，接口使用interface来定义* 2，Java中接口和类是两个并列结构* 3，如何定义接口：定义接口中的成员*           3.1，JDK7及以前：只能定义全局常量和抽象方法*                    全局常量：public static final的，书写时可以省略*                    抽象方法：public abstract的*           3.2，JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法* 4，接口中不可定义构造器！意味着接口不可以实例化* 5，Java开发中，接口都通过类实现（implements），如果实现类覆盖（重写）了接口中的所有抽象方法，则此实现类就可以实例化；*    如果实现类没有覆盖接口中所有的抽象方法，则此实现类就应该是一个抽象类*/
public class InterfaceTest {public static void main(String[] args) {System.out.println(Flyable.MAX_SPEED);System.out.println(Flyable.MIN_SPEED);
//      Flyable.MIN_SPEED=2;   //此处注释打开编译出错，final修饰不可变Plane plane =new Plane();plane.fly();}
}interface Flyable{//定义全局常量public static final int MAX_SPEED=7900;int MIN_SPEED=1;  //public static final的，书写时可以省略，结构依然在//定义抽象方法public abstract void fly();void stop();   //省略了public abstract，结构依然在，仍为抽象方法
}class Plane implements Flyable{ //让飞机类实现“可飞”的接口
//接口中有两个抽象方法，此处需要重写抽象方法或将此飞机类设为抽象类@Overridepublic void fly() {System.out.println("飞机通过引擎起飞");}@Override   //对于抽象的方法，严格来说不是重写，而是实现public void stop() {System.out.println("驾驶员加速停止");}
}abstract class kite implements Flyable{  //注意此处使用了abstract@Overridepublic void fly() {// TODO Auto-generated method stub}}

类引用

例如String，笔记转换将会介绍String类与八大数据类型之间的转换

这里只介绍一些常用类，其他不做介绍，类笔记将和OOP放在一起

Number 类

使用数字时，通常使用内置数据类型：byte、int、long、double 等

例如：

int a = 1;
double b = 2.3;
byte c = 0x4a;

而在实际开发过程中，经常会遇到需要使用对象，而不是内置数据类型的情形。为了解决这个问题，Java 语言为每一个内置数据类型提供了对应的包装类

所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类

举个例子：当需要往ArrayList，HashMap中放东西时，像int，double是放不进去的，因为容器都是装 object的，这时就需要Integer类

包装类	基本数据类型
Boolean	boolean
Byte	byte
Short	short
Integer	int
Long	long
Character	char
Float	float
Double	double

这种由编译器特别支持的包装称为装箱，所以当内置数据类型被当作对象使用的时候，编译器会把内置类型装箱为包装类。相似的，编译器也可以把一个对象拆箱

为内置类型。Number 类属于 java.lang 包

Math 类

Java 的 Math 包含了用于执行基本数学运算的属性和方法，常见的有：

序号	方法与描述
1	xxxValue() 将 Number 对象转换为xxx数据类型的值并返回。
2	compareTo() 将number对象与参数比较。
3	equals() 判断number对象是否与参数相等。
4	valueOf() 返回一个 Number 对象指定的内置数据类型
5	toString() 以字符串形式返回值。
6	parseInt() 将字符串解析为int类型。
7	abs() 返回参数的绝对值。
8	ceil() 返回大于等于( >= )给定参数的的最小整数，类型为双精度浮点型。
9	floor() 返回小于等于（<=）给定参数的最大整数。
10	rint() 返回与参数最接近的整数。返回类型为double。
11	round() 它表示四舍五入，算法为 Math.floor(x+0.5)，即将原来的数字加上 0.5 后再向下取整，所以，Math.round(11.5) 的结果为12，Math.round(-11.5) 的结果为-11。
12	min() 返回两个参数中的最小值。
13	max() 返回两个参数中的最大值。
14	exp() 返回自然数底数e的参数次方。
15	log() 返回参数的自然数底数的对数值。
16	pow() 返回第一个参数的第二个参数次方。
17	sqrt() 求参数的算术平方根。
18	toDegrees()将参数转化为角度。
19	random()返回一个随机数。

补充：Math 的 floor、round 、 ceil 方法实例比较

参数	Math.floor	Math.round	Math.ceil
1.4	1	1	2
1.5	1	2	2
1.6	1	2	2
-1.4	-2	-1	-1
-1.5	-2	-1	-1
-1.6	-2	-2	-1

Character 类

Character 类用于对单个字符进行操作

Character 类在对象中包装一个基本类型 char 的值

然而，在实际开发过程中，经常会遇到需要使用对象，而不是内置数据类型的情况。为了解决这个问题，Java语言为内置数据类型char提供了包装类——

Character类

Character类提供了一系列方法来操纵字符。可以使用Character的构造方法创建一个Character类对象，例如：

        Character ch = new Character('A');

关于拆箱装箱（以后会补充）

在某些情况下，Java编译器会自动创建一个Character对象

例如，将一个char类型的参数传递给需要一个Character类型参数的方法时，那么编译器会自动地将char类型参数转换为Character对象。这种特征称为装箱，反

过来称为拆箱，例如：

// 原始字符 'a' 装箱到 Character 对象 ch 中
Character ch = 'a';// 原始字符 'x' 用 test 方法装箱
// 返回拆箱的值到 'c'
char c = test('x');

反斜杠（转义序列）

反斜杠（\）的字符代表转义字符，它对编译器来说是有特殊含义的

下面列表展示了Java的转义序列：

转义序列	描述
\t	在文中该处插入一个tab键
\b	在文中该处插入一个后退键
\n	在文中该处换行
\r	在文中该处插入回车
\f	在文中该处插入换页符
’	在文中该处插入单引号
"	在文中该处插入双引号
\	在文中该处插入反斜杠

Character 方法

常见方法

序号	方法与描述
1	isLetter() 是否是一个字母
2	isDigit() 是否是一个数字字符
3	isWhitespace() 是否是一个空白字符
4	isUpperCase() 是否是大写字母
5	isLowerCase() 是否是小写字母
6	toUpperCase() 指定字母的大写形式
7	toLowerCase() 指定字母的小写形式
8	toString]() 返回字符的字符串形式，字符串的长度仅为1

String 类

字符串广泛应用在 Java 编程中，在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串

创建字符串：

        String str01 = "字符串";//最简单的方式String str02 = new String("这也是字符串");//构造函数的方式

String 创建的字符串存储在公共池中，而 new 创建的字符串对象在堆上：

差别请看菜鸟教程这张图：

String类常用方法

1）.length 返回字符串长度

2）.concat 链接两个字符串返回新字符串，例如：

        String str01 = "1";String str02 = "A";String concat = str01.concat(str02);

3）.format() 创建格式化字符串

4）.hashCode() 返回字符串的哈希码

5）.indexOf(String str) 根据指定内容（str参数）查找字符串中对应下标（从0开始），查到就返回，结束方法，全部查完没有结果返回-1

补充：其构造方法 public int indexOf(String str, int fromIndex)的 int fromIndex 参数则表示从指定（fromIndex）下标开始查

.lastIndexOf()和这个一样，只不过从右往左

6）.matches(String regex) 是否匹配regex（正则表达式）

7）.regionMatches(boolean ignoreCase, int toffset,String other, int ooffset, int len) 方法用于检测两个字符串在一个区域内是否相等

参数介绍：

ignoreCase – 如果为 true，则比较字符时忽略大小写

toffset – 此字符串中子区域的起始偏移量

other – 字符串参数（用于比较的字符串）

ooffset – 字符串参数中子区域的起始偏移量

len – 要比较的字符数

8）.charAt(int index) 方法用于返回指定索引处的字符。索引范围为从 0 到 length() - 1

        String str = "测试字符串";char c = str.charAt(0);System.out.println(c);//输出的是：测

9）.compareTo(String anotherString) 返回值是整型如果第一个字符和参数的第一个字符不等，结束比较，返回第一个字符的ASCII码差值。如果第一个字符和参数的第一个字符相等，则以第二个字符和参数的第二个字符做比较，以此类推,直至不等为止，返回该字符的ASCII码差值。如果两个字符串不一样长，可对应字符又完全一样，则返回两个字符串的长度差值。源码如下：

    public int compareTo(String anotherString) {int len1 = value.length;int len2 = anotherString.value.length;int lim = Math.min(len1, len2);char v1[] = value;char v2[] = anotherString.value;int k = 0;while (k < lim) {char c1 = v1[k];char c2 = v2[k];if (c1 != c2) {return c1 - c2;}k++;}return len1 - len2;}

补充：另一个构造方法的参数是对象，但太过抽象这里不介绍

10）.copyValueOf(char data[]) 把char数组变成字符串然后返回，如果是public static String copyValueOf(char[] data, int offset, int count)则offset表示截取下标（从0开始），count表示长度，例如：

        char str01[] = {'1','2','a','b'};String str02 = "123";System.out.println(str02.copyValueOf(str01,1,3));

输出的就是2ab

11）.endsWith(String suffix) 方法用于测试字符串是否以指定的后缀结束

12）.equals(Object anObject) 判断是否相等。醒目提示：！！！==和equals的区别是前者比较地址是否相同，后者比较内容是否相同

13）.String replaceAll(String regex, String replacement) 使用给定的参数 replacement 替换字符串所有匹配给定的正则表达式的子字符串

14）.split(String regex, int limit) 根据匹配给定的正则表达式来拆分字符串（返回字符串数组）

注意：

. 、 $、 | 和 * 等转义字符，必须得加 \

多个分隔符，可以用 | 作为连字符

regex – 正则表达式分隔符（理解为将该字摘掉）

limit – 分割的份数，切割第一次，重复不切割。不设置该参数，每次重复切割都将产生新的字符串数组

例如：

        String str02 = "ABCD1234";String[] split = str02.split("CD",2);for (int i = 0; i <split.length ; i++) {System.out.println(split[i]);}

因为limit为2所以分割两段，结果是

AB
1234

15）.startsWith(String prefix, int toffset) 用于检测字符串是否以指定的前缀开始

16）.subSequence(int beginIndex, int endIndex) 截取子字符串。beginIndex – 起始索引（包括），endIndex – 结束索引（不包括）

17）.toCharArray() 字符串转换为char数组

18）. toLowerCase()返回小写String类型

补充：.toUpperCase()是大写

19）.valueOf() 返回参数的字符串表示形式（所有得声明一个String然后调用这个方法），这也是八大基本数据类型转换成String的方法

20）.trim() 删除字符串的头尾空白符并返回字符串

21）.contains(CharSequence chars)判断字符串中是否包含指定的字符或字符串

22）.isEmpty()判断字符串是否为空

StringBuffer 和 StringBuilder

与String类的结构图

简单说，String类不能对字符串进行修改，且每次String操作都会生产新的对象导致效率低下，而 StringBuffer 和 StringBuilder就可以对字符串进行修改

在使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，所以如果需要对字符串进行修改推荐使用 StringBuffer

而StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类

面试题：String StringBuffer StringBuilder的区别是什么？

①可变性：

String类使用了关键字final修饰：private final char value[];

而StringBuffer和StringBuilder都继承自AbstractStringBuilder类。而AbstractStringBuilder没有关键字final修饰。

所以String不可变，StringBuffer和StringBuilder可变

②线程安全性：

String中的对象不可变，可理解为常量，线程安全

StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，也是线程安全的

StringBuilder就无，所以是非线程安全的

③性能：

String类在进行改变的时候，都会在内存生成新对象，然后指针引用

StringBuffer每次都会对StringBuffer类本身操作，不用生成新对象

StringBuilder类相比StringBuffer会有一成提升，但却冒多线程不安全的风险

使用原则：

如果要操作少量的数据，用String

单线程操作大量数据，用StringBuilder

多线程操作大量数据，用StringBuffer

数据类型间的转换

基本数据类型的范围排序：

byte→short→char→int→long→float→double

自动转换

类型范围小的变量可以复制给大的，例如

byte a = 127;
int b = a ;
System.out.println(b);

强制转换

条件是转换的数据类型必须是兼容的。

格式：(type)value type，例如

char c = (char) 65536;

（char的整数取值范围是0-655355）

基本数据类型和String相互转换

（粗略了解）

由基本数据型态转换成String

String.valueOf() 这个参数多载的方法

有以下几种：

1.String.valueOf(boolean b) : 将 boolean 变量 b 转换成字符串

2.String.valueOf(char c) : 将 char 变量 c 转换成字符串

3.String.valueOf(char[] data) : 将 char 数组 data 转换成字符串

4.String.valueOf(char[] data, int offset, int count) : 将 char 数组 data 中由 data[offset] 开始取 count 个元素转换成字符串

5.String.valueOf(double d) : 将 double 变量 d 转换成字符串

6.String.valueOf(float f) : 将 float 变量 f 转换成字符串

7.String.valueOf(int i) : 将 int 变量 i 转换成字符串

8.String.valueOf(long l) : 将 long 变量 l 转换成字符串

9.String.valueOf(Object obj) : 将 obj 对象转换成字符串, 等于 obj.toString()

例：

　　int i = 10; String str = String.valueOf(i);

这时候 str 就会是 “10”

由 String 转换成数字的基本数据型态

要将 String 转换成基本数据型态转，大多需要使用基本数据型态的包装类别

比如说 String 转换成 byte ，可以使用 Byte.parseByte(String s) ，这一类的方法如果无法将 s 分析则会丢出 NumberFormatException

1.byte : Byte.parseByte(String s) : 将 s 转换成 byte

2.Byte.parseByte(String s, int radix) : 以 radix 为基底将 s 转换为 byte ，比如说 Byte.parseByte(“11”, 16) 会得到 17

3.double : Double.parseDouble(String s) : 将 s 转换成 double

4.float : Double.parseFloat(String s) : 将 s 转换成 float

5.int : Integer.parseInt(String s) : 将 s 转换成 int

6.long : Long.parseLong(String s)

特殊：

char是字符，所以如果要把String转成char类型，那么要用char数组来存放。

String str = “abssd”；

char[] ch = str.toCharArray();

Java运算符

算数运算符

操作符	描述	例子 A:10 B:20
+	加法 - 相加运算符两侧的值	A + B 等于 30
-	减法 - 左操作数减去右操作数	A – B 等于 -10
*	乘法 - 相乘操作符两侧的值	A * B等于200
/	除法 - 左操作数除以右操作数	B / A等于2
％	取余 - 左操作数除以右操作数的余数	B%A等于0
++	自增: 操作数的值增加1	B++ 或 ++B 等于 21（区别详见下文）
–	自减: 操作数的值减少1	B-- 或 --B 等于 19（区别详见下文）

自增运算符的区别

前缀自增自减法(++a,–a): 先进行自增或者自减运算，再进行表达式运算。

后缀自增自减法(a++,a–): 先进行表达式运算，再进行自增或者自减运算

关系运算符

（大小关系）

运算符	描述	例子
==	检查如果两个操作数的值是否相等，如果相等则条件为真。	（A == B）为假。
!=	检查如果两个操作数的值是否相等，如果值不相等则条件为真。	(A != B) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是那么条件为真。	（A> B）为假。
<	检查左操作数的值是否小于右操作数的值，如果是那么条件为真。	（A <B）为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。	（A> = B）为假。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。	（A <= B）为真。

位运算符

位 bit：也叫比特，二进制数中的一个数位，是计算机中数据的最小单位。

字节 byte：每8位组成一个字节，计算机中数据的基本单位。

操作符	描述	例子A:0011 1100
		B:0000 1101
＆	如果相对应位都是1，则结果为1，否则为0	（A＆B），得到12，即0000 1100
\|	如果相对应位都是 0，则结果为 0，否则为 1	（A \| B）得到61，即 0011 1101
^	如果相对应位值相同，则结果为0，否则为1	（A ^ B）得到49，即 0011 0001
〜	按位取反运算符翻转操作数的每一位，即0变成1，1变成0。	（〜A）得到-61，即1100 0011
<<	按位左移运算符。左操作数按位左移右操作数指定的位数。	A << 2得到240，即 1111 0000
>>	按位右移运算符。左操作数按位右移右操作数指定的位数。	A >> 2得到15即 1111
>>>	按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。	A>>>2得到15即0000 1111

逻辑运算符

操作符	描述	例子A真B假
&&	称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。	（A && B）为假。
\| \|	称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。	（A \| \| B）为真。
！	称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。	！（A && B）为真。

赋值运算符

操作符	描述	例子
=	简单的赋值运算符，将右操作数的值赋给左侧操作数	C = A + B将把A + B得到的值赋给C
+ =	加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数	C + = A等价于C = C + A
- =	减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数	C - = A等价于C = C - A
* =	乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数	C * = A等价于C = C * A
/ =	除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数	C / = A，C 与 A 同类型时等价于 C = C / A
（％）=	取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数	C％= A等价于C = C％A
<< =	左移位赋值运算符	C << = 2等价于C = C << 2
>> =	右移位赋值运算符	C >> = 2等价于C = C >> 2
＆=	按位与赋值运算符	C＆= 2等价于C = C＆2
^ =	按位异或赋值操作符	C ^ = 2等价于C = C ^ 2
\| =	按位或赋值操作符	C \| = 2等价于C = C \| 2

三元运算符

条件表达式？表达式1:表达式2

如果条件表达式为真，返回表达式1，否则返回表达式2

案例：

int a = 1;int b = 100;int result = a>b?a++:b--;

result是100

因为三元运算的结果是return b–;

意思就是先返回b再b-1，

若

int result = a>b?a++:–b;

那么结果就是99

补充1：

使用细节

1.表达式1和表达式2必须是可以赋值给接受变量的类型（或可自动转换）

案例：

int a = 1;int b = 100;int result = a>b?1.1:2.2;

这样会因为没法把2.2转成int而报错，或着把int result改成double result

2.三元运算符可以转成if-else语句（略）

练习：实现三个数的最大值

int n1 = 55;

int n2 = 33;

int n3 = 100;

思路：比较n1和n2中最大的数，再和n3比较

解答：

public class Main {public static void main(String[] args) {// 三元表达式作业：实现三个数的最大值int n1 = 55;int n2 = 33;int n3 = 100;int result1 = n1>n2?n1:n2;int result2 = result1>n3?result1:n3;System.out.println(result2);//进阶：使用一条语句实现以提升代码可读性int result4 = (n1>n2?n1:n2)>n3?(n1>n2?n1:n2):n3;System.out.println(result4);}
}

Java循环

顺序结构的程序语句只能被执行一次

若想要同样的操作执行多次，就需要使用循环结构

while 循环

while (布尔表达式){//循环体
}
//不满足布尔表达式时执行的代码

只要布尔表达式为 true，循环就会一直执行下去

do…while 循环

do…while 循环至少会执行一次

        do{//循环体（至少一次）}while (布尔表达式);//不满足布尔表达式时执行的代码

for循环

虽然所有循环结构都可以用 while 或者 do…while表示，但 Java 提供了另一种语句 —— for 循环，使一些循环结构变得更加简单。

for循环执行的次数是在执行前就确定的。语法格式如下：

        for (初始化; 布尔表达式; 更新) {//代码语句}

关于 for 循环有以下几点说明：

先执行初始化代码。可以声明一种类型，可初始化一个或多个循环控制变量，也可以是空语句。

然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。

执行一次循环后，执行更新代码

再次检测布尔表达式。循环执行上面的过程

增强for

（也叫 For-Each）

Java5 引入了一种主要用于数组的增强型 for 循环

快捷键大写i，就是个简单版迭代器

关于iterator迭代器：

所有实现collection的类都有一个iterator()方法，用于返回一个实现了iterator接口的对象，即可返回一个迭代器

Java 增强 for 循环语法格式如下:

for (声明语句 : 表达式) {//代码句子
}

**声明语句：**声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

**表达式：**表达式是要访问的数组名，或者是返回值为数组的方法

例：

        char array[] = {'测','试','字','符','串'};for (char i: array) {System.out.println(i);}

输出的是：测试字符串

如果是：

char array[] = {'测','试','字','符','串'};
for (int i: array) {System.out.println(i);
}

输出的则是这些字符对应的值

Java条件

if…else

略

if…else if…else

if 后面可以跟 else if…else 语句，这种语句可以检测到多种情况

语法格式如下:

        if (布尔表达式 1){//布尔表达式 1为真执行的内容}else if(布尔表达式 2){//布尔表达式 2为真执行的内容}else if(布尔表达式 3){//布尔表达式 3为真执行的内容}else{//不满足上述所有布尔表达时执行的内容}

注意：

if 语句至多有 1 个 else 语句，else 语句在所有的 else if 语句之后
if 语句可以有若干个 else if 语句，它们必须在 else 语句之前
一旦其中一个 else if 语句检测为 true，其他的 else if 以及 else 语句都将跳过执行

switch case

switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支

语法格式如下：

switch (表达式){case 值1 ://当表达式值为值1时执行的内容break;//可选case 值2 ://当表达式值为值2时执行的内容break;//可选case 值3 ://当表达式值为值3时执行的内容break;//可选default ://可选，表示当所有case值都不匹配时执行的内容}

switch case 语句有如下规则：

case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量
当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句
当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句
switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支（可以在任何位置，但建议在最后一个）。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句

醒目提示：！！！如果 case 语句块中没有 break 语句时，匹配成功后，从当前 case 开始，后续所有 case 的值都会输出

例如：

public class Test {public static void main(String args[]){int i = 1;switch(i){case 0:System.out.println("0");case 1:System.out.println("1");case 2:System.out.println("2");default:System.out.println("default");}}
}

输出的结果就是

1
2
default

补充：↑如果后续case有break则会跳出

Java日期

java.util 包提供了 Date 类来封装当前的日期和时间

例如获取当前时间

        Date date = new Date();System.out.println(date);

Date方法

序号	方法和描述
1	boolean after(Date date) 若当调用此方法的Date对象在指定日期之后返回true,否则返回false。
2	boolean before(Date date) 若当调用此方法的Date对象在指定日期之前返回true,否则返回false。
3	Object clone( ) 返回此对象的副本。
4	int compareTo(Date date) 比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。
5	int compareTo(Object obj) 若obj是Date类型则操作等同于compareTo(Date) 。否则它抛出ClassCastException。
6	boolean equals(Object date) 当调用此方法的Date对象和指定日期相等时候返回true,否则返回false。
7	long getTime( ) 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
8	int hashCode( ) 返回此对象的哈希码值。
9	void setTime(long time) 用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。
10	String toString( ) 把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)。

Java正则表达式

是一种匹配字符串的方法，通过一些特殊符号，实现快速查找、删除、替换某个特定字符串。包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为"元字符"）

语法：

字符	说明
\	将下一字符标记为特殊字符、文本、反向引用或八进制转义符。例如， n匹配字符 n。\n 匹配换行符。序列 \\ 匹配 \ ，\( 匹配 (。
^	匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性，^ 还会与"\n"或"\r"之后的位置匹配。
$	匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性，$ 还会与"\n"或"\r"之前的位置匹配。
*	零次或多次匹配前面的字符或子表达式。例如，zo* 匹配"z"和"zoo"。* 等效于 {0,}。
+	一次或多次匹配前面的字符或子表达式。例如，"zo+"与"zo"和"zoo"匹配，但与"z"不匹配。+ 等效于 {1,}。
?	零次或一次匹配前面的字符或子表达式。例如，"do(es)?“匹配"do"或"does"中的"do”。? 等效于 {0,1}。
{n}	n 是非负整数。正好匹配 n 次。例如，"o{2}"与"Bob"中的"o"不匹配，但与"food"中的两个"o"匹配。
{n,}	n 是非负整数。至少匹配 n 次。例如，"o{2,}“不匹配"Bob"中的"o”，而匹配"foooood"中的所有 o。"o{1,}“等效于"o+”。"o{0,}“等效于"o*”。
{n,m}	m 和 n 是非负整数，其中 n <= m。匹配至少 n 次，至多 m 次。例如，"o{1,3}"匹配"fooooood"中的头三个 o。‘o{0,1}’ 等效于 ‘o?’。注意：您不能将空格插入逗号和数字之间。
?	当此字符紧随任何其他限定符（*、+、?、{n}、{n,}、{n,m}）之后时，匹配模式是"非贪心的"。"非贪心的"模式匹配搜索到的、尽可能短的字符串，而默认的"贪心的"模式匹配搜索到的、尽可能长的字符串。例如，在字符串"oooo"中，"o+?“只匹配单个"o”，而"o+“匹配所有"o”。
.	匹配除"\r\n"之外的任何单个字符。若要匹配包括"\r\n"在内的任意字符，请使用诸如"[\s\S]"之类的模式。
(pattern)	匹配 pattern 并捕获该匹配的子表达式。可以使用 $0…$9 属性从结果"匹配"集合中检索捕获的匹配。若要匹配括号字符 ( )，请使用"(“或者”)"。
(?:pattern)	匹配 pattern 但不捕获该匹配的子表达式，即它是一个非捕获匹配，不存储供以后使用的匹配。这对于用"or"字符 (\|) 组合模式部件的情况很有用。例如，'industr(?:y\|ies) 是比 ‘industry\|industries’ 更经济的表达式。
(?=pattern)	执行正向预测先行搜索的子表达式，该表达式匹配处于匹配 pattern 的字符串的起始点的字符串。它是一个非捕获匹配，即不能捕获供以后使用的匹配。例如，‘Windows (?=95\|98\|NT\|2000)’ 匹配"Windows 2000"中的"Windows"，但不匹配"Windows 3.1"中的"Windows"。预测先行不占用字符，即发生匹配后，下一匹配的搜索紧随上一匹配之后，而不是在组成预测先行的字符后。
(?!pattern)	执行反向预测先行搜索的子表达式，该表达式匹配不处于匹配 pattern 的字符串的起始点的搜索字符串。它是一个非捕获匹配，即不能捕获供以后使用的匹配。例如，‘Windows (?!95\|98\|NT\|2000)’ 匹配"Windows 3.1"中的 “Windows”，但不匹配"Windows 2000"中的"Windows"。预测先行不占用字符，即发生匹配后，下一匹配的搜索紧随上一匹配之后，而不是在组成预测先行的字符后。
x\|y	匹配 x 或 y。例如，‘z\|food’ 匹配"z"或"food"。‘(z\|f)ood’ 匹配"zood"或"food"。
[xyz]	字符集。匹配包含的任一字符。例如，"[abc]“匹配"plain"中的"a”。
[^xyz]	反向字符集。匹配未包含的任何字符。例如，"[^abc]“匹配"plain"中"p”，“l”，“i”，“n”。
[a-z]	字符范围。匹配指定范围内的任何字符。例如，"[a-z]"匹配"a"到"z"范围内的任何小写字母。
[^a-z]	反向范围字符。匹配不在指定的范围内的任何字符。例如，"[^a-z]"匹配任何不在"a"到"z"范围内的任何字符。
\b	匹配一个字边界，即字与空格间的位置。例如，“er\b"匹配"never"中的"er”，但不匹配"verb"中的"er"。
\B	非字边界匹配。“er\B"匹配"verb"中的"er”，但不匹配"never"中的"er"。
\cx	匹配 x 指示的控制字符。例如，\cM 匹配 Control-M 或回车符。x 的值必须在 A-Z 或 a-z 之间。如果不是这样，则假定 c 就是"c"字符本身。
\d	数字字符匹配。等效于 [0-9]。
\D	非数字字符匹配。等效于 [^0-9]。
\f	换页符匹配。等效于 \x0c 和 \cL。
\n	换行符匹配。等效于 \x0a 和 \cJ。
\r	匹配一个回车符。等效于 \x0d 和 \cM。
\s	匹配任何空白字符，包括空格、制表符、换页符等。与 [ \f\n\r\t\v] 等效。
\S	匹配任何非空白字符。与 [^ \f\n\r\t\v] 等效。
\t	制表符匹配。与 \x09 和 \cI 等效。
\v	垂直制表符匹配。与 \x0b 和 \cK 等效。
\w	匹配任何字类字符，包括下划线。与"[A-Za-z0-9_]"等效。
\W	与任何非单词字符匹配。与"[^A-Za-z0-9_]"等效。
\xn	匹配 n，此处的 n 是一个十六进制转义码。十六进制转义码必须正好是两位数长。例如，“\x41"匹配"A”。“\x041"与”\x04"&"1"等效。允许在正则表达式中使用 ASCII 代码。
num	匹配 num，此处的 num 是一个正整数。到捕获匹配的反向引用。例如，"(.)\1"匹配两个连续的相同字符。
n	标识一个八进制转义码或反向引用。如果 n 前面至少有 n 个捕获子表达式，那么 n 是反向引用。否则，如果 n 是八进制数 (0-7)，那么 n 是八进制转义码。
nm	标识一个八进制转义码或反向引用。如果 nm 前面至少有 nm 个捕获子表达式，那么 nm 是反向引用。如果 nm 前面至少有 n 个捕获，则 n 是反向引用，后面跟有字符 m。如果两种前面的情况都不存在，则 nm 匹配八进制值 nm，其中 n 和 m 是八进制数字 (0-7)。
\nml	当 n 是八进制数 (0-3)，m 和 l 是八进制数 (0-7) 时，匹配八进制转义码 nml。
\un	匹配 n，其中 n 是以四位十六进制数表示的 Unicode 字符。例如，\u00A9 匹配版权符号 (©)。

Java IO

Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标

I：input

O：out

用于数据传输：网络通讯、读写文件

对于数据的输入和输出是以流的方式进行的

面试题：Java中IO流分为几种

①按流的流分向：输入流和输出流

前者把硬件数据读入到内存（程序）中，后者相反

②按流的操作单元：字节流（8bit）和字符流（字符）

二者差别：前者按字节读取，后者按字符读取，比如在读取二进制文件时，字节流就不会有损失，字符流要把字符转换成二进制这样会损失，但是他读文本文件比

较好，例如：

数据通过Window自带的记事本软件打开，我们还可以读懂里面的内容，就使用字符流，否则使用字节流。如果你不知道该使用哪种类型的流，就使用字节流

③按流的角色：节点流和处理流

字节流

有两个超大抽象类（后文这俩标题），且子类名称都是以其父类名作为子类名后缀

InputStream

字节输入流，将文件中的数据读取到java程序中

InputStream是所有字节输入流的顶层父类，是一个抽象类。如果要用，需要使用子类

其最常用的子类是：FileInputStream

FileInputStream

需要创建对象来使用

构造方法：

FileInputStream(File file)：传递一个File类型的文件

        File f = new File("E:/temp/Fire Emblem Engage [0100A6301214E000][v0]");FileInputStream f2 = new FileInputStream(f);

FileInputStream(String name)：传递一个String类型的文件路径

        FileInputStream f1 = new FileInputStream("E:/temp/Fire Emblem Engage [0100A6301214E000][v0]");

创建了InputStream对象后，就可以使用下面的方法来读取流或者进行其他的流操作

序号	方法及描述
1	public void close() throws IOException{} 关闭此文件输入流并释放与此流有关的所有系统资源。抛出IOException异常。
2	protected void finalize()throws IOException {} 这个方法清除与该文件的连接。确保在不再引用文件输入流时调用其 close 方法。抛出IOException异常。
3	public int read(int r)throws IOException{} 这个方法从 InputStream 对象读取指定字节的数据。返回为整数值。返回下一字节数据，如果已经到结尾则返回-1。
4	public int read(byte[] r) throws IOException{} 这个方法从输入流读取r.length长度的字节。返回读取的字节数。如果是文件结尾则返回-1。
5	public int available() throws IOException{} 返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取的字节数。返回一个整数值。

除了 InputStream 外，还有一些其他的输入流：

DataInputStream

ByteArrayInputStream

OutputStream

与InputStream对应，不过多赘述。

FileOutputStream

该类用来创建一个文件并向文件中写数据。

如果该流在打开文件进行输出前，目标文件不存在，那么该流会创建该文件。

有两个构造方法可以用来创建 FileOutputStream 对象（和FileInputStream一样）

使用字符串类型的文件名来创建一个输出流对象

创建了OutputStream 对象后，就可以使用下面的方法来写入流或者进行其他的流操作。

序号	方法及描述
1	public void close() throws IOException{} 关闭此文件输入流并释放与此流有关的所有系统资源。抛出IOException异常。
2	protected void finalize()throws IOException {} 这个方法清除与该文件的连接。确保在不再引用文件输入流时调用其 close 方法。抛出IOException异常。
3	public void write(int w)throws IOException{} 这个方法把指定的字节写到输出流中。
4	public void write(byte[] w) 把指定数组中w.length长度的字节写到OutputStream中。

使用实例

//文件名 :fileStreamTest2.java
import java.io.*;public class fileStreamTest2 {public static void main(String[] args) throws IOException {File f = new File("a.txt");FileOutputStream fop = new FileOutputStream(f);// 构建FileOutputStream对象,文件不存在会自动新建OutputStreamWriter writer = new OutputStreamWriter(fop, "UTF-8");// 构建OutputStreamWriter对象,参数可以指定编码,默认为操作系统默认编码,windows上是gbkwriter.append("中文输入");// 写入到缓冲区writer.append("\r\n");// 换行writer.append("English");// 刷新缓存冲,写入到文件,如果下面已经没有写入的内容了,直接close也会写入writer.close();// 关闭写入流,同时会把缓冲区内容写入文件,所以上面的注释掉fop.close();// 关闭输出流,释放系统资源FileInputStream fip = new FileInputStream(f);// 构建FileInputStream对象InputStreamReader reader = new InputStreamReader(fip, "UTF-8");// 构建InputStreamReader对象,编码与写入相同StringBuffer sb = new StringBuffer();while (reader.ready()) {sb.append((char) reader.read());// 转成char加到StringBuffer对象中}System.out.println(sb.toString());reader.close();// 关闭读取流fip.close();// 关闭输入流,释放系统资源}
}

字符流

面试题：既然有字节流，为何还需要字符流

其问题本质是：无论文件都写与网络接受，信息的最小单元都是字节，那I/O流操作为什么要分字节流还是字符流呢？

答：字符流是Java虚拟机将字节转换得到的，但这个过程非常耗时，且如果我们不知道编码类型就很容易出现乱码。所有I/O提供了一个直接操作字符的接口，方便直接对字符操作。在音频、图片等媒体文件，使用字节流，设计到字符（文本）使用字符

Reader和字节的InputSteam对应，Writer和字节的OutputStream对应

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4YdiIZGs-1675071892451)(Java基础笔记.assets/Screenshot 2023-01-30 110308.jpg)]

常见的字符流

BufferedReader/BufferedWriter 字符缓存流（处理流）与BufferedInputStream/BufferedOutputStream 类似，增加了缓存机制，提高读写文本文件的效率

InputStreamReader/OutputStreamWriter 转换流（处理流）

FileReader/FileWriter 文件字符流（节点流）继承↑

Reader

字符输入流的抽象类，读取字符信息到内存

InputStreamReader

是字节流通向字符流的桥梁（转换），这里主要介绍他的子类FileReader

FileReader

通过以下几种构造方法创建需要的对象

①FileReader(File file)：

在给定从中读取数据的 File 的情况下创建一个新 FileReader，例：

        File file = new File("C:/Users/328_01/Desktop/test.txt");//创建File类final FileReader f1 = new FileReader(file);//这里就是创建对象char [] c = new char[10];f1.read(c);//读取数组中的内容for (char ch :c) {System.out.println(ch);//增强for，可参考前文笔记}

②FileReader(FileDescriptor fd) ：

在给定从中读取数据的 FileDescriptor 的情况下创建一个新 FileReader。

③FileReader(String fileName) ：

在给定从中读取数据的文件名的情况下创建一个新 FileReader。

创建FIleReader对象成功后，可以参照以下列表里的方法操作文件。

序号	方法及描述
1	public int read() throws IOException 每次读取单个字符，返回该字符，到文件末尾返回-1
2	public int read(char [] c, int offset, int len) 批量读取多个字符数组，返回字符数，到文件末尾返回-1

Writer

字符输出流的抽象类

由于Writer类是抽象类无法创建，这里运用多态的知识创建了其子类（后面OOP有笔记）：

Writer w1 = new FileWriter();

Writer提供的方法

序号	方法及描述
1	write(char[] array) 将指定数组中的字符写入输出流
2	write(String data) 将指定的字符串写入写入器
3	write(int) 写入单个字符
4	write(char[],off,len) 指定写入数组部分
5	write(String) 写入整个字符串
6	write(String,off,len) 指定写入字符串部分
7	.append(char c) 将指定字符插入当前写入器
8	.flush() 强制将写入器中存在的所有数据写入相应的目的地
9	.close() 关闭写入器

FileWriter使用后，必须要关闭(close)或刷新(flush)，否则写入不到指定文件

示例：

import java.io.*;public class FileRead {public static void main(String args[]) throws IOException {File file = new File("Hello1.txt");// 创建文件file.createNewFile();//这个表示创建新文件，若已存在该文件则返回false，没有则生成// creates a FileWriter ObjectFileWriter writer = new FileWriter(file);// 向文件写入内容writer.write("This\n is\n an\n example\n");writer.flush();writer.close();// 创建 FileReader 对象FileReader fr = new FileReader(file);char[] a = new char[50];fr.read(a); // 读取数组中的内容for (char c : a)System.out.print(c); // 一个一个打印字符fr.close();}
}

OutputStreamWriter

和InputStreamReader一样，也是桥梁：OutputStreamWriter流的作用就是利用字节流作为底层输出流然后构建字符输出流，字符输出流输出字符到流中，然后通过指定的字符集把流中的字符编码成字节输出到字节流中，其作用就是一个桥梁，使得双方链接起来

构造函数（源码略）

①public OutputStreamWriter(OutputStream out)

利用输出流构建默认字符编码的OutputStreamWriter流：本质是初始化StreamEncoder对象

②public OutputStreamWriter(OutputStream out,String charsetName)

通过指定的字符编码构建OutputStreamWriter流：本质是初始化StreamEncoder对象但是指定了字符编码

FileWriter类

以下几种构造方法创建需要的对象：

①覆盖模式：FileWriter(File file)：

在给出 File 对象的情况下构造一个 FileWriter 对象

②追加模式：FileWriter(File file,boolean append)：

在给出 File 对象的情况下构造一个 FileWriter 对象

参数详解：

file：要写入数据的 File 对象
append：如果 append 参数为 true，则将字节写入文件末尾处，相当于追加信息。如果 append 参数为 false, 则写入文件开始处。
构造与某个文件描述符相关联的 FileWriter 对象

③覆盖模式：FileWriter(FileDescriptor fd)：

构造与某个文件描述符相关联的 FileWriter 对象

④追加模式：FileWriter(String fileName, boolean append)：

在给出文件名的情况下构造 FileWriter 对象，它具有指示是否挂起写入数据的 boolean 值

创建FileWriter对象成功后，可以参照以下列表里的方法操作文件

序号	方法及描述
1	public void write(int c) throws IOException 写入单个字符c。
2	public void write(char [] c, int offset, int len) 写入字符数组中开始为offset长度为len的某一部分。
3	public void write(String s, int offset, int len) 写入字符串中开始为offset长度为len的某一部分。

Java异常和处理

引例：

int n1 = 1;
int n2 = 0;
System.out.println(n1/n2);

当执行到n1/n2时，就会出现（抛出）异常，程序就退出了

思考：程序不应该出现这样的奔溃

所以：java设计者提供了异常处理机制解决这个问题：

结论：选中代码后，ctrl+alt+t再加6（快捷键）

补充：e.getMessage()方法可以捕获异常信息。开发过程中的语法和逻辑错误不算异常

Throwable异常方法

序号	方法及说明
1	public String getMessage() 返回异常发生时的简要描述
2	public String getLocalizedMessage 返回异常对象的本地化信息
3	public String toString() 返回异常发生时的详细信息
4	public void printStackTrace() 将此 Throwable 及其回溯打印到标准错误流。。
5	public StackTraceElement [] getStackTrace() 返回一个包含堆栈层次的数组。下标为0的元素代表栈顶，最后一个元素代表方法调用堆栈的栈底。
6	public Throwable fillInStackTrace() 用当前的调用栈层次填充Throwable 对象栈层次，添加到栈层次任何先前信息中。

Error类

是程序无法处理的错误，表示运行程序中较严重的问题。大多错误与代码执行的操作无关，而是代码运行过程中JVM出现的问题

Exception类

所有的异常类是从 java.lang.Exception 类继承的子类

结构图：

（Exception：异常）

（Error：错误）

Java 程序通常不捕获错误。错误一般发生在严重故障时，它们在Java程序处理的范畴之外

Java内置异常类

Java 语言定义了一些异常类在 java.lang 标准包中

标准运行时异常类的子类是最常见的异常类。由于 java.lang 包是默认加载到所有的 Java 程序的，所以大部分从运行时异常类继承而来的异常都可以直接使用

Java 根据各个类库也定义了一些其他的异常，下面的表中列出了 Java 的非检查性异常

异常	描述
ArithmeticException	当出现异常的运算条件时，抛出此异常。例如，一个整数"除以零"时，抛出此类的一个实例。
ArrayIndexOutOfBoundsException	用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小，则该索引为非法索引。
ArrayStoreException	试图将错误类型的对象存储到一个对象数组时抛出的异常。
ClassCastException	当试图将对象强制转换为不是实例的子类时，抛出该异常。
IllegalArgumentException	抛出的异常表明向方法传递了一个不合法或不正确的参数。
IllegalMonitorStateException	抛出的异常表明某一线程已经试图等待对象的监视器，或者试图通知其他正在等待对象的监视器而本身没有指定监视器的线程。
IllegalStateException	在非法或不适当的时间调用方法时产生的信号。换句话说，即 Java 环境或 Java 应用程序没有处于请求操作所要求的适当状态下。
IllegalThreadStateException	线程没有处于请求操作所要求的适当状态时抛出的异常。
IndexOutOfBoundsException	指示某排序索引（例如对数组、字符串或向量的排序）超出范围时抛出。
NegativeArraySizeException	如果应用程序试图创建大小为负的数组，则抛出该异常。
NullPointerException	当应用程序试图在需要对象的地方使用 `null` 时，抛出该异常
NumberFormatException	当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常。
SecurityException	由安全管理器抛出的异常，指示存在安全侵犯。
StringIndexOutOfBoundsException	此异常由 `String` 方法抛出，指示索引或者为负，或者超出字符串的大小。
UnsupportedOperationException	当不支持请求的操作时，抛出该异常。

下面的表中列出了 Java 定义在 java.lang 包中的检查性异常类

异常	描述
ClassNotFoundException	应用程序试图加载类时，找不到相应的类，抛出该异常。
CloneNotSupportedException	当调用 `Object` 类中的 `clone` 方法克隆对象，但该对象的类无法实现 `Cloneable` 接口时，抛出该异常。
IllegalAccessException	拒绝访问一个类的时候，抛出该异常。
InstantiationException	当试图使用 `Class` 类中的 `newInstance` 方法创建一个类的实例，而指定的类对象因为是一个接口或是一个抽象类而无法实例化时，抛出该异常。
InterruptedException	一个线程被另一个线程中断，抛出该异常。
NoSuchFieldException	请求的变量不存在
NoSuchMethodException	请求的方法不存在

异常捕获

使用 try 和 catch 关键字可以捕获异常。try/catch 代码块放在异常可能发生的地方

try/catch代码块中的代码称为保护代码

try/catch 的语法如下：

try
{// 程序代码
}catch(ExceptionName e1)
{//Catch 块
}

Catch 语句包含要捕获异常类型的声明。当保护代码块中发生一个异常时，try 后面的 catch 块就会被检查

如果发生的异常包含在 catch 块中，异常会被传递到该 catch 块，这和传递一个参数到方法是一样，还是用引例：

        int n1 = 1;int n2 = 0;try {System.out.println(n1/n2);} catch (Exception e) {System.out.println("当try发生错误，这里就会执行");}

多重捕获

一个 try 代码块后面跟随多个 catch 代码块的情况就叫多重捕获

语法如下：

try{// 程序代码
}catch(异常类型1 异常的变量名1){// 程序代码
}catch(异常类型2 异常的变量名2){// 程序代码
}catch(异常类型3 异常的变量名3){// 程序代码
}

上面的代码段包含了 3 个 catch块

可以在 try 语句后面添加任意数量的 catch 块

如果保护代码中发生异常，异常被抛给第一个 catch 块

如果抛出异常的数据类型与 ExceptionType1 匹配，它在这里就会被捕获

如果不匹配，它会被传递给第二个 catch 块

如此，直到异常被捕获或者通过所有的 catch 块

finally关键字

只要使用这个关键字，在try catch中，必定会执行的，一般用于清理类型等收尾善后性质的语句，语法如下

try{// 程序代码
}catch(异常类型1 异常的变量名1){// 程序代码
}catch(异常类型2 异常的变量名2){// 程序代码
}finally{// 必定执行的代码
}

Java入门-少走弯路（女朋友备用，高效整理）相关推荐

java江湖2新手开局攻略_原神开局攻略：新手入门少走弯路
原神游戏开局怎么玩才能有快速的发展呢?很多朋友想要在一开始就能够快速的成长起来,但是不知道从哪些方面来入手,为了帮助大家在游戏中有更好的游戏体验,今天小编就为大家带来原神开局攻略:新手入门少走弯路,感 ...
小兵大乱斗服务器维修吗,小兵大乱斗攻略大全新手入门少走弯路[多图]
小兵大乱斗是一款带兵即时对战手游,目前已经可以在各大平台下载体验游戏,不知道怎么玩的小伙伴下面看乖乖小编为大家介绍小兵大乱斗新手入门少走弯路. 小兵大乱斗攻略大全 <小兵大乱斗>是一款带兵 ...
AI学习路线，少走弯路，最详细整理。
基础知识 1.数学数学是学不完的,也没有几个人能像博士一样扎实地学好数学基础,入门人工智能领域,其实只需要掌握必要的基础知识就好.AI的数学基础最主要是高等数学.线性代数.概率论与数理统计三门课程, ...
沙盒勇者服务器维护,沙盒勇者新手攻略新手入门少走弯路[多图]
沙盒勇者新手该怎么玩,相信很多小伙伴都不清楚,那么这款沙盒类型的冒险游戏如何通关呢,还不清楚的玩家一起来看看吧. 沙盒勇者新手攻略开局:选职业都可以随意选,玩什么都可以(本人选的法师开局) 前期发展 ...
王牌竞速服务器维护,王牌竞速攻略大全新手入门少走弯路[多图]
王牌竞速这款赛车类型的竞速游戏,还有很多玩家都在询问,那么大家如何快速上手呢,下面为大家介绍王牌竞速攻略大全. 王牌竞速攻略大全网易激爽驾驶手游<王牌竞速>"不飙寻常路&quo ...
超级兔子人三人按键_超级兔子人攻略大全新手入门少走弯路[视频][多图]
超级兔子人是一款非常有趣的休闲类型游戏,很多新手玩家都不知这款游戏怎么玩,接下来嗨客小陈为大家介绍超级兔子人攻略大全. 超级兔子人攻略大全从各种3D场景中选择一个闯关模式,可单人进行挑战,也可与好友 ...
Java入门到架构师知识点整理，P8的技术大咖是这样通关的
一个人最怕的不是路途遥远,而是看不到胜利曙光.我希望下面这篇文章能给你的学习之路带来一丝曙光,大家不妨试着读一下吧,如果有收获给我点个赞哟. 温馨提醒:这篇文章写着写着就一万字了,建议大家关注后再收藏 ...
给你整理好了，新手必备的设备和工具，让你做自媒体少走弯路
新手们在做自媒体的初期都是很迷茫的.今天大周给大家分享在做自媒体的前期需要投资多少.需要准备哪些必要的设备.新手该如何选择领域.推荐常用的工具等满足自媒体的日常需求,都是个人的实战经验.希望能帮助你们 ...
学习Java捷径，少走弯路，就是捷径
如何学好Java编程语言?下面小编就来和大家聊聊如何少走弯路 1 培养兴趣兴趣是能够让你坚持下去的动力.如果只是把写程序作为谋生的手段的话,你会活的很累,也太对不起自己了.多关心一些行业趣事,多想想 ...

Java入门-少走弯路（女朋友备用，高效整理）