今日内容

另: return补充说明
0 数组复习
1 数组内存
2 数组其他声明方式
3 数组遍历
4 数组在方法中的使用
5 数组排序算法

0.1 复习

1 中文描述方法的定义

• 方法是一段功能代码,完成某些事情,是独立的
• 有固定的写法 public static
• 根据方法是否返回数据,来确定要不要设置返回值类型,不返回设置void,要返回数据就设置对应数据类型
• 方法名随便写
• 根据方法功能,确定要不要参数

2 带参数的方法如何调用

• 调用时必须传入参数
• test(1.1);

3 有返回值的方法如何调用

• int a = test();
• 调用方法后在左边使用变量接收返回值

4 返回值是什么作用,返回给谁

• 返回值的作用是用来被别的代码继续使用的
• 只不过最常用的使用方式是输出,
• 返回值还可以继续做运算,也可以再当参数传递给别人
• 返回给谁? 谁调用方法返回给谁!

5 数组用来干什么,定义的语法是什么

• 数组是容器,用来装数据,有容量限制
• 定义: 数据类型[] 数组名 = new 数据类型[容量];
• 这样创建数组,数组中存储的是初始值
• 整型初始值是0,浮点型初始值0.0,String初始值是null
• 数组会自动分配下标

6 解释数组下标

• 下标就是位置编号,从0开始,最大长度-1
• 作用: 能够快速定位位置,找到数据

7 数组的存值取值语法

• 数据类型 变量 = 数组名[下标]; // 取值
• 数组名[下标] = 值;// 存值

0.2 return补充

return是返回的意思,有什么作用?

• 只有return,那就是单纯结束方法而已,方法定义是void
• 如果是return + 值; 结束方法并将数据返回

    public static void main(String[] args) {
        test1();
        System.out.println(3 );
    }

    // 只有return,方法定义可以是void
    public static void test1(){
        System.out.println(1 );
        return;// return是结束方法,该方法内后续代码无法执行
        // System.out.println(2 ); // 不会执行
    }

    public static int test2() {
        System.out.println(11 );
        return 1;// return是结束方法,该方法内后续代码无法执行
        // 并且还会将值返回
        // System.out.println(22 );// 报错,执行不到
    }

0.3 复习数组基本使用

    public static void main(String[] args) {
        /**
         * 创建长度为3的整型数组
         * 默认存储的是0,即[0,0,0]
         * 下标分别是0,1,2
         */
        int[] arr1 = new int[3];

        /**
         * 取出数组元素
         */
        int a1 = arr1[0];
        int a2 = arr1[1];
        int a3 = arr1[2];
        System.out.println(a1 );
        System.out.println(a2 );
        System.out.println(a3 );

        /**
         * 向数组存值
         */
        arr1[0] = 10;
        arr1[1] = 20;
        arr1[2] = 30;

        /**
         * 再次取出查看效果
         */
        System.out.println(arr1[0] );
        System.out.println(arr1[1] );
        System.out.println(arr1[2] );
    }

一、数组内存【理解】

 * @desc 数组内存
 */
public class Demo2 {
    // 主方法也是方法,也会进栈
    public static void main(String[] args) {
        /**
         * new 会进堆中开辟空间,产生地址值
         * 地址值会赋值给数组名,即数组名其实就是地址值
         * -------------------------------------
         * new 创建数组的同时,数组内部数据会初始化,
         * 会分配下标,从0开始
         */
        int[] arr1 = new int[3];
        System.out.println(arr1 );// 打印数组名就是地址值

        System.out.println(arr1[0] );// 0

        arr1[0] = 10;

        System.out.println(arr1[0] );// 10
    }
}

二、数组其他创建方式

之前的创建数组

• 数据类型[] 数组名 = new 数据类型[容量];
  • 这样创建数组是指定长度,没有指定数据,创建出的数组内部是默认值

其实还有其他创建方式

• 数据类型[] 数组名 = new 数据类型[]{值1,值2,…};
  • 这样创建数组是不指定长度,但是指定数据
  • 与之前的区别只是初始值不一样
• 上面的方式可以简化为: 数据类型[] 数组名= {数据1,数据2,....};
  • 其他数组的取值,赋值用法一模一样

 * @desc 创建数组的其他方式
 */
