526互联

day06 6.1 Java基础

发布时间 2023-07-01 10:46:41作者: Chimengmeng

day06 6.1 Java基础

【一】Python和Java中的字节与字符串的关系

【1】Java中字节数组与字符串之间的转换关系

字节数组的创建方式一

import java.lang.reflect.Array;
import java.util.Arrays;

public class Demo01 {
    public static void main(String[] args) {
        // （1）字节数组与字符串之间的转换关系
        byte[] b = new byte[]{'a', 98, 'b'};
        
        // 对象输出不好看
        System.out.println(b);
        // [B@1b6d3586
        
        // 美化输出 - 强转数据类型
        System.out.println(Arrays.toString(b));
        // [97, 98, 98]
    }
}

字节数组的创建方式二

import java.lang.reflect.Array;
import java.util.Arrays;
public class Demo01 {
    public static void main(String[] args) {
        // （1）字节数组与字符串之间的转换关系
        // 先声明容器内个数
        byte[] b = new byte[3];
        // 向容器内放 元素
        b[0] = 'a';
        b[1] = 98;
        b[2] = 'b';


        // 对象输出不好看
        System.out.println(b);
        // [B@1b6d3586

        // 美化输出 - 强转数据类型
        System.out.println(Arrays.toString(b));
        // [97, 98, 98]
    }
}

（1）字符串转字节数组

  • 在Java中的语法
import java.lang.reflect.Array;
import java.util.Arrays;

public class Demo01 {
    public static void main(String[] args) {
        // （2）字符串转字节数组
        String name = "蚩梦";
        // 转字节 编码
        // 不写默认就是utf-8编码
        // 相当于Python中的 name.encode('utf-8)
        byte[] b = name.getBytes();

        // 打印输出
        System.out.println(b);
        // [B@1b6d3586

        // 美化输出
        System.out.println(Arrays.toString(b));
        // [-24, -102, -87, -26, -94, -90]
    }
}
  • 在Python中的语法
name = '蚩梦'

b = name.encode('utf-8')

print(b)
# b'\xe8\x9a\xa9\xe6\xa2\xa6'

for item in b:
    print(item)
    
    # 232
    # 154
    # 169
    # 230
    # 162
    # 166

为什么和Java中的字符数组不一样？

Python是无符号的:[0,1,2,3...256]

Java是有符号的:[0,1,2,3...-1,-2,-3...-128]

Java中小于 0 的数组都要加 256

（2）字节数组转字符串

public class Demo01 {
    public static void main(String[] args) {
        // （3）字节数组转字符串
        byte[] b = new byte[]{-24, -102, -87, -26, -94, -90};

        // 声明字符串变量接收 b 的返回值
        String name = new String(b);

        // 打印输出 name
        System.out.println(name);
        // 蚩梦

    }
}

在Java中，要实例化得到一个对象。

必须 new 类名

String v1 = new String("dream");

【2】Java中字符数组与字符串之间的转换关系

（1）字符串转字符数组

public class Demo02 {
    public static void main(String[] args) {
        // 字符数据和字符串之间的转换

        // （1）字符串转字符数组
        String name = "蚩梦";

        // 转成字符数组
        char[] c = name.toCharArray();

        System.out.println(c);
        // 蚩梦

        // 数组可以按位置取值
        System.out.println(c[0]);
        // 蚩
        System.out.println(c[1]);
        // 梦
    }
}

（2）字符数组转字符串

public class Demo02 {
    public static void main(String[] args) {
        // 字符数据和字符串之间的转换

        // （2）字符数组转字符串
        // 在Java中单引号 引起来的是字符或者字节
        // 在Java中双引号 引起来的是字符串
        char[] c = new char[]{'蚩', '梦'};
        // 字符数组可以放空字符
        char[] d = new char[]{'蚩', '梦', ' '};

        String name = new String(c);
        String d_name = new String(d);

        System.out.println(name);
        // 蚩梦
        System.out.println(d_name);
        // 蚩梦 
        // System.out.println(name[0]);
        // 字符串不支持索引取值
    }
}

在Java中单引号 引起来的是字符或者字节

