java学习笔记(4) - 面向对象(4)

1. 对象

package chapter04;

public class oop2 {
    public static void main(String[] args){

        // TODO 常见类和对象
        // java.lang.Object : 对象(默认加载)
        Object obj = new Person();

        // 讲对象转换成字符串。
        // toString默认打印的就是对象的内存地址，所以，为了能够更直观理解对象的内容，所以可以重写这个方法
        String s = obj.toString();
        System.out.println(s); // chapter04.Person@3b07d329

        // TODO 获取对象的内存地址
        int i = obj.hashCode();
        System.out.println(i);// 990368553(内存地址)

        // TODO 判断两个对象是否相等, 如果相等，那么返回true，否则返回false
        // equals方法比较对象时，默认比较就是内存地址
        Person otherPerson = new Person();
        System.out.println(otherPerson.hashCode()); // 1096979270(内存地址)
        System.out.println(obj.equals(otherPerson));

        // getClass获取对象的类型信息
        Class<?> aClass = obj.getClass(); // 获取对象的实例化的类名
        System.out.println(aClass.getSimpleName()); // Person
        System.out.println(aClass.getPackageName());// 获取对象的报包名 chapter04
    }
}

// 常用类和对象
class Person { // 实际上等于: class Person extends Object
//    public String name = "zhangsan";
//    // 当然我们也可以复写这些方法
//    @Override
//    public String toString() {
//        return "Person["+name+"]";
//    }
//
//    // 复写方法
//    @Override
//    public boolean equals(Object obj) {
//        return true;
//    }
}

// 这个类也相当于间接继承 Object
class User extends Person {

}

// 数组对象
class User1 {
    // 声明一个方法
    public void test() {
        System.out.println("test...");
    }
}

2. 数组(二维数组)

• 官方文档

package chapter04;
import java.util.Arrays; // 引用常用操作数组的方法库

public class oop2 {
    public static void main(String[] args){

        // 数组对象
        // 可以直接初始化数组
        String[] a = {"张三","李四","王五"};
        for (String s1 : a) {
            System.out.println(s1); // 也是可以成功依次输出: 张三,李四,王五
        }

        // 循环遍历new同一个类生成同一个对象掉哟个同一个方法
        User1[] users = new User1[5];// 定义一个长度为5且以类User1为元素的数组
        for ( int i1 = 0; i1 < users.length; i1++ ) {
            users[i1] = new User1();
            users[i1].test();
        }


        // TODO 数组的声明方式：类型[] 变量；
        // TODO 数组的创建：new 类型[容量]；
        String[] names = new String[3]; // 定义一个长度为3且以字符串为元素的数组
        // 给数组的小格子添加数据，添加的方式为 ：数组变量[索引] = 数据
        // 添加数据和访问数据时，索引是不能超过指定的范围的（0 ~ length-1）
        // 如果重复给相同的索引添加数据，那么等同于修改数据
        names[0] = "zhangsan";
        names[0] = "zhaoliu"; // 重复赋值同一个数组元素相当于修改该数组元素
        names[1] = "lisi";
        names[2] = "wangwu";
        //names[3] = "zhaoliu"; // 不能超过一开始定义的数组长度

        // 查询(访问)数据，访问的方式为 ：数组变量[索引]
        System.out.println("***************************************");
        for ( int i2 = 0; i2 < 3; i2++ ) {
            System.out.println(names[i2]); // 成功循环输出数组元素
        }

        // 二维数组
        // TODO 所谓二维数组就是表: 有行和列(比较简单)
        // 直接初始化定义
        String[][] b = {{"1","2","3"},{"4","5","6"}};
        // 或者后面在初始化
        String[][] c = new String[3][3]; // 成功定义一个3*3(三行三列的二维数组)
        c[0][0] = "123"; // 数组的赋值

        for(int row = 0; row < c.length; row++){
            for (int col = 0; col < c[row].length; col++){
                System.out.println(c[row][col] + "   "); // 循环遍历输出二维数组中的所有元素
            }
            System.out.println();// 打印一个回车
        }

        int[] d = {12,21,55,2,61,18,8};
        Arrays.sort(d);
        for (int i1 : d) {
            System.out.println(i1);
        }
    }
}

