Java教程

Java学习笔记:基础语法

本文主要是介绍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!
}
⑤变量的命名:

image-20210703205216092

int score,myScore,myJavaScore;//驼峰命名法
int Score,MyScore,MyJavaScore;//帕斯卡命名法

二、基本数据类型:

image-20210326153941801

①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类型数据外,其他数据类型之间都可以进行转换。

①不同的基本数据类型之间可以直接相互转换:
  • 自动类型转换(隐式类型转换):从小类型到大类型可以自动完成

demo

  • 强制转换:从大类型到小类型需要强制转换符;但是这样转换有可能会造成精度损失或者溢出

demo

/**
 * 用来演示强制转换损失精度问题的程序
 * @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接受不到换行符,需要键盘输入
        }
    }
    

    image-20210703212626820

    • 可以单独接收换行符。
    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);
        }
    }
    

    image-20210703212951368

  • 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);
            //就算输入的时候加上了很多的空格,但是被忽略了!
        }
    }
    

    image-20210703213241452

    • 字符和字符之间不能包含空格,否则不能完整接收输入的字符串,到下一个空格出现的时候,它就停了,因此不能得到带空格的字符串。
    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);
            //因为空格的存在,所以断断续续的接收!
        }
    }
    

    image-20210703213441504


五、运算符和表达式:

image-20210704110611177

①算术运算符:

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变量ba&&ba||b!a
truetruetruetruefalse
truefalsefalsetruefalse
falsetruefalsetruetrue
falsefalsefalsefalsetrue
  • 关于逻辑短路的问题
    • 对于“&&”:当第一个操作数为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+=YX=X+Y
-=X-=YX=X-Y
*=X*=YX=X*Y
/=X/=YX=X/Y
%=X%=YX=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的值。
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学习笔记:基础语法的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!