Java学习笔记:基础语法
2021/7/7 12:35:00
本文主要是介绍Java学习笔记:基础语法,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!
文章目录
- 一、变量:
- ①什么是变量?
- ②变量的声明:
- ③变量的初始化:
- ④变量的初始化:
- ⑤变量的命名:
- 二、基本数据类型:
- ①int类型:
- ②long类型:
- ③double类型:
- ④boolean类型:
- ⑤char类型:
- 三、基本数据类型之间的转换:
- ①不同的基本数据类型之间可以直接相互转换:
- ②数值运算时的自动转换:
- ③byte、char、short类型数据转换为int:
- 四、Scanner类进行数据输入:
- ①基本特征:
- ②nextLine方法与next方法之间的区别:
- 五、运算符和表达式:
- ①算术运算符:
- ②关系运算符:
- ③逻辑运算符:
- ④赋值运算符:
- ⑤字符连接运算:
- ⑥条件(三目)运算符:
- 六、分支结构:
- ①if-else结构:
- ②switch case 语句:
- 七、循环结构:
- ①while循环:
- ②do…while循环:
- ③for循环:
- ④Java增强for循环:
- ⑤break关键字:
- ⑥continue关键字:
- 八、数组:
- ①什么是数组?
- ②定义基本类型数组:
- ③初始化数组:
- ④数组元素的访问:
- ⑤遍历数组元素:
- ⑥数组元素的复制:
- ⑦数组元素的排序:
- Ending……
一、变量:
①什么是变量?
- 变量就是指代在内存中开辟的内存空间,用于存储运算过程中需要使用到的数据。
②变量的声明:
- 当使用一个变量时,必须对于该变量进行声明;声明包括两点——变量名和变量类型。
- 在一条语句中声明多个同类型变量:如果多个变量的类型一样,可以在一条语句中同时声明,中间使用逗号进行隔开。
public static void main(String[] args){ int a = 1,int b = 2,c; }
③变量的初始化:
- 声明变量的同时进行初始化
//变量类型 变量名称 = 初始值 int data = 1;
- 声明和初始化可以分开,但是一定要确保在第一次使用变量之前对其进行初始化
//初始化:第一次赋值。 int data2;//先声明后赋值。 data = 12; data = 34;//修改变量的值,第一次叫赋值,后面的就不叫了!
④变量的初始化:
- 可以对变量中的值进行存取、操作:
- 变量是存放数据的空间,可以对其进行赋值、更改和操作;要把变量的操作理解是对其所存储数据的操作。
public static void main(String[] args){ int data = 10; data += 10; //将变量data中的值加上10的所得结果再度存入变量data中。 }
- 变量的操作必须和其类型相匹配:
- 变量在声明的时候指定了其类型,Java编译器会检测对该变量的操作是否和其类型相匹配,如果不匹配则会产生编译错误。
public static void main(String[] args){ int data = 3.14159;//编译报错! }
- 未经过声明的变量不可以使用:
- Java语言的语法规定,变量在使用之前必须声明,否则会有编译错误。
public static void main(String[] args){ int data = 10; System.out.println(daty);//编译错误 //使用之前未声明的错误很多时候是因为拼写错误引起的。 }
- 未经过初始化的变量不能使用:
- Java规定变量在使用之前必须初始化,必须给该变量赋予特定的值。
public static void main(String[] args){ int data,a = 2; System.out.println(data+a);//error! }
⑤变量的命名:
int score,myScore,myJavaScore;//驼峰命名法 int Score,MyScore,MyJavaScore;//帕斯卡命名法
二、基本数据类型:
①int类型:
int是最为常用的整数类型。一个int类型的变量占据4个字节,表示范围是: − 2 31 -2^{31} −231到 2 31 − 1 2^{31}-1 231−1。
-
整数直接量是int类型:
- 整数直接量(literal)就是能直接写出来的整数(10、100、1000)。
- 整数直接量的注意要点:
- 因为整数直接量是int类型,所以如果直接写出来的整数超过了int的表示数据范围,将会出现编译错误。
- 除了常见的十进制书写形式,整数直接量也可以写成16进制形式(以0X或者0x开头)或8进制的形式(以0开头)。
-
整数数据在除法运算中的取整:
- 两个整数相除,会舍弃小数的部分(非四舍五入),其结果也是整数。
public static void main(String[] args){ int data = 3/2; System.out.println(data);//结果是1,而不是1.5或2。 }
- 运算时要防止溢出的发生:
- 两个整数之间进行运算的时,其结果可能会超过整数的范围而溢出。
public static void main(String[] args) { int a = 2147483647; int b = -2147483648; a+=1; b-=1; System.out.println(a);//溢出报错 System.out.println(b);//溢出报错 }
②long类型:
一个long类型的变量需要占用8个字节,最大表示范围: − 2 63 -2^{63} −263到 2 63 − 1 2^{63}-1 263−1。
如果要表示long直接量,需要以L或者l结尾。
- 使用long类型进行较大整数的运算:
/** * 用来演示程序 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { long data = 10000*365*24*299792458L; //必须有一个long类型数据参与的运算结果才是long类型 System.out.println(data);//正确结果26261819320800000 long data2 = 10000*365*24*299792458; System.out.println(data2);//将会溢出,结果为1271239424 } }
- 借助long类型数据,通过时间毫秒数来存储日期和时间:
- JDK提供System.currentTimeMillis方法,返回1970年1月1日零点到当前所经历的毫秒数,数据类型是long类型。
/** * 用来演示程序 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { long data = System.currentTimeMillis(); System.out.println(data);//1616746242204 } }
③double类型:
-
使用double进行浮点数的运算:
- 浮点数就是小数,包括float和double。
- double类型数据的精度值是float类型的两倍,这也正是其名称(双精度)的由来。
- 大多数时候使用double表示浮点数。
-
浮点数的直接量是double类型:
- 浮点数的直接量有两种写法:
- 通常写法:3.14、3.0、.5
- 科学计数法:1.25E2(表示1.25乘以10的2次方)、1.25e2、1.25E-2
- 默认浮点直接量为double类型,如果需要表示float类型直接量的话,需要在其后面加上f或者F后缀。
- 浮点数的直接量有两种写法:
-
double运算时会出现舍入误差:
- 二进制系统中无法准确表示1/10,就像十进制系统中无法精确的表示1/3一样。所以使用二进制表示十进制数据后有一些舍入误差,对于一些要求精确运算的场合会导致代码的缺陷。
/** * 用来演示程序 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { double data = 3.0; double data2 = 2.9; System.out.println(data-data2);//0.10000000000000009 } }
④boolean类型:
- 特性介绍:
- boolean类型适用于逻辑运算,表示某一个条件是否成立,一般用于程序的流程控制。
- boolean类型只允许取值true或false,true表示条件成立而false表示条件不成立。
- boolean类型变量经常用于存储关系运算的结果,所谓关系运算就是比较两个变量的大小相等等关系。
- 代码举例:
/** * 用来演示程序 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { boolean b = 18>16; System.out.println(b);//true } }
⑤char类型:
字符类型事实上是一个16位的无符号整数,这个值是对应字符的编码。
Java字符类型采用Unicode字符集编码。Unicode是世界通用的定长字符集,所有字符都是16位置。
字符直接量可以采用诸如:‘中’的形式,也可以采用16进制的表示形式,例如:‘\u4e2d’
-
对于char类型数据进行赋值:
- 字符直接量:形如’A‘,变量中实际存储的是该字符Unicode编码(无符号整数),一个char类型变量只能存储一个字符。
- 整型直接量:范围在0~65535之间的整数,变量中实际存储的即该整数值,但表示的是该整数值所对应的Unicode字符。
- Unicode形式:形如:’\u0041’,Unicode字符的16进制形式。
-
使用转义字符:
- 对于不方便输出的字符采用转义字符进行表示。
转义字符 | 含义 |
---|---|
‘\n’ | 表示换行符 |
‘\r’ | 表示回车符 |
'\ \ ’ | 表示反斜杠 \ |
’\’‘ | 表示单引号 ‘ |
‘\“’ | 表示双引号 ” |
三、基本数据类型之间的转换:
除了boolean类型数据外,其他数据类型之间都可以进行转换。
①不同的基本数据类型之间可以直接相互转换:
- 自动类型转换(隐式类型转换):从小类型到大类型可以自动完成。
- 强制转换:从大类型到小类型需要强制转换符;但是这样转换有可能会造成精度损失或者溢出。
/** * 用来演示强制转换损失精度问题的程序 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { long L = 1024L*1024*1024*4; int data = (int)L;//强制转换 System.out.println(data);//发生了溢出,所以结果为0 } }
②数值运算时的自动转换:
- 多种基本类型参与的表达式运算中,运算结果会自动的向着较大的类型进行转换。
/** * 用来演示强制转换损失精度问题的程序 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { long longData = 10000*10*6666666L; //由于有long类型的直接量参与运算,所以真个表达式的结果为long型数据 double doubleData = 100-99.0; //由于有double类型的直接量参与运算,所以表达式的结果为double类型 double doubleData2 = 8/10; //由于参与运算的数据都是int直接量,所以运算结果为0,再自动转换为double类型,所以结果是0.0 double doubleData3 = 8.0/10; //由于表达式中有double直接量参与运算,所以运算结果为0.8。 } }
③byte、char、short类型数据转换为int:
- byte、char、short三种类型实际上存储的数据都是整型数据,在实际使用中遵循以下的规则:
- int直接量可以直接赋值给byte、char、short,只要不超过其表示范围即可。
- byte、char、short三种类型数据参与运算时,都会先一律转换为int类型,再进行运算。
四、Scanner类进行数据输入:
①基本特征:
- Scanner类位于java.util包中,所以使用的时候需要导入。
import java.util.Scanner;
- S y s t e m . i n System.in System.in作为参数传递给Scanner的构造函数,使Scanner用键盘输入作为输入,然后用new在内存中实例化一个Scanner出来,使得其它变量能调用这块内存区。
Scanner scanner = new Scanner(System.in);
②nextLine方法与next方法之间的区别:
-
nextLine方法:
- 当输入的不是一个Enter键时,该方法返回的是Enter键之前的所有字符,并且会带走这个换行符,它是可以得到带空格的字符串的。
package MyTest; import java.util.Scanner; /** * 用于一些代码的测试 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { Scanner s = new Scanner(System.in); System.out.println("你最爱的动物是什么?"); String name = s.nextLine(); System.out.print("你最爱的动物是:"+name ); //会打包带走换行符,但是不会包含在字符串里面! System.out.println("……"); //如果包含在了name中,那么会换行输出,但是并没有! System.out.println("This is a text!"); String text = s.nextLine(); System.out.println("Test results:"+text); //因为nextLine()会带走换行符,所以text接受不到换行符,需要键盘输入 } }
- 可以单独接收换行符。
package MyTest; import java.util.Scanner; /** * 用于一些代码的测试 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { Scanner s = new Scanner(System.in); System.out.println("你的年龄是多少?"); int age = s.nextInt(); System.out.println("你的年龄是:"+ age +"岁"); //因为nextInt()不会带走输入时产生的换行符。 //所以换行符被text给接收了,因此不用再键盘输入 System.out.println("This is a text!"); String text = s.nextLine(); System.out.println("Test results:"+text); } }
-
next方法:
- 会自动忽略输入字符前的空格,只返回输入的非空格字符。
package MyTest; import java.util.Scanner; /** * 用于一些代码的测试 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { Scanner s = new Scanner(System.in); System.out.println("你最爱的动物是什么?"); String name = s.next(); System.out.println("你最爱的动物是:"+name); //就算输入的时候加上了很多的空格,但是被忽略了! } }
- 字符和字符之间不能包含空格,否则不能完整接收输入的字符串,到下一个空格出现的时候,它就停了,因此不能得到带空格的字符串。
package MyTest; import java.util.Scanner; /** * 用于一些代码的测试 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { Scanner s = new Scanner(System.in); System.out.println("你最爱的动物是什么?"); String name = s.next(); System.out.println("你最爱的动物是:"+name); String name1 = s.next(); System.out.println("你最爱的动物是:"+name1); String name2 = s.next(); System.out.println("你最爱的动物是:"+name2); //因为空格的存在,所以断断续续的接收! } }
五、运算符和表达式:
①算术运算符:
Java算术运算符除了通常的加减乘除(+ -*/)之外,还包括取模运算(%)和自增(++)及自减(–)运算。
- 取模运算(%)意为取余数,可适用于整数、char类型、以及浮点数。
package MyTest; /** * 用于一些代码的测试 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { float data = 10.0F; System.out.println(data%3.3); } } //output:0.10000000000000053
- Java的自增运算符(++)和自减运算符(–)继承自C++,可以使变量的值加1或减1,但其写在变量前后有着不同的效果。
- 写在变量之前,表示在使用这个变量之前加1或者减1。
- 写在变量之后,表示在使用完变量之后在加1或者减1。
package MyTest; /** * 用于一些代码的测试 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { int a=10,b=20; int c=a++; int d=++b; System.out.println("a="+a+" b="+b+" c="+c+" d="+d); } } //output:a=11 b=21 c=10 d=21
②关系运算符:
- 关系运算符用于判断数据之间的大小关系。包括大于(>)、小于(<)、等于(==)、大于等于(>=)、小于等于(<=)、不等于(!=)六个运算符;关系运算符的运算结果为boolean类型,关系成立为true,反之为false。
package MyTest; /** * 用于一些代码的测试 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { System.out.println(10==9); System.out.println(2>=2); } } //output: //false //true
③逻辑运算符:
- 逻辑运算建立在关系运算的基础之上,逻辑运算包括:与(&&)、或(||)和非(!)。
- 参与逻辑运算的变量或者表达式都是boolean类型,运算结果也为boolean类型。
变量a | 变量b | a&&b | a||b | !a |
---|---|---|---|---|
true | true | true | true | false |
true | false | false | true | false |
false | true | false | true | true |
false | false | false | false | true |
- 关于逻辑短路的问题:
- 对于“&&”:当第一个操作数为false时,将不会判断第二个操作数;因为最终结果一定是false。
- 对于“||”:当第一个操作数为true时,将不会判断第二个操作数;因为最终结果一定是true。
④赋值运算符:
- “=”称为赋值运算符,用于对变量进行赋值。关于赋值运算符,除了将右边的表达式计算出结果赋给左边以外;赋值表达式本身也有值——即所赋之值。
package MyTest; /** * 用于一些代码的测试 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { int data; System.out.println(data=10); System.out.println(data); } } //output: //10 //10
- 在赋值运算符“=”前面加上其他运算符,就为扩展赋值运算符。
运算符 | 表达式 | 计算 |
---|---|---|
+= | X+=Y | X=X+Y |
-= | X-=Y | X=X-Y |
*= | X*=Y | X=X*Y |
/= | X/=Y | X=X/Y |
%= | X%=Y | X=X%Y |
- 扩展赋值运算符自带强转功能:
package MyTest; /** * 用于一些代码的测试 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { int data=10; data+=10.0;//相当于data=(int)(10+10.0); System.out.println(data); } } //output: //20
⑤字符连接运算:
- “+”可以实现字符串的连接,同时实现字符串与其他数据类型的“相连”。
package MyTest; /** * 用于一些代码的测试 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { String string = ""; int data = 10; string = "a="+data; System.out.println(string); string = ""+100+200; System.out.println(string); string = 100 + 200 + ""; System.out.println(string); } } //output: // a=10 //100200 //300
⑥条件(三目)运算符:
- 条件运算符又称为“三目”运算符,结构为:
boolean表达式? 表达式1:表达式2
- 条件运算符的规则如下:
- 先计算boolean表达式:
- 如果boolean表达式的值为true,则整个表达式的值为表达式1的值。
- 如果boolean表达式的值为false,则整个表达式的值为表达式2的值。
- 先计算boolean表达式:
package MyTest; /** * 用于一些代码的测试 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { int a = 10,b = 20; int flag = a>b? 1:-1; System.out.println(flag); } } //output: //-1
- 条件(三目)运算符的嵌套使用:
- 所谓的嵌套使用是指在条件表达式boolean表达式? 表达式1:表达式2中,表达式1或表达式2也可以是条件表达式。
package MyTest; import java.util.Scanner; /** * 用于一些代码的测试 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int data = scanner.nextInt(); String string = data>0? "正数":(data==0? "0":"负数"); System.out.println(string); scanner.close(); } } //output: // 12 //正数
六、分支结构:
①if-else结构:
- 一个if语句包含一个布尔表达式和一条或者多条语句。
if(布尔表达式){ //如果布尔表达式为true将执行的语句 }
如果布尔表达式的值为 true,则执行 if 语句中的代码块,否则执行 if 语句块后面的代码。
- if……else语句:
- if 语句后面可以跟 else 语句,当 if 语句的布尔表达式值为 false 时,else 语句块会被执行。
if(布尔表达式){ //如果布尔表达式的值为true }else{ //如果布尔表达式的值为false }
- if…else if…else 语句:
- if 语句后面可以跟 else if…else 语句,这种语句可以检测到多种可能的情况。
- 注意事项:
- if 语句至多有 1 个 else 语句,else 语句在所有的 else if 语句之后。
- if 语句可以有若干个 else if 语句,它们必须在 else 语句之前。
- 一旦其中一个 else if 语句检测为 true,其他的 else if 以及 else 语句都将跳过执行。
if(布尔表达式 1){ //如果布尔表达式 1的值为true执行代码 }else if(布尔表达式 2){ //如果布尔表达式 2的值为true执行代码 }else if(布尔表达式 3){ //如果布尔表达式 3的值为true执行代码 }else { //如果以上布尔表达式都不为true执行代码 }
- 嵌套的if…else 语句:
- 使用嵌套的 if…else 语句是合法的。也就是说你可以在另一个 if 或者 else if 语句中使用 if 或者 else if 语句。
if(布尔表达式 1){ //如果布尔表达式 1的值为true执行代码 if(布尔表达式 2){ //如果布尔表达式 2的值为true执行代码 } }
②switch case 语句:
- switch case 语句判断一个变量与一系列值中某个值是否相等,每个值称为一个分支。
switch(expression){ case value1 : //语句 break; //可选 case value2 : //语句 break; //可选 //你可以有任意数量的case语句 default : //可选 //语句 }
- switch case 语句有如下规则:
- switch 语句中的变量类型可以是: byte、short、int 或者 char。从 Java SE 7 开始,switch 支持字符串 String 类型了,同时 case 标签必须为字符串常量或字面量。
- switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
- case 语句中的值的数据类型必须与变量的数据类型相同,而且只能是常量或者字面常量。
- 当变量的值与 case 语句的值相等时,那么 case 语句之后的语句开始执行,直到 break 语句出现才会跳出 switch 语句。
- 当遇到 break 语句时,switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现,程序会继续执行下一条 case 语句,直到出现 break 语句。
- switch 语句可以包含一个 default 分支,该分支一般是 switch 语句的最后一个分支(可以在任何位置,但建议在最后一个)。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。
switch case 执行时,一定会先进行匹配,匹配成功返回当前 case 的值,再根据是否有 break,判断是否继续输出,或是跳出判断。
package MyTest; /** * 用于一些代码的测试 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { char grade='C'; switch(grade) { case 'A' : System.out.println("优秀"); break; case 'B' : case 'C' : System.out.println("良好"); break; case 'D' : System.out.println("及格"); break; case 'F' : System.out.println("你需要再努力努力"); break; default : System.out.println("未知等级"); } System.out.println("你的等级是 " + grade); } } //output: // 良好 //你的等级是 C
如果 case 语句块中没有 break 语句时,JVM 并不会顺序输出每一个 case 对应的返回值,而是继续匹配,匹配不成功则返回默认 case(default那一栏)。
package MyTest; /** * 用于一些代码的测试 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { int i = 5; 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"); } } } //output: // default
如果 case 语句块中没有 break 语句时,匹配成功后,从当前 case 开始,后续所有 case 的值都会输出。
package MyTest; /** * 用于一些代码的测试 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { char grade='D'; switch(grade) { case 'A' : System.out.println("优秀"); case 'B' : case 'C' : System.out.println("良好"); case 'D' : System.out.println("及格"); case 'F' : System.out.println("你需要再努力努力"); default : System.out.println("未知等级"); } System.out.println("你的等级是 " + grade); } } //output: // 及格 //你需要再努力努力 //未知等级 //你的等级是 D
七、循环结构:
①while循环:
while( 布尔表达式 ) { //循环内容 }
只要布尔表达式为 true,循环就会一直执行下去。
②do…while循环:
- 对于 while 语句而言,如果不满足条件,则不能进入循环。但有时候我们需要即使不满足条件,也至少执行一次。do…while 循环和 while 循环相似,不同的是,do…while 循环至少会执行一次。
do { //代码语句 }while(布尔表达式);
布尔表达式在循环体的后面,所以语句块在检测布尔表达式之前已经执行了。 如果布尔表达式的值为 true,则语句块一直执行,直到布尔表达式的值为 false。
③for循环:
-
for循环执行的次数是在执行前就确定的。
for(初始化; 布尔表达式; 更新) { //代码语句 }
-
关于 for 循环有以下几点说明:
- 最先执行初始化步骤。可以声明一种类型,但可初始化一个或多个循环控制变量,也可以是空语句。
- 然后,检测布尔表达式的值。如果为 true,循环体被执行。如果为false,循环终止,开始执行循环体后面的语句。
- 执行一次循环后,更新循环控制变量。
- 再次检测布尔表达式。循环执行上面的过程。
④Java增强for循环:
- Java5 引入了一种主要用于数组的增强型 for 循环。
for(声明语句 : 表达式) { //代码句子 }
-
声明语句:声明新的局部变量,该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块,其值与此时数组元素的值相等。
-
表达式:表达式是要访问的数组名,或者是返回值为数组的方法。
package MyTest; /** * 用于一些代码的测试 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { int[] data = {1,2,3,4,5,6,7,8,9,10}; for (int s:data){ System.out.print(s+" "); } } } //output: // 1 2 3 4 5 6 7 8 9 10
⑤break关键字:
- break 主要用在循环语句或者 switch 语句中,用来跳出所在的整个语句块。break跳出一层循环,并且继续执行该循环下面的语句。
package MyTest; /** * 用于一些代码的测试 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { int i; for (i = 1;i<=15;i++){ if (i==12) break; } System.out.println(i); } } //output: //12
⑥continue关键字:
- continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。在 for 循环中,continue 语句使程序立即跳转到更新语句。在 while 或者 do…while 循环中,程序立即跳转到布尔表达式的判断语句。
个人理解:其实就是跳出continue所在循环的本次循环,进入下一次循环。
package MyTest; /** * 用于一些代码的测试 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { int i; for (i = 1;i<=6;i++){ if (i==3) continue; else System.out.print(i+" "); } } } //output: //1 2 4 5 6
八、数组:
①什么是数组?
- 相同数据类型的元素组成的集合。
- 元素按线性顺序排列;所谓线性顺序是指除第一个元素外,每一个元素都有唯一的前驱元素;除了最后一个元素外,每一个元素都有唯一的后继元素。
②定义基本类型数组:
- 声明数组的语法:
数据类型[] 数组名 = new 数据类型[大小]; int[] array = new int[10];
补充:int[ ] array与int array[ ]两种写法都可以。
③初始化数组:
- 基本类型的数组创建之后,Java会自动对其进行初始化。byte、short、char、int、long为0;float和double为0;boolean为false。
- 也可以在数组声明的同时进行初始化:
int[] array = {1,2,3,4,5,6,7,8,9,10};
补充:元素的个数即为数组的长度。
- 上面的写法只能用于声明时的初始化,不能用于赋值;譬如下面的错误举例:
int[] array; array = {1,2,3,4,5,6,7,8,9,10};//error!
- 可以通过下面的方式对于已经声明的数组类型变量进行初始化:
int[] array; array = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};//right!
注意:[]中不可以写长度,元素的个数就是数组的长度。
④数组元素的访问:
- 数组中的元素通过下标进行访问:下表从0开始,最大到Length-1。
package MyTest; /** * 用于一些代码的测试 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { int[] array = {1,2,3,4,5,6,7,8,9,10}; System.out.println(array[6]); } } //output: //7
⑤遍历数组元素:
- 遍历数组元素,通常使用for循环语句,循环变量作为下标来逐个访问数组元素。
package MyTest; /** * 用于一些代码的测试 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { int[] array = {1,2,3,4,5,6,7,8,9,10}; for (int i=0;i<=array.length-1;i++) System.out.print(array[i]+" "); } } //output: //1 2 3 4 5 6 7 8 9 10
- 还可以使用foreach更加简单的遍历数组元素:
package MyTest; /** * 用于一些代码的测试 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { int[] array = {1,2,3,4,5,6,7,8,9,10}; for (int data:array) { System.out.print(data+" "); } } } //output: //1 2 3 4 5 6 7 8 9 10
⑥数组元素的复制:
- 使用System.arraycopy()方法:
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length) //src - 源数组。 //srcPos - 源数组中的起始位置。 //dest - 目标数组。 //destPos - 目的地数据中的起始位置。 //length - 要复制的数组元素的数量。
- 逐个元素进行复制:
public class Test { public static void main(String[] args) { int[] array1,array2; array1 = new int[6]; array2 = new int[array1.length]; for (int i=0;i< array1.length;i++)//初始化 array1[i] = (int)(Math.random()*100); for (int j=0;j< array1.length;j++)//逐个复制 array2[j] = array1[j]; } }
- 使用Arrays.copyof()方法:
public static object[] copyOf(object[] original,int newLength) //生成的新数组是原始数组的副本
newLength小于原数组,则进行截取。
newLength大于原数组,则大于的部分使用0或者null进行填充。
package MyTest; import java.util.Arrays; /** * 用于一些代码的测试 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { int[] array = {1,3,5,7,9}; int[] copy = Arrays.copyOf(array,7); for (int data:copy) {//大于原数组的部分补上0 System.out.print(" "+data); } } } //output: // 1 3 5 7 9 0 0
- 这个方法还可以用于数组的扩容:
- 本质上是建立了一个新数组,将原始的数据迁移过去了!初始的数组因为无引用,所以被回收机制给回收了!
package MyTest; import java.util.Arrays; /** * 用于一些代码的测试 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { int[] array = {1,3,5,7,9}; //该函数可用于数组的扩容! array = Arrays.copyOf(array,array.length+1); for (int data:array) { System.out.print(" "+data); } } } //output: //1 3 5 7 9 0
⑦数组元素的排序:
- 利用Arrays.sort()方法:
package MyTest; import java.util.Arrays; /** * 用于一些代码的测试 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { int[] array = new int[10]; for (int i=0;i<array.length;i++) array[i] = (int)(Math.random()*100); System.out.print("排序之前的数据:"); for (int data:array) { System.out.print(" "+data); } System.out.println(); //进行升序排序 Arrays.sort(array); System.out.print("排序之后的数据:"); for (int data:array) { System.out.print(" "+data); } } } //output: //排序之前的数据: 85 56 4 45 81 86 49 25 25 23 //排序之后的数据: 4 23 25 25 45 49 56 81 85 86
- 使用排序算法(以冒泡排序为例):
package MyTest; /** * 用于一些代码的测试 * @author YiWen Wan */ public class Test{ public static void main(String[] args) { int[] array = new int[10]; for (int i=0;i<array.length;i++)//赋予数据 array[i] = (int)(Math.random()*100); System.out.print("排序之前的数据:"); for (int data:array ) { System.out.print(" "+data); } System.out.println(); //进行冒泡排序,从小到大进行排序! for (int i=0;i<array.length-1;i++){ for (int j=1;j< array.length-i;j++){ //这里使用减法更好一点,不容易越界,便于控制! if (array[j]<array[j-1])//进行两数交换,更大的数据向后面走 array[j-1] = (array[j-1]+array[j])-(array[j]=array[j-1]); } } System.out.print("排序之后的数据:"); for (int data:array) { System.out.print(" "+data); } } } //output: //排序之前的数据: 17 84 93 31 2 97 1 82 61 12 //排序之后的数据: 1 2 12 17 31 61 82 84 93 97
Ending……
这篇关于Java学习笔记:基础语法的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!
- 2024-10-05小米13T Pro系统合集:性能与摄影的极致融合,值得你升级的系统ROM
- 2024-10-01基于Python+Vue开发的医院门诊预约挂号系统
- 2024-10-01基于Python+Vue开发的旅游景区管理系统
- 2024-10-01RestfulAPI入门指南:打造简单易懂的API接口
- 2024-10-01初学者指南:了解和使用Server Action
- 2024-10-01Server Component入门指南:搭建与配置详解
- 2024-10-01React 中使用 useRequest 实现数据请求
- 2024-10-01使用 golang 将ETH账户的资产平均分散到其他账户
- 2024-10-01JWT用户校验课程:从入门到实践
- 2024-10-01Server Component课程入门指南