java基础第四讲——数组、字符串、类与对象（构造器）

目录

数组
字符串
类与对象

数组

一维数组
冒泡排序
多维数组
定义：一组相同的数据构成的数据

一维数组

数组的声明：
数据类型 变量名;
int[] array1 = new int[大小];

初始化赋值 int [] array2 = { };

    // 数组的定义及初始化赋值的测试
    public static void shuZuTest() {
        // 数组的定义及初始化赋值
        int[] array1 = new int[10];
        array1[0] = 10;
        int[] array2 = { 0, 1, 2, 3 };// 静态初始化
        System.out.println(array2[2]);
        // 通过for循环遍历数组
        for (int i = 0; i < array2.length; i++) {
            System.out.print(array2[i] + " ");
        }
    }

    // 键盘输入数据计算总分平均分
    public static void averageGrade() {
        Scanner scanner = new Scanner(System.in);
        double[] score = new double[5];
        double sum = 0;
        for (int i = 0; i < score.length; i++) {
            score[i] = scanner.nextDouble();
            sum += score[i];
        }
        System.out.println("总分：" + sum);
        System.out.println("平均分：" + sum / score.length);
    }

    // 就输入数据的最大值
    public static void maxGrade() {
        Scanner scanner = new Scanner(System.in);
        double[] score = new double[5];
        double max = 0;
        for (int i = 0; i < score.length; i++) {
            score[i] = scanner.nextDouble();
            if (score[i] > max) {
                max = score[i];
            }
        }
        System.out.println(max);
    }

    // 复制数组
    public static void arrayTest() {
        int[] score = { 52, 75, 73, 42, 36, 92 };
        // 通过Arrays.copyOfRange(original, from, to)复制数组.
        // 包前不包后，Arrays.copyOfRange()返回的是一个数组
        int[] array = Arrays.copyOfRange(score, 2, 5);
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
        // 通过System.arraycopy(src, srcPos, dest, destPos, length);复制数组
        // src源数组,srcPos源数组起始位置, dest复制后数组, destPos复制后数组起始位置, length复制长度
        int[] array2 = new int[10];
        System.arraycopy(score, 2, array2, 3, 4);
        for (int i = 0; i < array2.length; i++) {
            System.out.print(array2[i] + " ");
        }
    }
        // 课堂训练
    // 随机10个两位数，然后从小到大排列
    public static void train1() {
        Random random = new Random();
        int[] array = new int[10];
        int a = 0;
        for (int i = 0; i < array.length; i++) {
            array[i] = random.nextInt(90) + 10;
        }

        // Array的方法
        // Arrays.sort(array);

        // 冒泡算法
        for (int j = 0; j < array.length - 1; j++) {
            for (int j2 = 0; j2 < array.length - 1 - j; j2++) {
                if (array[j2] > array[j2 + 1]) {
                    a = array[j2];
                    array[j2] = array[j2 + 1];
                    array[j2 + 1] = a;
                }
            }
        }

        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

冒泡排序

N个数字来排队
外层循环N-1
内层循环N-1-i

也可用Arrays中的sort()方法排序

// 冒泡排序
    public static void paiXu() {
        int[] score = { 52, 75, 73, 42, 36, 92 };
        int m = 0;// 引入中间变量
        for (int i = 0; i < score.length - 1; i++) {
            // 循环嵌套，注意内循环的循环条件
            for (int j = 0; j < score.length - i - 1; j++) {
                if (score[j] > score[j + 1]) {
                    // 通过中间变量进行两个值的排序
                    m = score[j + 1];
                    score[j + 1] = score[j];
                    score[j] = m;
                }
            }
        }
        //Arrays.sort(score);// 通过Array中的sort升序排序
        // 重新打印一遍
        for (int i = 0; i < score.length; i++) {
            System.out.println(score[i]);
        }
    }

多维数组(以二维数组为例)

int[][] array = new int[第一行大小][]
int[][] array = {{},{},{}…};

    // 多维数组的定义及赋值测试
    public static void duoWeiShuZu() {
        int[][] array1 = new int[3][4];
        array1[0] = new int[] { 2, 3, 1, 0 };
        System.out.println(array1[1][2]);// 输出null
        int[][] array2 = { { 1, 2, 4, 5 }, { 2, 4, 5 }, { 5, 2, 8, 2 }, { 1, 6 } };
        System.out.println(array2[2][1]);
    }

    // 随机4行4列的矩阵到一个二维数组里，求出主对角线元素的乘积以及副对角线元素的乘积
    public static void train2() {
        Random random = new Random();
        int[][] array = new int[4][4];
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length; j++) {
                array[i][j] = random.nextInt(100);
            }
        }
        int m1 = 1;
        int m2 = 1;
        // 打印矩阵
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length; j++) {
                System.out.print(array[i][j] + "\t");// 每循环完一行就会制表
            }
            System.out.println(Arrays.toString(array[i]));// 通过toString方法将array的每一行打印出来
        }
        // 计算主对角线及副对角线的乘积
        for (int i = 0; i < array.length; i++) {
            m1 *= array[i][i];
            m2 *= array[i][array.length - i - 1];
        }
        System.out.println("主对角线的乘积：" + m1);
        System.out.println("副对角线的乘积：" + m2);
    }

