java泛型和IO

泛型的出现避免了因为类型不同进行强制类型转换报错的情况
通常有：【泛型类】、【泛型接口】、【泛型方法】
泛型标记符：E、T、K、V、N、?

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * java 中泛型标记符：
 * <p>
 * E - Element (在集合中使用，因为集合中存放的是元素)
 * T - Type（Java 类）
 * K - Key（键）
 * V - Value（值）
 * N - Number（数值类型）
 * ? - 表示不确定的 java 类型
 */
public class TestT<T> {

    private final T data;

    //get
    public T getData() {
        return data;
    }

    //构造
    public TestT(T data) {
        this.data = data;
    }

    // 泛型方法 printArray[E - Element (在集合中使用，因为集合中存放的是元素)]
    public static <E> void printArray(E[] inputArray) {
        // 输出数组元素
        for (E element : inputArray) {
            System.out.printf("%s ", element);
        }
        System.out.println();
    }

    // 比较三个值并返回最大值[T - Type（Java 类）]
    public static <T extends Comparable<T>> T maximum(T x, T y, T z) {
        // 假设x是初始最大值
        T max = x;
        // 将max和y进行比较，如果是字符串就挨个字符，比较是负的就是max大，返回是正的y就更大
        if (y.compareTo(max) > 0) {
            //y 更大
            max = y;
        }
        if (z.compareTo(max) > 0) {
            // 现在 z 更大
            max = z;
        }
        // 返回最大对象
        return max;
    }


    // N - Number（数值类型）
    public static void getNumber(Number data) {
        System.out.println("Number : " + data);
    }


    // ? - 表示不确定的 java 类型
    public static void getData(List<?> data) {
        System.out.println("getData :" + data.get(0) + "\n");
    }

    // ? - 表示不确定的 java 类型 + N - Number（数值类型）
    public static void getUpNumber(List<? extends Number> data) {
        System.out.println("getUpNumber :" + data.get(0) + "\n");
    }


    public static void main(String args[]) {
        // 创建不同类型数组： Integer, Double 和 Character
        Integer[] intArray = {1, 2, 3, 4, 5};
        Double[] doubleArray = {1.1, 2.2, 3.3, 4.4};
        Character[] CharacterArray = {'H', 'E', 'L', 'L', 'O'};
        String[] stringArray = {"test", "element", "super", "title"};
        System.out.println("整型数组元素为:");
        // 传递一个整型数组
        printArray(intArray);

        System.out.println("\n双精度型数组元素为:");
        // 传递一个双精度型数组
        printArray(doubleArray);

        System.out.println("\n字符型数组元素为:");
        // 传递一个字符型数组
        printArray(CharacterArray);

        System.out.println("\n字符型数组元素为:");
        // 传递一个字符串数组
        printArray(stringArray);

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

        System.out.printf("%d, %d 和 %d 中最大的数为 %d\n\n", 3, 4, 5, maximum(3, 4, 5));
        System.out.printf("%.1f, %.1f 和 %.1f 中最大的数为 %.1f\n\n", 6.6, 8.8, 7.7, maximum(6.6, 8.8, 7.7));
        System.out.printf("%s, %s 和 %s 中最大的数为 %s\n", "pear", "apple", "orange", maximum("pear", "apple", "orange"));

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

        Integer data = 100;
        getNumber(data);

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

        List<String> name = new ArrayList<>();
        List<Integer> age = new ArrayList<>();
        List<Number> number = new ArrayList<>();

        name.add("test");
        age.add(18);
        number.add(365);

        getData(name);
        getData(age);
        getData(number);

        getUpNumber(age);
        getUpNumber(number);

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

        TestT<Integer> integerTestT = new TestT<>(1);
        System.out.println(integerTestT.getData());

        TestT<String> stringTestT = new TestT<>("test-string");
        System.out.println(stringTestT.getData());

        TestT<List<String>> listTestT = new TestT<>(Arrays.asList("test", "list"));
        System.out.println(listTestT.getData());
    }
}

java的io（字节流、字符流）

不同的编码格式占字节数是不同的，UTF-8编码中一个中文所占字节也是不确定的，可能是2个、3个、4个字节；
编码格式：UTF-8、GBK、ASCII 码、UTF-16、GB18030、ISO-8859-1、GB2312等等
idea中的编码格式：通常使用UTF-8

import java.io.*;
import java.nio.charset.StandardCharsets;

public class TestIO {

    /**
     * 字节流：程序直接操作文件
     * 字符流：程序先把数据缓存再写入文件
     *
     * @param args
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
        //文件字节流输出流
        OutputStream os = new FileOutputStream("test.txt");
        //将字节流转成字符流（OutputStreamWriter是字节流到字符流的连接桥梁）可以设置格式utf-8
        //因为字节流是单个字节获取，不同的字符字节不同，那就需要把字节转成字符，还要设置编码格式，
        //字符流读取文件默认是gbk格式，然后再把字符写入文件
        OutputStreamWriter writer = new OutputStreamWriter(os, StandardCharsets.UTF_8);
        //append可以放入CharSequence（String、StringBuilder、StringBuffer）写入文件
        writer.append("中文输入：");
        writer.append("\n");
        writer.append("English:");
        //关闭写入流
        writer.close();
        //关闭输出流
        os.close();

        //文件字节输入流
        InputStream is = new FileInputStream("test.txt");
        //字节流到字符流
        InputStreamReader reader = new InputStreamReader(is, StandardCharsets.UTF_8);
        StringBuilder stringBuilder = new StringBuilder();
        while (reader.ready()) {
            stringBuilder.append((char) reader.read());
        }
        System.out.println(stringBuilder);
        reader.close();
        is.close();
    }
}