java小白零基础（九）

最新推荐文章于 2024-11-13 20:43:20 发布

就一个耕地人

最新推荐文章于 2024-11-13 20:43:20 发布

阅读量160

点赞数

文章标签： java servlet jvm

本文链接：https://blog.csdn.net/A17719032175/article/details/129896608

版权

1.Map集合

Interface Map <K , V> key 键 value 值

双边队列

存的是键值对的数据

001===>瑞强

002====》子豪

将键映射到值的对象。地图不能包含重复的键; 每个键可以映射到最多一个值。

这个接口取代了Dictionary类，它是一个完全抽象的类而不是接口。

Map接口下面已经封装好实现类

–|HashMap

–|TreeMap

Map接口下面的方法

  增：
  V  put (K Key , V value)
  将指定的值与该映射中的指定键相关联(可选操作)
  void  putAll(Map < ?  extends K , ? exdents V > m)
  将指定地图的所有映射复制到此映射（可选操作）
  删：
  V remove (K Key); 通过键删除指定的值   返回值是被删除的值
  改:
	V put(K key, V value)  当键没有的话，就是添加，有的话，就是覆盖
   查:
	int size();  查看集合中的元素的个数
	boolean isEmpty(); 判断集合是否为空
	boolean containsKey(Obejct Key);  判断集合中是否包含这个键
	boolean containsValue(Obejct value);  判断集合中是否包含这个值
        
重要的方法:
	V get(K key);  通过键获取值
	Set<K> keySet()  获取所有的键存到set集合中
	Collection<V>	values()   获取所有集合中的值
	Set<Map.Entry<K,V>> entrySet()  将键值对 的map的实体存到set集合中

package com.qf.b_map;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * description:
 * 公司:千锋教育
 * author:博哥
 *
 * 公众号:Java架构栈
 */
public class Demo1 {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("001", "老邢");//ctrl + d
        map.put("002", "骚磊");
        map.put("003", "狗蛋");
        System.out.println(map);
        //{001=老邢, 002=骚磊, 003=狗蛋}
        //001=老邢  就叫键值对
        Map<String, String> map1 = new HashMap<>();
        map1.put("004", "恩东");//ctrl + d
        map1.put("005", "老万");
        map1.put("006", "阳仔");
        System.out.println(map1);
        map.putAll(map1);
        System.out.println(map);//{001=老邢, 002=骚磊, 003=狗蛋, 004=恩东, 005=老万, 006=阳仔}
//        Map<Integer, String> map2 = new HashMap<>();
//        map2.put(4, "恩东");//ctrl + d
//        map2.put(5, "老万");
//        map.putAll(map2);

        System.out.println(map.remove("003"));
        System.out.println(map);//{001=老邢, 002=骚磊, 004=恩东, 005=老万, 006=阳仔}

        System.out.println(map.put("005", "老实巴交的老万"));
        System.out.println(map);//{001=老邢, 002=骚磊, 004=恩东, 005=老实巴交的老万, 006=阳仔}

        System.out.println(map.size());//5
        System.out.println(map.isEmpty());//false

        System.out.println(map.containsKey("003"));//false
        System.out.println(map.containsKey("004"));//true

        System.out.println(map.containsValue("老邢"));//true


        System.out.println(map.get("001"));//老邢

        Set<String> strings = map.keySet();
        //返回值是nset 键是不可重复的 所以将键存到set集合中
        System.out.println(strings);
        Collection<String> values = map.values();
        System.out.println(values);
 
        Set<Map.Entry<String, String>> entries = map.entrySet();
        System.out.println(entries);
        //使用增强for循环  iter快捷键
        for (Map.Entry<String, String> entry : entries) {
            System.out.println(entry);//001=老邢 键值对对象
            System.out.println(entry.getKey());//获取的键
            System.out.println(entry.getValue());//获取值
            System.out.println("=====");

        }




    }
}

Map集合中的value值放的是自定一定的对象

package com.qf.b_map;

import java.util.HashMap;
import java.util.Map;

/**
 *description:
 *公司:千锋教育
 *author:博哥
 *公众号:Java架构栈
 */
class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class Demo2 {
    public static void main(String[] args) {
        Map<Integer, Person> map = new HashMap<>();
        map.put(1, new Person("侯丹", 23));
        map.put(2, new Person("黑八", 25));
        map.put(3, new Person("邢美人", 21));
        System.out.println(map);
        System.out.println(map.get(3).getName());
    }
}