在Java中双引号 引起来的是字符串

【3】Java和Python中的有无符号的问题

（1）Java和Python中的演示

name = '蚩梦'

b = name.encode('utf-8')

print(b)
# b'\xe8\x9a\xa9\xe6\xa2\xa6'

for item in b:
    print(item)
    
    # 232
    # 154
    # 169
    # 230
    # 162
    # 166

import java.lang.reflect.Array;
import java.util.Arrays;

public class Demo01 {
    public static void main(String[] args) {
        // （2）字符串转字节数组
        String name = "蚩梦";
        // 转字节 编码
        // 不写默认就是utf-8编码
        // 相当于Python中的 name.encode('utf-8)
        byte[] b = name.getBytes();

        // 打印输出
        System.out.println(b);
        // [B@1b6d3586

        // 美化输出
        System.out.println(Arrays.toString(b));
        // [-24, -102, -87, -26, -94, -90]
    }
}

为什么和Java中的字符数组不一样？

Python是无符号的:[0,1,2,3...256]

Java是有符号的:[0,1,2,3...-1,-2,-3...-128]

Java中小于 0 的数组都要加 256

（2）Java转Python中的字节数组

def java_str_to_python_str(java_str_list):
    # 【1】python_str_list = []  # 【1】拿到符合Python语法的字节数组 ----->  [232, 154, 169, 230, 162, 166]
    python_str_list = bytearray()  # 【2】语法：得到的对象支持转码 ----> 蚩梦
    for java_str_num in java_str_list:
        if java_str_num < 0:
            java_str_num += 256
            python_str_list.append(java_str_num)

    # 【1】return python_str_list
    return python_str_list.decode('utf-8')  # 【2】


python_str = java_str_to_python_str(java_str_list)
print(python_str)
# [232, 154, 169, 230, 162, 166]

【二】Java中的Object类

【1】Object类可以接受任意类型

import java.util.Arrays;

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

        // 【1】
        /*// 先声明了一个字符串类型
        String name = "蚩梦";
        // 已经声明的类型不支持修改
        name = 10;*/

        // 【2】
        /*// 定义一个数组，数组类型不固定，可以使任意类型
        String[] names = new String[]{"蚩梦","痴梦",18};
        // 这种方式只能放字符串，不能放其他类型*/

        // 【3】
        // 定义Object 类型 ----> 类似于Python中的object类，所有类都继承自object
        // Java中的所有类，都继承自object，他是所有类的父类
        // 根据声明的类 实例化得到对象
        Person p = new Person();
        Object[] names = new Object[]{"蚩梦", "痴梦", 18, p};
        // 这种方式可以放任意类型,甚至是类实例化出的对象
        System.out.println(names);
        // [Ljava.lang.Object;@1b6d3586
        // 强转数据类型 ----> 字符串
        System.out.println(Arrays.toString(names));

        // 【4】缺点
        // 如果是Object类型，不能使用具体类型的方法
        System.out.println(names[0]);
        // 字符串的有些方法不能使用
        // names[0].size()
    }
}

// 声明一个类
class Person {

}

  • 好处

    • 定义Object 类型 ----> 类似于Python中的object类，所有类都继承自object

    • Python中的所有类，都继承自object，他是所有类的父类

    • 这种方式可以放任意类型,甚至是类实例化出的对象

  • 坏处

    • 如果是Object类型，不能使用具体类型的方法

【2】Object类型的通用方法

![1](imgs/day06 6.1 Java基础.assets/1.png)

// 1. clone()
保护方法，实现对象的浅复制，只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。

// 2. getClass()
final方法，返回Class类型的对象，反射来获取对象。

//3. toString()
该方法用得比较多，一般子类都有覆盖，来获取对象的信息。

//4. finalize()
该方法用于释放资源。因为无法确定该方法什么时候被调用，很少使用。

//5. equals()
比较对象的内容是否相等

// 6. hashCode()
该方法用于哈希查找，重写了equals方法一般都要重写hashCode方法。这个方法在一些具有哈希功能的Collection中用到。