字符串

    // 字符串的定义及赋值
    public static void stringTest() {
        String s1 = "abd";
        String s2 = "dss";
        s1 = s1.concat(s2);// 在s1后面连接s2
        System.out.println(s1);
    }

    // 键盘输入信息，计算其长度
    public static void CountLength() {
        Scanner scanner = new Scanner(System.in);
        String words = scanner.next();
        System.out.println(words.length());
    }

    // 大小写互换
    public static void dXHuhuan() {
        String s = "adsfDFOJHdjf";
        String s1 = "";
        for (int i = 0; i < s.length(); i++) {
            char a = s.charAt(i);
            // 调用Character方法判断大小写并反转。
            if (Character.isLowerCase(a)) {
                a = Character.toUpperCase(a);
            } else if (Character.isUpperCase(a)) {
                a = Character.toLowerCase(a);
            } else {
                System.out.println(i + "此处不为英文字母");
                break;
            }
            s1 = s1 + a;// 连接符，将得到的char型连接到s1上。
        }
        System.out.println(s1);
    }

    // 判断是否为邮箱 xxxxx@xxx.com .cn .net
    // 不用正则表达式
    public static void isEmail() {
        Scanner scanner = new Scanner(System.in);
        String email = scanner.next();
        if (email.contains("@")) {// 判断是不是含有“@”
            int index = email.indexOf('@');
            boolean IsLetterOrNumber = true;
            String start = email.substring(0, index);
            for (int i = 0; i < start.length(); i++) {// 将前边的一段遍历查看是不是有不是字母和数字的
                char c = start.charAt(i);
                if (!Character.isLetterOrDigit(c)) {// 如果不是跳出
                    IsLetterOrNumber = false;
                    break;
                }
            }
            if (IsLetterOrNumber) {
                if (email.contains(".")) {// 判断是不是有“.”
                    int index1 = email.lastIndexOf('.');// 最后一次出现'.'的索引
                    String next = email.substring((index) + 1, index1);
                    for (int j = 0; j < next.length(); j++) {// 遍历中间一段是不是有不是字母和数字的
                        char b = next.charAt(j);
                        if (!Character.isLetterOrDigit(b)) {// 如果不是跳出
                            IsLetterOrNumber = false;
                            break;
                        }
                    }
                    if (IsLetterOrNumber) {
                        // 判断最后是不是以.com或.cn或.net结尾
                        if (email.endsWith(".com") || email.endsWith(".cn") || email.endsWith(".net")) {
                            System.out.println(email + "这是一个邮箱");
                        } else {
                            System.out.println("里边没有.com或.cn或.net,故不是一个邮箱");
                        }
                    } else {
                        System.out.println(next + "里边不只有数字和字母");
                    }
                } else {
                    System.out.println("里边没有‘.’故不是邮箱");
                }
            } else {
                System.out.println(start + "里边不只有数字和字母");
            }
        } else {
            System.out.println("不包含@，所以不是邮箱");
        }
    }

类与对象

类中只包含：
构造器
属性
方法：首字母小写

package com.pb.classtest;
/**
 * 汽车类 
 * 里边有2个构造器，一个无参，一个有参
 * 2个属性
 * 2个方法
 * @author Administrator
 *
 */
public class Car {
    //构造器
    //默认构造器
    public Car(){

    }
    //有参构造器，若只有有参构造器，系统会将默认构造器屏蔽，可以自己写
    public Car(String color){
        this.color = color;
    }
    //属性[访问修饰符][属性类型] 属性名称 可以赋初始值
    public String color;
    public String brand;
    //[访问修饰符][返回类型，如果没有用void][方法名称](参数类型 参数名){方法体}
    public void runing() {
        System.out.println("汽车正在跑...");
    }
    public  String gps(String gpsname) {
        System.out.println("正在导航..."+gpsname);
        return "不要着急";
    }
}
package com.pb.classtest;

/**
 * 创建一个学生类 
 * 里边包括4个属性5个方法，其中两个为Set，Get方法
 * 
 * @author Administrator
 *
 */
public class Student {
    private String name;
    private String number;
    private char sex;
    private String live;

    public void study(String major) {
        System.out.println(getName() + "正在学习" + major);
    }

    public void eat() {
        System.out.println("正在吃饭...");
    }

    public String sleeping() {
        return getName() + "在" + live + "公寓睡觉";
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}
//测试类，用于测试个各类
package com.pb.classtest;

public class Test {
    public static void main(String[] args) {
        Car car = new Car("红色");
        car.runing();
        String s = car.gps("北斗");
        System.out.println(car.color);
    }
}