package com.qf.b_map;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * description:
 * 公司:千锋教育
 * author:博哥
 * 公众号:Java架构栈
 */

public class Demo3 {
    public static void main(String[] args) {
        Map<Integer, List<String>> map = new HashMap<>();
        List<String> list = new ArrayList<>();
        list.add("旺财");
        list.add("狗蛋");
        list.add("常威");

        map.put(1,list);
        List<String> list1 = new ArrayList<>();
        list1.add("来福");
        list1.add("坤坤");
        list1.add("存爱");
        map.put(2, list1);
        System.out.println(map);
    }
}

开发中关于集合的：
    ArrayList
    HashMap

2.File 类

File类是Java内置的一个类，专门处理电脑磁盘上面的文件和文件夹的一个类

文件路径问题：

相对路径：

得有一个参照物

我在子豪的前面做，参照物是子豪

./代表的是当前的工作目录

…/上一级目录

…/…/上两级目录

…/…/…/上三级目录

绝对路径:

从磁盘的跟目录一直到文件的所在位置

C:\aaa\3.txt

2.1File构造方法

File (String pathname)

通过将给定的路径名字符串转换为抽象路径名来创建新的File实例

File(String parent, String child)

从父抽象路径名和子路径名字符串创建新的 File实例

static String	separator与系统相关的默认名称-分隔符字符

package com.qf.c_file;

import java.io.File;

/**
 * description:
 * 公司:千锋教育
 * author:博哥
 * 公众号:Java架构栈
 */
public class Demo1 {
    public static void main(String[] args) {
        //将文件和文件夹路径抽象成了一个对象
        File file = new File("c:/aaa/3.txt");
        System.out.println(file);//c:\aaa\3.txt


        File file1 = new File("c:/aaa", "3.txt");
        System.out.println(file1);

        System.out.println(File.separator);//\
        File file2 = new File("c:\\aaa\\3.txt");
        //得到一个结论： z在windows系统下面 /  和\都是可以的
        //但是在linux系统下面  只能/   才可以
        //	separator
        //与系统相关的默认名称 - 分隔符字符
        File file3 = new File("c:" + File.separator + "aaa" + File.separator + "3.txt");
        System.out.println(file3);




    }
}

2.2File类下面的方法

boolean createNewFile(); 新建一个文件

1.如果文件路径不存在，系统找不到指定的路径

2.如果文件已经存在返回一个false

3.磁盘坏了

boolean mkdir ( ) ; 创建单级的目录

boolean Mkdir ( ) ; 创建多级的目录

package com.qf.c_file;

import java.io.File;
import java.io.IOException;

/**
 * description:
 * 公司:千锋教育
 * author:博哥
 * 公众号:Java架构栈
 */
public class Demo2 {
    public static void main(String[] args) throws IOException {
        File file = new File("c:/aaa/sb.txt");
        System.out.println(file.createNewFile());


        File file1 = new File("c:/aaa/bbb");
        System.out.println(file1.mkdir());//创建单级目录

        File file2 = new File("c:/aaa/ccc/ddd");
        System.out.println(file2.mkdirs());
    }
}

删除文件或者文件夹

boolean delete（）；

package com.qf.c_file;

import java.io.File;
import java.io.IOException;

/**
 * description:
 * 公司:千锋教育
 * author:博哥
 * 公众号:Java架构栈
 */
public class Demo2 {
    public static void main(String[] args) throws IOException {
        File file = new File("c:/aaa/sb.txt");
        System.out.println(file.createNewFile());


        File file1 = new File("c:/aaa/bbb");
        System.out.println(file1.mkdir());//创建单级目录

        File file2 = new File("c:/aaa/ccc/ddd");
        System.out.println(file2.mkdirs());
        System.out.println(file1.delete());

        System.out.println(file.delete());

        File file3 = new File("c:/aaa/ccc");
        System.out.println(file3.delete());//因为ccc下面还有文件夹或者文件
        //delete只能删除空的文件夹或者文件
    }
}

File 类下面判断的方法

boolean is File();是否是文件

boolean is Directory();是不是文件夹

boolean is Hidden(); 是否是隐藏文件

boolean is Absolute(); 是否是绝对路径

boolean exists (); 文件或者文件夹是否存在

package com.qf.c_file;

import java.io.File;