// 7. wait()
wait方法就是使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。wait()方法一直等待，直到获得锁或者被中断。wait(long timeout)设定一个超时间隔，如果在规定时间内没有获得锁就返回。
调用该方法后当前线程进入睡眠状态，直到以下事件发生。
其他线程调用了该对象的notify方法。
其他线程调用了该对象的notifyAll方法。
其他线程调用了interrupt中断该线程。
时间间隔到了。
此时该线程就可以被调度了，如果是被中断的话就抛出一个InterruptedException异常。

// 8. notify()
该方法唤醒在该对象上等待的某个线程。

//9. notifyAll()
该方法唤醒在该对象上等待的所有线程。

    
/* 常用的
    getClass()
    toString()
    hashCode()
*/
  • 所有对象都具有的方法
    • getClass()
      • 获取具体的类型
    • toString()
      • 打印显示的样子

getClass()

  • 方式一
import java.util.Arrays;

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

        // Object类的常用方法
        // （1）把Object转回具体的类型
        Person p = new Person();
        Object[] names = new Object[]{"蚩梦", "痴梦", 18, p};
        System.out.println(names[0].getClass());
        // class java.lang.String 返回当前包下的 String 类型
        System.out.println(names[3].getClass());
        // class Person 返回当前包下的 Person 类型

    }
}

// 声明一个类
class Person {

}
  • 方式二
import java.sql.SQLOutput;
import java.util.Arrays;

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

        // Object类的常用方法
        // （1）把Object转回具体的类型
        // 方式一
        Person p = new Person();
        Object[] names = new Object[]{"蚩梦", "痴梦", 18, p};
        System.out.println(names[0].getClass());
        // class java.lang.String 返回当前包下的 String 类型
        System.out.println(names[3].getClass());
        // class Person 返回当前包下的 Person 类型

        // 方式二
        // 如果不是字符串类型，强转成字符串类型
        if (names[0] instanceof String) {
            String v1 = (String) names[0];
            System.out.println(v1);
            // class Person
        }

        // 如果不是字符串类型，强转成字符串类型
        if (names[2] instanceof Integer) {
            Integer a1 = (Integer) names[2];
            System.out.println(a1);
            // 蚩梦
        }

        // 如果不是Person类型，强转成Person类型
        if (names[3] instanceof Integer) {
            Person c1 = (Person) names[3];
            System.out.println(c1);
            // 18
        }


    }
}

// 声明一个类
class Person {

}

【3】Java中容器类型值List

List 是一个接口

  • 接口
    • 用来存放多个数据，类似与Python中的列表

  • 接口常见有两种类型

    • ArrayList

      • 底层是基于数组的，但是会自动扩容

    • LinkedList

      • 底层是基于链表的

Java中的接口相当于相当于Python中的父类

Java的数组，只能放、取，不能扩容、删除元素、增加元素

上面的两个接口跟Python中的列表很想，可以放多个元素

ArrayList 和 LinkedList 方法都一样，效率有所区别

ArrayList方法之add

import java.util.ArrayList;

public class Demo04 {
    public static void main(String[] args) {
        // List 接口类型：ArrayList 和 LinkedList

        // ArrayList ----->  内部放的是Object类型
        // Java会自动导入需要的包
        // 创建方式一
        ArrayList l1 = new ArrayList();
        // 创建方式二:泛型
        // ArrayList<Object> l1 = new ArrayList<Object>();

        // 增加元素
        // 可以增加任意类型
        l1.add("蚩梦");
        l1.add("痴梦"); // 增加字符串
        l1.add(18); // 增减数组
        l1.add(new Dog()); // 增加对象
        System.out.println(l1);


        // 定义一个 接口只能放字符串类型
         ArrayList<String> s1 = new ArrayList<String>();
         s1.add("蚩梦");
         // s1.add(18) // 不能放数组
         // s1.add('18') // 不能放字符
        // 只能放字符串类型
    }
}

class Dog {

}

LinkedList方法之add

方法同 ArrayList

import java.util.ArrayList;
import java.util.LinkedList;

