0x00

本系列-Java集训系列
记录我带领小组进行Java学习，按照《Java核心技术》第十版进行学习

0x01

从第三章开始内容变多，每次基本就一章

第三章

HelloWorld.java

//HelloWorld类，注意大小写，类名与文件名一致
public class HelloWorld {
    //main方法，作为程序入口，格式基本固定，void是方法的返回类型，这里void是没有返回的意思
    public static void main(String[] args)
    {
        //向控制台输出的方法，调用，传参Hello World ，运行程序将输出 Hello World
        System.out.println("Hello World");
        //单行注释，只能注释掉这一行的

        /*
          多行注释，可以在里面随便写，注意不能在这里嵌套另一个多行注释
        */

        /**
         *这也是注释，用于文档的注释，IDE中可以自动生成
         */
    }
}

先从第一个HelloWorld程序开始

Java区分大小写
文件名和类名一致，一般一个.java文件里只有一个类，如果有多个类，其他的类可以不需要与文件名同名（类名不可以重复），并且不能用public修饰类
类名的命名规则：名字必须以字母开头，后面可以跟字母和数字的任意组合，经测试可以使用下划线，名字长度无限制，不能使用Java保留字
如果需要运行，则需要一个main方法，此方法为程序的入口点
类、方法、属性，都是有访问控制符，有public、protected、private三种，后续章节会详细介绍
{}里的是代码段，Java中的任何方法的代码都要用"{“开始，用”}"结束，类也是如此
main里的代码作用是在控制台进行输出，调用的println方法，此方法位于System.out对象，调用对象的方法用.，方法可以传参，也可以不传参，但是一定要由()，里面的"Hello World"就是传进去的参数，如果是多个参数，就用,分隔，比如(“Hello”,“World”)
双斜线//后面的是注释，//后面的都会被忽略，Java一共由三种注释，//、/* /、/* */，都在代码中可以看到用法

规则讲完，以下是运行此代码的方法：

首先进入命令行</>，进入java文件所在的目录（注：命令行在Windows下进入方式:win+r，输入cmd，点击确认；进入java文件所在目录：cd xxxx，xxxx是java文件所在的目录，注意中间有个空格）

输入命令javac HelloWorld.java，运行，会在本文件夹下生成一个HelloWOrld.class文件，如果报错请查看jdk安装是否正确，java文件是否正确

输入命令java HelloWorld，运行，会看到输出结果，注意这里是HelloWorld，而不是HelloWorld.class

DataType.java