// 数组对象
class User1 {
    // 声明一个方法
    public void test() {
        System.out.println("test...");
    }
}

常用操作数组的方法(需要引用数组操作库java.util.Arrays)

• 首先在包中引入操作数组的库,就有一些操作需要将数组转化为集合才能操作,如移除,替换,倒序等..

package chapter04;
import java.util.Arrays; // 引用常用操作数组的方法库
import java.util.Collections; // 引入操作集合的方法

public class oop2 {
    public static void main(String[] args){}
}

1. 打印数组

int[] intArray = { 1, 2, 3, 4, 5 };
String intArrayString = Arrays.toString(intArray);
 
// print directly will print reference value
System.out.println(intArray);
// [I@7150bd4d
 
// 打印输出数组
System.out.println(intArrayString);
// [1, 2, 3, 4, 5]

2. 从数组创建一个 ArrayList(集合)

String[] stringArray = { "a", "b", "c", "d", "e" };
List<String> arrayList = new List<String>(Arrays.asList(stringArray));
System.out.println(arrayList);
// [a, b, c, d, e]

3. 检查数组是否包含某一个值

String[] stringArray = { "a", "b", "c", "d", "e" };
boolean b = Arrays.asList(stringArray).contains("a");
System.out.println(b);
// true

4. 合并数组

import java.util.ArrayList; // 引入数组集合
import java.util.Arrays; // 引入数组的操作方法
import java.util.List;// 引入集合

public class ArrayMergeExample {
    public static main(String[] args) {
        Integer[] array1 = {1, 2, 3};
        Integer[] array2 = {4, 5, 6};

        // 将数组转换为集合
        List<Integer> list1 = new ArrayList<>(Arrays.asList(array1));
        List<Integer> list2 = new ArrayList<>(Arrays.asList(array2));

        // 合并集合
        list1.addAll(list2);

        //合转换回数组
        Integer[] mergedArray = list1.toArray(new Integer[0]);

        // 打印合并后数组
        System.out.println("合并后的数组：" + Arrays.toString(mergedArray));
    }

5. 把一个 ArrayList 转换成数组

String[] stringArray = { "a", "b", "c", "d", "e" };
ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray));
String[] stringArr = new String[arrayList.size()];
arrayList.toArray(stringArr);
for (String s : stringArr)
	System.out.println(s);

6. 把一个数组转换成 Set

Set<String> set = new HashSet<String>(Arrays.asList(stringArray));
System.out.println(set);
//[d, e, b, c, a]

7. 反转数组

package chapter04;
import java.util.Arrays; // 引用常用操作数组的方法库
import java.util.Collections; // 引入操作集合的静态方法包
import java.util.List;// 引入集合

public class oop2 {
    public static void main(String[] args){

        Integer[] array = {1, 2, 3, 4, 5};

        // 将数组转换为List对象
        List<Integer> list = Arrays.asList(array);

        // 倒序操作
        Collections.reverse(list);

        // 将List转换回数组
        Integer[] reversedArray = list.toArray(new Integer[0]);

        // 打印倒序后的数组
        System.out.println(Arrays.toString(reversedArray));
    }
}

8. 移除或者新增数组中的元素

• 在Java中是一个固定数据结构，因此没有像JavaScript中的push()方法那样直接向数组末尾添加元素的内置方法。但是，你可以使用ArrayList类来实现类似于push()的功能。

/*
	在Java中是一个固定数据结构，因此没有像JavaScript中的push()方法那样直接向数组末尾添加元素的
	内置方法。但是，你可以使用ArrayList类来实现类似于push()的功能。
	ArrayList是Java中提供的一个动态数组类，它可以根据需要自动调整大小。你可以使用add()方法将元
	素添加到ArrayList的末尾下面是一个示例代码，演示了如何使用ArrayList类实现类似于push()的功能：
*/