public class Demo04 {
    public static void main(String[] args) {
        // List 接口类型：ArrayList 和 LinkedList

        // ArrayList ----->  内部放的是Object类型
        // Java会自动导入需要的包
        // 创建方式一
        LinkedList l1 = new LinkedList();
        // 创建方式二:泛型
        // ArrayList<Object> l1 = new ArrayList<Object>();

        // 增加元素
        // 可以增加任意类型
        l1.add("蚩梦");
        l1.add("痴梦"); // 增加字符串
        l1.add(18); // 增减数组
        l1.add(new Dog()); // 增加对象
        System.out.println(l1);


        // 定义一个 接口只能放字符串类型
        LinkedList<String> s1 = new LinkedList<String>();
        s1.add("蚩梦");
        // s1.add(18) // 不能放数组
        // s1.add('18') // 不能放字符
        // 只能放字符串类型
    }
}

class Dog {

}

什么是接口

  • 接口是用来规范子类行为，Java中不允许多继承
  • 实现多个接口，接口只是一个规范，规范了子类有那些方法，但是没有具体实现
/**
 * 定义了一个接口：
 * 接口规定：有两个方法，speak、run
 * 成为我的子类必须实现我定义的两个方法
 */
// 定义接口
interface Duck {
    // 接口里面放共同的方法
    public void speak();

    public void run();
}

// 定义单独的一个类
class TDuck implements Duck {
    // 单独的类中有对应的方法
    public void speak() {
        System.out.println("唐老鸭会说话");
    }

    public void run() {
        System.out.println("唐老鸭会走路");
    }
}

// 定义单独的一个类
class RDuck implements Duck {
    // 单独的类中有对应的方法
    public void speak() {
        System.out.println("肉鸭会说话");
    }

    public void run() {
        System.out.println("肉鸭会走路");
    }
}

public class Demo05 {
    public static void main(String[] args) {
        // 什么是接口
        // 接口是用来规范子类行为，Java中不允许多继承
        // 实现多个接口，接口只是一个规范，规范了子类有那些方法，但是没有具体实现

        // 接口的概念
        // 实例化两个对象
        TDuck t = new TDuck();

        RDuck r = new RDuck();

        // 接口的类型的变量，可以接收 实现该接口的所有类型
        Duck d = t;
        d = r;

    }
}

List的其他方法

ArrayList 和 LinkedList 相同的方法

import java.util.ArrayList;

public class Demo06 {
    public static void main(String[] args) {
        // List 其他操作
        ArrayList<String> l1 = new ArrayList();

        // (1)增加元素
        l1.add("蚩梦");
        l1.add("痴梦");
        l1.add("你好");
        l1.add("世界");
        l1.add("大虾");
        l1.add("排骨");
        l1.add("牛肉");

        // (2)索引取值
        System.out.println(l1.get(0));
        // 蚩梦

        // (3)修改值
        l1.set(0, "萌萌");
        System.out.println(l1);
        // [萌萌, 痴梦, 你好, 世界]

        // (4)删除值(方法重载)
        // 按元素删
        l1.remove("萌萌");
        System.out.println(l1);
        // [痴梦, 你好, 世界]
        // 按索引删
        l1.remove(0);
        System.out.println(l1);
        // [你好, 世界]

        // (5) 是否包含 --- 返回布尔类型
        System.out.println(l1.contains("你好"));
        // true

        // (6) 长度
        System.out.println(l1.size());

        // (7) 循环
        // 基于索引的循环（Python中没有）
        for (int i = 0; i < l1.size(); i++) {
            System.out.println(l1.get(i));
            // 5
            //你好
            //世界
            //大虾
            //排骨
            //牛肉
        }

        // 基于迭代的循环（Python中有）
        for (String item:l1) {
            System.out.println(item);
            // 5
            //你好
            //世界
            //大虾
            //排骨
            //牛肉
        }
    }
}

LinkedList 多的方法

import java.util.ArrayList;
import java.util.LinkedList;

