JAVA第五周小结（上）

最新推荐文章于 2024-09-15 19:46:31 发布

wei_5guang_

最新推荐文章于 2024-09-15 19:46:31 发布

阅读量129

点赞数

文章标签： java

本文链接：https://blog.csdn.net/wei_5guang_/article/details/129902307

版权

本文总结了Java中的Map集合，包括HashMap和TreeMap等实现类，以及File类的相关操作，如创建、删除文件和目录。还介绍了递归的概念以及IO流的基本用法，包括字节流和字符流。同时讲解了StringBuffer线程安全的特性，枚举类的使用，以及八大基本数据类型的包装类及其特点。

摘要由CSDN通过智能技术生成

1.Map集合

Interface Map<K,V> key 键 value 值

双边队列

存的是键值对的数据

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

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

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

--|HashMap

--|TreeMap

Map接口下面的方法

增：
   V  put(k key, V value)
	将指定的值与该映射中的指定键相关联（可选操作）。
	void	putAll(Map<? extends K,? extends 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.yhs.text;

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

public class Demo1 {
    public static void main(String[] args) {
        Map<String , String> map = new HashMap<>();
        map.put("001","路飞");
        map.put("002","索隆");
        map.put("003","乌索普");
        map.put("004","乔巴");
        System.out.println(map);//{001=路飞, 002=索隆, 003=乌索普, 004=乔巴}
        Map<String,String> map1 = new HashMap<>();
        map1.put("005","山治");
        map1.put("006","娜美");
        map1.put("007","罗宾");
        System.out.println(map1);//{005=山治, 006=娜美, 007=罗宾}
        map.putAll(map1);//将指定地图的所有映射复制到此映射
        System.out.println(map);//{001=路飞, 002=索隆, 003=乌索普, 004=乔巴, 005=山治, 006=娜美, 007=罗宾}
        System.out.println(map.remove("003"));//乌索普;通过键删除指定的值  返回值是被删除的值
        System.out.println(map);//{001=路飞, 002=索隆, 004=乔巴, 005=山治, 006=娜美, 007=罗宾}
        System.out.println(map.put("001","要当海贼王的路飞"));// 当键有的话，就是添加，没有的话，就是覆盖
        System.out.println(map);//{001=要当海贼王的路飞, 002=索隆, 004=乔巴, 005=山治, 006=娜美, 007=罗宾}
        System.out.println(map.size());//6, 查看集合中的元素的个数
        System.out.println(map.isEmpty());//false;判断集合是否为空
        System.out.println(map.containsKey("003"));//false ;判断集合中是否包含这个键
        System.out.println(map.containsKey("001"));//true;判断集合中是否包含这个键
        System.out.println(map.containsValue("乔巴"));//true;判断集合中是否包含这个值
        System.out.println(map.get("001"));//要当海贼王的路飞;通过键获取值
        Set<String> str = map.keySet();//获取所有的键存到set集合中
        System.out.println(str);//[001, 002, 004, 005, 006, 007]
        Collection<String> values = map.values();//获取所有集合中的值
        System.out.println(values);//[要当海贼王的路飞, 索隆, 乔巴, 山治, 娜美, 罗宾];
        Set<Map.Entry<String,String>> entries = map.entrySet();
        System.out.println(entries);//[001=要当海贼王的路飞, 002=索隆, 004=乔巴, 005=山治, 006=娜美, 007=罗宾]
        for (Map.Entry<String, String> entry : entries) {//使用增强for循环  iter快捷键
            System.out.println(entry);//001=要当海贼王的路飞,002=索隆,004=乔巴,005=山治,006=娜美,007=罗宾;键值对对象
            System.out.println(entry.getKey());//001,002,004,005,006,007;获取的键
            System.out.println(entry.getValue());//要当海贼王的路飞,索隆，乔巴，山治，娜美，罗宾;获取值
        }

    }
}

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

package com.yhs.text;

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

class Son {
    private String name;
    private int age;

    public Son(String name, int age) {//有参构造
        this.name = name;
        this.age = age;
    }

    public String getName() {//getandset进行赋值取值
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    @Override //重写to String方法
    public String toString() {
        return "Son{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class Demo2 {
    public static void main(String[] args) {
        Map<Integer,Son> map = new HashMap<>();
        map.put(1,new Son("常威",25));
        map.put(2,new Son("来福",5));
        map.put(3,new Son("星爷",26));
        System.out.println(map);//{1=Son{name='常威', age=25}, 2=Son{name='来福', age=5}, 3=Son{name='星爷', age=26}}
        System.out.println(map.get(2).getName());//来福

    }
}

package com.yhs.text;

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

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("巴尔泽布");
        list1.add("布耶尔");
        map.put(2,list);
        System.out.println(map);//{1=[枫原万叶, 神里绫华, 神里绫人], 2=[枫原万叶, 神里绫华, 神里绫人]}



    }
}

2.File类

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

文件路径问题：

相对路径：

得有一个参照物

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

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

../上一级目录

../../上两级目录

../../../上三级目录

绝对路径:

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

C:\aaa\3.txt

File构造方法

File(String pathname)

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

File(String parent, String child)

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

package com.yhs.text;

import java.io.File;

public class Demo4 {
    public static void main(String[] args) {
        //将文件和文件夹路径抽象成了一个对象
        File file = new File("D:/abcd/1.txt");
        System.out.println(file);//D:\abcd\1.txt
        //从父抽象路径名和子路径名字符串创建新的 `File`实例
        File file1 = new File("D:/abcd","1.txt");
        System.out.println(file1);//D:\abcd\1.txt
        System.out.println(File.separator);// ;\,separator`与系统相关的默认名称 - 分隔符字符
        //得到一个结论： 在windows系统下面 /  和\都是可以的
        //但是在linux系统下面  只能/   才可以
        //	separator
        //与系统相关的默认名称 - 分隔符字符
        File file2 = new File("D:" + File.separator + "abcd" + File.separator + "1.txt");
        System.out.println(file2);//D:\abcd\1.txt




    }
}

File类下面的方法

boolean createNewFile(); 新建一个文件

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

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

3.磁盘坏了

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

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

package com.yhs.text;

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

public class Demo5 {
    public static void main(String[] args) throws IOException {//声明了一个IOException的异常
        File file = new File("D:/abcd/2b.txt");
        System.out.println(file.createNewFile());//此处会报错需要抛一个异常;打印结果:true;说明文件已经建好
        File file1 = new File("D:/abcd/ccc");
        System.out.println(file1.mkdir());//true;创建单级目录(文件夹)
        File file2 = new File("D:/abcd/ccc/eee");
        System.out.println(file2.mkdirs());//true;创建多级的目录(文件夹)
    }
}

删除文件或者文件夹

boolean delete();

package com.yhs.text;

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

public class Demo6 {
    public static void main(String[] args) throws IOException {
        File file = new File("D:/abcd/sb.txt");
        System.out.println(file.createNewFile());//此处会报错需要抛一个异常;打印结果:true;说明文件已经建好
        File file1 = new File("D:/abcd/fff");
        System.out.println(file1.mkdir());//true;创建单级目录
        File file2 = new File("D:/abcd/ggg/hhh");
        System.out.println(file2.mkdirs());//创建多级目录
        System.out.println(file1.delete());//true;删除了file1创建的fff目录
        System.out.println(file.delete());//true;删除了file创建的sb.txt文件
        File file3 = new File("D:/abcd/bbb");
        System.out.println(file3.delete());//false;因为bbb下面还有文件夹或者文件;delete只能删除空的文件夹或者文件
    }
}

File类下面判断的方法

boolean isFile();是否是文件

boolean isDirectory(); 是否是文件夹

boolean isHidden(); 是否是隐藏文件

boolean isAbsolute(); 是否是绝对路径

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

package com.yhs.text;

import java.io.File;

public class Demo7 {
    public static void main(String[] args) {
        File file = new File("D:/abcd/1.txt");
        System.out.println(file.isFile());//true;是否是文件
        File file1 = new File("D:/abcd/bbb");
        System.out.println(file1.isDirectory());//true;是否是文件夹
        System.out.println(file1.isHidden());//false;是否是隐藏文件
        System.out.println(file1.isAbsolute());//true;是否是绝对路径
        System.out.println(file1.exists());//true;文件或者文件夹是否存在  
    }
}

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

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

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

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

package com.yhs.text;

import java.io.File;

public class Demo8 {
    public static void main(String[] args) {
        File file = new File("D:/abcd/1.txt");
        System.out.println(file.getName());//1.txt;获取文件或者文件夹的名字的
        System.out.println(file.getParent());//D:\abcd;获取上一级目录
        System.out.println(file.getPath());//D:\abcd\1.txt;获取file对象的绝对路径

    }
}

方法是long类型数据

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

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

package com.yhs.text;

import java.io.File;

public class Demo9 {
    public static void main(String[] args) {
        File file = new File("D:/abcd/1.txt");
        System.out.println(file.length());//0;获取文件占用磁盘的字节数;此处为0，代表此文件是空的
        System.out.println(file.lastModified());//1680329724956 ;获取当前文件修改的时间;时间戳
        //时间戳是指格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总秒数。

    }
}

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

File[] listFiles();

String[] list();

package com.yhs.text;

import java.io.File;

public class Demo9 {
    public static void main(String[] args) {
        File file = new File("D:/abcd");
        File[] files = file.listFiles();
        for (File file1 : files) {
            System.out.println(file1);//D:\abcd\1.txt;D:\abcd\bbb;获取文件夹和文件对象
        }
        String[] list = file.list();
        for (String s : list) {
            System.out.println(s);//1.txt;bbb;获取文件夹和文件名字
        }
    }
}

3.递归

一句话来概括：

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

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

package com.yhs.text;

import java.io.File;

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


        }
        public static void  test () {
            test();
            System.out.println("呵呵");
        }
}

