Java SE 学习记录08

@学习记录

开始学习Java

遵从同学的指导，从Java se开始学习

黑马的JavaSE零基础入门

day08-01 字符串的使用与练习

package day08;

/*
字符串的特点：
1.字符串的内容永不可变【重点】
2.正是因为字符串不可改变，所以字符串是可以共享使用的，节省内存
3.字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组

创建字符串的常见3+1种方式
public String();创建一个空白字符串，不含有任何内容
public String(char[] array);根据字符数组的内容，创建对应的字符串
public String(byte[] array);根据字节数组的内容，创建对应的字符串
一种直接创建：
String str = "Hello"; // 右边直接双引号

注意：直接写上双引号就是字符串对象


字符串常量池：程序中直接写上的双引号字符串，就在字符串常量池中，new不在字符串常量池中  。

对于基本类型来说， ==是进行【数值】的比较
对于引用类型来说， ==是进行【地址值】的比较

如果确实需要字符串内容的比较，可以使用两个方法：
public boolean equals(Object obj);参数可以是任何对象，只有当参数是一个字符串并且内容相同的才会给true，否则返回false

注意事项：
1.任何对象都能用Object进行接收。
2.equals方法具有对称性，即a.equals(b)和b.equals(a)效果一样
3.如果比较双方一个常量一个变量，推荐把常量字符串写在前面
即 推荐："abc".equals(str)      不推荐：str.equals("abc")
若变量为空，后者会报错，空指针异常NullPointException

public boolean equalsIgnoreCase(String str);忽略大小写，进行内容比较
注意：只有英文字母区分大小写，其他类似于中文数字都不区分


String中与获取相关的常用方法有：
public int length();获取字符串中含有的字符个数，拿到字符串长度
public String concat(String str);将当前字符串和参数字符串拼接成为返回值【新的】字符串
public cha charAt(int index);获取指定索引位置的单个字符（索引从0开始）
public int indexOf(String str);查找参数字字符串在本字符串当中首次出现的索引位置，如果没有返回-1


字符串的截取方法：
public String substring(int index);截取从参数位置一直到字符串末尾，返回新字符串
public String substring(int begin, int end);截取从begin开始，一直到end结束中间的字符串
备注：[begin,end)，包含左边，不包含右边


String当中与转换相关的常用方法有：
public char[] toCharArray();将当前字符串拆分成为字符数组作为返回值
public byte[] getBytes();获得当前字符串拆分的字节数组
public String replace(CharSequence oldString, CharSequence newString);将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串
备注：CharSequence意思就是可以接受字符串类型


字符串的切割方法：
public String[] split(String regex);按照参数的规则，将字符串切分成若干部分

注意事项：
split方法的参数是一个“正则表达式”，今后学习
如果按照英文据点“.”进行切分，必须写“\\.”（两个反斜杠）

 */

