JAVA学习记录

---

前言

本篇分享：

学习JAVA时的笔记

环境介绍：

系统：Windows
IDE：Eclipse

---

Pta做题样例

做题样例

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextInt()) {
            int a = in.nextInt();
            int b = in.nextInt();
            System.out.println(a + b);
        }
    }
}

命名规范&代码风格

• 包名 – 所有字母小写
• 类名、接口名 – 首字母大写
• 常量名 – 所有字母大写，单词用’_'连接
• 变量名、方法名 – 第二个单词开始首字母大写
• 尽量使用英文定义标识符
• 标识符不能是true、false、null
• 标识符第一个字符不能是数字
• 使用驼峰命名法，即第一个单词小写，后面的单词首字母大写，例如：myVariableName
• 使用有意义的名字，尽量不使用缩写或单个字母的名字，例如：使用studentName代替sn
• 避免使用下划线作为变量名的一部分，除非它是一个常量，例如：MAX_VALUE
• 使用空格来提高可读性，例如：在二元运算符两侧和逗号后面添加空格
• 使用代码缩进来显示代码块，例如：在if语句或for循环中缩进

基本数据类型

类型	boolean	byte	short	int	long	float	double	char
内存分配字节	–	1	2	4	8	4	8	2

给float类型变量赋值时，数字末尾应该加上 f 或 F 表示这是一个float类型的数值，而给double类型变量赋值时，可以加上 d 或 D 表示这是一个double类型的数值，也可以不加，因为没有加字母的浮点数默认为double类型。

基本语法

• 输出时不在""内的+表连接作用，输出数值不需要""
• 定义常量在类型前面加final
• 输出提示类语言（不换行）：System.out.print("")
• 读入需要构造Scanner:

import java.util.Scanner;
Scanner in = new Scanner(System.in);

• 在读入字符串时，使用in.next()方法遇到空格会结束，使用in.nextLine()方法遇到回车会结束
• public -> 公共的，在任意一个地方可以访问
• private -> 私有的，只可以在文件内部访问
• 未标明以上两种即friendly -> 可以在一个类里面访问
• 不在同一个包的类需要用 import（例如import java.util.Scanner）。Java包内有util这个包，util内有Scanner这个类。

类变量

在类的属性中，含有static的变量表示该变量为类变量，不属于类里的任何一个对象，可以直接使用(类名称.变量名)调用。

类函数

static函数只能调用static函数，只能访问static成员变量。

关系运算

Java中关系判断（>、<、>=……）的结果为true或false。Java中的true字面值不等于1，false字面值也不等于0。在Java中，它们只能分配给声明为boolean的变量。在C语言中，为1或0。

数字/true/false与true/false之间不可比较大小，只能判断是否相等。

判断真假通常使用boolean，定义：boolean 变量名 = true或false。boolean的值只能是true或false。

浮点数（实型）

浮点运算是有误差的：1.0与十个0.1相加不相等。因此，判断两个浮点数是否相等通常采用：

Math.abs(f1-f2)<1e-6

其中1e-6为10的-6次方，即求两数的差距是否小于一个比较小的数字。

数组

Java定义数组

int[] 数组名 = new int[大小]；

在Java内，定义一个普通变量可以存放数据，是数据的“所有者”。而定义一个数组时（比如说int[] a = new int[10]），其中的数组名a是这个数组的“管理者”，a本身不可以存放数值。若定义(int[] b = a)，即表示b与a共同管理一个数组，都为a数组的管理者。因此，可以使用任意一个管理者对数组的值进行更改。

注意以下几点：

1. 数组变量是数组的管理者而非数组本身。
2. 数组必须创建出来然后交给数组变量来管理。
3. 数组变量之间的赋值时管理权限的赋予。
4. 数组变量之间的比较是判断是否管理同一个数组（两数组内容相同时也并非同一数组）。

Java程序遍历整个数组

for (i = 0; i < 数组名.length; i++)

length代表数组的元素数量。

使用FOR-EACH循环输出整个数组

for (类型 变量i : 数组名a) {
    // 对于数组a内的每一个元素依次拿出来作为i
    System.out.print(i);
}

Java中使用 new 创建的数组可以得到默认的0值，无需遍历赋初始值为0。

Java也可以像C语言一样直接初始化数组：

类型[] 数组名 = {1, 2, 3, ......};

循环

使用标号可以结束内循环且不执行外循环后面的语句，即结束内循环直接进行下次外循环：

******：
// 外循环
for() {
    // 内循环
    for() {	
        if() {
            // 结束内循环并执行下次外循环
            continue ******;
        }
    }
    System.out.print("Yes");	
}

其中，****** 为标号。

若在 for 内定义变量，则该变量为局部变量，离开 for 则不可以使用。例如：

for(int i = 1; i <= n; i++) {
    // ...
}

