JAVA笔记-API及字节流

哈哈~haha

已于 2022-08-02 20:07:01 修改

阅读量464

点赞数

分类专栏： JAVA 文章标签： java 开发语言

于 2022-07-27 21:51:45 首次发布

本文链接：https://blog.csdn.net/zjj960908/article/details/125994150

版权

JAVA 专栏收录该内容

13 篇文章 1 订阅

订阅专栏

在线查看JDK1.8 的 API文档: Java Platform SE 8

API（Application Programming Interface，应用程序接口）是一些预先定义的函数。目的是提供应用程序与开发人员基于某软件可以访问的一些功能集，但又无需访问源码或理解内部工作机制的细节.

Object

hashCode()：用于返回对应对象的int型的哈希码值，用于区分对象，哈希码值是根据对象的地址值生成。

toString()：用于返回对应对象的字符串表示，该字符串由类名+“@”+对象哈希码的无符号十六进制表示组成，即getClass().getName() + '@' + Integer.toHexString(hashCode())

equals()：用于指示其他某个对象是否与当前对象”相等”，此方法的重写时，hashCode()也需重写，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。

String

int hashCode() 返回此字符串的哈希码。
boolean equals(Object anObject) 将此字符串与指定的对象比较,比较的是重写后的串的具体内容
String toString() 返回此对象本身（它已经是一个字符串！）。

int length() 返回此字符串的长度。
String toUpperCase() 所有字符都转换为大写。
String toLowerCase() 所有字符都转换为小写
boolean startsWith(String prefix) 测试此字符串是否以指定的元素开头。
boolean endsWith(String suffix) 测试此字符串是否以指定的字符串结束。

char charAt(int index) 返回指定索引/下标处的 char 值/字符
int indexOf(String str) 返回指定字符在此字符串中第一次出现处的索引。
int lastIndexOf(String str) 返回指定字符在此字符串中最后一次出现处的索引。
String concat(String str) 将指定字符串连接/拼接到此字符串的结尾,注意:不会改变原串
String[] split(String regex) 根据给定元素来分隔此字符串。

String trim() 返回去除首尾空格的字符串
byte[] getBytes() 把字符串存储到一个新的 byte 数组中
String substring(int beginIndex) 返回一个新子串,从指定下标处开始,包含指定下标
String substring(int beginIndex, int endIndex) 返回一个新子串,从执定下标开始,到结束下标为止,但不包含结束下标
static String valueOf(int i) 把int转成String

import java.util.Arrays;

public class TestString {
    public static void main(String[] args) {
        String name = "Abc";
        System.out.println(name);
        System.out.println(name.length());
        System.out.println(name.toUpperCase());//字符串转大写
        System.out.println(name.toLowerCase());//字符川转小写
        System.out.println(name.startsWith("A") );//判断当前字符是否以某字符开始
        System.out.println(name.endsWith("c"));//判断当前字符是否以某字符结束
        System.out.println(name.charAt(0));
        System.out.println(name.charAt(2));//获取指定下表处的字符

        String s = "ancvksd";
        System.out.println(s.indexOf("c"));//获取指定字符第一次出现的下标
        System.out.println(s.lastIndexOf("d"));//获取指定字符最后一次出现的下标
        System.out.println(s.concat("sss") );
        System.out.println(s);
        System.out.println(Arrays.toString(s.split("v")));

        String s1 = "  safsf  dfdfg  ";
        System.out.println(s1);
        System.out.println(s1.trim());//去除字符串首尾空格

        String s2 = "ADFDKMCVC";
        System.out.println(s2.substring(2) );//截取指定下标开始字符
        System.out.println(s2.substring(2,4));//截取 指定下标字符串，含头不含尾
        System.out.println(String.valueOf(10+10));
        System.out.println(String.valueOf("10"+10));
        System.out.println(String.valueOf(10+""+10));
    }
}

StringBuilder/StringBuffer