import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        // 使用空参构造
        String str1 = new String();
        System.out.println("第一个字符串是：" + str1);

        // 根据字符数组，创建字符串
        char[] charArray = {'A', 'B', 'C'};
        String str2 = new String(charArray);
        System.out.println("第二个字符串是：" + str2);

        // 根据字节数组创建字符串
        byte[] byteArray = {97, 98, 99};
        String str3 = new String(byteArray);
        System.out.println("第三个字符串是：" + str3);

        // 直接创建
        String str4 = "Hello";
        System.out.println("第四个字符串是：" + str4);
        System.out.println("==================================");

        // 字符串的比较
        String str5 = "Hello";
        String str6 = "Hello";
        char[] charArray1 = {'H', 'e', 'l', 'l', 'o'};
        String str7 = new String(charArray1);
        System.out.println(str5.equals(str6));
        System.out.println(str5.equals(str7));
        System.out.println(str6.equals(str7));
        System.out.println(str7.equals("Hello"));
        System.out.println("Hello".equals(str6));

        // 忽略大小写进行比较
        String strA = "Java";
        String strB = "java";
        System.out.println(strB.equals(strA));
        System.out.println(strA.equalsIgnoreCase(strB));
        System.out.println("==================================");

        // 获取字符串的长度
        System.out.println("字符串的长度为：" + "asdfhciosjfweifj".length());

        // 拼接字符串
        System.out.println("拼接后新的字符串为：" + str4.concat(str6));

        // 获取指定索引位置的单个字符
        System.out.println("第3号索引位置的字符是：" + str7.charAt(3));

        // 查找参数字符串在本字符串中出现的第一次索引位置
        // 如果没有，返回-1
        System.out.println("字符“a”在该字符串中第一次出现的索引位置是：" + strA.indexOf('a'));
        System.out.println("字符“e”在该字符串中第一次出现的索引位置是：" + strA.indexOf('e'));
        System.out.println("==================================");

        // 截取字符串
        System.out.println(str7.substring(1));
        System.out.println(str7.substring(1,4));
        System.out.println("==================================");

        // 转换为char[]
        char[] chars = "Hello".toCharArray();
        System.out.println(chars.length);

        //　转换为byte[]
        byte[] bytes = "abc".getBytes();
        System.out.println(bytes[2]);

        //  替换字符串
        System.out.println("How do you do?".replace("How", "What"));
        System.out.println("==================================");

        // 切割字符串
        System.out.println("aaa,bbb,ccc".split(",")[1]);
        System.out.println("aaa.bbb.ccc".split("\\.")[2]);
        System.out.println("==================================");

        // 按指定格式拼接字符串
        // 定义一个方法，把数组{1，2，3}按照指定格式拼接成一个字符串，格式参照如下：[word1#word#word]
        int[] array = {1,2,3};
        toSting(array);
        System.out.println(together(array));
        System.out.println("==================================");

        // 统计输入的字符串中各种字符的个数
        // 键盘输入一个字符串，并且统计其中各种字符出现的次数
        // 种类有：大写字母，小写字母，数字，其他
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str = sc.next();
        int charCap = 0;
        int charSmall = 0;
        int charNum = 0;
        int charOther = 0;
        char[] char1 = str.toCharArray();
        for (int i = 0; i < char1.length; i++) {
            if (char1[i] >= 'A' && char1[i] <= 'Z') {
                charCap += 1;
            } else if (char1[i] >= 'a' && char1[i] <= 'z') {
                charSmall += 1;
            } else if (char1[i] >= '0' && char1[i] <= '9') {
                charNum += 1;
            } else {
                charOther += 1;
            }
        }
        System.out.println("大写字母出现次数为：" + charCap + "，小写字母出现的次数为：" + charSmall + "，数字出现的次数为：" + charNum + "，其他字符出现的次数为：" + charOther);

    }
    // 该方法没有拼接
    public static void toSting(int[] array){
        for (int i = 0; i < array.length; i++) {
            if (i == 0) {
                System.out.print("[" + "word" + array[i]);
            } else if (i < array.length - 1) {
                System.out.print("#" + "word" + array[i]);
            } else{
                System.out.println("#" + "word" + array[i] + "]");
            }
        }
    }

    // 拼接方法
    public static String together(int[] array) {
        String str = "[";
        for (int i = 0; i < array.length; i++) {
            if (i != array.length - 1) {
                str += "word" + array[i] + "#"; // 对字符串而言，加法是在原有的基础上拼接内容
            } else {
                str += "word" + array[i] + "]";
            }

        }
        return  str;
    }
}

day08-11 静态static关键字的使用

package day08;

/*
如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类。多个对象共享同一份数据。


一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。

如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。
如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。

无论是成员变量，还是成员方法，如果有了static，都推荐使用类名称进行调用。
成员变量：类名称.静态变量
静态方法：类名称.静态方法（）

注意事项：
1. 静态只能直接访问静态，不能直接访问非静态
原因：内存中先有的静态内容，后有的非静态内容
2. 静态方法中不能用this
原因：this代表当前对象，通过谁调用，设就是当前对象

 */
public class Demo02 {
    public static void main(String[] args) {
        Student one = new Student("胡歌", 30);
        one.room = "148教室";
        Student two = new Student("七哥", 20);

        System.out.println("姓名:" + one.getName() + ",年龄：" + one.getAge() + ",教室是：" + one.room + ",学号是：" + one.getId());
        System.out.println("姓名:" + two.getName() + ",年龄：" + two.getAge() + ",教室是：" + two.room + ",学号是：" + two.getId());
        System.out.println("==============================================");

        // 首先创建对象
        MyClass obj = new MyClass();
        // 然后才能使用没有static关键字的内容
        obj.method();

        // 对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名称来调用
        obj.methodStatic(); // 正确，不推荐。这种方法在被javac编译成为类名称.静态方法名
        MyClass.methodStatic(); // 正确，推荐

        // 对于本类当中的静态方法，可以省略类名称

    }
}

package day08;

public class Student {
    private int id;
    private String name;
    private int age;
    static String room;
    private static int idCounter = 0; // 学号计数器，每当new了一个新对象的时候，计数器++