/**
 * description:
 * 公司:千锋教育
 * author:博哥
 * 公众号:Java架构栈
 */
public class Demo3 {
    public static void main(String[] args) {
        File file = new File("c:/aaa/1.txt");
        System.out.println(file.isFile());
        File file1 = new File("c:/aaa/ccc");
        System.out.println(file1.isFile());//false

        System.out.println(file.isDirectory());//false
        System.out.println(file1.isDirectory());//true
        System.out.println(file.isHidden());//true

        File file2 = new File("../");
        System.out.println(file2);
        System.out.println(file2.isAbsolute());//false
        System.out.println(file.isAbsolute());//true
        System.out.println(file.exists());//判断一个文件是否文件
        System.out.println(file1.exists());

    }
}

获取方法返回值的是字符串的方法

String getName（）；获取文件或者文件夹的名字的

STring getParent();获取上一级目录

String getPath();获取file对象的绝对路径

package com.qf.c_file;

import java.io.File;

/**
 * description:
 * 公司:千锋教育
 * author:博哥
 * 公众号:Java架构栈
 */
public class Demo4 {
    public static void main(String[] args) {
        File file = new File("c:/aaa/1.txt");
        System.out.println(file.getName());//1.txt
        System.out.println(file.getParent());//c:\aaa
        System.out.println(file.getPath());//c:\aaa\1.txt
    }
}

方法是long类型数据

long length();获取文件占用磁盘的字节数

long lastModified(); 获取当前文件修改的时间时间戳

package com.qf.c_file;

import java.io.File;

/**
 * description:
 * 公司:千锋教育
 * author:博哥
 * 公众号:Java架构栈
 */
public class Demo5 {
    public static void main(String[] args) {
        File file = new File("c:/aaa/1.txt");
        System.out.println(file.length());//获取文件的大小的 是一个字节数

        System.out.println(file.lastModified());//1679904357979
        //时间戳是指格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总秒数。
        

    }
}

获取当前文件夹下面的所有的文件

File[] listFiles();

String[] list();

package com.qf.c_file;

import java.io.File;

/**
 * description:
 * 公司:千锋教育
 * author:博哥
 * 公众号:Java架构栈
 */
public class Demo6 {
    public static void main(String[] args) {
        File file = new File("c:/");
        File[] files = file.listFiles();
        for (File file1 : files) {
            System.out.println(file1);//获取文件对象
        }

        System.out.println("=======");

        String[] list = file.list();
        for (String s : list) {
            System.out.println(s);//获取名字而已
        }
    }
}

3.递归

一句话来概括：

一个方法自己多次调用自己，但是得有结束的条件

在递归调用的过程中，系统为每一层的返回点或者局部变量开辟了栈来存储
package com.qf.d_digui;

/**
 * description:
 * 公司:千锋教育
 * author:博哥
 * 公众号:Java架构栈
 */
public class Demo1 {
    public static void main(String[] args) {
        test();
    }
    public static void test () {
        test();
        System.out.println("xixi zalba");
    }
}
求1-100的和，使用递归的方式来写

package com.qf.d_digui;

/**
 * description:
 * 公司:千锋教育
 * author:博哥
 * 公众号:Java架构栈
 */
public class Demo2 {
    public static void main(String[] args) {
        System.out.println(sum(1));
    }
    public static int sum (int num) {
        /**
         * 1 + sum(2)
         * 1 +  2 + sum(2 + 1)
         * 1 + 2 + 3 + sum(3+1)
         *
         */
        //终止条件
        if (num == 10) {
            return 100;//结束 方法的调用而已
        }
         return num + sum(num + 1);

    }
}

删除某一个目录下面的所有文件

package com.qf.d_digui;

import java.io.File;

/**
 * description:
 * 公司:千锋教育
 * author:博哥
 * 公众号:Java架构栈
 */
public class Demo3 {
    public static void main(String[] args) {
        File file = new File("c:/bbb");
        del(file);
    }
    public static void del (File file) {
        //找到bbb文件夹下面所有的文件和文件夹
        File[] files = file.listFiles();
        for (File file1 : files) {
            if (file1.isDirectory()) {//如果是文件夹 就继续执行del方法
                del(file1);
            } else {//不是文件夹
                file1.delete();

            }
        }
    }
}

4.io流

以后会遇到上传和下载等这些需求。

I input 输入

O output 输出

咱们电脑上面文件，在进行读取和存储的时候，都是以流的形式进行操作的

