Java基础——Arrays工具类、二维数组

Arrays工具类、二维数组

1.Arrays工具类
2.方法传参和返回值
3.可变参数
4.二维数组
 1.1 二维数组的概念
 1.2 二维数组的定义
 1.3 数组的初始化
 1.4 二维数组的访问
5.调试和文档注释 

第一节 Arrays工具类

使用帮助文档:
 1.6
 1.8  

作用：主要用于对数组进行排序，查找，填充，比较等的操作
Arrays工具类存在于java.util包下，所以使用的第一步就是导包：import java.util.Arrays;

注意1：如果在同一个Java文件中同时使用Scanner和Arrays，则可以向如下方式导包：
      import java.util.Scanner;
      import java.util.Arrays;

      或者简写为：* 所有的类
      import java.util.*;

注意2：但凡是工具类，类中的方法全部是静态的，方便调用
      调用语法：类名.方法名（实参列表）

代码实现：

//演示Arrays工具类的使用
package com.qf.day07;

import java.util.Arrays;

/*
 * Arrays工具类的使用
 * 1 二分查找
 * 2 排序
 * 3 复制
 * 4 填充 
 * 5 把数组转成字符串
 *
 * 
 */

public class Demo1 {
    public static void main(String[] args) {
    //  binarySearch();
        //sort();
        //copy();
        //fill();
        toStr();
    }
    //binarySearch 二分查找
    public static void binarySearch() {
        int[] arr=new int[] {5,8,10,20,65,100}; 
        int result=Arrays.binarySearch(arr,22);
        if(result>=0) {
            System.out.println("找到了");
        }else {
            System.out.println("没找到 ");
        }
    }
    //排序
    public static void sort() {
        int[] arr=new int[] {12,8,100,2,9};
        Arrays.sort(arr);
        System.out.println("排序之后:");
        for(int i=0;i

第二节 方法的传参和返回值

2.1 基本类型作为方法的参数

案例1:交换两个数字

public class Demo2 {
    public static void main(String[] args) {
        int num1=10;
        int num2=20;
        swap(num1, num2);
        System.out.println(num1);
        System.out.println(num2);
    }
    public static void swap(int a,int b) {
        System.out.println("交换之前: a:"+a+" b:"+b);
        int temp=a;
        a=b;
        b=temp;
        System.out.println("交换之后: a:"+a+" b:"+b);
    }

}

2.2 引用类型作为方法的参数

案例2：实现数组排序

import java.util.Arrays;

/*
 * 方法的参数传递和返回值
 * 1 交换两个数字
 * 2 实现数组排序
 * 
 */
public class Demo2 {
    public static void main(String[] args) {
        int[] nums=new int[] {15,8,3,9,20,50};
        sort(nums);
        //遍历nums
        System.out.println("遍历nums");
        for(int i=0;iarr[j+1]) {
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        //排序之后
        System.out.println("排序之后");
        System.out.println(Arrays.toString(arr));

    }

}

总结： Java中的方法传参采用的是传值的方式。

     1 基本类型传递的实际数据，对调用方没有影响

     2 引用类型传递的是地址，对调用方有影响

2.3 基本类型作为方法返回值

案例3 编写一个方法，实现1-100和，并返回结果

public class Demo3 {

    public static void main(String[] args) {
        int result=sum();
        System.out.println(result);
    }

    public static int sum() {
        //计算1-100的和
        int sum=0;
        for(int i=0;i<=100;i++) {
            sum+=i;
        }
        return sum;
    }
}

2.4 引用类型作为方法返回值

案例4 : 编写一个方法，返回一个数组

package com.qf.day07;

import java.util.Arrays;

/*
 * 方法返回值
 * 1 基本类型作为方法返回值
 * 2 引用类型作为方法返回值
 */
public class Demo3 {

    public static void main(String[] args) {
        int[] nums2=getNums();
        for(int i=0;i

总结：方法的返回值如果是基本类型则返回实际数据，如果是引用类型则返回地址。

特殊：String类型传值方法和返回值遵循基本类型。

第三节 可变参数

不定长参数

在设计方法时，方法的形参的个数是不确定的
语法
类型... 变量名称
例如：int... num

好处：不用创建数组，直接写数组元素

代码实现：

package com.qf.day07;
/*
 * 可变参数
 * int...
 * 好处：不用创建数组，直接写数组元素
 * 注意事项：
 * 1 一个方法只能有一个可变参数
 * 2 可变参数只能方法参数列表最后
 */
public class Demo4 {
    public static void main(String[] args) {
        //调用
        //int[] nums= {10,4,8,20};
        //sort(nums);
        sort(10,4,8,20,1,2); //实际运行是，把这些数据变成数组

    }
    public static void sort(int a,int... arr) {
        for(int i=0;iarr[j+1]) {
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
    }
}

注意：

a.不定长的参数在进行使用的时候被当做数组来进行处理

b.一个方法只能有一个可变参数

c. 可变参数只能方法参数列表最后

第四节 二维数组

4.1 二维数组的概念

本质上还是一个一维数组，只是其数组元素又是一个一维数组

    举例说明: 变量，一维数组，二维数组之间的关系
    吸烟：
    没钱      1根       一个变量
    稍微有钱  一包       一维数组【20根】    
    有钱      一条      二维数组【10包】

4.2 二维数组的定义

    方式一：元素类型[][] 数组名称；

    方式二：元素类型 数组名称[][]；
    推荐使用方式一

4.3 数组的初始化

    静态初始化：

    语法：元素类型[][] 数组名称 = new 元素类型[][]{{一维数组1,一维数组2,一维数组3....};
    简化：元素类型[][] 数组名称 =m{{一维数组1,一维数组2,一维数组3....};

    举例：int[][] arr = new int[][]{{2,3},{5,2,1},{10,45,22,54}};
          int[][] arr = {{2,3},{5,2,1},{10,45,22,54}};

    动态初始化：

    语法：元素类型[][] 数组名称 = new 元素类型[二维数组的长度][一维数组的长度]
    举例：int[][] arr = new int[3][4];
    说明：定义一个数组arr，二维数组中一维数组的个数为3个，每个一维数组中元素的个数为4个

4.4 二维数组的访问

通过下标访问二维的指定元素

class TwiceArrayDemo01 
{
    public static void main(String[] args) 
    {
        int[][] arr = new int[3][4];

        System.out.println(arr);//[[I@15db9742
        System.out.println(arr.length);//3
        System.out.println(arr[0]);//[I@6d06d69c
        System.out.println(arr[0].length);//4
        System.out.println(Arrays.toString(arr));//[[I@6d06d69c, [I@7852e922, [I@4e25154f]
        System.out.println(Arrays.toString(arr[0]));//[0, 0, 0, 0]

        /*
        [[I@15db9742
        3
        [I@6d06d69c
        4
        [[I@6d06d69c, [I@7852e922, [I@4e25154f]
        [0, 0, 0, 0]
        */
    }
}

遍历二维数组

//常见的操作：遍历二维数组
class TwiceArrayDemo02 
{
    public static void main(String[] args) 
    {
        //如果二维数组中一维数组的元素个数不确定
        //int[][] arr = new int[3][];

        int[][] arr = new int[][]{{2,3},{5,2,1},{10,45,22,54}};

        //遍历arr
        for(int i = 0;i < arr.length;i++) {
            System.out.println(arr[i]);
        }

        //赋值：给arr中的第1个元素修改值
        arr[1] = new int[2];

        //给arr[0]中的第0个元素修改值
        arr[0][0] = 10;

        //遍历arr[0]
        for(int i = 0;i < arr[0].length;i++) {
            System.out.println(arr[0][i]);
        }

        //二维数组的遍历：嵌套for循环
        //简单for循环
        for(int i = 0;i < arr.length;i++) {
            int[] subArr = arr[i];
            for(int j = 0;j < subArr.length;j++) {
                System.out.println(subArr[j]);
            }
        }

        //增强for循环
        for(int[] subArr1:arr) {
            for(int n:subArr1) {
                System.out.println(n);
            }
        }
    }
}

4.5 内存中的二维数组

画图分析：

第五节：调试技巧

使用eclipse的调试技巧，帮助开发人员理解程序执行过程。使用eclipse调试程序需要两个步骤：

• 1添加断点：

• 2单步执行：
  快捷键： F5单步进入 Step Into
  F6单步跳过 Step Over
  F8继续执行 Resume
  查看变量窗口、断点窗口

第六节：文档注释

java中注释

• 单行注释：//这里是单行注释

• 多行注释：/*这里是多行注释，

                   可以多行*/
  

• JavaDoc注释：用来注释类、属性和方法等
  使用语法 /* …../

• JavaDoc常用标签

  标签 含义 标签 含义
  @author 标识一个类的作者，例如 @author wgy @version 指定类的版本
  @see 指定参考的链接或内容 @param 说明一个方法的参数
  @since 标记一个特定的变化时，@since jdk1.2 @return 说明返回值类型

  /**

  • 学校类
  • @author wgy
  • @version 2.0 2018/03/20
    */
    public class School {
    /* 学校名称 /
    String schoolName;
    //…
    /**
    
    • 招生方法
    • @return total
      */
      public void DrawStudent() {
      System.out.println(schoolName+”开始招生…”);
      }
      //…
      }

文档注释作用：

1.编写代码时可通过提示显示文档注释

2.JavaDoc能够从源代码中抽取类、属性、方法等的注释，形成一个配套的API帮助文档 。

  演示1：eclipse生成帮助文档。注意编码 -encoding utf-8 -charset utf-8

  演示2：javadoc -d doc -encoding utf-8 -charset utf-8 src\com\qf\day23_3\Person.java

总结

1 Arrays工具类 的使用

binarySearch() //二分查找

    sort();// 排序

    copyOf();// 复制数组

fill();// 填充

toString();//把数组转成字符串形式

2 方法的参数传递和返回值

1 方法的参数传递采用传值方式： 基本类型传递的实际数据   引用类型传递的地址

    2 方法的返回值，返回数据，基本返回实际数据，引用类型返回地址。

3 二维数组，实际上是由一维数组组成，一维数组的每个元素还是一个数组。

4 二维数组的声明、初始化、访问(通过下标访问，遍历)

int[][] arr=new int[][]{{10,20},{30,40}}

5 调试技巧

1 添加断点

2 单步执行    F6单步跳过   F5单步进入  F8继续执行   ctrl+f12 终止调试

6 文档注释

 帮助开发人员生成API文档

面试题

1.二维数数组在内存中的存储方式是怎样的？

    Java本质上没有设置多维数组，其实现二维数组的方式为在一维数组中储存一维数组，即一维数组的每一个元素为一个一维数组。