public class Demo3 {

    public static void main(String[] args) {

        // 不指定长度,但是指定数据
        // 数据类型[] 数组名 =new 数据类型[]{数据1,数据2,....};
        // 虽然没有指定长度,但是长度以及下标程序会自己算出来
        String[] nameArr = new String[]{"李白","安其拉","百里玄策"};

        // 从数组中取出数据
        System.out.println(nameArr[0] );// 李白
        System.out.println(nameArr[1] );// 安其拉
        System.out.println(nameArr[2] );// 百里玄策

        // 可以重新赋值
        nameArr[0] = "刘备";
        nameArr[1] = "关羽";
        nameArr[2] = "张飞";
        System.out.println(nameArr[0] );// 李白
        System.out.println(nameArr[1] );// 安其拉
        System.out.println(nameArr[2] );// 百里玄策

        double[] priceArr = new double[]{450.0,1350.0,4800.0,6300.0};
        System.out.println(priceArr[0] );// 450

        // =============================================
        // 简化格式(推荐)
        int[] arr1 = {1,2,3,4,5};
        // 创建了int型数组,长度为5,存储元素是1,2,3,4,5,下标0,1,2,3,4
        System.out.println(arr1[0] );//1
        System.out.println(arr1[1] );//2

        arr1[0] = 11;
        arr1[1] = 22;

        System.out.println(arr1[0] );//11
        System.out.println(arr1[1] );//22
    }
}

获得数组长度

• 数组提供了一个属性,调用即可获得长度
• length
• 用法: int a = 数组名.length;

 		int[] arr2 = {11,22,33,44,55};
        int length = arr2.length;
        System.out.println("长度: " + length );

三、数组遍历【重要】

数组遍历,就是一个一个将数组中存储的数据取出来

 * @desc 数组遍历
 *  一个一个将数组中存储的数据取出来
 *  ps: 遍历不只是一个一个输出出来
 */
public class Demo4 {

    public static void main(String[] args) {

        int[] arr = {1,2,3,4,5,6,7,8};
        // 数组遍历,找规律,发现重复的取值,变化的是下标
        // 可以使用循环来简化遍历
        // System.out.println(arr[0]);
        // System.out.println(arr[1]);
        // System.out.println(arr[2]);
        // System.out.println(arr[3]);
        // System.out.println(arr[4]);

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

遍历练习

 /* @desc 数组遍历
 *  一个一个将数组中存储的数据取出来
 *  ps: 遍历不只是一个一个输出出来
 */
public class Demo4 {

    public static void main(String[] args) {    
        // 设计数组,存储5个位置英雄名字,并将其输出
        // String[] nameArr = new String[5]; // 这种方式比较麻烦
        // nameArr[0] = ""; // 还要一个一个再单独存储数据
        // nameArr[1] = "";
        // nameArr[2] = "";
        // nameArr[3] = "";
        // nameArr[4] = "";
        // 建议直接存储数据
        String[] nameArr = {"德玛西亚","格雷福斯","沙漠皇帝","圣枪游侠","唤潮鲛姬"};
        for (int i = 0; i < nameArr.length; i++) {
            System.out.println(nameArr[i] );
        }

        // 假设现有数组,存储5个英雄的价钱,将它们5人全部涨价1000
        double[] priceArr = {450,4800,6300,6300,4800};

        for (int i = 0; i < priceArr.length ; i++) {
            System.out.println("原价:"+ priceArr[i] );
            // 涨价
            priceArr[i] = priceArr[i] + 1000;

            System.out.println("现价:" + priceArr[i]);
        }
         // 假设现有数组,存储5个英雄的身高cm,输出其中最高身高
        int[] heightArr = {180,150,230,190,160};
        int max = heightArr[0];// 假设第一个人最高
        for (int i = 0; i < heightArr.length; i++) {
            if(heightArr[i] > max){
                max = heightArr[i];
            }
        }
        System.out.println("最高的是: " + max );
    }
}

目前总结

数组就几个核心

• 创建
  • int[] arr = new int[3]; // 指定长度不指定容量
  • int[] arr = {11,22,33} // 不指定长度,指定数据;
• 取值
  • 数组名[下标]
  • sout(arr[0]);
  • int a = arr[0];
• 存值
  • 数组名[下标] = 值;

---

数组常用的技巧

• 遍历数组
• 数组的长度, .length

四、数组在方法中的使用

4.1 将数组做为方法的参数

   public static void main(String[] args) {

        int[] arr1 = {1,2,3,4,5};
        foreach(arr1);// 调用方法传入数组

        int[] arr2 = {11,22,33,44};
        foreach(arr2);

    }

    // 数组做为方法的参数
    public static void foreach(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i] );
        }
    }