流这个概念是比较抽象的

4.1缓冲的概念

看视频有点卡？暂停的时候在缓冲的

缓冲其实就是为了提高读取和存储的效率的

计算机通过cpu读取硬盘的数据，在Java中可以加上缓冲的概念，每次读取具体的缓冲值。可以提高效率

4.2 IO流

从磁盘（c盘）读取数据到内存（Java代码） 1.txt====》java代码（输出出来）

输入流：

input ：场景使用从磁盘的c:/aaa/1.txt文件中读取数据到内存中（Java代码）

字节输入流

字符输入流

从内存（Java代码 String=“狗蛋”）写入数据到磁盘（c盘 1.txt）

输出流:

output : 从内存（String str = " 还是数据库的借口借口"）写入到磁盘的c:/aaa/1.txt文件中

字节输出流：

字符输出流

参照物体是内存

4.2.1字节输入流

FileInputStream

能干嘛？将磁盘上面文件的内容读取到Java代码中

package com.qf.a_fileinputstream;

import java.io.*;

/**
 * description:
 * 公司:千锋教育
 * author:博哥
 * 公众号:Java架构栈
 */
public class Demo2 {
    public static void main(String[] args) throws IOException {
        //1.创建一个file对象的  文件抽象
        File file = new File("c:/aaa/1.txt");
        //2.创建字节输入流的核心的类
        FileInputStream fis = new FileInputStream(file);
        //3.加缓冲功能
        BufferedInputStream bis = new BufferedInputStream(fis);
        //4.创建一个数组  缓冲数组
        byte[] buf = new byte[4 * 1024];//4096字节

        /**
         * 5.读取方法
         * public int read(byte[] b)   将文件中的数据 读取到缓冲数组中
         *          throws IOException
         * 从该输入流读取最多b.length字节的数据到字节数组。 此方法将阻塞，直到某些输入可用。
         * 重写：
         * read在 InputStream类
         * 参数
         * b - 读取数据的缓冲区。
         * 结果
         * 读入缓冲区的总字节数，如果没有更多的数据，因为文件的结尾已经到达， -1 。
         */
        int length;
        while ((length = bis.read(buf)) != -1) {
            System.out.println(new String(buf, 0, length));
        }
        //6.关闭
        bis.close();
        fis.close();


    }
}

4.2.2字节输出流

FileOutputStream

将Java代码中的一个字符串写入到磁盘中的一个2.txt

package com.qf.b_fileoutputstream;

import java.io.*;

/**
 * description:
 * 公司:千锋教育
 * author:博哥
 * 公众号:Java架构栈
 */
public class Demo1 {
    public static void main(String[] args) throws IOException {
        //1.创建文件对象
        File file = new File("c:/aaa/2.txt");
        //2.创建核心的字节输出流对象FileOutputStream
        FileOutputStream fos = new FileOutputStream(file);
        //3.加缓冲的效果  BufferedOutputStream
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //4.声明一个字符串
        String str = "abcdefgh";
        /**
         * void	write(byte[] b)  将字节数组中的数据写入到
         * 将 b.length个字节从指定的字节数组写入此文件输出流。
         */
        //bos.write(str.getBytes());
        /**
         * void	write(byte[] b, int off, int len)
         * 将 len字节从位于偏移量 off的指定字节数组写入此文件输出流。
         */
        //bos.write(str.getBytes(), 0, 3);
        bos.write(1);
        bos.close();
        fos.close();

    }
}

针对于上面讲的写一个案例：

c:/bbb下面有一个视频文件复制到c:/aaa下面

使用Java代码

思路：先从磁盘读取到内存缓冲数组（输入流）中然后再写入磁盘中（输出）

package com.qf.c_zonghe;

import java.io.*;

/**
 * description:
 * 公司:千锋教育
 * author:博哥
 * 公众号:Java架构栈
 */
public class Demo1 {
    public static void main(String[] args) throws IOException {
        copyVideo1();
    }
    public static void copyVideo () throws IOException {
        //创建缓冲输入流对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(new File("c:/bbb/12转义字符.mp4")));
        //创建缓冲输出流对象
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(new File("c:/aaa/sb.mp4")));
        //准备一个缓冲数组
        byte[] buf = new byte[4096];
        int length;
        while ((length = bis.read(buf)) != -1) {//length = bis.read(buf)  从磁盘读取数据到缓冲数组中
            bos.write(buf, 0, length);//从缓冲数组中写入到磁盘
        }
        bos.close();
        bis.close();
    }
    //不带缓冲的
    public static void copyVideo1 () throws IOException {
       FileInputStream fis = new FileInputStream(new File("c:/bbb/12转义字符.mp4"));
       FileOutputStream fos = new FileOutputStream(new File("c:/aaa/2b.mp4"));
       int length;
       while ((length = fis.read()) != -1) {
            fos.write(length);
       }
       fos.close();
       fis.close();

    }

}

