Java第三章

一、数组的声明与创建

数组的基本概念：

• 数组内的元素的数据类型都相同，可以看做是一个容器。

• 数组本身是一个引用数据类型，是一个对象。

• 数组既可以储存基本数据类型，也可以储存引用数据类型（例如字符串）。

• 数组创建时必须指定长度，且长度不可变。

• 数组中的每个空间都是连续的。

代码示例如下： 

import java.util.Arrays;

public class Practice2 {
    public static void main(String[] args) {
        /*
          数组的定义
                数组内的元素的数据类型都相同，可以看做是一个容器
                数组本身是一个引用数据类型，是一个对象
                数组既可以储存基本数据类型，也可以储存引用数据类型（例如字符串）
                数组创建时必须指定长度，且长度不可变
                数组中的每个空间都是连续的
          数组的声明
                数据类型 [] 数组名字   （建议使用）
                数据类型  a []
         */
        int[] a, c;// a、c都被声明成了数组
        int b[], d;// b被声明成了数组，而d不是
        
        // 数组的创建    创建一个已知容量的数组,使用默认值对其进行初始化
        int[] e = new int[5];
        float[] f = new float[6];
        String[] g = new String[7];
        System.out.println(Arrays.toString(e));// [0, 0, 0, 0, 0]
        System.out.println(Arrays.toString(f));// [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
        System.out.println(Arrays.toString(g));// [null, null, null, null, null, null, null]

        // 这两种创建方式的本质相同
        int[] h = new int[]{1, 2, 3, 4, 5};
        int[] i = {1, 2, 3, 4, 5, 6};
        System.out.println(Arrays.toString(h));// [1, 2, 3, 4, 5]
        System.out.println(Arrays.toString(i));// [1, 2, 3, 4, 5, 6]
    }
}

二、数组的访问和迭代

1.数组的访问

• 数组元素的访问：
          数据名[索引]        e.g.a[0]、a[6]......
• 注意:
  1、数组的索引从0开始。
  2、索引的数据类型是整数(int)。
  3、索引最大值和数组长度始终差1。
• 获取数组长度：
  数组名.length

2.数组的迭代

数组的迭代有两种方式 ：

1. for循环
2. 增强for循环

代码示例如下：

import java.util.Arrays;

public class Practice2 {
    public static void main(String[] args) {
        /*
          数组的遍历
                for循环（可对流程进行控制）
                增强for循环（只能从0开始将数组遍历完全）
         */
        int[] j = new int[4];
        j[0] = 10;// 对数组中的元素赋值
        j[1] = 9;
        j[2] = 8;
        j[3] = 7;

        for (int t = 0; t < j.length; t++) {
            System.out.println(j[t]);
        }// for循环
        for (int t : j) {
            System.out.println(t);
        }// 增强for循环
    }
}

三、数组排序

• 冒泡排序
• 选择排序

 1.冒泡排序

代码实现如下：

import java.util.Arrays;

public class Practice3 {
    public static void main(String[] args) {
        /*
          冒泡排序
                排序次数为：长度减一
                e.g.{5,4,3,2,1}（极端情况）
                -->4,3,2,1,5
                -->3,2,1,4,5
                -->2,1,3,4,5
                -->1,2,3,4,5
                共5-1=4次
         */
        int []a = new int[]{21,45,22,12,7,4};
        for (int i = 0; i < a.length-1; i++) {
            for (int j = 0; j < a.length-1-i; j++) {
                if(a[j]>a[j+1]){
                    int temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(a));
    }
}

输出结果：

2.选择排序

import java.util.Arrays;

public class Practice3 {
    public static void main(String[] args) {
        /*
          选择排序
                把第一个元素最为最值，依次与后面的值进行比较，满足条件交换两值；
                然后再从第二个元素开始重复此操作
         */
        int[] b = new int[]{10, 43, 4, 76, 44, 20};
        for (int i = 0; i < b.length - 1; i++) { // 长度减一防止越界
            for (int j = i + 1; j < b.length; j++) {
                if (b[i] > b[j]) {
                    int temp = b[i];
                    b[i] = b[j];
                    b[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(b));
    }
}

输出结果： 

 * 补充拓展

Java中的方法

基本概念：
        Java中的方法类似于其它语言的函数，方法是解决一类问题步骤的组合,表示一种功能和行为. 将功能封装为方法的目的是，可以`实现代码重用，减少冗余，简化代码` Java里的方法`不能独立存在`，所有的方法必须定义在类中。

public class Practice1 {
    public static void main(String[] args) {
        print();
        int num = max(10,15);
        System.out.println(num);
        System.out.println(max(12,24));
        printstars(6);
    }

    /**
     * 打印九九乘法表
     */
    public static void print() {
        for (int i = 1; i < 10; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j + "*" + i + "=" + (i * j) + "  ");
            }
            System.out.println();
        }
    }

    /**
     * 比较两个数的大小
     * @param a  第一个int型的参数
     * @param b  第二个int型的参数
     * @return  返回一个int型的结果
     */
    public static int max(int a,int b){
            int c = (a>b)?a:b;
            return c;// return在具有返回值类型的方法中，做返回处理结果的作用。
    }

    /**
     * 打印星星
     * @param a
     */
    public static void printstars(int a){
        if(a<=0){
            return;// return在没有返回值的方法中，其后面不接任何返回值，仅仅作终止该方法的作用。
        }
        for (int i=0;i<a;i++){
            for(int j=0;j<a;j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

运行结果：