使用对象

字符类型

Java中字符类型 char 大致与C语言相同。

包装类型

除了 int 和 char 以外，Java中的包装类型就是把基本类型的名字的第一个字母大写。

boolean Boolean
char    Character
byte    Byte
short   Short
int     Integer
long    Long
float   Float
double  Double

包装类型的用处

1. 获得该类型的最大、最小值：Integer.MAX_VALUE、Integer.MIN_VALUE
2. 判断这个字符是不是数字/小写字母/大写字母/大写字母或小写字母/字母或数字/空格：static boolean isDigit(char ch)、static boolean isLetter(char ch)等
3. 把这个字符转换成大写/小写：static char toUpperCase(char ch)、static char toLowerCase(char ch)等

Math类

Math类是Java中的一个标准类，它提供了一些常用的数学方法，例如绝对值、幂函数、三角函数等。

绝对值

求一个数的绝对值可以使用Math类中的abs()方法，例如：

int a = -10;
int b = Math.abs(a); // b的值为10

幂函数

求一个数的n次幂可以使用Math类中的pow()方法，例如：

double a = 2;
double b = Math.pow(a, 3); // b的值为8

0~1之间的随机数

生成一个0~1之间的随机数可以使用Math类中的random()方法，例如：

double a = Math.random(); // a的值为一个0~1之间的随机数

四舍五入

对一个小数进行四舍五入可以使用Math类中的round()方法，例如：

double a = 3.6;
int b = Math.round(a); // b的值为4

需要注意的是，round()方法的返回值是一个整数，因此会对小数进行取整操作。如果要对小数保留一定的位数，可以使用DecimalFormat类。

字符串（字符串本身是不可修改的）

定义

使用以下语法定义一个字符串变量：

String 变量名 = new String("a string");

这将执行以下步骤：

1. 创建一个 String 对象；
2. 使用 “a string” 初始化该对象；
3. 创建一个变量 s，用于管理该对象；
4. 使变量 s 管理该对象。

String 是一个类，字符串变量是对象的管理者而不是所有者，类似于数组。使用 + 可以连接两个字符串。如果 + 的一侧是字符串，而另一侧不是，则该侧将被转换为字符串，然后再进行连接。

输入

使用以下语法读入一个字符串：

• in.next()：读入一个单词。单词的标志是空格（包括空格、制表符和换行符）。
• in.nextLine()：读入一整行。

字符串排序

1. 将字符串转换为字符数组：

char[] 数组名 = 字符串.toCharArray();

1. 使用选择排序、冒泡排序等算法对数组进行排序。
2. 将排序后的数组重新转换为字符串：

String 字符串 = new String(数组名);

字符串数组

使用以下语法定义一个字符串数组：

String[] 字符串 = new String[长度];

比较两个字符串

1. if (string == "bye") 或 if (string1 == string2)：这样的比较是比较两个变量是否引用同一个字符串对象，而不是比较字符串的内容是否相同。
2. if (string.equals("bye"))：比较字符串 string 与括号内的字符串内容是否相同，判断两个字符串的内容是否相同。

得到字符串的子串

1. s.substring(n) 得到从n号位置到末尾的全部内容
2. s.substring(b,e) 得到从b号位置到e号位置之前的内容(不含e号位)

寻找字符

1. 得到c字符所在位置,-1表示不存在: s.indexOf('c')
2. 从n号位置开始寻找c字符: s.indexOf('c',n)
3. 找到字符串t所在位置: s.indexOf("t")
4. 从右边开始找: s.lastIndexOf('c'), s.lastIndexOf('c',n), s.lastIndexOf("t")

字符串的switch-case

switch(s)
{
        case "this": ……；break；
        case "that": ……；break;
}

比较两个String

1. if(string == "bye") / if(string1 == string2): 这样的比较是比较是否为同一个字符串，两个长相一样的人不是同一个人
2. if(string.equals("bye")): 比较字符串string与括号内字符串内容是否相同，判断是否长得一样

String的排序

1. 先将字符串转换为字符数组: char [] 数组名= 字符串.toCharArray()；
2. 运用选择、冒泡排序法等对数组进行排序
3. 将排序后的数组重新转换为字符串: String 字符串 = new String(数组名)

访问String里的字符

使用 s.charAt(index) 函数，其中：

1. 返回 index 位置上的单个字符
2. 第一个字符的 index 是 0，和数组一样
3. 字符串不能使用 for-each 循环来遍历
4. 索引范围：0 到 s.length() - 1

得到字符串的子串

使用 s.substring(n) 函数，其中：

1. 返回从 n 号位置到末尾的全部内容
2. 使用 s.substring(b, e) 返回从 b 号位置到 e 号位置之前的内容（不含 e 号位）

寻找字符

使用以下函数来寻找字符：