4.2.3字符输入流【非重点】

FileReader

将磁盘中的文件的内容读取到Java代码中

阅读字符文件的便利类

FileReader是用于读取字符流。要读取原始字节流（图片音频视频），请考虑使用FileInputStream

FileReader是从字节流到字符流的桥：它读取字节，并使用指定的charset将其解码为字符。

package com.qf.d_filereader;

import java.io.*;

/**
 * description:
 * 公司:千锋教育
 * author:博哥
 * 公众号:Java架构栈
 */
public class Demo1 {
    public static void main(String[] args) throws IOException {
        //1.创建file对象
        File file  = new File("c:/aaa/1.txt");
        //2.创建字符输入流的核心的对象
        FileReader fr = new FileReader(file);
        //3.加缓冲效果
        BufferedReader br = new BufferedReader(fr);
        //4.准备缓冲的数组
        char[] cbuf = new char[2];
        //从磁盘读取数据到缓冲数组中
        int length;
        while ((length = br.read(cbuf)) != -1) {
            System.out.println(new String(cbuf, 0, length));
        }
        br.close();
        fr.close();
    }
}

4.2.4字符输出流【非重点】

FileWriter

场景: Java中有一个字符串然后写入到磁盘的一个文件中

package com.qf.e_filewriter;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

/**
 * description:
 * 公司:千锋教育
 * author:博哥
 * 公众号:Java架构栈
 */
public class Demo1 {
    public static void main(String[] args) throws IOException {
        //File file = new File();
        FileWriter fw = new FileWriter("c:/aaa/2.txt", true);
        BufferedWriter bw = new BufferedWriter(fw);
        String str = "bhxsanxn";
        //write
        //bw.write(str);
        //void	write(String str)
        //写一个字符串
//        void	write(String str, int off, int len)
//        写一个字符串的一部分。
        //bw.write(str, 3, 2);
        //void	write(int c)
        //写一个字符
        //bw.write(97);
//        void	write(char[] cbuf)
//        写入一个字符数组。
        bw.write(str.toCharArray());
        //abstract void	write(char[] cbuf, int off, int len)
        //写入字符数组的一部分。
        //bw.write(str.toCharArray(), 3, 1);
//        bw.write("狗蛋");
//        bw.newLine();
//        bw.write("毛蛋");
//        bw.newLine();
//        bw.write("老邢");
        bw.close();
        fw.close();
    }
}

复制一个文本文档到另外一个盘符下面

package com.qf.f_zonghe;

import java.io.*;

/**
 * description:
 * 公司:千锋教育
 * author:博哥
 * 公众号:Java架构栈
 */