public class Demo06 {
    public static void main(String[] args) {
        // List 其他操作
        LinkedList<String> l1 = new LinkedList();

        // (1)增加元素
        l1.add("蚩梦");
        l1.add("痴梦");
        l1.add("你好");
        l1.add("世界");
        l1.add("大虾");
        l1.add("排骨");
        l1.add("牛肉");

        // (2)索引取值
        System.out.println(l1.get(0));
        // 蚩梦

        // (3)修改值
        l1.set(0, "萌萌");
        System.out.println(l1);
        // [萌萌, 痴梦, 你好, 世界]

        // (4)删除值(方法重载)
        // 按元素删
        l1.remove("萌萌");
        System.out.println(l1);
        // [痴梦, 你好, 世界]
        // 按索引删
        l1.remove(0);
        System.out.println(l1);
        // [你好, 世界]

        // (5) 是否包含 --- 返回布尔类型
        System.out.println(l1.contains("你好"));
        // true

        // (6) 长度
        System.out.println(l1.size());

        // (7) 循环
        // 基于索引的循环（Python中没有）
        for (int i = 0; i < l1.size(); i++) {
            System.out.println(l1.get(i));
            // 5
            //你好
            //世界
            //大虾
            //排骨
            //牛肉
        }

        // 基于迭代的循环（Python中有）
        for (String item:l1) {
            System.out.println(item);
            // 5
            //你好
            //世界
            //大虾
            //排骨
            //牛肉
        }

        /// ************ LinkedList 多的方法
        // (8) 将元素放在首位
        l1.push("我是 push");
        System.out.println(l1);
        // [我是 push, 你好, 世界, 大虾, 排骨, 牛肉]

        l1.addFirst("我是 addFirst");
        System.out.println(l1);
        // [我是 addFirst, 我是 push, 你好, 世界, 大虾, 排骨, 牛肉]

        l1.addLast("我是 addLast");
        System.out.println(l1);
        // [我是 addFirst, 我是 push, 你好, 世界, 大虾, 排骨, 牛肉, 我是 addLast]
    }
}

【4】Java中容器类型之Set

  • Set 是一个接口
    • 常见实现这个接口的类有两个
    • 用于实现不重复的多元素集合
  • HashSet
    • 去重，无序
  • TreeSet
    • 去重，内部默认排序（ASCII、Unicode）
    • 不同的数据类型，无法进行比较

HashSet

  • 添加元素
import java.util.HashSet;

public class Demo07 {
    public static void main(String[] args) {
        // Set 接口下有TreeSet 和 HashSet

        // （1）HashSet的使用
        // 实例化方式一
        // HashSet hs = new HashSet(); // 可以放任意类型

        // 实例化方式二
        HashSet<String> sh = new HashSet(); // 只能放字符串类型

        // 增加元素
        sh.add("蚩梦");
        sh.add("蚩梦");
        sh.add("痴梦");
        sh.add("梦梦");
        System.out.println(sh);
        // 自动去重功能
        // [痴梦, 蚩梦, 梦梦]


    }
}
  • 交集
//import java.util.HashSet;
//import java.util.TreeSet;
//
//public class Demo07 {
//    public static void main(String[] args) {
//        // Set 接口下有TreeSet 和 HashSet
//
//        // （1）HashSet的使用
//        // 实例化方式一
//        // HashSet hs = new HashSet(); // 可以放任意类型
//
//        // 实例化方式二
//        TreeSet<String> sh = new TreeSet(); // 只能放字符串类型
//
//        // 增加元素
//        sh.add("蚩梦");
//        sh.add("蚩梦");
//        sh.add("痴梦");
//        sh.add("梦梦");
//        System.out.println(sh);
//        // 自动去重功能 且 会进行排序
//        // [梦梦, 痴梦, 蚩梦]
//
//
//    }
//}


import java.util.HashSet;
import java.util.TreeSet;

public class Demo07 {
    public static void main(String[] args) {
        // Set 接口下有TreeSet 和 HashSet


        // （2）集合的交叉并集

        HashSet<String> sh1 = new HashSet<>();

        sh1.add("蚩梦");
        sh1.add("痴梦");
        sh1.add("萌萌");

        HashSet<String> sh2 = new HashSet<>();
        sh2.add("猛猛");
        sh2.add("萌萌");
        sh2.add("朦朦");

        // (1) 交集
        sh1.retainAll(sh2);
        System.out.println(sh1);
        // 二者的交集只有一个元素 ： [萌萌]
    }
}
  • 并集