求1-100的和，使用递归的方式来写

package com.yhs.text;

import java.io.File;

public class Demo9 {
    public static void main(String[] args) {
        System.out.println(sum(1));//5050
        }
        public static int sum (int num) {
            //终止条件
            if (num == 100) {
                return  100;//结束 方法的调用而已
            }
            return num + sum(num + 1);
        }
}

4 .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.1字节输入流

FileInputStream

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

package com.yhs.text;

import java.io.*;

public class Demo9 {
    public static void main(String[] args) throws IOException {//这里声明异常
        //1.创建一个file对象的  文件抽象
        File file = new File("D:/abcd/1.txt");
        //2.创建字节输入流的核心的类
        FileInputStream fis = new FileInputStream(file);//这里要抛异常
        //3.加缓冲功能
        BufferedInputStream bis = new BufferedInputStream(fis);
        //4.创建一个数组  缓冲数组
        byte[] buf = new byte[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));//枫原万叶 ;将磁盘上面文件的内容读取到Java代码中
        }
        //6.关闭 这里先开的后关
        bis.close();
        fis.close();
    }

4.2.字节输出流

FileOutputStream

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

package com.yhs.text;

import java.io.*;

public class Demo10 {
    public static void main(String[] args) throws IOException {
        //1.创建文件对象
        File file = new File("D:/abcd/1.txt");
        //2.创建核心的字节输出流对象FileOutputStream
        FileOutputStream fos = new FileOutputStream(file);
        //3.加缓冲的效果  BufferedOutputStream
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //4.声明一个字符串
        String str = "摩拉克斯";
        //5.输出方法
        bos.write(str.getBytes());
        //6.关闭 这里先开的后关
        bos.close();
        fos.close();
    }
}

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

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