public class Demo1 {
    public static void main(String[] args) throws IOException {
        //字符流将一个文本赋值2到另外一个文件夹下面
        //BufferedReader  专门将文本内容读取到内存中
        BufferedReader br = new BufferedReader(new FileReader("c:/bbb/《雪中悍刀行》.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("c:/aaa/88.txt"));
        char[] cbuf= new char[1024];
        int length;
        while ((length = br.read(cbuf)) != -1) {
            bw.write(cbuf, 0, length);
        }
        bw.close();
        br.close();
    }
}

自己去演示图片音频视频发现字符流不能操作这些。只能使用字节流操作

总结 ：
     1.输入流和输出流功能
        输入流 ： 从磁盘到内存（java 代码）
        输出流 ： 从内存（jave 代码）到磁盘
     2.输入流
        分为两种：
          字节输入流
            FileInputSrteam
          字符输入流
            FileReader
            核心方法 ： red
            
            关于效率问题，他们两个有对应的缓冲流
				FileInputSrteam 对应的BufferedInputStream
				FileReader 对应的 BufferedReader
	3.输出流
		分为两种:
			字节输出流：
				FileOutputStream
			字符输出流:
				FileWriter
					核心的方法 write
			关于效率问题，他们两个有对应的缓冲流
			FileOutputStream对应的缓冲流 BufferedOutputStream 
			FileWriter对应缓冲流   BufferedWriter
	4.记住一句话 用字节流

5.序列化和反序列化

新建类然后创建对象，然后对对象的二属性赋值。对象真实存在了，然后可以通过流来将对象存到本地磁盘上面，这就叫序列化。本次磁盘上面存的有对象的数据，咱们可以再通过流读取到Java代码中变成对象

这叫反序列化持久性操作

从内存到磁盘序列化输出流 ObjectOutputStream write

package com.qf.g_serialize;

import java.io.*;
import java.util.ArrayList;

/**
 * description:
 * 公司:千锋教育
 * author:博哥
 * 公众号:Java架构栈
 */
class Employee implements Serializable {
    String name;
    int age;
    transient int ID;//短暂的  此属性不可序列化
    String adress;//地址

    public void eat() {
        System.out.println("今天中午没有吃饱");
    }
}

public class Demo1 {
    public static void main(String[] args) throws IOException {
        ArrayList arrayList = new ArrayList();
        Employee employee = new Employee();
        employee.name = "gousheng";
        employee.adress = "航海中路";
        employee.age = 18;
        employee.ID = 8989;
        //将Java代码中的对象存到磁盘中
        FileOutputStream fos = new FileOutputStream("c:/aaa/emp.ser");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(employee);
        oos.close();
        fos.close();

    }
}

反序列化从磁盘到内存中 inputStream

package com.qf.g_serialize;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.ObjectInputStream;

/**
 * description:
 * 公司:千锋教育
 * author:博哥
 * 公众号:Java架构栈
 */
public class Demo2 {
    public static void main(String[] args) throws Exception {
        //反序列化
        FileInputStream fis = new FileInputStream("c:/aaa/emp.ser");
        ObjectInputStream ois = new ObjectInputStream(fis);
        Employee emp = (Employee)ois.readObject();
        System.out.println(emp.name);
        System.out.println(emp.age);
        System.out.println(emp.adress);
        System.out.println(emp.ID);//0

    }
}

注意事项:
请注意，一个类的对象要想序列化成功，必须满足两个条件：

该类必须实现 java.io.Serializable 接口。

该类的所有属性必须是可序列化的。如果有一个属性不是可序列化的，则该属性必须注明是短暂的

6.StringBuffer

线程安全，可变的字符序列。字符串缓冲区就像一个String，但可以修改。在任何时间地点，它包含一些特定的字符序列，但可以通过某些方法调用来更改序列的长度和内容

String str = “abc”; 常量池中 abc 0x009

str+= “ef”; 常量池中会有新的地址 abcdef 0x008

StringBuffer sb = new StringBuffer(“abc”); "abc“ 0x007

sb.append(“ef”)；字符串变成 “abcef” 0x007

String ,Stringbuffer和StringBuilder 这三个类的区别

StringBuilder 自己查一下官方的API

public class Demo1 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("abcdef");
        System.out.println(sb);
        //System.out.println(sb.toString());//将StringBuffer类型的数据转为String
        sb.append("a");//追加   abcdtrue
        sb.insert(2, "狗");
        //ab狗cdefa
        sb.delete(2, 4);//abdefa
        //字符串反转
        System.out.println(sb.reverse());//afedba
        System.out.println(sb);
        System.out.println(sb.capacity());//容量 容量是新插入字符可用的存储量
        StringBuffer sb1 = new StringBuffer();
        System.out.println(sb1.capacity());//16
        sb1.append("12345678912345671");
        System.out.println(sb1.capacity());







    }
}

7.枚举类

Java中有一个特殊的类叫枚举类，一般表示的是常量。
public  static final int A = 23;

语法格式：

public enum 枚举类名 {
	各组常量，常量之间使用逗号隔开
}

enum Color {
    RED, GREEN, BLUE
}
public class Demo1 {
    public static void main(String[] args) {
        Color red = Color.RED;
        System.out.println(red);//RED
    }
}

构造方法：

enum Ball {
    TYPE_BALL_FOOTBALL(1, "足球"),
    TYPE_BALL_PINGPANGBALL(2, "乒乓球"),
    TYPE_BALL_BASEGETBALL(3, "篮球"),
    ;
    int key;
    String name;

    Ball(int key, String name) {
        this.key = key;
        this.name = name;
    }