//import java.util.HashSet;
//import java.util.TreeSet;
//
//public class Demo07 {
//    public static void main(String[] args) {
//        // Set 接口下有TreeSet 和 HashSet
//
//        // （1）HashSet的使用
//        // 实例化方式一
//        // HashSet hs = new HashSet(); // 可以放任意类型
//
//        // 实例化方式二
//        TreeSet<String> sh = new TreeSet(); // 只能放字符串类型
//
//        // 增加元素
//        sh.add("蚩梦");
//        sh.add("蚩梦");
//        sh.add("痴梦");
//        sh.add("梦梦");
//        System.out.println(sh);
//        // 自动去重功能 且 会进行排序
//        // [梦梦, 痴梦, 蚩梦]
//
//
//    }
//}


import java.util.HashSet;
import java.util.TreeSet;

public class Demo07 {
    public static void main(String[] args) {
        // Set 接口下有TreeSet 和 HashSet


        // （2）集合的交叉并集

        HashSet<String> sh1 = new HashSet<>();

        sh1.add("蚩梦");
        sh1.add("痴梦");
        sh1.add("萌萌");

        HashSet<String> sh2 = new HashSet<>();
        sh2.add("猛猛");
        sh2.add("萌萌");
        sh2.add("朦朦");

        /*// (1) 交集
        sh1.retainAll(sh2);
        System.out.println(sh1);
        // 二者的交集只有一个元素 ： [萌萌]*/

        // (2) 并集
        sh1.addAll(sh2);
        System.out.println(sh1);
        // 去重并将全部元素合并到一起 ：[萌萌, 痴梦, 朦朦, 蚩梦, 猛猛]


    }
}
  • 差集
//import java.util.HashSet;
//import java.util.TreeSet;
//
//public class Demo07 {
//    public static void main(String[] args) {
//        // Set 接口下有TreeSet 和 HashSet
//
//        // （1）HashSet的使用
//        // 实例化方式一
//        // HashSet hs = new HashSet(); // 可以放任意类型
//
//        // 实例化方式二
//        TreeSet<String> sh = new TreeSet(); // 只能放字符串类型
//
//        // 增加元素
//        sh.add("蚩梦");
//        sh.add("蚩梦");
//        sh.add("痴梦");
//        sh.add("梦梦");
//        System.out.println(sh);
//        // 自动去重功能 且 会进行排序
//        // [梦梦, 痴梦, 蚩梦]
//
//
//    }
//}


import java.util.HashSet;
import java.util.TreeSet;

public class Demo07 {
    public static void main(String[] args) {
        // Set 接口下有TreeSet 和 HashSet


        // （2）集合的交叉并集

        HashSet<String> sh1 = new HashSet<>();

        sh1.add("蚩梦");
        sh1.add("痴梦");
        sh1.add("萌萌");

        HashSet<String> sh2 = new HashSet<>();
        sh2.add("猛猛");
        sh2.add("萌萌");
        sh2.add("朦朦");

        /*// (1) 交集
        sh1.retainAll(sh2);
        System.out.println(sh1);
        // 二者的交集只有一个元素 ： [萌萌]*/

        /*// (2) 并集
        sh1.addAll(sh2);
        System.out.println(sh1);
        // 去重并将全部元素合并到一起 ：[萌萌, 痴梦, 朦朦, 蚩梦, 猛猛]
*/
        // (3) 差集
        sh1.removeAll(sh2);
        System.out.println(sh1);
        // 只保留二者不同的元素 ： [痴梦, 蚩梦]


    }
}

TreeSet

import java.util.HashSet;
import java.util.TreeSet;

public class Demo07 {
    public static void main(String[] args) {
        // Set 接口下有TreeSet 和 HashSet

        // （1）HashSet的使用

        // 实例化方式二
        TreeSet<String> sh = new TreeSet(); // 只能放字符串类型

        // 增加元素
        sh.add("蚩梦");
        sh.add("蚩梦");
        sh.add("痴梦");
        sh.add("梦梦");
        System.out.println(sh);
        // 自动去重功能 且 会进行排序
        // [梦梦, 痴梦, 蚩梦]


    }
}