封装了char[]数组
是可变的字符序列
提供了一组可以对字符内容修改的方法
常用append()来代替字符串做字符串连接”+”
内部字符数组默认初始容量是16：super(str.length() + 16);
如果大于16会尝试将扩容，新数组大小原来的变成2倍+2，容量如果还不够，直接扩充到需要的容量大小。int newCapacity = value.length * 2 + 2;
StringBuffer 1.0出道线程安全，StringBuilder1.5出道线程不安全

public class TestString1 {
    public static void main(String[] args) {
        String s = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        method2(s);
    }

    private static void method2(String s) {
        StringBuffer sb = new StringBuffer();
        StringBuilder sb1 = new StringBuilder();
        Long t1 = System.currentTimeMillis();
        for(int i = 1;i<=1000;i++){
//            sb.append(s);
            sb1.append(s);
        }
        Long t2 = System.currentTimeMillis();
        System.out.println(sb1);
        System.out.println(t1);
        System.out.println(t2);
        System.out.println(t2-t1);
    }

正则表达式Regex

用来判断用户输入的内容是否符合格式的要求，严格区分大小写的

Matches(正则) : 当前字符串能否匹配正则表达式
replaceAll(正则,子串) : 替换子串
split(正则) : 拆分字符串

import java.util.Scanner;

public class TestRegex {
    public static void main(String[] args) {
        String regex = "[0-9]{17}[0-9X]";
        String regex1 = "\\d{6}[\\dX]";
        System.out.println("请输入身份证号码：");
        String pnum = new Scanner(System.in).nextLine();
        if(pnum.matches(regex1)){
            System.out.println("输入数值正确");
        }else{
            System.out.println("输入号码不正确，请检查！");
        }
    }
}

包装类

把基本类型进行包装，提供更加完善的功能。
基本类型是没有任何功能的,只是一个变量,记录值,而包装类可以有更加丰富的功能

在这里插入图片描述

public class TestNumber {
    public static void main(String[] args) {
        Integer  i1 = new Integer(5);
        Integer i2 =  Integer.valueOf(6);

        Double d1 = new Double(3.4);
        Double d2 = Double.valueOf(3.4);

        System.out.println(i1.parseInt("80"));
        System.out.println(Integer.parseInt("80")+3);//parseInt()将String类型的数据转为int类型
        System.out.println(Double.parseDouble("80.3")+4.3);//parseDouble()将String类型的数据转为double类型
        
    }

}

import java.math.BigDecimal;
import java.util.Scanner;

public class TestBigDecimal {
    public static void main(String[] args) {
        f2();
    }

