初识Java Java基础知识

　　今天给大家带来的是初级Java基础部分的知识：包括初识Java、变量、常量、数据类型、运算符、各种选择结构、循环结构、数组等Java的基础语法部分！！！内容、步骤超详细，附有各种案例的源代码（可以直接用O(∩_∩)O~）！！！仔细看完它，扎实的基础不再是空谈，万丈高楼平地起，当有了扎实的基础知识，后面学习面向对象以及项目的开发时，压力就减少了很多，所以基础知识不能被轻易的忽略。

一、初识Java

使用记事本开发程序的步骤（注意：整个操作过程都是英文）：

1 编写源程序

首先新建一个文本文件，修改其后缀名为“.java" ---->然后再里面编写我们需要的代码

  public  class  HelloWorld{

    public  static  void main(string[] args){

       system.out.println("Hello  kh87");

   }

}

public:公共的公开的，处处可以访问。

class：类，类别，类似狗狗类，电脑类等。

HelloWorld:类名称，有一个要求，必须和文件名称保持一致

public static void main(String[] args){}   ---->>> 入口方法，所有需要运行的代码都需要放到这里来，固定写法

static：关键字（计算机中已经使用的名字，我们就不能再使用）

void:返回值类型，void表示没有返回值

main:是入口方法的方法名

易错点：

①大括号要成对出现

②String中的”s”要大写

③我们在每一句话之后都需要使用英文的分号结束

④System中的”s”需要大写

⑤类名需要和文件名保持一致

所有的输出内容需要在引号里面

2 编译源程序

因为编写的是我们人写的，但是计算机是看不懂的，所以需要一个“翻译” 编译成一个 ".class" 结尾的文件（半机器语言）。我们在dos命令中进入到文件所在目录，输入命令  javac  xxx.java  类编译同时会生成一个以“class”结尾的字节码文件

3 运行

编译成功之后，即可运行，输入  java xxx  即可.在控制台即可出现在打印语句中双引号中的内容了（所有需要打印的内容都需要在双引号中）

符号的含义：

\t：一个制表符的空格

\n：换到下一行的初识位置

注释的作用：
解释说明，不会被编译运行
单行注释： //
多行注释： /* */
文档注释： /** */

二、变量，常量，数据类型和运算符

1.变量

1.1 定义：

一个存储空间的表示，其值是可以变化的。（例如买了一双鞋，鞋盒用来孵小鸡，鞋盒就是变量，鞋子和小鸡是里面的值。）

通过变量名可以简单快速的找到它存储的数据！！！

1.2 使用步骤：

第一步：声明变量（声明变量的时候变量名不能重复）

即根据数据类型在内存申请空间

数据类型 变量名；int money;（int是数据类型，money是变量名）

第二步：赋值

即将数据存储在对应的内存空间

变量名=数值； money=1000;

上面两步可以合二为一

int money =1000; 其含义是：在内存中开辟了一个int类型的空间，给其命名为money，并为其赋值为1000；

第三步：使用

即取出数据

注意：

在声明变量的时候变量名不能重复

当在程序中使用“+”的时候，符号左右两侧如果有一个数据是字符串则将两个值拼接（如果后面有多个“+”则将多个值拼接），如果都是数值型则计算和

1.3 命名的规则

1、以数字，字母，下划线和$符号组成，其中不能以数字开头

2、不能和java中的关键字重名

3、尽量遵守见名知意和驼峰命名（有多个单词首个单词首字母小写后面单词首字母大写）规则

public static void main(String[] args) {
　　　　　//1声明
        int money;

        //2赋值
        money=100;
        /**
         * 第一第二两步合并
         * 声明变量的时候变量名不能重复
         */
        int m = 100;

        String name="张三";
        int age =27;
        double score=89.0;
        //是否及格  使用 true :  及格     false:不及格
        boolean  flag =true;

        //3使用
        System.out.println("和"+age+score);
        System.out.println("金额:："+money);
        System.out.println("姓名："+name);
        System.out.println("年龄："+age);
        System.out.println("分数："+score);
    }

2.常量

2.1 定义：

一个存储空间的表示，其值是不可以发生变化的。

final修饰常量，final修饰的值在声明的时候就赋值且后面不能改变（在数据类型前加final 如 final int）

2.2 优点：

一旦定义后期不能修改，所以其是相对安全的

2.3 命名规则：

常量名都要大写，如果是多个单词组成，则使用下划线分割