使用Java代码

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

package com.yhs.text;

import java.io.*;

public class Demo11 {
    public static void main(String[] args) throws IOException {
        copyvideo ();
    }
    public static void copyvideo () throws IOException {
        //创建缓冲输入流对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(new File("D:/abcd/bbb/1.mp4")));
        //创建缓冲输出流对象
        BufferedOutputStream bos =  new BufferedOutputStream(new FileOutputStream(new File("D:/abcd/aaa/2.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();

    }
}

4.3字符输入流【非重点】

FileReader

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

阅读字符文件的便利类

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

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

package com.yhs.text;

import java.io.*;

public class Demo12 {
    public static void main(String[] args) throws IOException {
        //1.创建file对象
        File file = new File("D:/abcd/1.txt");
        //2.创建字符输入流的核心的对象
        FileReader fr = new FileReader(file);
        //3.加缓冲效果
        BufferedReader br = new BufferedReader(fr);
        //4.准备缓冲的数组(字符数组)
        char[] cbuf = new char[8];
        int length;
        while ((length= fr.read(cbuf)) != -1) {
            System.out.println(new String(cbuf, 0 ,length));//总有地上的生灵敢于直面雷霆的威光
        }
        //关流
        br.close();
        fr.close();
    }
}

字符输出流【非重点】

FileWriter

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

package com.yhs.text;

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

public class Demo13 {
 public static void main(String[] args) throws IOException {
     File file = new File("D:/abcd/1.txt");
     FileWriter fw = new FileWriter(file);
     BufferedWriter bw = new BufferedWriter(fw);
     String str = "天动万象";
     bw.write(str.toCharArray());
     bw.close();
     fw.close();
 }
}

5.StringBuffer

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

package com.yhs.text;

public class Demo14 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("123456");
        System.out.println(sb);//123456
        System.out.println(sb.toString());//123456;将StringBuffer类型的数据转为String
        System.out.println(sb.append("a"));//123456a;追加
        System.out.println(sb.insert(3,"猫"));//123猫456a
        System.out.println(sb.delete(1,7));//1a
        System.out.println(sb.reverse());//a1;字符串反转
        System.out.println(sb.capacity());//22;容量 容量是新插入字符可用的存储量
        StringBuffer sb1 = new StringBuffer();
        System.out.println(sb1.capacity());//16
        sb1.append("12345678912345671");
        System.out.println(sb1.capacity());//34
    }
}

6.枚举类

Java中有一个特殊的类叫枚举类，一般表示的是常量。
public static final int A = 23;
枚举就是替换上面常量的写法的！！！！

语法格式：

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

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

package com.yhs.text;
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 Demo15 {
    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();返回值的指定的字符串的常量

package com.yhs.text;
enum Color1 {
    RED, GREEN, BLUE
}
public class Demo16 {
    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);
    }
}

7.包装类

Java八大基本数据类型，都有与之对应的包装类

为啥会有这些包装类？其实就代表基本数据类型所有东西

包装类能够实例化处理对象，有很多的方法，来处理当前的数据

这样来操作八大基本数据类型很方便

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***(); 将一个字符串转为所对应基本数据类型

package com.yhs.text;
class User {
    String name;
    Integer age;
    String email;
    Integer sex;
}
public class Demo17 {
    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


    }
}