day5数组

Hello，World！

1. 随便新建一个文件夹，存放代码

2. 新建一个Java文件

   • 文件后缀名为.java
   • Hello.java

3. 编写代码

   public class Hello{public static void main(String[] args){System.out.print("Hello,World");}
   }
   

4. 编译javac java文件，会生成一个class文件

5. 运行class文件，Java class文件

可能遇到的问题

1. 每个单词的大小不能出现问题，Java的大小写是敏感的
2. 尽量使用英文
3. 文件名和类名必须保证一致，并且首字母大写
4. 符号使用中文

Java基础语法

注释

// 单行注释

/**/多行注释

标识符

关键字

起名不可与关键字重复

• 所有的标识符都应该以字母（A-Z或者a-z），美元$,或者下划线（_）开始

• 首字母之后可以说是任意字符组合

• 不能使用关键字作为变量名或方法名

• 标识符是大小写敏感的

  public class HelloWorld {public static void main(String[] args) {System.out.println("Hello,World!");String student ="tyz";String 认真学习的人 ="tyz";System.out.println(认真学习的人);}//单行注释，输出一个HelloWorld!//多行注释   /*   注释   *//*多行注释*///JavaDoc:文档注释   /**   *//*** @Description HelloWorld* @Author tyz*/
  }

数据类型

• 强类型语言

  要求变量的使用严格符合规定，所有的变量都必须先定义后才能使用。

• 弱类型语言

  Java的数据类型分为两大类

  基本类型

  • 数值类型

    • 整数类型：byte，short，int，long
    • 浮点类型：float，double
    • 字符类型：char

  • boolean类型：只要true和false两个

     //八大基本数据类型//整数int num1=10;  //最常用byte num2=20;short num3=30;long num4=40L;   //long类型要在数字后面加个L用于区分//小数：浮点型float num5=50.1F;//float类型要在数字后面加个F用于区分double num6=3.1415926;//字符char name ='田';//字符串,String不是关键字，是类//String namea="田耀宗";//布尔值：是非boolean flag=true;//boolean flag=false;
    

  引用类型（除基本类型以外）

• 类

• 接口

• 数组

数据类型扩展

 //整数拓展 进制， 二进制  十进制 八进制0 十六进制0x(0~9 A~F)//----------------------------------------//浮点数拓展？ 银行业务怎么展示？钱//BigDecimal 数学工具类//-------------------------------------------//float  有限 离散 舍入误差 大约 接近但不等于//double//最好完全使用浮点数进行比较//最好完全使用浮点数进行比较//最好完全使用浮点数进行比较//最好完全使用浮点数进行比较float f=0.1f;//0.1double d=1.0/10;//0.1System.out.println(f==d);//输出为falseSystem.out.println(f);System.out.println(d);float d1=23333333333333333F;float d2=d1+1;System.out.println(d1==d2);//输出为true
//----------------------------------------------//字符拓展char c1='a';char c2='田';System.out.println( c1);System.out.println((int)c1);//强制换行System.out.println(c2);System.out.println((int)c2);//强制换行
//所有的字符本质还是数字//编码 Unicode 表：97=a 3000=田   占2字节//U000 UFFFchar c3='\u0061';System.out.println(c3);//a//------------------------//转义字符//\t   制表符//\n   换行//---------------//对象 从内存分析//----------------------------------//布尔值扩展boolean flag=true;if (flag==true){//新手//if(flag){}老手，两者意思相同

类型转换

int i = 128;byte b=(byte) i;//内存溢出//强制转换   （类名）变量名  高到低//自动转换    低到高double d=i;System.out.println(i);System.out.println(b);System.out.println(d);/*注意点1.不能对布尔值进行转换2.不能把对象类型转换为不相干的类型3.在把高容量转换为低容量的时候，强制转换4，在转换的时候可能存在内存溢出或者精度问题*/System.out.println((int)23.7);//输出为23//===================================char c='a';int f=c+1;System.out.println(f);//输出为98（a=97）System.out.println((char) f);//输出为b

类型转换的常见问题

public static void main(String[] args) {//操作比较大的数的时候，注意溢出问题//JDK7新特性，数字之间可以用下划线分割int money=10_0000_0000;int years=20;int total=money*years;//输出为-1474836480，计算的时候溢出了long total2=money*years;//输出还是为-14..，默认是int，转换之前已经存在问题long total3=money*((long)years);//先把一个数转换为long类型System.out.println(total);System.out.println(total2);System.out.println(total3);//输出为20亿
}