    public int getKey() {
        return key;
    }

    public void setKey(int key) {
        this.key = key;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
public class Demo3 {
    public static void main(String[] args) {

        Ball.TYPE_BALL_FOOTBALL.setKey(4);
        int key = Ball.TYPE_BALL_FOOTBALL.getKey();
        System.out.println(key);
        String name = Ball.TYPE_BALL_FOOTBALL.getName();
        System.out.println(name);
    }
}

枚举方法

values();  枚举类中的所有的值
oridnal();每个常量的索引值
valueOf();返回值的指定的字符串的常量

enum Color1 {
    RED, GREEN, BLUE
}
public class Demo4 {
    public static void main(String[] args) {
        Color1[] values = Color1.values();
        for (Color1 value : values) {
            System.out.println(value +"对应的索引:" + value.ordinal() );
        }
        //valueOf();返回值的指定的字符串的常量
        Color1 red = Color1.valueOf("RED");
        System.out.println(red);
    }
}

举例：

Java在生产环境中如何使用的

枚举一般在使用的时候确定业务场景的。

支付功能，需要使用以下几种支付的方式：

微信小程序支付 wxma  
微信H5支付    wxh5
支付宝小程序支付  zfbma
支付宝生活号支付  zfbshm
微信医保支付  wxyb

可以使用枚举类来维护这几种支付方式，一旦需要新增，需要修改需要删除的时候，随时修改枚举类即可

enum PayTypeEnum {
    WEI_XIN_MINI_APP("1", "wxma", "微信小程序支付"),
    WEI_XIN_H5("2", "wxh5", "微信H5支付"),
    ZFB_MINI_APP("3", "zfbma", "支付宝小程序支付"),
    ZFB_SHH("4", "zfbshm", "支付宝生活号支付"),
    WEI_XIN_YB("5", "wxyb", "微信医保支付"),
    ;

    private final String id;
    private final String code;//支付类型码
    private final String type;//支付方式类型

    PayTypeEnum(String id, String code, String type) {
        this.id = id;
        this.code = code;
        this.type = type;
    }

    public String getId() {
        return id;
    }

    public String getCode() {
        return code;
    }

    public String getType() {
        return type;
    }
}
public class Demo5 {
    public static void main(String[] args) {
        //获取枚举类的id‘值
        String id = PayTypeEnum.ZFB_MINI_APP.getId();
        System.out.println(id);

    }
}

列

enum SexEnum {
    MALE(0, "男"),
    FEMALE(1, "女"),
    ;
    private int sex;//0代表男 or 1  代表女
    private String sexName;//男 or 女

    SexEnum(int sex, String sexName) {
        this.sex = sex;
        this.sexName = sexName;
    }

    public int getSex() {
        return sex;
    }

    public String getSexName() {
        return sexName;
    }
}
class User {//用户类
    private String name;//用户名字
    private SexEnum sex;//用户的性别

    public String getName() {
        return name;
    }

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

    public SexEnum getSex() {
        return sex;
    }

    public void setSex(SexEnum sex) {
        this.sex = sex;
    }
}
public class Demo6 {
    public static void main(String[] args) {
        User user = new User();
        user.setName("狗蛋");//赋值
        user.setSex(SexEnum.MALE);

        System.out.println(user.getSex().getSexName());



    }
}

7.包装类

八大基本数据类型：

int==>Integer

byte===>Byte

short====>Short

long====>Long

float====>Float

double====>Double

boolean====>Boolean

char====>Character

【重点】：

1.自从jdk5之后，有自动拆箱和自动装箱

自动装箱: 将基本数据类型转为包装类类型

自动拆箱: 将包装类转为基本数据类型

 		2. static String    toString();  将基本数据类型转为 字符串
              		3. static  parse***(); 将一个字符串转为 所对应基本数据类型

class User {
    String name;
    Integer age;
    String email;
    Integer sex;
}
public class Demo1 {
    public static void main(String[] args) {
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);

        //1.自动装箱:  将基本数据类型转为包装类型
        int i = 30;
        Integer i1 = i;
        System.out.println(i1.hashCode());
        //2.自动拆箱:  将包装类转为基本数据类型
        int i2 = i1;
        System.out.println(i2);


        //3.***Value();
        Integer i3 = 40;//i3是包装类类型的数据
        int i4 = i3.intValue();//intValue
        System.out.println(i4);//i4是基本数据类型
        //shortValue()

        //4.toString方法
        String s = Integer.toString(34);
        System.out.println(s);

        //5将整数字符串转为基本数据类型
        int i5 = Integer.parseInt("999");
        System.out.println(i5);//999
        double v = Double.parseDouble("89.7");

        //

        Integer i6 = 30;
        Integer i7 = 30;
        System.out.println(i6 == i7);//true
        Integer i8 = new Integer(30);
        System.out.println(i6 == i8);
        Integer i9 = 129;
        Integer i10 = 129;
        System.out.println(i9 == i10);//false


    }
}

8.Math

math类包含执行基本数字运算的方法，如基本指数，对数，平方根和三角函数

public class Demo1 {
    public static void main(String[] args) {
        System.out.println(Math.E);
        System.out.println(Math.PI);

        System.out.println(Math.abs(-89));//求一个数的绝对值  absolute
        System.out.println(Math.max(3, 7));//7   求两个数最大值的
        System.out.println(Math.max(1, Math.max(3, 9)));//9
        System.out.println(Math.min(1, 2));
        System.out.println(Math.ceil(34.5));//向上取整
        System.out.println(Math.floor(34.5));//34.0  向下取整

        System.out.println(Math.round(34.6));//35 long
        System.out.println(Math.random());//double  大于等于 0.0 ，小于 1.0 。
    }
}

9.Random

public class Demo1 {
    public static void main(String[] args) {
        Random random = new Random();
        System.out.println(random.nextInt());
        System.out.println(random.nextBoolean());
        System.out.println(random.nextInt(3));
        System.out.println(random.nextDouble());
    }
}

10.System

System类提供的System包括标准输入，标准输出和错误输出流; 访问外部定义的属性和环境变量; 一种加载文件和库的方法; 以及用于快速复制阵列的一部分的实用方法。