public static void main(String[] args) {
        // TODO Auto-generated method stub
/**
 * 常量的案列演示
 * 计算圆的面积
 */
        final   double       MY_PI =3.14;
        /*pi=3;*/
        double  r=2;
        double  area=MY_PI * r * r;
        System.out.println("面积是："+area);

    }

3.数据类型

分类：

3.1 基本数据类型：

1、数值型

1）整型（可以存放整数）：

byte(1个字节)

short(2个字节)

int(4个字节) （默认使用）

long(8个字节)

2）浮点型（表示小数）：

float(4个字节)

double(8个字节) （默认使用）

2、非数值型

1）字符型—————需要给值加上单引号，只能存一个字符

char(2个字节)：本质上是一个整数，是字符的Unicode码值

2）布尔型————结果只有两种 true/false

boolean

3.2 引用数据类型：

1）String：可以存储多个字符使用双引号引起来

2）数组

3）枚举

4.运算符

分类：

4.1 赋值运算符：

赋值符号：=       将右边的值赋给左边的变量

4.2 算术运算符：

符号：+ - * / % ++ --

++放在变量前指先加1在使用；放在变量后指先使用在加1

--放在变量前指先减1在使用；放在变量后指先使用在减1

%指求余数

num+=2;(意思为num=num+2;)

public static void main(String [] args){
       //++ --
       int a=4;
       int b=2;
       int c=5;
       /*
       System.out.println((a+b));
       System.out.println((a-b));
       System.out.println((a*b));
       System.out.println((a/b));
       System.out.println((a+b));
       System.out.println((a+b));*/

       System.out.println(a++);//输出结果为4
       System.out.println(a);//输出结果为5
       System.out.println(++a);//输出结果为6
       System.out.println(c%b);//输出结果为1
   }

4.3 关系运算符

运算符	含义	举例	结果
==	等于	5==6	false
!=	不等于	5!=6	true
>	大于	5>6	false
<	小于	5<6	true
>=	大于等于	5>=6	false
<=	小于等于	5<=6	true

注意：

= 为赋值运算符，== 等于运算符

表达式返还给我们的结果类型都是boolean 类型

4.4 逻辑运算符：

运算符	含义	运算规则
&&	短路与	两个表达式结果都是true结果才是true
||	短路或	只要有一个为true 结果就为true
!	取反	将原来表达式结果取反
&
|

A	B	A&&B	A||B
T	T	T	T
T	F	F	T
F	T	F	T
F	F	F	F

&& 一假必假

|| 一真必真

public static void main(String[] args) {
        // TODO Auto-generated method stub
      int a=4;
      int b=2;
      int c=5;

      //a>b为T,b>c为F 所以a>b||b>c为T；a<c为T所以整个表达式为T
      System.out.println(a>b   ||    b>c    &&    a<c);
    }

4.5 三目运算符（条件运算符）：

语法：

boolean表达式？ 表达式1:表达式2;

当boolean表达式的结果为true的时候 执行表达式1

当boolean表达式的结果为false的时候 执行表达式2

  int a=5;
      int b=10;
      int c= a>b?  0:1;
      System.out.println(c);//结果为1
   int a=5;
      int b=10;
      String c= a>b?  "正确":"错误";
      System.out.println(c);//结果为错误

返回值的数据类型需要和执行的表达式的数据类型一致

运算符优先级

5.类型转换

5.1 自动类型转换

好比生活中有两个水杯，一个大的一个小的，如果将装满水的小杯中水倒入空的大杯，是可以的，类似于这样的场景在java中称之为自动类型转换

      double first=81.99;
      int duo=2;
      double  seconde=first+duo;

规则：

①在整个表达式中，如果有double数据类型的话，则整个表达式的结果会自动的提升为double类型

②在自动类型转换的表达式中数据类型需要兼容

​ 如：都是数值型

③目标类型要大于原类型

5.2 强制类型转换

好比生活中有两个水杯，一个大的一个小的，如果将装满水的大杯中水倒入空的小杯，是可以的但是会溢出，类似于这样的场景在java中称之为自强制类型转换

语法：

数据类型 变量名=（数据类型）（表达式）；————是先运算表达式，然后将结果转换