import java.util.ArrayList;

// 删除也是如此
public class ArrayListPushExample {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        int elementToAdd = 5;

        list.add(elementToAdd);// 删除.remove()

        System.out.println("ArrayList: " + list    }
}

3. 字符串

package chapter04;

public class string {
    public static void main(String[] args) throws Exception {

        // TODO 常见类和对象
        // TODO 字符串连续字符组成形成的数据整体
        // java.lang.String
        // 字符串，字符，字节的关系
        
        // 定义字符串的四种方式如下
        String name = "zhangsan";// 推荐
        String name1 = new String("zhangsan");// 不推荐
        char[] cs = {'a', '中', '国'}; // 不推荐(字符串数组转字符串)
        byte[] bs = {-28,-72,-83,-27,-101,-67};// 不推荐

        String s = new String(cs);// "a中国"
        String s1 = new String(bs, "UTF-8");// "中国"

        System.out.println(s);
        System.out.println(s1);
        System.out.println(name);
        System.out.println(name1);
        String s2 = "\"";
        // 转义字符：\" => 文字内容的双引号
        // \'(转义输出 '), \t(空格), \n(换行), \\(转义输出\)
        System.out.println(s2);// "
        System.out.println("\'"); // \为转义字符串,用于转义jvm中自定义的代码,如",'
        System.out.println("a\tb");// a	b
        System.out.println("c\nd");// c 空行 d
        System.out.println("e\\f");// e\f
    }
}

拼接

package chapter04;

public class string1 {
    public static void main(String[] args) throws Exception {
        // TODO 拼接：将多个字符串连接在一起
        String s = "a" + "b"; // "ab"
        String s1 = "ab";
        String s2 = "abc" + 1 + 2; // abc12
        String s3 = 1 + "abc" + 2; // 1abc2
        String s4 = (1 + 2) + "abc"; // 3abc

        System.out.println(s.hashCode());// 3105
        System.out.println(s1.hashCode());// 3105
        // 这标识拼接形成的字符串对象以及初始化定义的字符串对象只要相等就是同一个对象
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);

        System.out.println(s1.concat("abc"));// ababc
    }
}

比较

package chapter04;

public class string1 {
    public static void main(String[] args) throws Exception {

        // TODO 字符串的比较
        String a = "a";
        String b = "A";

        // 相等(严格)
        System.out.println(a.equals(b));// false
        // 忽略大小写的相等(非严格)
        System.out.println(a.equalsIgnoreCase(b));// true

        // i = 正数，a > b
        // i = 负数，a < b
        // i = 0, a = b

        byte b1 = (byte)'A';
        byte b2 = (byte)'a';
        System.out.println("A = " + b1);// A = 65(码数)
        System.out.println("a = " + b2);// a = 97(码数)

        int i = a.compareTo(b);
        System.out.println(i);//32 -> 正数表明 a>b
        // 忽略大小写的比较
        System.out.println(a.compareToIgnoreCase(b));// 0 -> 0 a=b
    }
}

截断

package chapter04;

public class string1 {
    public static void main(String[] args) throws Exception {
		// TODO 字符串的截断操作 : 截取字符串的操作
        String s = "  Hello World   ";
        // 子字符串
        // substring方法用于截取字符串，需要传递两个参数，
        //     第一个参数表示截取字符串的起始位置（索引，包含）
        //     第二个参数表示截取字符串的结束位置（索引，不包含）
        System.out.println(s.substring(0, 3));
        System.out.println(s.substring(0, "Hello".length())); // 同等与上面的代码
        System.out.println(s.substring(6, s.length()));
        // substring方法如果只传递一个参数，那么就表示从指定位置开始截取字符串，然后截取到最后
        System.out.println(s.substring(6));

        // 分解字符串(转换为数组) ：根据指定的规则对字符串进行分解。可以将一个完整的字符串，分解成几个部分。
        String[] s1 = s.split(" ");// 指定分隔符
        System.out.println(s1.length);
        for (String s2 : s1) {
            System.out.println(s2);// 元素1: Hello,元素2: World
        }

        // TODO trim : 去掉字符串的首尾空格的意思
        System.out.println("!" + s.trim() + "!");// !Hello World! 表明首位的空格均被去掉了        
    }
}