变量

数据类型 变量名 = 值；

• 每个变量都必须声明其类型
• 要素包括变量名，变量类型和作用域

注意

• 每个变量都有类型，类型可以是基本类型，可以是引用类型。

• 变量名必须是合法的标识符。

• 变量声明必须是一条完整的语句，因此每一个声明都必须以分号结束。

变量的作用域

• 类变量
• 实例变量
• 局部变量

public class Demo08变量作用域 {//类变量 staticstatic double salary=2500;//属性：变量//实例变量：从属于对象（这个类）；如果不自行初始化，会变成这个类型的默认值//布尔值：默认是false//除了基本变量类型，其余的默认值都是null。String name;int age;//main方法public static void main(String[] args) {//局部变量；必须声明和初始化值,只在这一种方法中有效int i=10;System.out.println(i);//变量类型  变量名字=new Demo08（）；Demo08变量作用域 demo08变量作用域=new Demo08变量作用域();System.out.println(demo08变量作用域.age);System.out.println(demo08变量作用域.name);//类变量 staticSystem.out.println(salary);}//其他方法public void add(){}
}

变量的命名规范

• 所有变量，方法，类名：见名知意
• 类成员变量：首字母小写和驼峰原则：monthSalary除了第一个单词意外，后面的单词首字母大写（lastName）
• 局部变量：首字母小写和驼峰原则
• 常量：大写字母和下划线MAX_VALUE
• 类名：首字母大写和驼峰原则：Man，GoodMan
• 方法名：首字母小写和驼峰原则：run（），runRun（）

常量

常量：初始化后不能在改变的值！不会变动的值。

final 常量名=值;

常量名一般使用大写字符

public class Demo09常量 {//修饰符，不存在先后顺序static final double PI=3.14;public static void main(String[] args) {}
}

运算符

算术运算符：+-*%（余），++，--