如：int seconde=(int) (first+duo);  或   int seconde=(int) (first）+duo;————先将first转换为int类型在计算，最后将结果转换为int类型

缺点：丢失精度，慎用（double转int 丢失的是小数点后面的所有值不是四舍五入）

　　double  first=81.99;
　　int  duo=2;
　　int  seconde=(int) (first+duo);//结果是83

6.Scanner

作用：接收用户在键盘输入的值

使用步骤：

①导包

import java.util.Scanner; / import java.util.*; (java.util是包名 Scanner是类名，

如果用*则表示取java.util包下的所有类，两种方法都行)

②创建Scanner 对象

Scanner tx = new Scanner (System.in);

③使用 常用方法

接收int型 int age= tx.nextInt();

接收double型 double score=tx.nextDouble();

接收String类型 String name=tx.next();

注意

第二步中新建的Scanner中用的什么名（tx）第三步中就用什么名

由于工具的原因，在编写提示语的时候将ln去掉；如将System.out.println("请输入年龄：");的ln去掉即为System.out.print("请输入年龄：");

package cn.kgc.tx.ketang;
​
//1、导包
import java.util.Scanner;
​
public class Demo4 {
​
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        //2、创建Scanner  对象
     Scanner  tx = new Scanner (System.in);

     //3、使用
     System.out.print("请输入年龄：");
     int age=tx.nextInt();
     System.out.print("请输入姓名：");
     String name=tx.next();
     System.out.print("请输入分数：");
     double score=tx.nextDouble();
     System.out.print("年龄是："+age+"，姓名是："+name+"，分数是："+score);
    }
}

7.包的使用

新建的包都使用小写字母组成，不能有中文或者特殊符号

新建的包使用公司域名去掉3w其他内容倒写，如 www.kgc.cn cn.kgc.公司定义

新建的每个类我们使用的每个单词的首字母大写

在每个类中都会有且只有一个 package+包的名字（且在代码的第一行）

三、程序选择结构

3.1基本选择结构

语法：

if(布尔类型的条件){

​ 如果条件为真，则执行

}

条件为假的时候执行大括号后面的内容

流程图

案例：

如果张浩的Java考试成绩大于98分，张浩就能获得一个MP4作为奖励

public static void main(String[] args){
       //  如果    。。。java>98
       //就有奖励
        double   javaScore=100;

        if(javaScore  >98){
            //条件为真则执行这里再向下执行
            System.out.println("有一个硬盘奖励");
        }
       //条件结果为假的话，直接跳到这里执行
        System.out.println("程序结束");
   }

　　

3.2复杂程序结构

主要是和我们的各种运算符相互结合使用

如：张浩的Java成绩大于98分，而且音乐成绩大于80分，老师会奖励他；或者Java成绩等于100分，音乐成绩大于70分，老师也会奖励他

public static void main(String[] args) {
        // TODO Auto-generated method stub
    Scanner tx=new Scanner(System.in);
    System.out.print("张浩的Java成绩是：");
    int javaScore=tx.nextInt();
    System.out.print("张浩的音乐成绩是：");
    int musicScore=tx.nextInt();
    if((javaScore>98&&musicScore>80)||(javaScore==100&&musicScore>70)){
        System.out.println("奖励张浩一个MP5");
    }
         System.out.println("程序结束");
}

if-else

为什么使用if-else ?

使用传统的if选择结构也可能完成如果否则之类的问题，但是可能造成代码的冗余，浪费时间。

如：

 if(zhangScore>98){
        System.out.println("奖励一个MP4");
    }
    //使用之前的基本选择结构可以做，但是可能会造成代码的冗余
    //执行的效率就降低了
    if(zhangScore<60){
        System.out.println("俯卧撑30个");
    }

所以我们使用if-else

语法：

if(){    //布尔类型的表达式
  //条件为真进入执行代码块1
}else{
  //条件为假进入代码块2
}

流程图：

案例：

 if(zhangScore>98){            //如果张浩成绩大于98有奖励
         System.out.println("奖励一个MP4");
    }else {  //否则俯卧撑30个
        System.out.println("俯卧撑30个");
        }

多重if选择结构

语法：

if(){
}else  if(){
}else  if(){
}else{
}

流程图：

案例：

//对学员的结业考试成绩评测 成绩>=80 ：良好   成绩>=60 ：中等 成绩<60   ：差
    public static void main(String[] args) {
        // TODO Auto-generated method stub
      Scanner tx=new Scanner(System.in);
      System.out.print("请输入考试成绩：");
      int score=tx.nextInt();
      if(score>=80){
          System.out.println("良好");
      }else if(score>=60){
          System.out.println("中等");
      }else {
          System.out.println("差");
      }
    }

在我们执行的程序过程中，程序是自上而下执行的，所以条件判断的时候，会在第一个判断条件满足的时候停下并执行，后面的内容就不会再执行了