替换

package chapter04;

public class string1 {
    public static void main(String[] args) throws Exception {
        // TODO 字符串的替换。
        String s = "Hello World zhangsan"; // Hello Java Java
        // 替换
        System.out.println(s.replace("World zhangsan", "Java")); // Hello Java
        // [重点]replaceAll按照指定的规则进行替换(下面是`逻辑或`)
        System.out.println(s.replaceAll("World|zhangsan", "Java")); // Hello Java Java        
    }
}

大小写

package chapter04;

public class string1 {
    public static void main(String[] args) throws Exception {
        // TODO 字符串的大小写转换
        String s = "Hello World";

        // toLowerCase:全部变成小写, toUpperCase:全部变成大写
        System.out.println(s.toLowerCase());// hello world
        System.out.println(s.toUpperCase());// HELLO WORLD
        String className = "user"; // u + ser

        // 字符串的截取操作
        String s1 = className.substring(0, 1); // u
        String s2 = className.substring(1); // ser

        System.out.println(s1.toUpperCase() + s2);// User 成功将首字母变成大写
    }
}

查询

package chapter04;

public class string1 {
    public static void main(String[] args) throws Exception {
        // TODO 字符串的查找
        String s = "Hello World World";
        char[] chars = s.toCharArray();// 转化为字节数组
        byte[] bytes = s.getBytes("UTF-8");/// 转化为字节码数组
        System.out.println(chars[0]); // H
        System.out.println(bytes[0]); // 72(H的ASCII码)
        // charAt可以传递索引定位字符串中指定位置的字符
        System.out.println(s.charAt(1));// e
        // indexof方法用于获取数据在字符串中第一次出现的位置。
        System.out.println(s.indexOf("World"));// 6
        // lastIndexOf方法用于获取数据在字符串中最后一次出现的位置。
        System.out.println(s.lastIndexOf("World"));// 12

        // 是否包含指定的字符串，返回布尔类型
        System.out.println(s.contains("Hello123"));// false,不包含
        // 判断字符串是否以指定的数据开头，返回布尔类型
        System.out.println(s.startsWith("Hello"));// true
        // 判断字符串是否以指定的数据结尾，返回布尔类型
        System.out.println(s.endsWith("World"));// true
        // 判断字符串是否为空，空格其实是一个特殊的字符，所以看不到，但是不为空(空字符串不算空)。
        System.out.println(s.isEmpty());// false   
    }
}

StringBuilder

package chapter04;

public class string1 {
    public static void main(String[] args) throws Exception {
        // StringBuilder : 构建字符串
        // concat,下面这种方法构建字符串不推荐使用
//        String s = "";
//        for ( int i = 0; i < 100; i++ ) {
//            s = s + i; // 01234....
//        }
//        System.out.println(s);

        // "a" + "b" => "ab"
        // 推荐使用 StringBuilder 来构建字符串,它拥有更多的方法且底层是使用数组结构,性能更好
        StringBuilder s = new StringBuilder();
        for ( int i = 0; i < 100; i++ ) {
            s.append(i);
        }
        System.out.println(s.toString());
        StringBuilder ss = new StringBuilder();
        s.append("abc"); // "abc"
        System.out.println(ss.toString());// 输出"abc"
        System.out.println(ss.length());// 3
        System.out.println(ss.reverse()); // 反转字符串 "cba"
        // 第二个字符中插入d
        System.out.println(ss.insert(1, "d"));// 插入字符串,"adbc"        
    }
}