 public static void main(String[] args) {
        PrintStream out = System.out;//标准输出
        out.println("hehe");
        System.out.println("xiix");
        Scanner scanner = new Scanner(System.in);
        //m	err
        //“标准”错误输出流。
        System.err.println("haha");

        //返回当前的时间
        long l = System.currentTimeMillis();   //ms
        System.out.println(l);//1680076586166
        //在1970年1月1日UTC之间的当前时间和午夜之间的差异，以毫秒为单位。

        //通过类 获取当前系统的一个属性
        Properties properties = System.getProperties();
        System.out.println(properties.get("os.name"));//Windows 10
        System.out.println(properties.get("user.name"));//bowang
        System.out.println(properties.get("java.version"));//1.8.0_241
    }

11.Date

专门处理时间的一个类

public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date);
        //Wed Mar 29 16:17:57 IRKT 2023
        //我难受 看不懂？ 吧咋办？ 转成你能看懂的   格式化
        //SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期
        //SimpleDateFormat(String pattern)
        //使用给定模式 SimpleDateFormat并使用默认的 FORMAT语言环境的默认日期格式符号。
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = sdf.format(date);
        System.out.println(format);
    }
}

public class Demo2 {
    public static void main(String[] args) {
        Date date = new Date();
        //返回一个值，该值是从包含本开始时间的年份中减去1900的值
        System.out.println(date.getYear() + 1900);
        //返回一个数字，表示包含或开始于此Date对象所代表的时刻的月份 。 返回的值在0和11之间，其值为0代表一月。
        System.out.println(date.getMonth() + 1);//2


        //返回由此日期表示的星期几。 返回值（ 0 =星期日， 1 =星期一， 2 =星期二， 3 =星期三， 4 =星期四， 5 =星期五， 6 =星期六）表示包含或以此时间表示的时刻开始的星期几Date对
        System.out.println(date.getDay());//3

        Calendar rightNow = Calendar.getInstance();//获取日历的对象
        System.out.println(rightNow);

        System.out.println(rightNow.get(Calendar.YEAR));//2023
        System.out.println(rightNow.get(Calendar.MONTH) + 1);//3
        System.out.println(rightNow.get(Calendar.DAY_OF_MONTH));//29
        System.out.println(rightNow.get(Calendar.DAY_OF_YEAR));//88
        System.out.println(rightNow.get(Calendar.DAY_OF_WEEK) - 1);//4
        System.out.println(rightNow.get(Calendar.HOUR));//4  pm
        System.out.println(rightNow.get(Calendar.HOUR_OF_DAY));//16
  




    }
}