所以，在条件判断的时候，条件的语句顺序不能随便的写，要按照一定的顺序

嵌套if选择结构

语法：

if(条件1){
  if(条件2){
   // 代码块1 当两个if都满足时才运行
  }else{
    //代码块2
  }
}else{
  //代码块3
}

流程图：

案例：

@Test
    public void demo8(){
        System.out.print("请输入你的跑步成绩：");
        //输入成绩
        double score=tx.nextDouble();
        //对成绩进行判断
        if(score<=10){
            //如果成绩合格在判断性别
            System.out.print("请输入你的性别：");
            String sex=tx.next();
            //判断性别
            if(sex.equals("男")){
                System.out.println("恭喜进入男子组决赛");
            }else if(sex.equals("女")){
                System.out.println("恭喜进入女子组决赛");
        }    else {
                System.out.println("输入错误");
        }
    }else{
        System.out.println("很遗憾你没有进入决赛");
    }
  }

　

switch选择结构

语法：

switch(表达式){     //表达式为 int、short、byte、char、枚举、String类型
    case常量1:   //计算表达式的值
    语句;        //如果等于常量1
    break;
    case常量2:
    语句;       //如果等于常量2
    break;
   ……
    default:
    语句;           //如果没有找到匹配的值
    break;
}

注意：

switch后面只能跟6种类型

3种整数型：byte、short、int

两个字符相关：char、String

一个枚举型

字符串需要在jdk7.0之后才能使用

案例

韩嫣参加计算机编程大赛
如果获得第一名，将参加麻省理工大学组织的1个月夏令营
如果获得第二名，将奖励惠普笔记本电脑一部
如果获得第三名，将奖励移动硬盘一个
否则，不给任何奖励
​
        @Test
      public void demo3(){
          int mc=2;
          if(mc==1){
              System.out.println("夏令营");
          }else if(mc==2){
              System.out.println("电脑");
          }else if(mc==3){
              System.out.println("硬盘一个");
          }else{
              System.out.println("明年继续努力");
          }
          System.out.println("程序结束");
      }

以上是使用多重if选择结构的完成，但是从代码的结构上看，显得代码冗余，结构复杂，有多次的等值判断。

为了解决上述问题，我们引出switch的选择结构

if选择结构和switch选择结构的使用场景

if选择结构我们一般都是使用在区间判断上，而switch选择结构一般是作用在等值判断

注意：

①常量名不能重复

②case后面的常量不是必须要按照某种顺序的，switch后面的值会去找和自己匹配的常量值，然后执行对应的代码块，如果没有找到，则执行default中的值

③break结束当前的执行内容，在case后面执行，如果没有break代码会继续向下执行，一直到遇到break或整个switch语句运行完

④default在最后的时候，break是可以省略的（不推荐），在其他位置的时候，不能省略，否则会一直向下执行直到遇到break为止

案例：