【5】Java中容器类型之Map

  • Map 是一个接口
    • 用于存储键值对
  • 常见实现这个接口的类有两个
    • HashMap
      • 无序
    • TreeMap
      • 默认会根据 KEY 排序

HashMap(无序)

  • 添加元素
import java.util.HashMap;
import java.util.TreeMap;

public class Demo08 {
    public static void main(String[] args) {
        // Map 接口： HashMap   TreeMap


        // HashMap <键的类型，值的类型>
        HashMap<String, String> hs = new HashMap();

        // 添加元素
        hs.put("name", "蚩梦");
        hs.put("age", "18");
        hs.put("gender", "male");

        System.out.println(hs);
        // 默认无序
        // {gender=male, name=蚩梦, age=18}


    }
}

TreeMap(默认排序)

import java.util.HashMap;
import java.util.TreeMap;

public class Demo08 {
    public static void main(String[] args) {
        // Map 接口： HashMap   TreeMap


        // HashMap <键的类型，值的类型>
        // HashMap<String, String> hs = new HashMap();
        TreeMap<String, String> hs = new TreeMap();

        // 添加元素
        hs.put("name", "蚩梦");
        hs.put("age", "18");
        hs.put("gender", "male");

        System.out.println(hs);
        // 默认有序 ： 根据 KEY 排序
        // {age=18, gender=male, name=蚩梦}


    }
}

公共方法

//import java.util.HashMap;
//import java.util.TreeMap;
//
//public class Demo08 {
//    public static void main(String[] args) {
//        // Map 接口： HashMap   TreeMap
//
//
//        // HashMap <键的类型，值的类型>
//        // HashMap<String, String> hs = new HashMap();
//        TreeMap<String, String> hs = new TreeMap();
//
//        // 添加元素
//        hs.put("name", "蚩梦");
//        hs.put("age", "18");
//        hs.put("gender", "male");
//
//        System.out.println(hs);
//        // 默认有序 ： 根据 KEY 排序
//        // {age=18, gender=male, name=蚩梦}
//
//        //
//
//    }
//}


import java.util.*;

public class Demo08 {
    public static void main(String[] args) {
        // Map 接口： HashMap   TreeMap


        TreeMap<String, String> hs = new TreeMap<>();
        hs.put("name", "蚩梦");
        hs.put("age", "18");
        hs.put("gender", "male");

        // （1） 移除元素
        hs.remove("age");
        System.out.println(hs);
        // {gender=male, name=蚩梦}

        // （2） 大小
        System.out.println(hs.size());
        // 2

        // （3） 获取值
        System.out.println(hs.get("name"));
        // 蚩梦

        // （4） 是否包含
        System.out.println(hs.containsKey("name"));
        System.out.println(hs.containsValue("蚩梦"));
        // true
        // true

        // （5） 替换
        hs.replace("name", "萌萌");
        System.out.println(hs);
        // {gender=male, name=萌萌}

        // （6） 循环
        // 方式一 : 以键取值
        for (String key : hs.keySet()
        ) {
            System.out.printf("key 是:>>>%s\n", key);
            System.out.printf("value 是:>>>%s\n", hs.get(key));
            // key 是:>>>gender
            // value 是:>>>male
            // key 是:>>>name
            // value 是:>>>萌萌
        }

        // 方式二 : 以键值对取值
        for (Map.Entry<String, String> item : hs.entrySet()
        ) {
            System.out.println(item.getKey());
            System.out.println(item.getValue());
            // gender
            // male
            // name
            // 萌萌
        }

        // 方式三 : 类似于Python中的装饰器
        Set s2 = hs.entrySet();
        Iterator it3 = s2.iterator();

        while (it3.hasNext()) {
            // 强转数据类型
            Map.Entry mp = (Map.Entry) it3.next();
            System.out.println(mp.getKey());
            System.out.println(mp.getValue());
            // gender
            // male
            // name
            // 萌萌
        }


    }
}

【三】Java中的面向对象

