JAVA8-CSDN博客

本文链接：https://blog.csdn.net/leiunit/article/details/123347769

1泛型方法

是在调用方法时指明泛型的具体类型

//语法：方法访问控制符 <T,E...> 返回类型 方法名(形参列表) {}
//注意：访问控制符和返回值类型中间的<T>非常重要，它表示此方法是泛型类型，但是泛型类中使用了泛型成员的方法并不是方法
public static <T,E,K> void printType(T t,E e,K k) {
    System.out.println(t+"\t"+t.getClass().getSimpleName());
    System.out.println(e+"\t"+e.getClass().getSimpleName());
    System.out.println(k+"\t"+k.getClass().getSimpleName());
}

可变参数的泛型方法

我们在定义方法的时候可以在方法形参出声名，

//格式：访问控制符 <泛型类型> 返回值类型 方法名(泛型标识... 变量名) {}
//该变量可以接受任意个数的该类型数值，封装在一个数组中
public static  <E> void print(E... e) {
    for (int i = 0; i < e.length; i++) {
        System.out.println(e[i]);
    }
}

注意：使用三个点标识可变参数，也就是随便多少参数

//注意：在泛型中没有继承的概念，如果定义一个泛型的引用指向任意该泛型类的对象，那么对象中的泛型类型需要使用通配符号 ?  表示。
ArrayList<String> strList = new ArrayList<>();
List<?> list = new ArrayList();
list = strList;

2 流（IO）

流的分类：
1.输入流和输出流
	输入还是输出我们拥有站在程序的角度去看待，写文件是输出，读文件是输入
2.字节流和字符流
	按照传输数据的最小单位划分
3.节点流和处理流
	按照功能分为节点流和处理流，节点流是一些基本的流，处理流是一些功能强大的流，它包在节点流外面

所有的流都继承自以下四个抽象类：
	InputStream	字节输入流
	OutputStream 字符输出流
	Reader	字符输入流
	Writer  字符输出流

节点流

2.1 FileInputStream

FileInputStream文件字节输入流，它用来以一个字节一个字节的方式来读文件
read()	读取文件中的一个字节，并返回int型的编码，若读到最后返回-1
close()	关闭输入流
不可以按照字节打印汉字

public class Test1 {
    public static void main(String[] args) {
        InputStream is = null;
        //这么写的目的在于扩大is的作用范围
        try {
            is = new FileInputStream("D:\\ClassFile\\Idea_File\\test0302\\src\\com\\iweb\\test\\Test1.java");
            int i = 0;
            while ((i=is.read())!=-1){
                System.out.print((char) i);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

2.2 File.separator

File.separator表示当前操作系统的文件分隔符
注意：在实际开发中同一使用 / ；因为windows会自动转成\

2.3 FileOutputStream

文件字节输出流，以一个字节一个字节写文件
write(int) 将某个字节写入文件，注意：如果文件不存在，会首先创建文件
close() 关闭该输出流

//复制的功能
public class Test2 {
    public static void main(String[] args) {
        InputStream is = null;
        OutputStream os = null;
        try {
            is = new FileInputStream("D:/ClassFile/Idea_File/test0302/src/com/iweb/test/Test2.java");
            os = new FileOutputStream("D:/test2.java");
            int i = 0;
            while ((i=is.read())!=-1) {
                os.write(i);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

2.4 NullPointException

空指针异常，当某个变量不指向任何对象时，使用该变量调用方法，就会抛这个异常，所以我们为了代码稳定性，通常会判断对象是否为空

2.5 FileReader

文件字符输入流，它用来以一个字符一个字符的方式读文件
read() 读取文件中的一个字符，并返回int型该字符编码，如果读到末尾返回-1
close() 关闭该输入流
注意：创建该对象时，可以传入2个参，第2个boolean型的参表示是否追加在后面

2.6 FileWriter

文件字符输出流，它用来以一个字符一个字符的方式写文件
write() 向文件中的写字符 //其中是字符unicode编码
close() 关闭该输入流

处理流

2.7 BufferedInputStream

缓冲字节输入流，它包着一个InputStream对象
read():它用来读取数据，一次性从数据源读取8k个字节存入缓冲区，然后从缓冲区中取一个字节返回,再从缓冲区读取一个字节，极大减少了对数据源的读取次数
is = new FileInputStream("D:/ClassFile/Idea_File/test0302/src/com/iweb/test/Test1.java");
bfs = new BufferedInputStream(is);
int i = 0;
while ((i=bfs.read())!=-1){
    System.out.print((char) i);//打印
}

2.8 BufferedReader

缓冲字符输入流，里面包着一个Reader对象
readline()	用来读取一行数据，同样也有缓冲区概念

2.9 BufferedWriter

缓冲字符输出流，里面包着一个Weiter对象
write() 一次性写入一个字符串
newLine() 另起一行
flush() 清空缓冲区
close() 关闭该输入流，同时会关闭里面的节点流

2.10 打印流（PrintWriter）

PrintWriter 打印字符流
它提供各种重载的print方法和println()方法来向目标资源打印数据

2.11 InputStreamReader

这是一个字节流转字符流的桥梁，将传入的字节数据转为字符数据

//InputStreamReader、PrintWriter、FileReader
public class Test8 {
    public static void main(String[] args) {
        String s = null;
        PrintWriter log = null;
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        try {
            FileWriter fw = new FileWriter("d:log.txt",true);
            log = new PrintWriter(fw);
            while ((s=br.readLine())!=null) {
                if ("exit".equals(s)) {
                    break;
                }
                System.out.println(s);
                log.println("-------------");
                log.println(s);
                log.println("=="+(new Date()) +"==");
                log.flush();

            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}