新人学Java很难吗？---好好和我学
（1）初识Java程序前言就国内来说，Java毫无疑问是后端语言中的No.1没有之一，所以今天我们也来0基础学习Java！！！Java的好处(针对测试工程师)
[*]面试加分->涨薪
[*]大多数公司服务端用的都是Java，学习之后能看懂后台逻辑，方便快速定位问题
[*]在如此卷的环境下，不得不去跟着一起卷(躺平不香吗？学什么Java)
[*]Java生态两个字"完美"，前辈们坑都采完了，库也帮你写好了
操作环境配置环境这里就不展开讲述了，简单说一下
[*]操作系统：macOS
[*]Java版本：jdk1.8.0_333
[*]开发工具：IntelliJ IDEA
简单的Java应用程序环境配置完成后，废话不多说，直接上代码public class FirstSample {
public static void main(String[] args){
System.out.println("Hello, World!");
}
}疑问？
[*]这段代码什么意思？为什么这么写？
[*]程序的执行结果是什么？
答
[*]public是访问修饰符，用于控制程序的其他部分对这段代码的访问级别
[*]class表名Java程序中的全部内容都包含在类中（类就是1个容器，程序逻辑定义了应用程序的行为）
[*]类名必须以字母开头，后面可以跟字母和数字的任意组合，长度无限制，但不能使用Java保留字
public class FirstSample 就解释完了，定义了一个类FirstSample，在类中我们必须指定一个main方法，Java虚拟机总是从指定类的main方法开始执行
static：代表静态方法
void：无返回值
main: 主函数，程序的执行入口
string[] args:表明main方法将接收一个字符串数组，也就是命令行上的参数
接下来研究这句代码{
System.out.println("Hello, World！");
}注意
[*]Java中每个句子必须用分号结束。
[*]字符串必须使用双引号，单引号会报错
其次这里我们使用System.out对象并调用了它的printIn方法并传递给它一个字符串参数。这个方法将传递给它的字符串参数显示在控制台上。然后终止这个输出行。
虽然是第一天学习Java，但是我们也可以试着看一下printIn方法的源码 /**
* Prints a String and then terminate the line.This method behaves as
* though it invokes <code>{@link #print(String)}</code> and then
* <code>{@link #println()}</code>.
*
* @param xThe <code>String</code> to be printed.
*/
public void println(String x) {
synchronized (this) {
print(x);
newLine();
}
}可以看到里面使用了2个方法print和newLine
[*]print方法是打印字符串，并且不会在输出之后增加换行符
[*]newline方法是换行的作用
接下来测试一下程序的执行结果，我们在IntelliJ中在空白处点击右键选择Run，输出结果如下上面说道print方法是不换行，我们来测试下public class FirstSample {
public static void main(String[] args){
System.out.print("abc");
System.out.println("Hello, World!");
}
}输出结果如下；可以看到abc后面紧跟着Hello，World，说明print方法确实是不换行
注释Java中注释有3种
[*]最常用的是//
[*]/*和*/注释一个段落
[*]以/**开始，以*/结束，这种注释用来自动生成文档，这个后面再讲
本文链接：https://www.cnblogs.com/jiakecong/p/16405252.html 零基础学Java（2）数据类型与变量
前言java是一种强类型语言。这就意味着必须为每一个变量声明一种类型。在Java中，一共8种基本类型，其中有4种整型、2种浮点型、1种字符串类型char(用于表示Unicode编码的代码单元)和1种用于表示真值的boolean类型。注释
Java有一个能够表示任意精度的算术包，通常称为"大数"(big number)，它不是一种基本Java类型，而是一个Java对象。 数据类型 整型Java提供了4种整型，如下表格通常情况下，int类型最常用，long类型可以忽略，byte和short类型主要用于特定的应用场合，例如，底层的文件处理或者存储空间很宝贵的大数组。
浮点类型浮点类型用于表示有小数部分的数值。在Java中有两种浮点类型如下double表示双精度浮点型，数值精度是float两倍。在很多情况下，float类型的精度并不能满足需求。实际上，只有很少的情况适合使用float类型，例如，需要单精度数的库，或者需要存储大量数据时。
float类型的数值有一个后缀F或f(例如3.14F)。没有后缀F的浮点数值(如3.14)总是默认为double类型。当然，也可以浮点数值后面添加后缀D或者d(例如3.14D)double x1 = 3.14D;// 双精度
double x2 = 3.14;// 双精度
float y = 3.14F;// 单精度有三个特殊的浮点数
[*]Double.POSITIVE_INFINITY：正无穷大
[*]Double.NEGATIVE_INFINITY：负无穷大
[*]Double.NaN：不是一个数字
char类型char类型原本用于表示单个字符。如今，有些Unicode字符可以用一个char值描述，另外一些Unicode字符则需要两个char值。
char类型的字面量值要用单引号括起来。例如：'A'是编码值为65的字符常量。它与"A"不同，"A"是包含一个字符A的字符串。char类型的值可以表示为十六进制值
boolean类型boolean类型有两个值：false和true，用来判断逻辑条件。整型值和布尔值之间不能进行相互转换。
注释
在C++中，数值甚至指针可以代替boolean值。值0相当于布尔值false，非0值相当于布尔值true。在Java中则不是这样。因此，Java程序员不会遇到下述麻烦：if(x = 0) 在C++中这个测试可以编译运行，其结果总是false。而在Java中，这个测试将不能通过编译，其原因是整数表达式x=0不能转换为布尔值。
变量与常量
声明变量在Java中，每个变量都有一个类型(type)。在声明变量时，先指定变量的类型，然后是变量名，示例如下：double salary;
int vacationDays;
long earthPopulation;
boolean done;注意点
[*]变量名必须是一个字母开头并由字母或数字构成的序列。
[*]变量名大小写敏感
[*]+这样的符号不能出现在变量名中，空格也不行
[*]不能使用Java保留字作为变量名
变量初始化声明一个变量之后，必须用赋值语句对变量进行显式初始化，千万不要使用未初始化的变量的值。例如，Java编译器认为下面的语句序列是错误的：报错原因如下：所以声明变量格式如下：String student = "jkc";注意：在Java中，变量的声明尽可能地靠近变量第一次使用的地方
常量在Java中，利用关键字final指示常量。例如：public class FirstSample {
public static void main(String[] args) {
final double CM_PER_INCH = 2.54;
}
}关键字final表示这个变量只能被赋值1次。一旦被赋值之后，就不能修改了。习惯上，常量名使用全大写。我们可以看到当我们要修改常量时，就会报错，原因如下：在Java中，经常希望某个常量可以在一个类的多个方法中使用，通常将这些常量称为类常量。可以使用关键字static final设置一个类常量。public class FirstSample {
public static final double CM_PER_INCH = 2.54;
public static void main(String[] args) {
System.out.println(CM_PER_INCH);
}
}需要注意，类常量的定义位于main方法的外部。因此，在同一个类的其他方法中也可以使用这个常量。而且，如果一个常量被声明为public，那么其他类的方法也可以使用这个常量。public class FirstSample {
public static final double CM_PER_INCH = 2.54;
public static void main(String[] args) {
System.out.println(CM_PER_INCH);
FirstSample.write();
}
public static void write() {
// 在write方法中依然可以使用类变量，因为都是FirstSample这个类中的方法
System.out.println(CM_PER_INCH);
}
}枚举类型有时候，变量的取值只在一个有限的集合内。例如，销售的服装或比萨只有小、中、大这三种尺寸。当然，可以将这些尺寸分别编码为1、2、3。但这种设置很容易出错。很可能在变量中保存的是一个错误的值(比如0)。
针对这种情况，可以自定义枚举类型。例如：enum Size { SMALL, MEDIUM, LARGE };现在，可以声明这种类型的变量：Size s = Size.MEDUIM;Size类型的变量只能存储这个类型声明中给定的某个枚举值，或者特殊值null，null表示这个变量没有设置任何值。
零基础学Java（3）运算符
运算符运算符用于连接值。Java提供了一组丰富的算术和逻辑运算符以及数学函数。
算术运算符在Java中，使用算术运算符+、-、*、/表示加、减、乘、除运算。当参与/运算的两个操作数都是整数时，表示整数除法；否则，表示浮点除法。整数的求余操作用%表示。例如，15/2=7，15%2=1，15.0/2=7.5
需要注意，整数被0除将虎产生一个异常，而浮点数被0除将会得到无穷大或NaN结果。
数学函数与常量在Math类中，包含了各种各样的数学函数。在编写不同类别的程序时，可能需要的函数也不同。要想计算一个数值的平方根，可以是一个sqrt方法public class FirstSample {
public static void main(String[] args) {
double x = 4;
double y = Math.sqrt(x);
System.out.println(y);// 打印结果2.0
}
}在Java中，没有幂运算，因此需要借助于Math类的pow方法double y = Math.pow(x, a)将y的值设置为x的a次幂。pow方法有两个double类型的参数，其返回结果也为double类型
数值类型之间的转换我们经常需要将一种数值类型转换为另一种数值类型。下图给出了数值类型之间的合法转换图中有6个实现箭头，表示无信息丢失的转换；另外有3个虚线箭头，表示可能有精度损失的转换。例如，123456789是一个大整数，它所包含的位数比float类型所能够表示的位数多。当将这个整数转换为float类型时，将会得到正确的大小，但是会损失一些精度。public class FirstSample {
public static void main(String[] args) {
int n = 123456789;
float f = n;
System.out.println(f);
}
}输出结果1.23456792E8当用一个二元运算符连接两个值时(例如n+f，n是整数，f是浮点数)，先要将两个操作数转换为同一种类型，然后再进行计算。
[*]如果两个操作数中有一个是double类型，另一个操作数就会转换为double类型。
[*]否则，如果其中一个操作数是float类型，另一个操作数将会转换为float类型。
[*]否则，如果其中一个操作数是long类型，另一个操作数将转换为long类型。
[*]否则，两个操作数都将被转换为int类型
强制类型转换在Java中，允许进行这种数值之间的类型转换，当然，有可能会丢失一些信息。这种可能损失信息的转换要通过强制类型转换来完成。强制类型转换的语法格式是在圆括号中给出想要转换的目标类型，后面紧跟待转换的变量名。例如：double x = 8.997;
int nx = (int) x;这样，变量nx的值为8，因为强制类型转换通过截断小数部分将浮点值转换为整型。
如果想对浮点数进行舍入运算，以便得到最接近的整数(在很多情况下，这种操作更有用)，那就需要使用Math.round方法：double x = 8.997;
int nx = (int) Math.round(x);现在，变量nx的值为10。当调用round的时候，仍然需要使用强制类型转换(int)。其原因是round方法返回的结果为long类型，由于存在信息丢失的可能性，所以只有使用显式的强制类型转换才能够将long类型转换成int类型。
结合赋值和运算符可以在赋值中使用二元运算符，这是一种很方便的简写形式。例如x += 4;等价于：x = x + 4;自增与自减运算符程序员都知道加1，减1是数值变量最常见的操作。在Java中也有：n++将变量n的当前值加1，n--则将n的值减1.++在前会先完成加1；++在后会使用变量原来的值。
关系和boolean运算符Java包含丰富的关系运算符
[*]相等使用两个等号==
[*]不相等使用!=
[*]&&表示逻辑与运算符
[*]||表示逻辑或运算符
注意：&&和||运算符，如果第一个操作数已经能够确定表达式的值，第二个操作数就不必计算了最后，Java支持三元操作符?:，这个操作符很有用。如果条件为true，下面的表达式condition? expression1: expression2就为第一个表达式的值，否则计算为第二个表达式的值。例如x < y ? x: y会返回x和y中较小的一个。
零基础学Java（4）字符串
字符串从概念上讲，Java字符串就是Unicode字符序列。例如，字符串"Java\u2122"由5个Unicode字符J、a、v、a和™组成。Java没有内置的字符串类型，而是在标准Java类库中提供了一个预定义类，很自然地叫做String。每个双引号括起来的字符串都是String类中的一个实例String e = "";// an empty string
String greeting = "Hello"子串String类的substring方法返回字符串的子字符串。
语法public String substring(int beginIndex)
或
public String substring(int beginIndex, int endIndex)
参数
[*]beginIndex -- 起始索引（包括）, 索引从 0 开始。
[*]endIndex -- 结束索引（不包括）
例子public class FirstSample {
public static void main(String[] args) {
String Str = "This is text";
System.out.print("返回值 :" );
System.out.println(Str.substring(4) );// 从第4个索引开始到结束
System.out.print("返回值 :" );
System.out.println(Str.substring(4, 10) );// 从第4个索引开始到第10个结束，不包括第10个
}
}结果返回值 : is text
返回值 : is te现在我们知道了substring的用法，接下来看看源码源码分析 /**
* Returns a string that is a substring of this string. The
* substring begins at the specified {@code beginIndex} and
* extends to the character at index {@code endIndex - 1}.
* Thus the length of the substring is {@code endIndex-beginIndex}.
* <p>
* Examples:
* <blockquote><pre>
* "hamburger".substring(4, 8) returns "urge"
* "smiles".substring(1, 5) returns "mile"
* </pre></blockquote>
*
* @param beginIndex the beginning index, inclusive.
* @param endIndex the ending index, exclusive.
* @return the specified substring.
* @exceptionIndexOutOfBoundsExceptionif the
* {@code beginIndex} is negative, or
* {@code endIndex} is larger than the length of
* this {@code String} object, or
* {@code beginIndex} is larger than
* {@code endIndex}.
*/
// 定义了substring方法，有两个参数beginIndex和endIndex
public String substring(int beginIndex, int endIndex) {
// 如果起始索引小于0，抛出异常
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
// 如果结束索引大于值的长度，抛出异常
if (endIndex > value.length) {
throw new StringIndexOutOfBoundsException(endIndex);
}
// 子串的长度
int subLen = endIndex - beginIndex;
// 如果子串的长度小于0，抛出异常
if (subLen < 0) {
throw new StringIndexOutOfBoundsException(subLen);
}
// 如果起始索引等于0并且结束索引等于字符串的长度，那么返回字符串本身，否则创建一个新的字符串
return ((beginIndex == 0) && (endIndex == value.length)) ? this
: new String(value, beginIndex, subLen);
}
折叠 拼接与绝大多数程序设计语言一样，Java语言允许使用+号连接(拼接)两个字符串。这个没什么说的。
但是要注意：当将一个个字符串与一个非字符串的值进行拼接时，后者会转换字符串。例如：int age = 13;
String x = "jkc" + age;结果是jkc13
如果我们需要把多个字符串放在一起，并用一个界定符分隔，可以使用静态join方法：public class FirstSample {
public static void main(String[] args) {
System.out.print("返回值 :" );
System.out.println(String.join("/", "A", "B", "C", "D"));
}
}结果返回值 :A/B/C/Djoin方法有两种重载方法，这里只介绍以下这一种public static String join(CharSequence delimiter, CharSequence… elements)
[*]delimiter：字符串分隔符
[*]...elements：指定的字符串
String.join("/", "A", "B", "C", "D")的意思就是用分隔符/将ABCD这4个字符串连接起来，结果自然就是A/B/C/D
不可变字符串在Java中是不能修改Java字符串中的单个字符的，所以再Java文档中将String类对象称为是不可变的，如果真的想修改，可以提取想保留的子串，再与希望替换的字符拼接：greeting = greeting.substring(0, 3) + "p!";检测字符串是否相等可以使用equals方法检测两个字符串是否相等，语法：s.equals(t)如果字符串s与字符串t相等，则返回true；否则，返回false。
要想检测两个字符串是否相等，而不区分大小写，可以使用equalsIsIgnoreCase方法。"Hello".equalsIgnoreCase("hello");注意：一定不要使用==运算符检测两个字符串是否相等！这个运算符只能够确定两个字符串是否在同一个内存地址上。当然，如果字符串在同一个内存地址上，它们必然相等。但是，完全有可能将内容相同的多个字符串放置在不同的内存地址上。public class FirstSample {
public static void main(String[] args) {
String greeting = "Hello";
System.out.println("变量greeting的内存地址为：" + System.identityHashCode(greeting));
System.out.println("hello的内存地址为：" + System.identityHashCode(greeting));
if (greeting == "Hello") {
System.out.println("同一个内存地址，相等");
}
String x =greeting.substring(0, 3);
System.out.println("变量x的内存地址：" + System.identityHashCode(x));
if (x == "Hel") {
System.out.println("内存地址不同");
}
}
}如果虚拟机始终将相同的字符串共享，就可以使用==运算符检测是否相等。但实际上只有字符串字面量是共享的，而+或substring等操作得到的字符串并不共享。因此，千万不要使用==运算符测试字符串的相等性，以免在程序中出现这种最糟糕的bug，看起来这种bug就像随机产生过的间歇性错误。
空串与Null串空串""是长度为0的字符串。可以调用以下代码检查一个字符串是否为空：if (str.length() == 0) 或if (str.equals(""))空串是一个Java对象，有自己的串长度(0)和内容(空)。不过String变量还可以存放一个特殊的值，名为null，表示目前没有任何对象与该变量关联。要检查一个字符串是否为null，要使用以下条件：if (str == null)有时要检查一个字符串既不是null也不是空串，这种情况下就需要使用以下条件：if (str !=null && str.length() != 0)首先要检查str不为null，如果在一个null值上调用方法，会出现错误。
String APIJava中的String类包含了50多个方法，接下来介绍一些最常用的方法java.lang.String 1.0
[*]char charAt(int index)
返回给定位置的代码单元。除非对底层的代码单元感兴趣，否则不需要调用这个方法。
[*]int codePointAt(int index)
返回从给定位置开始的码点。
[*]int offsetByCodePoints(int startIndex, int cpCount)
返回从startIndex码点开始，cpCount个码点后的码点索引。
[*]int compareTo(String other)
按照字典顺序，如果字符串位于other之前，返回一个负数；如果字符串位于other之后，返回一个正数；如果两个字符串相等，返回0.
[*]IntStream codePoints()
将这个字符串的码点作为一个流返回。调用toArray将它们放在一个数组中
[*]new String(int[] codePoints, int offset, int count)
用数组中从offset开始的count个码点构造一个字符串。
[*]boolean isEmpty()
如果字符串为空，返回true
[*]boolean equals(Object other)
如果字符串与other相等，返回true
[*]boolean equalsIgnoreCase(String other)
如果字符串与other相等(忽略大小写)，返回true
[*]boolean startsWith(string prefix)
判断字符串是否是以prefix前缀开始
[*]boolean endsWith(String suffix)
判断字符串是否是以suffix后缀开始
[*]int indexOf(String str)
[*]int indexOf(String str, int fromIndex)
[*]int indexOf(int cp)
[*]int indexOf(int cp, int fromIndex)
返回与字符串str或码点cp匹配的第一个子串的开始位置。从索引0或fromIndex开始匹配。如果在原始字符串中不存在str，则返回-1
[*]int lastIndexOf(String str)
[*]int lastIndexOf(String str, int fromIndex)
[*]int lastIndex(int cp)
[*]int lastIndex(int cp, int fromIndex)
返回与字符串str或码点cp匹配的最后一个子串的开始位置。从原始字符串末尾或fromIndex开始匹配。
[*]int length()
返回字符串代码单元的个数
[*]int codePointCount(int startIndex, int endIndex)
返回startIndex和endIndex-1之间的码点个数
String replace(CharSequence oldString, CharSequence newString)
返回一个新字符串。这个字符串用newString代替原始字符串中所有的oldString。可以用String或StringBuilder对象作为CharSequence参数。
[*]String substring(int beginIndex)
[*]String substring(int beginIndex, int endIndex)
返回一个新字符串。这个字符串包含原始字符串中从beginIndex到字符串末尾或endIndex-1的所有代码单元
[*]String toLowerCase()
[*]String toUppCase()
返回一个新字符串。这个字符串将原始字符串中的大写字母改成小写，或者将原始字符串中的所有小写字母改成大写。
[*]String trim()
[*]String strip() 11
返回一个新字符串。这个字符串将删除原始字符串头部和尾部小于等于U+0020的字符(trim)或空格(strip)。
[*]String join(CHarSequence delimiter, CharSequence... elements)
返回一个新字符串，用给定的定界符连接所有元素
[*]String repeat(int count) 11
返回一个字符串，将当前字符串重复count次
构建字符串有些时候，需要由较短的字符串构建字符串，例如，按键或来自文件中的单词。如果采用字符串拼接的方式来达到这个目的，效率会比较低。每次拼接字符串时，都会构建一个新的String对象，既耗时，又浪费空间。使用StringBuilder类就可以避免这个问题发生。
如果需要用许多小段的字符串来构建一个字符串，那么应该按照下列步骤进行。首先，构建一个空的字符串构建器：StringBuilder builder = new StringBuilder();当每次需要添加一部分内容时，就调用append方法builder.append("jkc");
builder.append("jkc2");
builder.append("jkc3");在字符串构建完成时就调用toString方法，将可以得到一个String对象，其中包含了构建器中的字符序列。String completedString = builder.toString();下面的API包含了StringBuilder类中的重要方法
[*]StringBuilder()
构造一个空的字符串构建器
[*]int length()
返回构建器或缓冲器中的代码单元数量
[*]StringBuilder append(String str)
追加一个字符串并返回this
[*]StringBuilder append(char c)
追加一个代码单元并返回this
[*]StringBuilder appendCodePoint(int cp)
追加一个码点，并将其转换为一个或两个代码单元并返回this
[*]void setCharAt(int i, char c)
将第i个代码单元设置为c
[*]StringBuilder insert(int offset, String str)
在offset位置插入一个字符串并返回this
[*]StringBuilder insert(int offset, char c)
在offset位置插入一个代码单元并返回this
[*]StringBuilder delete(int startIndex, int endIndex)
删除偏移量从startIndex到endIndex-1的代码单元并返回this
[*]String toString()
返回一个与构建器或缓冲器内容相同的字符串
零基础学Java（5）输入与输出
输入与输出 读取输入要想通过控制台进行输入，首先需要构造一个与"标准输入流"System.in关联的Scanner对象。// 创建输入流对象
Scanner in = new Scanner(System.in);现在，就可以使用Scanner类的各种方法读取输入了。例如，nextLine方法读取一行数据System.out.print("What is your name? ");
String name = in.nextLine();我们使用nextLine方法是因为在输入行中可能包含空格。如果想要读取一个单词(以空白符作为分隔符)，可以调用next方法String firstName = in.next();要想读取一个整数，就调用nextInt方法。System.out.print("How old are you? ");
int age = in.nextInt();与此类似，想要读取下一个浮点数，就调用nextDouble方法。
最后，在程序的最前面需要添加一行代码：import java.util.Scanner;Scanner类定义在java.util包中。当使用的类不是定义在基本java.lang包中时，一定要用import指令导入相应的包
java.util.Scanner
Scanner类常用的API如下：
[*]Scanner(InputStream in)
用给定的输入流创建一个Scanner对象
[*]String nextLine()
读取输入的下一行内容
[*]String next()
读取输入的下一个单词(以空格作为分隔符)
[*]int nextInt()
[*]double nextDouble()
读取并转换下一个表示整数或浮点数的字符序列
[*]boolean hasNext()
检测输入中是否还有其他单词
[*]boolean hasNextInt()
[*]boolean hasNextDouble()
检测是否还有下一个表示整数或浮点数的字符序列。
java.lang.System
[*]static Console console()
如果可以进行交互，就返回一个Console对象通过控制台窗口与用户交互，否则返回null。对于任何一个在控制台窗口启动的程序，都可使用Console对象。否则，是否可用取决于所使用的系统。
java.io.Console
[*]static char[] readPassword(String prompt, Object... args)
[*]static String readLine(String prompt, Object... args)
显示字符串prompt(提示符)并读取用户输入，直到输入行结束。args参数可以用来提供格式参数。
格式化输出打印语句System.out.print(x)将数值x输出到控制台。这条命令将以x的类型所允许的最大非0数位个数打印输出x，例如：double x = 10000.0 / 3.0;
System.out.print(x);结果3333.3333333333335如果我们想显示小数点后只存在2位，Java中沿用了C语言函数库中的printf方法。例如：System.out.printf("%8.2f", x);结果将包括8个字符，另外精度为小数点后2个字符。也就是说，这会打印一个前导的空格和7个字符，如下所示：3333.33可以为printf提供多个参数，例如：System.out.println("Hello, " + name + ". Next year, you'll be " + (age + 1));没一个以%字符开始的格式说明符都用相应的参数替换。格式说明符尾部的转换符指示要格式化的数值的类型：f表示浮点数，s表示字符串，d表示十进制整数。以下表格列出了所有转换符另外，还可以指定控制格式化输出外观的各种标志。例如：逗号标志可以增加分组分隔符。即：System.out.printf("%,.2f", 10000.0 / 3.0);会打印3,333.33
本帖最后由 韶光暗淡 于 2022-7-27 15:49 编辑
零基础学Java（6）控制流程
控制流程与任何程序设计语言一样，Java使用条件语句和循环结构确定控制流程。
块作用域我们首先要了解块(block)的概念。
块是指由若干条Java语句组成的语句，并用一对大括号括起来。块确定了变量的作用域。一个块可以嵌套在另一个快中。下面就是嵌套在main方法块中的一个块。public static void main(String[] args) {
int n = 1;
{
int k = 3;
System.out.println(k); // success
}// k只在这个块中被定义
System.out.println(k);// error
}但是，不能在嵌套的两个块中声明同名的变量，否则就会有错误，无法通过编译：public static void main(String[] args) {
int n = 1;
{
int k = 3;
int n = 2;
}
}这里已经在外面定义了n，就不能再嵌套的块中再定义n了。
条件语句在Java中，条件语句的形式为if (condition) statement这里的条件必须用小括号括起来。剩下的跟其他语言语法几乎一直，直接看以下例子import java.util.Scanner;
public class SecondSample {
public static void main(String[] args) {
/*
* 根据销售额来评价你的表现，奖励你不同的金额
* */
// 创建输入对象
Scanner in = new Scanner(System.in);
System.out.println("请输入你的销售额");
// 在控制台输入你的销售额
int yourSales = in.nextInt();
// 定义一个目标
int target = 1000;
// 初始化表现
String performance;
// 初始化奖金
int bonus;
if (yourSales >= 2 * target) {
performance = "优秀";
bonus = 1000;
System.out.printf("你的表现为%s，奖励你%d元%n", performance, bonus);
} else if (yourSales >= 1.5 * target) {
performance = "良好";
bonus = 500;
System.out.printf("你的表现为%s，奖励你%d元", performance, bonus);
} else if (yourSales >= target) {
performance = "及格";
bonus = 100;
System.out.printf("你的表现为%s，奖励你%d元", performance, bonus);
} else {
System.out.println("You 're fired");
}
}
}
折叠 while循环当条件为true时，while循环执行下一条语句。一般形式如下：while (condition) statement我们设定一个程序，计算需要多长时间才能够存储一定数量的退休金，假定每年存入相同数量的金额，而且利率是固定的。import java.util.Scanner;
public class ThirdSample {
public static void main(String[] args) {
/*
* 计算需要多长时间才能够存储一定数量的退休金
* */
Scanner in = new Scanner(System.in);
System.out.println("你需要多少退休金?");
double goal = in.nextDouble();
System.out.println("你每年将增加多少钱?");
double payment = in.nextDouble();
System.out.println("利率是多少：");
double interestRate = in.nextDouble();
double balance = 0;
int years = 0;
// 未达到目标时更新帐户余额
while (balance < goal) {
// 加上今年的付款和利息
balance += payment;
double interest = balance * interestRate / 100;
balance += interest;
years++;
}
System.out.printf("你可以在%d年内退休", years);
}
}
折叠 while循环是先判断后执行，如果条件不满足则永远是false，那么可能永远不会执行，如果我们想无论条件是否为true，我们都要先执行一条语句，那么在Java中提供了do..while...这种循环形式。do statement while (condition)下面的例子中，首先计算退休账户中的新的余额，然后再询问是否打算退休：public class ThirdSample {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.println("你每年将增加多少钱?");
double payment = in.nextDouble();
System.out.println("利率是多少?");
double interestRate = in.nextDouble();
double balance = 0;
int year = 0;
String input;
do {
balance += payment;
double interest = balance * interestRate / 100;
balance += interest;
year++;
System.out.printf("%d年后，你的余额为%,.2f%n", year, balance);
System.out.println("准备退休？（Y/N）");
input = in.next();
}
while (input.equals("N"));
}
}for确定循环 for循环语句是支持迭代的一种通用结构，由一个计数器或类似的变量控制迭代次数，每次迭代后这个变量将会更新。for (int i=1; i<=10; i++){
System.out.println(i);
}for语句的第1部分通常是对计数器初始化；第2部分给出每次新一轮循环执行前要检测的循环条件；第3部分指定如何更新计数器。
与C++一样，尽管Java允许在for循环的各个部分放置任何表达式，但有一条不成文的规则：for语句的3个部分应该对同一个计数器变量进行初始化、检测和更新。若不遵守这一规则，编写的循环常常晦涩难懂。
注意：在循环中，检测两个浮点数是否相等需要格外小心。for (double x=0;x!=10;x+=0.1)，这条语句永远不会结束。由于舍入的误差，永远达不到精确的最终值。因为0.1无法精确地用二进制表示，所以，x将从9.999 999 999 999 98跳到10.099 999 999 999 98。
多重选择：switch语句在处理多个选项时，使用if/else语句就显得有些笨拙。Java有一个与C/C++完全一样的switch语句。例如，下面包含4个选项的菜单系统public class FifthSample {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.println("Select an option (1, 2, 3, 4)");
int choice =in.nextInt();
switch (choice)
{
case 1:
System.out.println("我选择了1");
break;
case 2:
System.out.println("我选择了2");
break;
case 3:
System.out.println("我选择了3");
break;
case 4:
System.out.println("我选择了4");
break;
default:
System.out.println("默认选择");
break;
}
}
}switch语句将从与选项值相匹配的case标签开始执行，直到遇到break语句，或者执行到switch语句的结束处为止。如果没有相匹配的case标签，而有default子句，就执行这个子句。
注意：强烈不建议使用switch语句，最好永远不要使用，因为如果在case分支语句的末尾没有break语句，那么就会接着执行下一个case分支语句。这种情况跟相当危险，常常会引发错误。
case的标签可以是：
[*]类型为char、byte、short或int常量表达式
[*]枚举常量
[*]从Java7开始，case标签还可以是字符串字面量
零基础学Java（7）大数
大数如果基本的整数和浮点数精度不能够满足需求，那么可以使用java.math包中两个很有用的类：BigInteger和BigDecimal。这两个类可以处理包含任意长度数字序列的数值。BigInteger类实现任意精度的整数运算，BigDecimal实现任意精度的浮点数运算。
使用静态的valueof方法可以将普通的数值转换为大数：BigInteger a = BigInteger.valueOf(100);
对于更大的数，可以使用一个带字符串参数的构造器：BigInteger reallyBig = new BigInteger("134443493494321591498614658741974141641519614974168416516114914196419");另外还有一些常量：BigInteger.ZERO、BigInteger.ONE和BigInteger.TEN
注意：我们不能使用算术运算符(如：+和*)处理大数，而需要使用大叔类中的add和multiply方法。BigInteger c = a.add(b); //c = a + b
BigInteger d = c.multiply(b.add(BigInteger.valueOf(2))); //d = c * (b + 2)案例
假设你被邀请参加抽奖活动，并从500个可能的数值中抽取60个，下面程序会告诉你中彩的概率是多少import java.math.BigInteger;
import java.util.Scanner;
/**
* @author JKC
* @Description:
* @date 2022/6/29 09:42
*/
public class SixSample {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.println("你需抽多少次？");
int k = in.nextInt();
System.out.println("你能抽的最高数是什么？");
int n = in.nextInt();
BigInteger lotteryOdds = BigInteger.valueOf(1);
for (int i = 1; i <= k; i++) {
lotteryOdds = lotteryOdds.multiply(BigInteger.valueOf(n - i + 1).divide(BigInteger.valueOf(i)));
}
System.out.printf("你的概率在%d分之一", lotteryOdds);
}
}java.math.BigInteger APIBigInteger add(BigInteger other)
BigInteger subtract(BigInteger other)
BigInteger multiply(BigInteger other)
BigInteger divide(BigInteger other)
BigInteger mod(BigInteger other)
返回这个大整数和另一个大整数other的和，差，积，商以及余数
BigInteger sqrt()
得到这个BigInteger的平方根
int compareTo(BigInteger other)
如果这个大整数与另一个大整数other相等，返回0；如果这个大整数小于另一个大整数other，返回负数；否则，返回正数
static BigInteger ValueOf(long x)
返回值等于x的大整数
java.math.BigDecimal APIBigDecimal add(BigDecimal other)
BigDecimal subtract(BigDecimal other)
BigDecimal multiply(BigDecimal other)
BigDecimal divide(BigDecimal other)
BigDecimal divide(BigDecimal other, RoundingMode mode)
返回这个大实数与other的和，差，积。如果商是个无限循环小数，第一个divide方法会抛出一个异常。要得到一个舍入的结果，就要使用第二个方法。
RoundingMode.HALF_UP是指四舍五入方式。
int compareTo(BigDecimal other)
如果这个大实数与other相等，返回0；如果这个大实数小于other，返回附属；否则返回正数
static BigDecimal ValueOf(long x)
static BigDecimal ValueOf(long x, int n)
返回值等于x或x/10ⁿ的一个大实数
零基础学Java（8）数组
数组
数组存储相同类型值的序列。
声明数组
数组是一种数据结构，用来存储同一类型值的集合。通过一个整型下标(index，或称索引)可以访问数组中的每一个值。例如，如果a是一个整型数组，a就是数组中下标为i的整数。
在声明数组变量时，需要指出数组类型(数据元素类型紧跟[])和数组变量的名字。下面声明了整型数组a：
int[] a;不过，这条语句只声明了变量a，并没有将a初始化为一个真正的数组。应该使用new操作符创建数组
int[] a = new int;这条语句声明并初始化了一个可以存储100个整数的数组。
数组长度不要求是常量：new int会创建一个长度为n的数组。
一旦创建了数组，就不能再改变它的长度。如果程序运行中需要经常扩展数组的大小，就应该使用另一种数据结构---数组列表(array list)
在Java中，提供了一种创建数组对象并同时提供初始值的简写形式。如下：int[] a = {2, 3, 5, 7, 11, 13};请注意，这个语法不需要使用new，甚至不用指定长度。
最后一个值后面允许有逗号，如果你要不断为数组增加值，这会很方便：String[] authors = {"James", "Kobe", "Curry", "Durant",};当然，我们也可以声明一个匿名数组；new int[] {17, 19, 23, 29, 31, 37}这会分配一个新数组并填入大括号中提供的值。它会统计初始值的个数，并相应地设置数组大小。可以使用这种语法重新初始化一个数组而无须创建新变量。例如：smallPrimes = new int [] {17, 19, 23, 29, 31, 37};注意
在Java中，允许有长度为0的数组。在编写一个结果为数组的方发时，如果碰巧结果为空，这样一个长度为0的数组就很有用。可以如下创建长度为0的数组：new elementType;
或
new elementType2[] {};访问数组前面的数组元素的下标为从0~99(不是1~100)。一旦创建了数组，就可以在数组中填入元素，例如，使用一个循环：int[] a = new int;
for (int i = 0; i < 100; i++) {
a = i;
}创建一个数字数组时，所有元素都初始化为0，boolean数组的元素会初始化为false。对象数组的元素则初始化为一个特殊值null，表示这些元素还未存放任何对象。刚开始我们可能有些不了解，例如：String[] names = new String;我们会创建一个包含10个字符串的数组，所有字符串都为null。如果希望这个数组包含空串，必须为元素指定空串：for (int i=0; i < 10; i++) names = "";注意：如果创建了一个100个元素的数组，并且试图访问元素a(或在0~99之间的任何下标)，就会引发array index out of bounds异常。
如果我们想获得数组中的元素个数，可以使用array.length。例如：for (int i=0; i<a.length; i++) {
System.out.println(a);
}for each循环Java有一种功能很强的循环结构，可以用来依次处理数组(或者其他元素集合)中的每个元素，而不必考虑指定下标值。这种增强的for循环的语句格式为：for (variable: collection) statement它定义一个变量用于暂存集合中的每一个元素，并执行相应的语句(当然，也可以是语句块)。collection这一集合表达式必须是一个数组或者是一个实现了Iterable接口的类对象(例如ArrayList)，例如：int[] a = {2, 3, 4, 5, 6};
for (int element: a) {
System.out.println(element);
}打印数组a的每一个元素，一个元素占一行。2
3
4
5
6这个循环应该读作"循环a中的每一个元素"(for each element in a)。当然，使用传统的for循环也可以获得同样的效果：for (int i = 0;i < a.length; i++) {
System.out.println(a);
}但是，for each循环语句显得更加简洁、更不易出错，因为你不必为下标的起始值和终止值而操心。
for each循环语句的循环变量将会遍历数组中的每个元素，而不是下标值
总结：如果需要处理一个集合中的所有元素，for each循环语句相对于传统循环语句所做的改进很让人欣喜。然而，很多情况下还是需要使用传统的for循环。例如，如果不希望变量整个集合，或者在循环内部需要使用下标值时。
数组拷贝在Java中，允许将一个数组变量拷贝到另一个数组变量。这时，两个变量将引用同一个数组：public class SevenSample {
public static void main(String[] args) {
int[] smallPrimes = {2, 3, 4, 5, 6, 7, 8};
// 拷贝smallPrimes
int[] luckyNumbers = smallPrimes;
System.out.println(Arrays.toString(luckyNumbers));
}
}结果下图显示了拷贝的结果。如果希望将一个数组的所有值拷贝到一个新的数组中去，就要使用Arrays类的copyOf方法：import java.util.Arrays;
public class SevenSample {
public static void main(String[] args) {
int[] smallPrimes = {2, 3, 4, 5, 6, 7};
int[] copiedLuckyNumbers = Arrays.copyOf(smallPrimes, smallPrimes.length);
System.out.println(Arrays.toString(copiedLuckyNumbers));
}
}结果如下：Array.copyOf方法中，第1个参数是拷贝的对象，第2个参数是新数组的长度。这个方法通常用来增加数组的大小：luckNumbers = Arrays.copyOf(luckyNumbers, 2 * luckyNumbers.length);①如果数组元素是数值型，那么额外的元素将被赋值为0；②如果数组元素是布尔值，那么额外的元素将被赋值为false。③如果长度小于原始数组的长度，则只拷贝前面的值
页:
[1]