1. 使用 s.indexOf('c') 找到 c 字符所在位置，如果不存在则返回 -1。
2. 使用 s.indexOf('c', n) 从 n 号位置开始寻找 c 字符。
3. 使用 s.indexOf("t") 找到字符串 "t" 所在位置。
4. 使用 s.lastIndexOf('c') 从右边开始找到 c 字符所在位置，s.lastIndexOf('c', n) 从右边开始从第 n 号位置往左查找，s.lastIndexOf("t") 找到字符串 "t" 最后出现的位置。

函数

定义

public static 返回类型 函数名(形参) {
    函数主体
}

函数调用

和C语言相同。

调用时给的值的类型与函数期望类型不符

1. 当函数期望参数类型比调用函数时给的值的类型宽的时候，编译器能悄悄替你把类型转换好。
2. 当函数期望参数类型比调用函数时给的值的类型窄的时候，需要写强制类型转换。
3. 当函数期望参数类型与调用函数时给的值的类型不可相互转换的时候，编译器报错。

本地变量

本地变量的生命周期和作用域都在声明它的花括号内，即块（block）内。

类

类与对象

1.类是一种面向对象编程(OOP)的概念，包含属性和方法(或称为动作)，用来描述某种事物或概念。 2.属于该类的对象具有该类的属性和方法，即可以通过对象来访问类的属性和方法。 3.创建对象的过程称为实例化，使用关键字new，例如：ClassName obj = new ClassName();，其中ClassName为类名，obj为对象名。 4.类是一个模板，对象是基于类创建出来的实例。 5.类定义了对象中所具有的属性，这些属性称作成员变量或实例变量。 6.类中的方法可以访问对象的成员变量，也可以对成员变量进行操作，每个对象都有自己的成员变量。

构造函数

1.与类名字相同的函数为构造函数，在使用new关键字实例化对象时自动调用该函数，用于初始化对象的属性。 2.一个类可以有多个构造函数，只要它们的参数列表不同，这被称为构造函数的重载(overloading)。 3.构造函数没有返回类型，包括void，因为其返回的是新创建的对象的引用。 4.使用this()关键字可以调用同一个类中的其他构造函数，但必须在构造函数内部的第一条语句中使用，例如this(param1, param2)，其中param1和param2为其他构造函数的参数。

类类似于C语言中的结构体，但是它不仅可以包含数据成员，还可以包含成员方法。对象则是使用类模板创建出来的具体实例。

泛型容器类

容器类有两个类型

1. 容器类型，如：ArrayList
2. 元素类型，如：String

功能

1. add(element)：添加元素
2. size()：获取元素数量
3. get(index)：获取指定索引处的元素
4. remove(index)：移除指定索引处的元素

输出容器全部内容

使用 System.out.println(container)，Java 会默认调用容器类中的 toString() 方法来输出容器中的全部元素。

定义 toString() 方法

可以在容器类中定义 toString() 方法，以实现自定义的输出格式。例如：

public String toString() {
    return String.format("%02d:%02d:%02d", hour, minute, second);
}

这里的 hour、minute、second 是容器类中的属性，这个方法返回一个字符串，以表达容器类中的对象按照指定格式输出的结果。

ArrayList 容器

容器的引入

import java.util.ArrayList;

构建一个储存字符串的容器

private ArrayList<String> 名称 = new ArrayList<String>();

注：ArrayList 表示字符串类型的数组列表。

Set 集合容器

集合的引入

import java.util.HashSet;

1. 集合就是数学中的集合的概念，所有的元素都具有唯一的值，元素在其中没有顺序。
2. 没有重复的元素。

构建一个储存字符串的容器

HashSet<String> 名称 = new HashSet<String>();

散列表(Hash)

引入

import java.util.HashMap;

1.所有东西都是以一对值放进去的，一个为key(键)，一个为value(值) 2.取值需要对应的键 3.key的类型不可以是基本类型

构建Hash表

private HashMap<key类型, value类型> 名称 = new HashMap<key类型, value类型>();

填入信息

名称.put(key, value)

得到key对应的value

名称.get(key)

判断是否存在这个key

名称.containsKey(key)

存在即为true不存在即为flase

Hash表中key的数量

名称.keySet().size();

keySet()是Hash表中所有key的集合

用for-each遍历所有的key和value

for(key类型 变量1：Hash表名称.keySet())
{
        value类型 变量2=Hash表名称.get(变量1);
        System.out.println(变量2);
}

异常

关键字

try catch

try {
    // 可能会产生异常的代码
} catch (异常类型 变量e) {
    // 处理异常的代码
}

操作

System.out.println(e.getMessage()); // 输出异常对象里的一个数值
System.out.println(e); // 输出异常类的名字
e.printStackTrace(); // 输出异常在哪发生以及调用轨迹
throw e; // 抛出异常