文章目录

• • • • 一、变量：
      • • ①什么是变量？
        • ②变量的声明：
        • ③变量的初始化：
        • ④变量的初始化：
        • ⑤变量的命名：
      • 二、基本数据类型：
      • • ①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进制形式。

• 使用转义字符：

  • 对于不方便输出的字符采用转义字符进行表示。

三、基本数据类型之间的转换：

除了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类型。

• 关于逻辑短路的问题：
  • 对于“&&”：当第一个操作数为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

• 在赋值运算符“=”前面加上其他运算符，就为扩展赋值运算符。

• 扩展赋值运算符自带强转功能：

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……