package operator;public class Demo01算数运算符 {public static void main(String[] args) {//二元运算符//ctrl+D复制当前行到下一行int a=10;int b=20;int c=30;int d=40;System.out.println(a+b);System.out.println(a-b);System.out.println(a*b);System.out.println(a/(double)b);long e=123123123123L;int f=123;short g=10;byte h=8;double i=3;System.out.println("===============================");System.out.println(e+f+g+h);//输出为LongSystem.out.println(f+g+h);//输出为intSystem.out.println(g+h);//输出为intSystem.out.println(i+g);}
}

赋值：=

关系：>,<,<=,>=,==(等于)，！=（不等于），instanceof

package operator;public class Deom02关系运算符 {public static void main(String[] args) {//关系运算符返回结果int a=10;int b=20;int c=21;System.out.println(c%a);System.out.println(a>b);System.out.println(a<b);System.out.println(a==b);System.out.println(a!=b);}
}

逻辑：&&与 ||或， ！非

package operator;public class Demo04逻辑运算符 {public static void main(String[] args) {boolean a=true;boolean b=false;System.out.println("a&&b:"+(a&&b));//falseSystem.out.println("a||b:"+(a||b));//trueSystem.out.println("!(a&&b):"+!(a&&b));//true//短路运算System.out.println("a&&b:"+(b&&a));//a不进行运算int c=5;boolean d=(c<4)&&(c++<4);//由于c<4是false,c++不进行运算System.out.println(d);//输出为falseSystem.out.println(c);//输出为5，没有自增}
}

位运算符

package operator;public class Demo05位运算 {public static void main(String[] args) {/*A  =0011 1100B  =0000 1101
------------------------------------------------A&B=0000 1100 两者相同输出1，不同0A/B=0011 1101 两者有1则输出1A^B=0011 0001 亦或：相同取0，不同取1~B =1111 0010 取反：与原来相反2*8=16   2*2*2*2效率极高！！！<<左移 相当于*2>>右移 相当于/2*/System.out.println(2<<3);}
}

条件

package operator;public class Demo07三元运算符 {public static void main(String[] args) {//?:       x? y : z//如果x==true，则结果为y，否则结果为zint score=80;String type=score<60?"不及格":"及格";System.out.println(type);//及格}
}

扩展赋值

package operator;public class Demo06扩展赋值运算符 {public static void main(String[] args) {int a=10;int b=20;a+=b;//a=a+ba-=b;//a=a-b//字符串连接符 +  如果出现String出现，那么后面其他操作数都转化为string类型进行链接System.out.println(a+b);//30System.out.println(""+a+b);//1020System.out.println(a+b+"");//30}
}

++a先自增

a++后自增

package operator;public class Deom03自增自减 {public static void main(String[] args) {//++自加   --自减  一元运算符int a=3;int b=a++;//执行这段代码后，先给b赋值，a再自增//a=a+1System.out.println(a);int c=++a;//执行这段代码前，先给a自增，再给c赋值System.out.println(a);System.out.println(b);System.out.println(c);//幂运算double pow = Math.pow(2, 3);System.out.println(pow);}
}

包机制

本质就是一个文件加

把语句的语法格式：

package pkg1[.pkg2[.pkg3...]];

• 一般利用公司域名倒置作为包名；
• 为了能够使用某一个包的成员，我们需要导入该包，使用import语句

import package1.[.package2...].(classname|*);

狂神说包机制

import com.kuang.bacs.*;导入这个包下所有的类！

JavaDOC

javadoc命令是用来生成自己API文档的

参数信息

• @author 作者名
• @version版本号
• @since 指明需要最早使用的jdk版本
• @param 参数名
• @return返回值情况
• @throws异常抛出情况

Java流程控制

Scanner

scanner就是用户与电脑（程序）互动

我们可以通过Scanner类来获取用户的输入

基本语法

Scanner s=new Scanner(System.in);

变量类型 变量名=scanner.Next变量类型；

scanner.close();

凡是属于IO流（输入输出流）的类如果不关闭会一直占用资源，要养成好习惯用完就关掉

通过Scanner类的next（）与nextLine（）方法获取输入的字符串

使用hasNext（）与hasNextLine（）判断是否还有输入的数据

next（）

• 一定要读取到有效字符后才可以结束输出

• 遇到空格后面的字符将去掉

• package scanner;import java.util.Scanner;public class Demo01 {public static void main(String[] args) {//创建一个扫描器对象，用于接收键盘数据Scanner scanner = new Scanner(System.in);System.out.println("使用next方式接收：");//判断用户有没有输入字符串if (scanner.hasNext()==true){//使用next方式接收用户的输入String str=scanner.next();//程序会等待用户输入完毕System.out.println("输出的内容为："+str);}//凡是属于IO流（输入输出流）的类如果不关闭会一直占用资源，要养成好习惯用完就关掉scanner.close();}
  }

nextLine（）

• 可以有空白

• package scanner;import java.util.Scanner;public class Demo02 {public static void main(String[] args) {//从键盘接收数据Scanner scanner = new Scanner(System.in);System.out.println("使用nextLine方式接收：");//判断是否还有输入if (scanner.hasNextLine()==true){String str = scanner.nextLine();//等待用户输入System.out.println("输出的内容为："+str);}scanner.close();}
  }

  也可以不用if语句

  package scanner;import java.util.Scanner;public class Demo03 {public static void main(String[] args) {//从键盘接收数据Scanner scanner = new Scanner(System.in);System.out.println("请输入数据：");String str = scanner.nextLine();//等待用户输入System.out.println("输出的内容为：" + str);scanner.close();}
  }

  Scanner也可以有其他用法，可以用基本数据类型

package scanner;import java.util.Scanner;public class Demo04 {public static void main(String[] args) {Scanner scanner=new Scanner(System.in);//从键盘接收数据int i=0;float f=0.0f;System.out.println("请输入整数数据：");//if语句if (scanner.hasNextInt()==true){i = scanner.nextInt();System.out.println("整数数据："+i);}else{System.out.println("输入的不是整数数据！");}
//=============================================================System.out.println("请输入小数数据：");//if语句if (scanner.hasNextFloat()==true){f = scanner.nextFloat();System.out.println("小数数据："+f);}else{System.out.println("输入的不是小数数据！");}scanner.close();}
}

package scanner;import java.util.Scanner;public class Demo05 {public static void main(String[] args) {//我们要输入多个数字，并且求其总和与平均值，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果；Scanner scanner = new Scanner(System.in);//和double sum=0;//计算输入了多少个数字int m=0;System.out.println("请输入数据");//通过循环判断是否还有输入，并且在里面对每一次进行求和和统计while (scanner.hasNextDouble()==true){double x = scanner.nextDouble();//m=m+1m=++m;sum=sum+x;System.out.println("当前输入了第"+m+"个数据,当前结果sum="+sum);}System.out.println(m+"个数和为："+sum);System.out.println(m+"个数的平均值是：："+(sum/m));scanner.close();}
}

顺序结构

java的基本结构

选择结构

if单选择结构

package struct;import java.util.Scanner;public class Demo01if单选 {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.println("请输入一个内容：");String s = scanner.nextLine();//equals判断字符串是否相等if (s.equals("Hello")){System.out.println(s);}System.out.println("End");scanner.close();}
}

if双选择结构

package struct;import java.util.Scanner;public class Demo02if双选择 {public static void main(String[] args) {//考试分数大于60分就是及格，小于60分就是不及格。Scanner scanner = new Scanner(System.in);System.out.println("请输入成绩:");int score = scanner.nextInt();if (score>=60){System.out.println("及格");}else {System.out.println("不及格");}scanner.close();}
}

if多选择结构

if(){

}else of(){

}else of(){

}else of(){

.....

}else

}

package struct;import java.util.Scanner;public class Demo03多选择结构 {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.println("请输入成绩:");int score = scanner.nextInt();if (score==100){System.out.println("恭喜满分！");}else if (score<100&&score>=90){System.out.println("A级");}else if (score<90&&score>=80){System.out.println("B级");}else if (score<80&&score>=70){System.out.println("C级");}else if (score<70&&score>=60) {System.out.println("D级");}else if (score<60&&score>=0) {System.out.println("不及格");}else {System.out.println("成绩不合法");}scanner.close();}
}

switch多选择结构

反编译，把class文件反编译为java文件

点击项目结构，打开项目编译输出的路径，找到class文件，复制到idea文件夹中，从idea中打开文件夹

package struct;public class Demo02switch {public static void main(String[] args) {String name="田";
//字符的本质还是数字//反编译 java编译---class（字节码文件）---反编译switch (name){case "tyz":System.out.println("tyz");break;case"田":System.out.println("田");break;default:System.out.println("弄啥嘞？");}}
}

循环结构

while循环

避免死循环

计算1加到100

package struct;public class Demo02while循环 {public static void main(String[] args) {//计算1+2+3.。。。+100=？int i=0;int sum=0;while (i<=100){sum=sum+i;i++;}System.out.println(sum);}
}

do...while循环

至少会执行一次

package struct;public class Demo02dowhile循环 {public static void main(String[] args) {int a=0;while (a<0){System.out.println(a);//不输出a++;}System.out.println("==================================");do {System.out.println(a);//输出0a++;}while (a<0);}
}

for循环（最有效最灵活）

for（初始化值；布尔值；更新值）{

//代码

}

快捷键：条件判断.for

计算0~100之间奇数和偶数的和

package struct;public class for循环Demo02 {public static void main(String[] args) {//0~100之间奇数和偶数和int oddSum=0;//奇数和int evenSum=0;//偶数和for (int i = 0; i <=100; i++) {if (i%2!=0){oddSum+=i;}else {evenSum+=i;}}System.out.println("奇数的和："+oddSum);System.out.println("偶数的和："+evenSum);}
}

for循环1~1000之间能被5整除的数，并且每行输出3个

package struct;public class for循环Demo03 {public static void main(String[] args) {//1~1000能被5整除的数  ，并且每行输出三个for (int i = 0; i <= 1000; i++) {if (i%5==0){System.out.print(i+"\t");//转义字符}if(i%(5*3)==0){//换行System.out.println();//System.out.println("\n");}}//println输出完换行//print输出完不换行}
}

for循环的九九乘法表

package struct;public class for循环打印99乘法表Demo04 {public static void main(String[] args) {//去掉重复项，用i<=j判断语句for (int j= 1; j <= 9; j++) {for (int i = 1; i <=j; i++) {System.out.print(i+"*"+j+"="+(i*j)+"\t");}System.out.println();}}
}

增强for循环

package struct;public class for循环增强for循环Demo05 {public static void main(String[] args) {int [] numbers={10,20,30,40,50};//定义了一个数组for (int i=0;i<5;i++){System.out.println(numbers[i ]);}System.out.println("===================");//输出遍历数组的元素for (int x:numbers){System.out.println(x);}}
}

break,continue

break在任何循环语句的主体部分，都可以用break控制循环结束

break用于强行退出循环，不执行循环中剩余的语句（break语句也在switch语句中使用）

continue语句用与循环语句中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定

break

package struct;public class breakDemo01 {public static void main(String[] args) {int i=0;while (i<100){i++;System.out.println(i);if (i==30){break;}//输出1-30}}
}

continue

package struct;public class continueDemo01 {public static void main(String[] args) {int i=0;while (i<100){i++;if (i%10==0){System.out.println();continue;}System.out.println(i);//到10的倍数输出空格}}
}

练习打印三角形

package struct;public class 练习打印三角形Demo01 {public static void main(String[] args) {//打印三角形 打印5行三角形for (int i = 1; i <= 5; i++) {for (int j=5;j>=i;j--){System.out.print(" ");}for (int k=1;k<=i;k++){System.out.print("*");}for (int l=1;l<i;l++){System.out.print("*");}for (int m=5;m>=i;m--) {System.out.print(" ");}System.out.println();}}
}

Java的方法

保持原子性：一个方法只完成一个功能，有利于后期的扩展

• 方法是解决一类问题的步骤的有序组合
• 方法包含于类或者对象中
• 方法在程序中被创建，在其他地方被引用

package method;public class Demo01 {//main 方法public static void main(String[] args) {//实际参数，实际调用传递给他的参数int sum =add(1,2);System.out.println(sum);test();}//加法 方法//形式参数，用来定义作用的public  static int add(int a,int b){return a+b;}//调用for循环public static void test(){
//1~1000能被5整除的数  ，并且每行输出三个for (int i = 0; i <= 1000; i++) {if (i%5==0){System.out.print(i+"\t");//转义字符}if(i%(5*3)==0){//换行System.out.println();//System.out.println("\n");}}}}

方法的定义

一段用来完成特定功能的代码片段

修饰符 返回值类型 方法名（参数类型 参数名）{

。。。

方法体

。。。

return 返回值；

}

• 修饰符：是可选的

• 返回值类型：方法可能返回值，输出一句话返回值为void（为空）

• 方法名：方法的实际名字（首字母小写，驼峰）

• 参数类型:像是一个占位符，可选，也可以不包含任何参数

  • 形式参数：在方法被调用时用于接收外界输入的数据
  • 实参：调用方法实际传给方法的数据

• 方法体：方法里的具体语句，定义该方法的功能

package method;public class Demo02 {public static void main(String[] args) {//int max = max(10, 20);System.out.println(max(10,20));}//比大小的方法public static int max(int i,int j){int result=0;if (i>j){result=i;}else if (i==j){System.out.println("一样大");return 0;//return有终止方法的意思}else {result=j;}return result;}
}

方法的调用

如果返回值是void，那么返回值一定是一条语句

当方法返回一个值的时候，方法调用通常被当作一个值

方法的重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数

规则：

• 方法名称必须相同
• 参数列表必须不同（个数，类型，参数排列顺序）

命令行传参

运行程序的时候再传给程序数据，需要靠传递命令行参数给main（）函数实现。

可变参数

• 在方法声明中，在指定参数类型后加一个”...“
• 一个方法只能指定一个可变参数，它必须是方法的最后一个参数，任何普通参数必须在他之前声明

递归

边界条件

前阶段

返回阶段

package method;public class Demo03 {//阶乘public static void main(String[] args) {System.out.println(f(5));}public static int f(int n){if (n==1){return 1;//边界条件}else {//前阶段return n*f(n-1);//返回阶段}}
}

自己调用自己

递归结构包括两个部分

• 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环
• 递归体：什么时候需要调用自身方法

计算器的编程（scanner，switch）

package method;import java.util.Scanner;public class 计算器Demo4 {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.println("请输入第一个数字");double num1 = scanner.nextInt();System.out.println("请输入运算符");String operator1 = scanner.next();System.out.println("请输入第二个数字");double num2 = scanner.nextInt();System.out.println("请输入运算符");String operator2 = scanner.next();System.out.println("请输入第三个数字");double num3 = scanner.nextInt();double result1=0;double result2=0;switch (operator1){case "+":result1=num1+num2;break;case "-":result1=num1-num2;break;case "*":result1=num1*num2;break;case "/":result1=num1/num2;break;default:System.out.println("您的输入不合法！");return ;}//==============================================switch (operator2){case "+":result2=result1+num3;break;case "-":result2=result1-num3;break;case "*":result2=result1*num3;break;case "/":result2=result1/num3;break;default:System.out.println("您的输入不合法！");return ;}System.out.println("结果是："+num1+operator1+num2+operator2+num3+"="+result2);
scanner.close();}
}

Java数组

定义

• 相同类型数据的有序集合
• 相同类型的若干个数据，按照一定的先后次序排列组合而成
• 每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问他们

声明创建

数据类型[] 变量名=new 数据类型[数组大小]；

数组长度：arrays.length

package struct;public class for循环增强for循环Demo05 {public static void main(String[] args) {int [] numbers={10,20,30,40,50};//定义了一个数组for (int i=0;i<5;i++){System.out.println(numbers[i ]);}System.out.println("===================");//输出遍历数组的元素for (int x:numbers){System.out.println(x);}}
}

三种初始化

• 静态初始化

• 动态初始化

• 数组的默认初始化

  数组是引用类型，它的元素相当于类的实例变量。因此数组一经分配空间（int[] a=new int[10];）,其中每个元素也被按照实例变量被隐式初始化

package array;public class arrayDemo02 {public static void main(String[] args) {//静态初始化:创建加赋值int[] a={1,2,3,4,5,6,7,8};System.out.println(a[0]);//输出1//动态初始化:包含默认初始化int[] b=new int[10];b[0]=10;System.out.println(b[0]);

数组的四个特点

• 其长度是确定的，数组一旦被创建，它的大小就是不可改变的
• 必须是相同类型
• 可以是任意数据类型，包括基本类型和引用类型
• 属于引用类型，数组可以看成是对象，数组中的每个元素都相当于该对象的成员变量。数组本身就是对象，Java中的对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

数组边界：合法区间[0,length-1]

越界：ArrayIndexOutOfBoundsException:数组下标越界

数组的使用

• 普通的for循环

package array;public class arrayDemo03for循环 {public static void main(String[] args) {int[] array={1,2,3,4,5};//打印全部的数组元素for (int i = 0; i < array.length; i++) {System.out.println(array[i]);}//计算所有元素的和int sum=0;//获取数组长度：arrays.Lengthfor (int i = 0; i <array.length ; i++) {sum+=array[i];}System.out.println("和为："+sum);//找最大数int max=array[0];for (int i = 1; i < array.length; i++) {if (array[i] >=max){max=array[i];}}System.out.println("最大值为："+max);}
}

• for-Each循环

• 数组作方法入参

• 数组作为返回值

package array;public class arrayDemo04forEach循环 {public static void main(String[] args) {int[] arrays = {1, 2, 3, 4, 5};//没有下标 array为array[]数组中的元素for (int array : arrays) {System.out.println(array);}System.out.print("数组元素为：");printArray(arrays);//打印数组元素System.out.println('\n');System.out.print("数组元素反转为：");int[] reverse = reverse(arrays);//打印反转后数组元素printArray(reverse);}
//--------------------------------------------------------------//打印数组元素
//创建一个方法，输出数组元素public static void printArray(int[] arrays) {for (int i = 0; i < arrays.length; i++) {System.out.print(arrays[i]+"");}}//--------------------------------------------------------------//反转数组//创建一个方法，反转数组元素public static int[] reverse(int[] arrays) {int[] result=new int[arrays.length];for (int i = 0, j=result.length-1;i<result.length; i++,j--) {//result[]=arrays[i];result[j]=arrays[i];}return result;}
}

多维数组

package array;public class arrayDemo05多维数组 {public static void main(String[] args) {//定义了一个四行两列的数组/*1，2  array[0]2，3  array[1]3，4  array[2]4，5  array[3]*/int[][] array={{1,2},{2,3},{3,4},{4,5}};printArray(array[0]);System.out.println('\n');System.out.println(array[0][0]);System.out.println(array[0][1]);for (int i = 0; i < array.length; i++) {for (int j = 0; j < array[i].length; j++) {System.out.println(array[i][j]);//输出数组的元素}}}//创建一个方法，输出数组元素public static void printArray(int[] arrays) {for (int i = 0; i < arrays.length; i++) {System.out.print(arrays[i]+"");}}
}

Arrays类

给数组赋值：通过fill方法

给数组排序：通过sort，按升序

比较数组：equals比较数组中元素值是否相等

查找数组元素：通过binarySearch能对排序号的数组进行二分查找法操作

package array;import java.util.Arrays;public class arrayDemo06类的使用 {public static void main(String[] args) {int[]a={1,2,3,4,1231,434,5433,64363};//System.out.println(a);输出为[I@1b6d3586//打印数组元素Arrays.toStringSystem.out.println(Arrays.toString(a));//数组进行排序，升序Arrays.sortArrays.sort(a);System.out.println(Arrays.toString(a));Arrays.fill(a,2,4,0);//数组填充，2~4填充为0System.out.println(Arrays.toString(a));}
}