4.2 将数组做为方法的返回值

public static int[] test(){}

---

方法的返回值类型需要写的是数据类型

Java数据类型有两大类

• 基本数据类型: byte short int long doube float boolean char
• 引用数据类型: 数组,类,接口

public class Demo5 {
    public static void main(String[] args) {
        double[] arr3 = test();// 调用方法,返回数组
        for (int i = 0; i < arr3.length; i++) {
            System.out.println(arr3[i] );
        }
    }

    public static double[] test(){
        // 假设方法执行完,返回了好多数据
        // 这些数据存储到数组中
        double[] arr = {60.1,59.9,70.2,99.9};
        return arr;
    }
}

五、数组排序算法

5.1 双层for循环[了解]

    public static void main(String[] args) {
        System.out.println("----演示ln区别-----" );
        System.out.println("加ln,输出完换行,注意看光标");
        System.out.print("不加ln,输出完不换行,注意看光标");
        System.out.println( );

        System.out.println("----演示ln区别1-----" );
        System.out.println(11 );
        System.out.println(22 );
        System.out.println(33 );

        System.out.println("----演示ln区别2-----" );
        System.out.print(10 );
        System.out.print(20 );
        System.out.print(30 );
        System.out.println( );

        System.out.println("----- 演示双层for循环 -----" );
        /**
         * 外层循环循环一次,内部代码都要重新执行一遍
         * 即外层循环一次,里边for循环就要循环10次
         */
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 10; j++) {
                System.out.print("*" );// 不换行
            }
            System.out.println( );// 纯换行
        }
    }

5.2 排序算法

通过一系列操作,将整数数组按照顺序排序

比如一个数组{3,1,5,2,4} , 经过算法执行 这个数组变成 {1,2,3,4,5}

---

排序算法很多

• 冒泡排序,选择排序,插入排序
• 快速排序,堆排序,希尔排序,归并排序
• 桶排序,基数排序,计数排序

冒泡排序, 就像吐泡泡,往后越来越大

其实对于代码来说,就是相邻两个数字比较,大的放后面,小的前面,依次向后

 * @desc
 */
public class Demo7 {

    // 相邻两个数字比较,大的放后面,小的前面,依次向后
    public static void main(String[] args) {

        int[] arr = {3,2,5,1,4};
        System.out.println("--- 排序前 ---" );
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] +" ");
        }
        System.out.println( );

        // 排序
        // 外层循环控制比较趟数,-1最后一趟不用比较
        for (int i = 0; i < arr.length-1; i++) {
            // 内层循环控制每趟里边相邻两个比较次数
            // -1为了防止越界
            // -i为了每趟比较时,最后i个不用比较
            for (int j = 0; j < arr.length-1-i; j++) {
                if (arr[j] > arr[j+1]) {
                    int temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] =temp;
                }
            }
        }
        
        System.out.println("--- 排序后 ---" );
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] +" ");
        }
        System.out.println( );
    }
}

六、Arrays

Arrays 数组工具类,帮助我们快速操作数组

• toString(),将数组转字符串的
• sort(),将数组按照升序排序

    public static void main(String[] args) {
        int[] arr = {3,2,5,1,4,6};

        // Arrays需要导包
        // 直接通过名字.方法名调用
        // 传入数组参数
        // 将数组元素按照字符串返回
        String s = Arrays.toString(arr);
        System.out.println(s );

        // 将数组按照升序排序
        Arrays.sort(arr);

        System.out.println(Arrays.toString(arr) );
    }

单词

index 下标,一般见到变量i,要么是int缩写,要么就是index缩写
name 姓名
array 数组
price 价格
width 宽度
height 高度
line 行