@Test
    public void demo9(){
        System.out.print("输入1到7选择周一到周日大礼包：");
        String num=tx.next();
        switch(num){
        case "1":
            System.out.println("早上8点起床写代码");
        break;
        case "2":
            System.out.println("早上9点起床写代码");
        break;
        case "3":
            System.out.println("早上8半点起床写代码");
        break;
        case "4":
            System.out.println("早上7点半起床写代码");
        break;
        case "5":
            System.out.println("早上7点起床写代码");
        break;
        case "6":
            System.out.println("写代码写到晚上12点");
        break;
        case "7":
            System.out.println("早上8点起床写代码");
        break;
        default:
            System.out.println("别想逃，输别的没有用的");
        break;
        }

比较switch和多重if选择结构

相同点

都是用来处理多分支条件的结构

不同点

if多用于区间的判断

switch用于等值条件的判断

用switch能做的，用if都能做，但反过来则不行

如何处理系统异常

使用hasNextInt()解决问题2

Scanner input = new Scanner(System.in);
       //如果输入的是数字
    if (input.hasNextInt()) {
        int num = input.nextInt();
        switch (num) {
        case 1:
            //显示系统主菜单；
            break;
        case 2:
            System.out.println("谢谢您的使用！");  break;
        default:
            System.out.println("输入错误。");break;
        }
    } else {     //如果输入的不是数字
        System.out.println("请输入正确的数字！");
    }

　　

四、循环结构

为什么使用循环：

在达到同样的效果的同时可以用较简洁的代码

public void demo1(){
        //直接打印：易错、代码量多、效率低
        System.out.println("好好学习第一遍");
        System.out.println("好好学习第二遍");
        System.out.println("好好学习第三遍");
        System.out.println("好好学习第四遍");
    }

使用循环即可解决

概念：

一直重复做的有开始有结束的事

循环的特征：

循环条件：开始结束的条件

循环操作：一直需要重复做的事

循环变量：能够对循环条件的结果产生影响的量

4.1 while循环

特点：

先判断，后执行

如果循环条件开始就不符合的时候，循环操作一遍也不会执行

语法：

while(循环条件//boolean类型表达式){
  循环操作
}

流程图：

案例：

/*打印50份试卷
     * 循环特征：
     *            循环条件：开始结束的条件
     *            循环操作：一直需要重复做的事
     *            循环变量：能够对循环条件的结果产生影响的量
     *
     */
    @Test
    public void demo3(){
        int a=1;
        while (a<=50){     //循环条件
            //循环操作
            System.out.println("打印第"+a+"份试卷");
            a++;   //循环变量
        }
    }

　　

4.2 do—while循环

为什么需要使用do—while循环？

在生活中往往会有一些事情是需要我们先做然后再去判断的。如：期末考试之前需要先学习一个学期

语法：

do{
  循环操作
}while(循环条件)；//循环条件时boolean类型

流程图：

执行特点：

先执行，后判断。

条件为假，也至少执行一次循环操作

案例：

经过几天的学习，老师给张浩一道测试题，
让他先上机编写程序完成，
然后老师检查是否合格。如果不合格，则继续编写。……
@Test
public void demo1(){
        String answer;
        do {
            //循环操作
            System.out.println("先上机考试");
            System.out.println("老师我合格了吗？");
            answer=tx.next();
        }while ("n".equals(answer));
        System.out.println("程序结束");
    }

　　

4.3 for循环

为什么使用for循环：

代码更简洁：while循环中有的表达式在for中都有

适用场景：循环次数固定的情况下使用

语法：

for(初始化循环变量;循环条件;修改循环变量的值){
  循环操作
}

易错点：

初识化循环变量可以省略但是需要在for上面写

循环条件和修改循环变量的值不能省略否则会死循环

初始化循环变量、循环条件、修改循环变量的值都不写的话（分号不能省）会死循环

案例：

商场对顾客的年龄层次进行调查
计算各年龄层次的顾客比例
@Test
    public void demo6(){
        double num2=0; //声明30岁以下人员数
        double num3=0; //声明30岁以上人员数
        for (int i=1;i<=10;i++){
            System.out.print("请输入第"+i+"位顾客的年龄：");
            int num1=tx.nextInt();
            if (num1<=30){
                 num2++;
            }else {
                 num3++;
            }
        }
        System.out.println("30岁以下的比列是："+(num2/(num2+num3)));
        System.out.println("30岁以上的比列是："+(num3/(num2+num3)));
    }

　　

4.4 break和continue的不解之缘

含义：

break：终止本循环，继续向后执行

continue：终止本次循环，继而执行下一次的循环操作

break作用：

改变程序控制流

用于do-while、while、for中时，可跳出循环而执行循环后面的语句

break通常在循环中与条件语句一起使用

案例：

break：

循环录入某学生5门课的成绩并计算平均分。如果某分数录入为负，停止录入并提示录入错误
循环录入成绩，判断录入正确性。录入错误，使用break语句立刻跳出循环；否则，累加求和
@Test
    public void demo7(){
        int sum=0;    //成绩总和
        boolean flag=false;   // false 表示输入的分数不是负数       true表示输入的分数是负数
        for (int i=0;i<5;i++){
            System.out.print("请输入第"+(i+1)+"门课的成绩：");
            //循环录入的成绩
            int score=tx.nextInt();
            if (score<0){
                flag =true;
                break;
            }
            sum=sum+score;
        }
        if(flag){
            System.out.println("输入错误");
        }else {
            int avg= sum/5;
            System.out.println("平均分为："+avg);

        }
    }

　　

continue：

@Test
    /*
     * 循环录入Java课的学生成绩，统计分数大于等于80分的学生比例
     */
    public void demo9(){
        int sum=0;  //用来累加学生人数的变量
        System.out.print("班级总人数为：");
        int penNo=tx.nextInt();
        for (int i=1;i<=penNo;i++){
            System.out.print("输入第"+i+"位学生的成绩：");
            double score=tx.nextDouble();
            if (score<80){
                continue;
            }
            sum++;
        }
        double a=(double)sum/penNo*100;
        System.out.println("80分以上的学生个数为："+sum);
        System.out.println("80分以上学生占比为："+a+"%");
    }　

对比break和continue：

使用场合：

break常用于switch结构和循环结构中

continue一般用于循环结构中

作用（循环结构中）：

break语句终止某个循环，程序跳转到循环块外的下一条语句

continue跳出本次循环，进入下一次循环

五、数组

什么是数组：

数组是一个变量，存储相同数据类型的一组数据

数组基本要素：

标识符：

数组的名称，用于区分不同的数组

数组元素：

向数组中存放的数据

元素下标：

对数组元素进行编号，从0开始，数组中的每个元素都可以通过下标来访问

元素类型：

数组元素的数据类型

注意：

声明一个变量就是在内存空间划出一块合适的空间

声明一个数组就是在内存空间划出一串连续的空间

数组长度固定不变，避免数组越界

数组中的所有元素必须属于相同的数据类型

如何使用数组：

1、声明数组

数组类型 数组名 [];

数组类型[] 数组名;

int[] a; int a[];

2、分配空间

数组类型[] 数组名 = new 数据类型[大小];

a=new int[5];

3、赋值

数组名[元素下标] =要赋的值;

a[0]=8;

赋值：

一、边声明边赋值：赋值的时候给了几个值，数组的长度就是多少

数组类型[] 数组名 = {x ; y ; z};

int[ ] score = {89, 79, 76};

数组类型[] 数组名 = {x ; y ; z};

int[ ] score = new int[ ]{89, 79, 76};

二、动态的从键盘录入信息并赋值（需要先定义数组长度）

Scanner input = new Scanner(System.in);
for(int i = 0; i < 30; i ++){
     score[i] = input.nextInt();
}

4、处理数据

a[0]=a[0]*10;

Arrays类

返回值类型	方法名称	说明
boolean	equals(array1,array2)	比较array1和array2两个数组是否相等
	sort(array)	对数组array的元素进行升序排列
String	toString(array)	将一个数组array转换成一个字符串
	fill(array,val)	把数组array所有元素都赋值为val
原数组什么类型复制的新数组也是什么类型	copyOf(array,length)	把数组array复制成一个长度为length的新数组，返回类型与复制的数组一致
int	binarySearch(array, val)	查询元素值val在数组array中的下标（要求数组中元素已经按升序排列）

案例：

@Test
    public void test05(){
        int[] array1 ={12,21,13};
        int[] array2 ={12,21,13};
        int[] array3 ={12,21,13,24};
        //int binarySearch(array, val)      查询元素值val在数组array中的下标（要求数组中元素已经按升序排列）
        Arrays.sort(array3);
        int i =Arrays.binarySearch(array3,13);
        System.out.println(i);
        //copyOf(array,length)      把数组array复制成一个长度为length的新数组，返回类型与复制的数组一致
        /*int array4[] =Arrays.copyOf(array3,6);
        System.out.println(Arrays.toString(array4));*/

        /*//void fill(array,val)    把数组array所有元素都赋值为val
        Arrays.fill (array3,22);
        System.out.println(Arrays.toString(array3));

        //sort(array)        对数组array的元素进行升序排列
        //String toString(array)    将一个数组array转换成一个字符串
        Arrays.sort(array3);
        System.out.println(Arrays.toString(array3));

     // boolean equals(array1,array2);        比较 array1 和 array2 是否相等
        boolean a=Arrays.equals(array1,array2);
        boolean b=Arrays.equals(array1,array3);
        System.out.println(a+","+b);*/
    }

　　

六、equals

最后再补充一点关于equals 和 == 的区别哈！！！

== 和 equals 的区别是？

==

既可以比较数值类型，也可以比较引用数据类型。当比较的是数值类型的时候比较的是值比较的是引用数据类型的是后，比较的就是地址值

equals

如果没有对equals方法进行重写的时候，比较的方式和==是一样的，如果重写的则按照重写的方式进行比较

在使用equals 的时候我们将肯定有值的变量写在前面，避免空指针异常的出现

案例：

@Test
    public void test2(){
        String i =null;//String 的默认值  为空
        if (i.equals("")){
            System.out.println("合格");
        }
        System.out.println("程序结束");
    }//此时运行会报错
@Test
    public void test2(){
        String i =null;
        if ("".equals(i)){
            System.out.println("合格");
        }
        System.out.println("程序结束");
    }//换位后运行正常