public class DataType { public static void main(String[] args) { // 整型，分四种，分别为 int 、 short 、 long 、 byte // int，整型，占4个字节，取值范围：-2,147,483,648 +2,147,483,647 int intPrice0; intPrice0 = 2147483647; int intPrice1 = -2_147_483_648; // short，整型，占2个字节，取值范围：-32 768 +32 767 short shortPrice0; shortPrice0 = 32767; short shortPrice1 = -32_768; // long，整型，占8个字节，取值范围：-9 223 372 036 854 775 808 +9 223 372 036 854 775 807 long longPrice0; longPrice0 = 9223372036854775807L; // 注意，必须在数字后面加一个字母L或小写l，不然会被识别为int类型 long longPrice1 = -9_223_372_036_854_775_808l; // byte，整型，占1个字节，取值范围：-128 +127 byte bytePrice0; bytePrice0 = 127; byte bytePrice1 = -128; // 还可以使用二进制、八进制、十六进制赋值 int intPrice2 = 0b1001; // 二进制赋值，可以使用0b或者0B前缀来表示 System.out.print("intPrice2="); System.out.println(intPrice2); // 输出：9 int intPrice3 = 010; // 八进制赋值，以0开头，容易混淆，谨慎使用 System.out.print("intPrice3="); System.out.println(intPrice3); // 输出：8 int intPrice4 = 0xCAEF; // 十六进制赋值，可以使用0x或者0X前缀来表示 System.out.print("intPrice4="); System.out.println(intPrice4); // 输出：51951 // 浮点类型，两种，float 、 double // float，浮点数，占4个字节，取值范围大约 -3.402 823 47 * 10的38次方 +3.402 823 47 * 10的38次方用科学计数法表示为大约正负 3.402 823 47E38F float floatPrice0; floatPrice0 = 3.14F; // 注意，必须在数字后面加F或f，不然会被识别为double float floatPrice1 = -3.14f; // double,浮点数，占8个字节，取值范围大约 -1.797 693 134 862 315 70 * 10的308次方 +1.797 693 134 862 315 70 * 10的308次方用科学计数法表示为大约正负 1.797 693 134 862 315 70E308 double doublePrice0; doublePrice0 = 3.14; // double可以不加后缀，也可以在数字后面加D或d double doublePrice1 = -3.14D; // 浮点数有三个特殊的浮点数值，正无穷大、负无穷大、NAN（不是一个数字） // 例子 double doublePrice2 = 33/0.0; // 注意除数不能写成0，会报错 System.out.print("（正无穷）doublePrice2 = "); System.out.println(doublePrice2); // 输出：Infinity double doublePrice3 = (-33)/0.0; // 注意除数不能写成0，会报错 System.out.print("（负无穷）doublePrice3 = "); System.out.println(doublePrice3); // 输出：-Infinity double doublePrice4 = 0/0.0; // 注意除数不能写成0，会报错 System.out.print("（NaN）doublePrice4 = "); System.out.println(doublePrice4); // 输出：NaN // 如果需要判断是否是特殊数值，请用方法来判断 System.out.println("doublePrice4 is NaN ? " + Double.isNaN(doublePrice4)); // 如果用 == 来判断，会出现错误的结果 System.out.println("(Mistake)doublePrice4 is NaN ？" + (doublePrice4 == Double.NaN)); // 判断永远为false，与书上写的不一致，以实践结果为准 // char类型 char charTest0 = 'A'; System.out.println("charTest0 is "+ charTest0); char charTest1 = '\u03C0'; System.out.println("charTest1 is " + charTest1); // 注：char类型应用场景很少，正常建议使用String类型 // boolean类型 boolean booleanValue0 = true; boolean booleanValue1 = false; // 注，boolean只有这两个值，表示真和假 // 变量与常量 // 上面广泛使用的就是变量的定义 int i; // 声明变量i为int类型 i = 1; // 将i赋值为1 int a = 2; // 也可以在声明的同时直接初始化为某个值 int j,k,n,m; // 也可以同时声明多个变量，用逗号，分隔 final int CONT_INT_PRICE = 30; // 常量用final 修饰，惯例是变量名大写，便于与变量区分 // CONT_INT_PRICE = 23; // 对常量的值进行修改会报错 final int CONT_INT_PP; CONT_INT_PP = 25; // 可以先声明，再赋值 // CONT_INT_PP = 55; // 赋值过之后再更改就会报错，即如果声明的同时没有初始化，第一次赋值的时候是合法的，第二次修改就会报错 } }

Java共有8种基本类型，包括：4种整型（int,short,long,byte）、2种浮点类型（float,double）、1种char类型（char）、1种boolean类型（boolean）

String不属于基本类型

数据类型和变量常量的规则详见代码注释

Operator.java

public class Operator { public static void main(String[] args) { // 基本算术运算符 +、-、*、/ 即，加减乘除，以及求余 % // 按照书里说，由于Java的跨平台性，会保证在所有机器上运算结果一致 int a = 5; int b = 2; System.out.println("5 + 2 = " + (a + b) ); System.out.println("5 - 2 = " + (a - b)); System.out.println("5 * 2 = " + (a * b)); System.out.println("5 / 2 = " + (a / b) ); System.out.println("5 % 2 = " + (a % b)); // 一个数学运算库Math类 double x = 4; double y = Math.sqrt(x); // 计算x的平方根，赋给y System.out.println(y); // 输出：2.0 double y2 = Math.pow(x, 3); // 计算x的3次幂，赋给y2 System.out.println(y2); // 输出：64.0 // Math类还有好多方法，就不一一列举了，具体的可以参考Java手册 } }

四则运算这些没什么好说的，看代码就好。

TypeConversion.java

public class TypeConversion { public static void main(String[] args) { // 隐式类型转换，从int转float可能会丢失精度，即如果int的位数比float能表示的位数大，则会丢失精度 int n = 123456789; float f = n; System.out.println(f); // 输出：1.23456792E8 // 不同数值类型间进行四则运算会先进行转换，将其中的一个类型转成另一个类型，再进行计算 // 转换优先级为 double->float->long->int，即如果其中有一个double类型，则另一个数字转成double再进行计算，之所以是这种优先级，是因为从位数少的类型转到类型高的类型不会丢失精度 System.out.println(n+f); // 输出：2.46913584E8 // 强制类型转换 // 从double到int会进行截断，直接从小数位截，不会进行四舍五入 double x = 9.997; int nx = (int)x; System.out.println(nx); // 输出：9 // 进行舍入操作要用Math的方法 int nx2 = (int)Math.round(x); // 由于round返回类型是long，所以此处需要强制类型转换 System.out.println(nx2); // 输出：10 } }

关于两个不同类型进行四则运算

如果两个操作数中有一个是double类型，另一个操作数就会转换为double类型

否则，如果其中一个操作数是float类型，另一个操作数将会转换为float类型

否则，如果其中一个操作数是long类型，另一个操作数将会转换为long类型

否则，两个操作数都将被转换为int类型

关于数值类型之间的合法转换

byte -> short

short -> int

char -> int

int -> long

int -> double

float -> double

int ~> float (此符号表示会丢失精度)

long ~> float

long ~> double

如果转换前的类型比转换后的类型大很多，就会造成转换之后的数字和转换之前的完全不同，比如(byte)300 = 44，以二进制进行截断，而不是以十进制进行截断

Operator2.java

public class Operator2 { public static void main(String[] args) { // 赋值与运算符结合，得到简略形式 int x = 1; x += 4; // += 运算符表达的意义为 x = x + 4 // x = x + 4; // 即上面的完整形式 // 更多的类似运算符 += 、 -= 、 *= 、/= 、 %= x /= 4; // 自增自减运算符 x++; // 即 x = x + 1; x--; // 即 x = x - 1; // 比较运算符 boolean b_1 = (3 == 7); // == 用来检测两个数字、变量或对象的相等性，返回boolean值，注意：用 == 来判断两个对象只会判断是否是同一对象 boolean b_2 = (3 != 7); // != 用来检测不等性，正好与上面相反，用法一样 // 其他通常用于比较数值的还有大于 > 、小于 < 、大于等于 >= 、小于等于 <= // 举个栗子 boolean b_3 = (3 <= 7); // 逻辑运算符与或非 && || ! // 其中与、或是需要两个返回值为boolean的表达式，非只需要一个 boolean b_4 = (x != 0) && (x > 0); // 与逻辑运算符，当两个表达式的结果都为true（真）的时候，b_4 为 true，其余情况为false。此值为真 boolean b_5 = (x == 0) || (x < 0); // 或逻辑运算符，当两个表达式结果都为false（假）的时候，b_5为false，其余情况为true，此值为假 // && 与 || 都存在短路操作，即，如果在获得符号前面部分表达式的结果，就能得到整个表达式的结果，将不会运行符号后面的表达式 // 栗子： (x == 0) && (x > 0) ;由于&&符号的特性，在(x == 0)为假的情况下，整个表达式返回结果必然为假，所以后面的( x > 0)不会运行（注意是不会运行） // 再来个栗子： (x != 0) || (x < 0) ;由于||符号的特性，再(x != 0)为真的情况下，整个表达式返回结果必然为假，所以后面的(x < 0)不会运行 boolean b_6 = !(x == 0); // 非逻辑运算符，当表达式为真，返回结果为假，当表达式结果为假，返回结果为真，即将表达式的boolean值反转一下 // 三元操作符 ?: String result = (x != 0)? "aaa" :"bbb"; // 问号之前的表达式必须返回值为boolean，然后如果为true，则执行问号和冒号中间的语句，如果为false，则执行冒号后面的语句 System.out.println(result); // 输出：aaa // (x != 0)?System.out.println("aaa"):System.out.println("bbb"); // 注：上面注释里这句会被识别成错误，编译不通过，要将整个三元表达式赋值给一个变量，不清楚是不是由于IDE // 位运算符& | ^ ~ ，位与位或位异或位非 // 与逻辑运算符差不多，不过是针对位来进行的运算，多了个异或，异或是在两个条件同时为真或同时为假的时候，结果为假，不同时为真 byte n = 127; int fourthBitFromRight = (n & 0b1000); // 0b1111 & 0b1000 = 0b1000; 换算成10进制为8 System.out.println(fourthBitFromRight); // 输出：8 // 左移 << 右移 >> 以0填充的右移 >>> int intUse0 = 8; // 0b 0000 0000 0000 0000 0000 0000 0000 1000 int intUse1 = (intUse0 >> 2); // 0b 0000 0000 0000 0000 0000 0000 0000 0010 ,所有位向右移2位，左侧以符号位填充，正数的符号位为0，所以填充0 System.out.print("intUse0 的二进制："); System.out.println(Integer.toBinaryString(intUse0)); // 输出：1000 System.out.print("intUse1 的二进制："); System.out.println(Integer.toBinaryString(intUse1)); // 输出：10 // 注，负数采用补码方式，所以负数是反着来的 int intUse2 = -128; // 0b 1111 1111 1111 1111 1111 1111 1000 0000 注意，左边的第一位是符号位，负数为1，正数为0 int intUse3 = (intUse2 >> 3); // 0b 1111 1111 1111 1111 1111 1111 1111 0000 整体向右移三位，并且以符号位填充 System.out.print("intUse2 的二进制："); System.out.println(Integer.toBinaryString(intUse2)); // 输出：11111111111111111111111110000000 System.out.print("intUse3 的二进制："); System.out.println(Integer.toBinaryString(intUse3)); // 输出：11111111111111111111111111110000 int intUse4 = (intUse2 >>> 3); //0b 0001 1111 1111 1111 1111 1111 1111 0000 整体向右移三位，符号位以0填充 System.out.println(intUse4); System.out.print("intUse4 的二进制："); System.out.println(Integer.toBinaryString(intUse4)); // 输出：11111111111111111111111110000 // 运算符的优先级，这里只举个栗子，具体的看《运算符优先级》表，平常就使用（）就好，一般不要依赖优先级，首先不容易调试，其次看起来也很乱 int a1, b1, c1; a1 = 3; b1 = 5; c1 = 7; a1 += b1 += c1; // 因为同属同一个操作符，并且此操作符是从右向左，所以先计算 b1+=c1 ，在计算 a1 += ((b1+=c1)的结果) // a1 += (b1 += c1); // 与上面等价 int result1 = a1 + b1 - c1; // 因为+ 和 - 同级，并且与数学运算顺序一样，从左至右 // int result1 = (a1 + b1) - c1; // 与上面等价 // 其他不一一举例，有需要看请看书里相关章节的表 } }

关于负数介绍点击这里，剩下的看代码

Strings.java

import java.io.IOException; import java.io.PrintWriter; import java.nio.file.Paths; import java.util.*; public class Strings { public static void main(String[] args) throws IOException { // 字符串，就是由字符组成的串（貌似废话-。-） String e = ""; // 定义了一个空字符串，定义方式与其他变量一样，不在赘述。这里注意S一定要大写 String greeting = "HelloWorld"; // 字串操作 String s = greeting.substring(0, 3); // 从greeting中提取字符串，然后赋给新的变量，两个参数分别表示，从哪个位置开始（从0开始，大部分编程语言的默认索引都是从0开始）、到哪个位置结束（不包含当前数字位置） System.out.println(s); // 输出：Hel // 拼接 String expletive = "Expletive"; String PG13 = "deleted"; String message = expletive + PG13; // 直接使用加号，将两个字符串拼接起来，赋值给message System.out.println("message = " + message); // 输出：message = Expletivedeleted int age = 13; String rating = "PG" + age; // 可以用其他类型与字符串进行拼接，int将转换成String，任何一个对象都可以转换成字符串，后续有详细讲解 System.out.println("rating = " + rating); // 输出：rating = PG13 String all = String.join(" /" , "S", "M", "L", "XL"); // 如果拼接的太多，可以考虑用String.join方法，第一个参数是拼接符，将后面N个参数（字符串）拼接起来，变成一个字符串 System.out.println("all = " + all); // 输出：all = S /M /L /XL // 这里有个概念，叫不可变字符串，即字符串是不可修改的 greeting = "test"; // 这里的含义是，将greeting变量重新赋值成test，即在内存中重新创建一个test的字符串，然后将greeting指向test，原来的HelloWorld还在原来的内存位置，并没有被修改 // 由于指向 HelloWorld 的变量名没有了，所以并不能再使用，不过不用担心，java 的 GC 会对这种内存进行回收，不用担心占用太多内存 // 比较两个字符串是否相同 System.out.println("test".equals(greeting)); // 前面可以是变量，也可以是现写的字符串，同理，参数也可以是字符串，也可以是变量 System.out.println(greeting.equalsIgnoreCase("TEST")); // 忽略大小写的比较 System.out.println(greeting == "test"); // ！！！不要使用 == 来比较两个字符串是否相等，因为这不可靠，由于Java的机制， == 比较的是两个字符串是否是同一个，而不是他们是否相等，由于Java会共享相同常量，所以这两个test实际是再同一个内存位置 // 空串和 null if (e.length() == 0) // 使用字符串的长度来判断 { System.out.println("e is empty String"); } if (e.equals("")) // 也可以用方法来判断 { System.out.println("e allways is empty String"); } String str = null; if (str == null) // 用== 来判断是否是null，null与""不一样，注意需要使用的时候两个都需要判断 { System.out.println("str is null"); } // 码点与代码单元 int n = greeting.length(); // 通过length()获得代码单元数量 System.out.println(n); // 输出：4 int cpCount = greeting.codePointCount(0, greeting.length()); // 通过.codePointCount()获取码点数量，第一个参数是从哪个位置开始 System.out.println(cpCount); // 输出：4 由于这里都是字母，所以与代码单元数量相同 char first = greeting.charAt(0); // 通过.charAt()获取第N个位置的代码单元 // 通过以下代码获取第i个码点 int i = 2; int index = greeting.offsetByCodePoints(0, i); int cp = greeting.codePointAt(index); // 关于码点操作和其他StringAPI就不多演示，很多API还是很有用处的，建议多看看，最起码熟悉可以使用API做到什么操作，这样以后需要用到的时候进行查手册 // StringBuilder 这个用的比较多，这是String可修改的版本 StringBuilder builder = new StringBuilder(); // 这里使用了new操作符，再后续会详细讲，这里知道必须这样用就好 builder.append("abc"); // 上面创建完StringBuilder对象之后，使用builder调用方法向对象里添加字符 builder.append("def"); System.out.println(builder); // 输出：abcdef String completedString = builder.toString(); // 也可以调用.toString()方法转成String // 输入输出，到现在运行程序都是直接输出，然后程序就停止了，现在可以从控制台里读取用户的输入 Scanner in = new Scanner(System.in); // 注意这个不是Java标准库的里，所以需要导入，请注意文件顶部多的代码，这一行是new 对象 System.out.print("what is your name? "); // 给与提示 String name = in.nextLine(); // 从控制台等待用户输入，换行结束等待，然后将用户输入的字符串保存到name里 System.out.println("Hello " + name); String firstName = in.next(); // 也是从控制台等待输入，区别就是上面的可以保存一整行，这个方法只能保存住空格之前或者换行之前的 System.out.println(firstName); // 比如如果输入 sing ll aa bb ，那么firstName 里只会存下sing System.out.print("How old are you"); int age1 = in.nextInt(); // 只读取int，读取浮点数用in.nextDouble() System.out.println("your age is " + age1); // 格式化输出 double x = 1000.0/3.0; System.out.println(x); System.out.printf("%8.2f", x); // 使用printf方法进行格式化输出，表示小数点前方有8个字符宽度，小数点后2个字符，输出： 333.33 System.out.println(); // 增加一个空格以分开上下两个输出的显示 System.out.printf("%,.2f", 10000.0/3.0); // 注意使用,号分隔，便于看数字位数输出：3,333.33 // 格式化输出异常强大，可以有N多组合格式，没有办法都列出来，所以请看书和文档来进行组合输出 // 文件输入和输出 Scanner in1 = new Scanner(Paths.get("myfile.txt"), "UTF-8"); // 注意：这里需要再main附近添加抛异常的关键词，还需要导入包，请见文件头部 // 将读取文件，将内容放到in中 PrintWriter out = new PrintWriter("myfileout.txt","UTF-8"); // 注意：这也需要引入类库 out.print("test out"); // 向文件中写入内容 // 注：这里没有写路径，就是再当前路径下找文件，除了这种相对路径的方式，也可以使用绝对路径，比如C:\\mydirectory\\myfile.txt // 注意这里的\ 使用了两个，/ 则不用 } }

由于API众多，这里只讲怎么用，就不繁琐的每个都列以下怎么用，用到的时候查询官方手册，总是一个好办法

ControlProcess.java

public class ControlProcess { public static void main(String[] args) { // 块作用域 int n = 1; { int i = n + 2; // 在子块中可以使用父块的变量 // int n = 2; // 不可以在子块中定义同名变量，会冲突 } // 但是在子块结束后，这里不可以使用子块里定义的变量 // int a = i + 1; // 这是不合法的，会报错，提示没有定义i // 条件语句 if(n == 1) { System.out.println("n == 1 ,会看到我"); // 根据if后面的判断条件，如果为真则执行这个代码块里的代码 } // 如果为假，则跳过上面代码块，继续执行下面的语句 if (n != 1) { System.out.println("跳过这条语句"); }else { System.out.println("这个代码块会被执行"); // 可以使用if else 来执行，else表示除了上面为真的情况，执行这个代码块 } if (n == 4) { System.out.println("n 是4"); } else if (n == 2) { System.out.println("n 是2"); } else if (n == 1) { System.out.println("猜对了"); }else if(n == 1){ System.out.println("但是不会再看到我了"); } else { System.out.println("上面都没捕获的就交给我处理"); } // 可以通过else if语句来依次来判断里面的语句是否为真，判断为真则执行代码块里的代码，然后忽略之后所有的else if 和else // 循环 int i = 0; while(n == 1) // 当（）中的为真则执行下面的代码块，再执行一遍之后，再回到这个（），继续判断，为真则继续执行，如此循环，如果（）首次为false，则直接跳过代码块，连一次都不会执行 { System.out.println(n); // 下面的是为了跳出循环，不然程序会一直执行，直到手动停止 i++; if (i > 10){ break; // 用来终止循环，当1 大于10 的时候，终止，终止循环之后继续沿着代码块之后的代码执行 } } do { System.out.println("不论判断的结果是什么，我都会先输出一次，之后就和上面的while没区别了"); }while(n==2); for (int a = 0; a >10; a ++) // 这是一个带条件的while，自带三段式，第一个是初始化一个变量，第二个是终止条件（当a>10的时候终止循环）,第三个是每次先执行的一段代码，一般用来对变量进行增量，比如i++,或者减量i--，当然也可以加任意数，比如i+3 { System.out.println(a); // 代码块里可以放任意代码，这点再前面的代码块也一样，比如这里可以嵌套if else，也可以嵌套while和for } // 多重选择 switch(n) // n来和每个case后面的进行比较，如果相同则执行下面的代码 { case 1: // case标签可以是char、byte、short、int、枚举常量、字符串字面量 System.out.println("n 是 1 ，执行这里"); break; // 这里的break是不必须的，但是如果不加，会从这里继续执行，而不是跳出这个switch case 2: System.out.println("如果不是上面的break，你就能看到我了"); break; case 3: System.out.println("我要在上面两个break都没有的情况下才能看到"); break; default: System.out.println("如果上面都匹配不上，执行我就对了"); break; // 这个加与不加没区别，为了格式整齐就加上吧 } // 中断控制流程语句 // break 在上面已经简单介绍了，其实就是忽略下面的语句，从循环开始的地方继续执行，这里注意，如果是多层嵌套循环，则从本层的循环头开始执行 // 如果想跳的更远，可以增加标签，直接跳到标签上 /* 这块代码在我这里不显示，后续看是什么情况 zero: // 标签用: 冒号来结尾 for (int a1 = 0; a1 > 20 ; a1++) { System.out.println(a1); for (int a2 = 0; a2 >20; a2 ++) { if(a2 == 10){ break zero; // 到10 就不输出了 } System.out.println(a2); } } */ // continue与break一样，也是跳过剩下的代码 } }

分为if，if else ，if else if else，while，for，switch，这些控制流程，都是很简单的结构，看看代码就知道了

BigNumber.java

import java.math.BigInteger; public class BigNumber { public static void main(String[] args) { // 大数值 BigInteger a = BigInteger.valueOf(100); // 可以通过valueOf() 来进行转换 BigInteger b = BigInteger.valueOf(200); BigInteger c = a.add(b); // 运算的话必须通过这种调用方法的形式，而不可以用四则运算符，并且参数必须是大数值格式，不能是int等，这是进行a+b BigInteger d = c.multiply(b.add(BigInteger.valueOf(2))); // d = c * (b+2) // 解锁更多方法请看手册和书，不是需要很精准的地方一般用不到 } }

略

Arrayst.java

import java.util.*; public class Arrayst { public static void main(String[] args) { // 数组 int[] a; // 声明int型数组 a，这里也可以写成 int a[]; 数组里必须存放int型 a = new int[100]; // 初始化数组，必须在用之前就确定数组是多少个元素，在后面int[]里存放的数组一共有多少个元素 int[] b = new int[200]; // 也可以直接初始化 // 初始化的时候，int数组在没赋值的情况下，每个元素都是0，boolean数组是false，对象数组是null a[10] = 100; // 可以通过下标来对单个进行赋值 System.out.println(a[10]); //可以直接按下标来取，注意下标是从0开始，即a[0]是第一个元素，以此类推，a[100-1]即是最后一个元素，a[n-1] n为数组元素个数 for (int i = 0; i < 100; i ++) // 常见的用法是用循环进行赋值 { a[i] = i; } for (int i = 0; i < 100 ; i ++) { System.out.println(a[i]);// 通过循环来遍历输出数组各个元素 } for(int a3 : a) // foreach 是系统自带的简单的for实现，语法是for(变量：数组) 这样就不用自己设置循环次数，foreach会保证每个元素循环到 { System.out.println(a3); } // 数组拷贝 int[] lockyNumbers = a; a[0] = 123; System.out.println(lockyNumbers[0]);// 注意，这里两个数组使用的是同一组数据，改一个另一个也会变,输出：123 lockyNumbers = Arrays.copyOf(a, a.length); // 如果希望各自维护一套元素，则使用copyOf来进行拷贝 a[1] = 234; System.out.println(lockyNumbers[1]);// 输出：1 // main方法的参数args就是一个数组，从命令行进行读取参数，放到args里 // 如果运行 java Arrayst.java test aaa bbb // 则args[0] = "test"，args[1] = "aaa" ，args[2] = "bbb" // 数组排序 Arrays.sort(a); // 对数组进行了排序 // 多维数组 int[][] magicSquare = { {16, 3, 2, 13}, {5, 10, 11, 8}, {9, 6, 7, 12}, {4, 15, 14, 1} }; // 多维数组的初始化，一维数组也可以直接初始化，注意用{}来进行初始化 for (int i = 0; i < magicSquare.length;i++) // 多维数组的遍历方式，即循环嵌套循环 { for (int j =0; j < magicSquare[i].length; j++) { System.out.println(magicSquare[i][j]); } } // 二维数组的第二维不是必须长度相同，可以每个都不同，利用循环初始化 } }

String[] str 就是字符串数组，里面没有写，但是应该清楚

Java Java

本博客所有文章除特别声明外，均采用 CC BY-SA 3.0协议。转载请注明出处！