【1】构造方法

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

        // （1）实例化类得到对象时，无参数会触发无参构造方法
        Cat c = new Cat();
        // 这是无参构造方法

        // 对象调用方法
        c.speak();
        // 猫说话了!

        // （2） 构造方法
        // 实例化类得到对象时，传参数会触发有参构造方法
        Cat a = new Cat("咪咪", 18);
        // 这是有参构造方法

    }
}

/**
 * 定义类
 */
class Cat {

    // 如果 this 想使用某个属性，需要先提前定义
    public String name;
    public int age;


    /**
     * 构造方法：无参构造方法，构造方法可以写多个
     */
    public Cat() {
        System.out.println("这是无参构造方法");
        /**
         * 在Java中 this 代指 Python中的 self
         */
    }

    /**
     * 构造方法：有参构造方法
     */
    public Cat(String name, int age) {
        System.out.println("这是有参构造方法");

        this.name = name;
        this.age = age;
    }

    // 类添加功能
    public void speak() {
        System.out.println("猫说话了!");
    }
}

【2】静态成员

public class Demo10 {
    public static void main(String[] args) {
        // 静态成员
        // （1）当定义的类中只有有参构造方法时，必须传参数，否则会报错
        Snake s = new Snake("dream", 120);
        System.out.println(s.name);
        // dream

        Snake sa = new Snake("萌萌", 150);
        System.out.println(sa.name);
        // 萌萌

        // （2）Python中具有的类属性 类比于 Java中的static修饰
        // Java类中的静态成员，对象和类都可以调
        // System.out.println(sa.school); // 无法调用，因为没有赋值

        // 赋值操作
        sa.school = "梦梦学堂";
        System.out.println(sa.school);
        // 梦梦学堂
        System.out.println(s.school);
        // 梦梦学堂

        // （3）改了类的静态成员，所有对象都受影响
        // 类也可以修改静态成员
        Snake.school = "萌萌学堂";
        System.out.println(sa.school);
        // 萌萌学堂
        System.out.println(s.school);
        // 萌萌学堂

        // （4）调用静态方法
        // 类调用方法
        Snake.speak();
        // 小蛇正在嘶嘶嘶~~~

        // 对象调用方法
        sa.speak();
        // 小蛇正在嘶嘶嘶~~~


    }
}

class Snake {
    /**
     * 静态成员：属于类的
     */
    public static String school;

    /**
     * 静态方法
     */
    public static void speak() {
        // 静态方法
        System.out.println("小蛇正在嘶嘶嘶~~~");
    }

    /**
     * 这些成员是属于对象的
     */
    public String name;
    public int age;

    /**
     * 有参构造方法
     *
     * @param name
     * @param age
     */
    public Snake(String name, int age) {
        this.name = name;
        this.age = age;


    }


}

【3】继承

在 Java 中只允许单继承

public class Demo11 {
    public static void main(String[] args) {
        // 类实例化得到对象
        Chicken c = new Chicken();
        // 【1】直接调用 - 没有参数
        c.eat();
        // 触发 重写方法
        // 正在吃东西!
        // 父类方法正在被重写

        // 【2】调用并传参数 - 触发 重载方法
        c.eat("basketball");
        // 触发重载方法 进行重载
        // 正在吃东西!
        // 父类方法正在被重写
        // 正在重载方法

    }
}

class Base{
    public void eat(){
        System.out.println("正在吃东西!");

    }
}

class Foo{

}

/**
 * 只能单继承，不允许多继承
 */
class Chicken extends Base{
    // 子类重写父类方法
    // 重写：把父类的方法 super 重写了一遍
    @Override
    public void eat(){
        super.eat();
        System.out.println("父类方法正在被重写");
    }

    // 重载 ： 方法同名，但是参数不一样，跟父类没有联系
    public void eat(String a){
        // 方法可以同名，参数不一样，这个叫重载，跟父类没有联系
        System.out.println("正在重载方法");
    }
}

【4】小结

  • Java中只允许单继承，使用 extends 方法
    • 子类中重写父类的方法叫重写
    • 方法名相同，但是参数不同，叫重载，跟父类没有必然联系