    public Student() {
        this.id = ++idCounter;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.id = ++idCounter;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package day08;

public class MyClass {
    int num;
    static int numStatic;

    // 成员方法
    public void method() {
        System.out.println("这是一个普通的成员方法");
        // 成员方法可以访问成员变量
        System.out.println(num);
        // 成员方法可以访问静态变量
        System.out.println(numStatic);
    }

    // 静态方法
    public static void methodStatic(){
        System.out.println("这是一个静态方法");
        // 静态方法可以访问静态变量
        System.out.println(numStatic);
        // 静态方法不能直接访问非静态【重点】
//        System.out.println(num);
    }

}

静态代码块

package day08;

/*
静态代码块的格式：

public class 类名称 {
    static {
        // 静态代码块的内容
    }
}

特点：当第一次用到本类时，静态代码块执行唯一的一次。
静态内容总是优先于非静态，所以静态代码块比构造方法先执行.

静态代码块的典型用途：
用来一次性的对静态成员变量进行赋值

 */
public class Person {
    static {
        System.out.println("静态代码块执行");
    }

    public Person() {
        System.out.println("构造方法执行！");
    }
}

package day08;

public class Demo03 {
    public static void main(String[] args) {
        Person one = new Person();
        Person two = new Person();

    }
}

day08-17 数组工具类Arrays的使用与练习

package day08;

import java.util.Arrays;

/*
java.util.Arrays是一个与数组相关的工具类，里面提供了大量的静态方法，用来实现数组的常见操作。

public static String toString(数组);将参数数组变成字符串（按照默认格式：【元素1，元素2...】）
public static void sort(数组);按照默认升序（从小到大）对数组的元素进行排序。

备注：
1.如果是数值，sort默认按照升序从小到大
2.如果是字符串，sort默认按照字母升序
3.如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持（今后学习）
 */
public class Demo04 {
    public static void main(String[] args) {
        int[] intArray = {20, 30, 10};
        String intStr = Arrays.toString(intArray);
        System.out.println(intStr);
        System.out.println("==============================");

        int[] array1 = {1, 2, 2, 3, 4, 5, 7};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1));
        System.out.println("==============================");

        // 练习：字符串倒序
        // 请使用Arrays相关的API，将一个随机字符串中的所有字符升序排列，并倒叙打印
        String str = "dasjopikwsjnflocihsaklrfmniov";
        // 首先变成一个数组
        char[] charArray = str.toCharArray();
        // 再运用数组升序排序
        Arrays.sort(charArray);
        for (int i = charArray.length - 1; i >= 0; i--) {
            System.out.println(charArray[i]);
        }




    }
}

day08-17 数学工具类Math的使用与练习

package day08;

/*
java.util.Math类是数学相关的工具，里面提供了大量的静态方法，完成于数学运算相关的操作

public static double abs(double num);获取绝对值
public static double ceil(double num)；向上取整
public static double floor(double num)；向下取整
public static long round(double num)；四舍五入

Math.PI代表圆周率（double）
 */

public class Demo05 {
    public static void main(String[] args) {
        // 获取绝对值
        System.out.println(Math.abs(3.14));
        System.out.println(Math.abs(-5));
        System.out.println(Math.abs(234.234));
        System.out.println("=======================");

        // 向上取整
        System.out.println(Math.ceil(8.25));
        System.out.println(Math.ceil(3.0));
        System.out.println("=======================");

        // 向下取整
        System.out.println(Math.floor(8.25));
        System.out.println(Math.floor(3.0));
        System.out.println("=======================");

        // 四舍五入
        System.out.println(Math.round(1324.34563462));
        System.out.println(Math.round(743.5343));
        System.out.println(Math.round(1324.34563462));
        System.out.println("=======================");

        System.out.println(Math.PI);

        // 练习：小学数学真题
        // 计算再-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个
        int count = 0;
        double min = -10.8;
        double max = 5.9;
        // 这样处理，就是区间内的所有整数
        // 如果使用Math.ceil方法，-10.8 --> -10.0, double也是可以进行++的
        for (int i = (int) min; i < max; i++) {
            int abs = Math.abs(i);
            if (abs > 6 || abs < 2.1) {
                count++;
            }
        }
        System.out.println("共有" + count + "个整数符合要求");

        System.out.println((int)5.9);;
        System.out.println((int)-10.8);;
        int numCount = 0;
        for (int i = (int)-10.8; i <= (int)5.9; i++) {
            if (Math.abs(i) > 6 || Math.abs(i) < 2.1) {
                numCount++;
            }
        }
        System.out.println(numCount);
    }
}