    private static void f1() {
        System.out.println("请输入需要计算的两位小数");
        double a = new Scanner(System.in).nextDouble();
        double b = new Scanner(System.in).nextDouble();
        BigDecimal  bd1 = new BigDecimal(a+"");
        BigDecimal bd2 = new BigDecimal(b+"");
        BigDecimal bd3;
        bd3 = bd1.add(bd2) ;//加
        System.out.println(bd3);

        bd3 = bd1.subtract(bd2);//减
        System.out.println(bd3);

        bd3 = bd1.multiply(bd2) ;//乘
        System.out.println(bd3);
        //divide(m,n,o)m是要除以哪个对象,n指要保留几位,o指舍入方式(比如四舍五入)*
        bd3 = bd1.divide(bd2,4,BigDecimal.ROUND_HALF_UP);
        System.out.println(bd3);//除
    }

舍入方式解析
ROUND_HALF_UP 四舍五入,五入
ROUND_HALF_DOWN 五舍六入,五不入
ROUND_HALF_EVEN 公平舍入
比如:在5和6之间,靠近5就舍弃成5,靠近6就进位成6,如果是5.5,就找偶数,变成6
ROUND_UP 直接进位
ROUND_DOWN 直接舍弃
ROUND_CEILING(天花板) 向上取整,取实际值的大值
朝正无穷方向round 如果为正数，行为和round_up一样，如果为负数，行为和round_down一样
ROUND_FLOOR 向下取整,取实际值的小值
朝负无穷方向round 如果为正数，行为和round_down一样，如果为负数，行为和round_up一样

File

在这里插入图片描述


import java.io.File;
import java.io.IOException;
import java.util.Arrays;

public class TestFile {
    public static void main(String[] args) throws IOException {
        File file = new File("E:\\a\\b\\1.txt");
        System.out.println(file.length());//获取文件字节量
        System.out.println(file.exists());//判断文件是否存在
        System.out.println(file.isFile());//判断当前内容是否是文件
        System.out.println(file.isDirectory());//判断当前文件是否是文件夹
        System.out.println(file.getParent() );//获取父级路径
        System.out.println(file.getAbsoluteFile());//获取绝对路径
        //新建文件
        File f2 = new File("E:\\a\\b\\2.txt");
        System.out.println(f2.createNewFile());
        //新建文件夹
        File f3 = new File("E:\\a\\b\\C");
        System.out.println(f3.mkdir());
        //多层文件夹新建
        File f4 = new File("E:\\a\\b\\e\\f");
        System.out.println(f4.mkdirs());
        //删除方法只能删除文件及空文件夹
        f2.delete();
        f3.delete();
        f4.delete();

        File f5 = new File("E:\\a\\b");
        String [] lsit= f5.list();
        File[] fs = f5.listFiles();
        System.out.println(fs[0].length());
        System.out.println(fs[0].getName());
        System.out.println(Arrays.toString(fs));
        System.out.println(fs[1].getName());
        System.out.println(fs[0].toString());
    }
}

字节流

字节流是由字节组成的,字符流是由字符组成的.
Java里字符由两个字节组成.字节流是基本流，主要用在处理二进制数据。
所以字节流是比较常用的，可以可以处理多种不同种类的文件，比如文本文档/音频/视频等等

字节输入流InputStream & BufferedInputStream & FileInputStream

InputStream 字节输入流的所有类的超类/抽象类, FileInputStream直接插在文件上，直接读取文件数据BufferedInputStream 为输入流添加一些功能，在创建BufferedInputStream 时，会创建一个内部缓冲区数组(默认8k大小)。在读取或跳过流中的字节时，可根据需要从包含的输入流再次填充该内部缓冲区，一次填充多个字节。

abstract int read() 从输入流中读取数据的下一个字节
int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中
int read(byte[] b, int off, int len) 将输入流中最多 len 个数据字节读入 byte 数组,off表示存时的偏移量
void close() 关闭输入流并释放与该流关联的所有系统资源

import java.io.*;

public class TestIn {
    public static void main(String[] args) {
        method1();
        method2();
    }
    private static void method1() {
        BufferedInputStream in = null;
        BufferedInputStream in1 = null;
        try {//创建流对象
             in1 = new BufferedInputStream(
                    new FileInputStream(new File("E:\\a\\b\\1.txt")));
             in = new BufferedInputStream(
                    new FileInputStream("E:\\a\\b\\1.txt"));
            int b;
            while (true){
                try {
                    if (!((b=in.read()) != -1)) break;
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
                System.out.println(b);
            }
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        }finally {
            try {
                in.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        
    }

    private static void method2() {
        FileInputStream in2 = null;
//            FileInputStream  in1 = new FileInputStream( new File("E:\\a\\b\\1.txt"))
        try {
            //使用流对象读取数据
             in2 = new FileInputStream("E:\\a\\b\\1.txt");
            int b;
            while ((b=in2.read())!=-1){
                System.out.println(b);
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }finally {
            try {
                in2.close();//关闭流资源
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }


    }
}

字符输入流 FileReader & BufferedReader

FileReader用来读取字符文件的便捷类,此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。BufferedReader从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了

import java.io.*;

public class TestIn2 {
    public static void main(String[] args) {
        method1();
        method2();
    }

    private static void method1() {
        FileReader in2 = null;
        FileReader in1 = null;
        try {
            in1 = new FileReader(new File("E:\\a\\b\\1.txt"));
            in2 = new FileReader("E:\\a\\b\\1.txt");
            int b;
            while (( b = in2.read()) != -1 ){
                System.out.println(b);
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }finally {
            try {
                in2.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
    //使用高效字符输入流BufferedReader进行读取
    private static void method2() {
        BufferedReader br = null;
        try {
            br = new BufferedReader(new FileReader("E:\\a\\b\\1.txt"));
            int b;
            while ((b = br.read()) != -1){
                System.out.println(b);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

字节输出流OutputStream & FileOutputStream&BufferedOutputstream

OutputStream此抽象类是表示输出字节流的所有类的超类.输出流接受输出字节并将这些字节发送到某个接收器；FileOutputStream直接插在文件上,直接写出文件数据；BufferedOutputstream该类实现缓冲的输出流,通过设置这种输出流,应用程序就可以将各个字节写入底层输出流中,而不必每次针对字节写出调用底层系统

package cn.zjj.api;

import java.io.*;

public class TestOut {
    public static void main(String[] args) {
        method1();
        method2();
    }

    private static void method2() {
        BufferedOutputStream o2 = null;
        BufferedOutputStream o3 = null;
        try{
            // 覆盖追加
            o2 = new BufferedOutputStream(new FileOutputStream(
                     new File("E:\\a\\b\\1.txt")));
            o2 = new BufferedOutputStream(new FileOutputStream("E:\\a\\b\\1.txt"));
            o2.write(102);
            o2.write(102);
            o2.write(102);
            o2.write(102);
            //追加输出
            o3 = new BufferedOutputStream(
                    new FileOutputStream("E:\\a\\b\\1.txt",true));
            o3.write(103);
            o3.write(103);
            o3.write(103);
            o3.write(103);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                o2.close();
                o3.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private static void method1() {
        FileOutputStream o1 = null;
        try{
            o1 = new FileOutputStream("E:\\a\\b\\1.txt");//覆盖输出
            o1 = new FileOutputStream("E:\\a\\b\\1.txt",true);//追加输出
            o1.write(100);
            o1.write(100);

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                o1.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

字节输入流InputStream

FileInputStream 子类,操作文件的字节输入流,普通类
BufferedInputStream 子类,缓冲字节输入流,普通类

字节输入流Reader

FileReader,子类,操作文件的字符输入流,普通类
BufferedReader,子类,缓冲字符输入流,普通类

字节输出流OutputStream

FileOutputStream 子类,操作文件的字节输出流,普通类
BufferedOutputStream 子类,缓冲字节输出流,普通类

字符输出流Writer

FileWriter,子类,操作文件的字符输出流,普通类
BufferedWriter,子类,缓冲字符输出流,普通类

import java.io.*;
import java.util.Scanner;

public class TestCopyFile {
    public static void main(String[] args) {
        System.out.println("请输入需要复制文件路径");
        String f1 = new Scanner(System.in).nextLine();
        System.out.println("请输入新文件的路径");
        String f2 = new Scanner(System.in).nextLine();
        ZFCopy(f1,f2);//使用字符流方式复制
        ZJCopy(f1,f2);//使用字节流方式复制
    }
    private static void ZJCopy(String f,String o) {
        BufferedInputStream in = null;
        BufferedOutputStream out = null;
        try{
            in = new BufferedInputStream(
                    new FileInputStream(f));
            out = new BufferedOutputStream(new FileOutputStream(o));
            int b;
            while ((b=in.read()) != -1){
                out.write(b);
            }
            System.out.println("复制成功");
        }catch (Exception e){
            System.out.println("复制失败");
            e.printStackTrace();
        }finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private static void ZFCopy(String f,String o) {
        BufferedReader in = null;
        BufferedWriter out = null;
        try{
            in = new BufferedReader(new FileReader(f));
            out = new BufferedWriter(new FileWriter(o,true));
            int b ;
            while ((b=in.read()) != -1){
                out.write(b);
            }
            System.out.println("复制成功");
        }catch (Exception e){
            System.out.println("复制失败");
            e.printStackTrace();
        }finally {
            try {
                out.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            try {
                in.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

本文仅个人学习笔记