JavaSE学习笔记

‘/t’ 制表符

• 在打印的时候，把前面的字符长度补齐到8后者8的整数倍数，最少1个空格，最多2个空格

JDK7进制表示

long型数据

• 定义long型数据需要在数据后面加一个L

// 数据后加入L
long n = 999999999L;

Scanner键盘输入运用

//scanner调用方法nextInt一次就会键盘输入一次.下面代码会键盘输入两次
Scanner sc = new Scanner(System.in);
System.out.println("请输入整数");
sc.nextInt();
int i = sc.nextInt();
System.out.println(i);

IDEA快捷建

• psvm主函数
• sout 输出

取值范围

byte->short->int->long->float->double

byte short char 三种类型的数据进行计算的时候,都会直接提升到int类型,再进行计算

""和’'的区别

""表示内容为字符串
''表示类容为字符即char类型

赋值运算符

+= -= /= %= 四种关系运算符包含强制类型转换

短路运算

++a < 5 $$ ++b < 5;
当左边表达式能得出结果,便不再计算右边的值

隐式转换底层原理

byte类型 : 1个字节
short类型 : 2个字节
int类型 : 4个字节
long类型 : 8个字节

• 隐式转换 : 前面加入缺少的零
• 强制转换 : 前面消除多余位数

if和else if 判断

多条件判断.按顺序逐个判断,有一个为true遍退出循环

case穿透

• 原因:代码中没有写braek结束语句
• 执行流程:首先拿着小括号里面的值跟每一个case进行匹配,如果匹配上了就执行case语句体,此时若遇到break便会结束switch语句,若是没有break,那么程序就会继续执行下一个case的语句体,直到遇到break或者所有case语句体执行完
• 注意: switch中按先后顺序执行case

while循环语句条件为true时,下方不能写代码

//while 循环条件为true时是无限循环,无法到达while循环下面的代码
        Scanner scanner = new Scanner(System.in);
        int x = scanner.nextInt();
        int temp = x;
        int num = 0;
        while (true){
            int shu = x % 10;
            x = x / 10;
            num = num * 10 + shu;
        }
        System.out.println(num == temp);//本行代码报错

break 和 switch 的区别

This的本质

• this指向的是成员变量, 但其本质是指向调用这的地址值
• 调用方法的时候默认其方法前有一个this

键盘录入体系

    第一套体系:
    nextInt(); 接收整数
    nextDouble();接收小数
    next();接收字符串
    遇到空格，制表符，回车就停止接受。这些符号后面的数据就不会接受了
    
    第二套体系：
    nextLine();接收字符串
    可以接收空格，制表符，遇到回车才停止接受数据

char类型字符参与计算

char类型字符参与计算的时候,会自动查找ASCII码表,转换为相应的int型数据进行计算

对Srting对象的比较要使用equals方法进行而不是用’==’

---

String拼接

• String s1 = “a” + “b” + “c”;
• String s2 = “abc”;
• s1 == s2 ? 为true
• 字符串拼接没有变量时,直接在编译阶段优化,即代码还未运行时s1便已被优化为abc字符串
• 字符串拼接包含变量时,JDK8以前通过new StringBuilder在该容器内拼接, JDK8版本以后系统通过预估字符串长度创建数组进行存储

StringBuilder

• StrinBuilder容器的append方法是一直往后添加, 即在原有的基础上往后面添加字符, 所以再使用是无需append(sb).append(“xxx”), 直接append(“xxx”)即可
  

ArrayList

• 集合底层已处理,返回的数据不是地址值而是其中的内容
• 集合只可以存储引用数据类型

Util工具类特点

• 构造方法私有化
• 成员方法静态化

方法重写

多态

使用规则:

• 需要有继承关系
• 声明父类对象new子类
• 子类重写父类方法

调用规则

public class Test {
    public static void main(String[] args) {
        //创建对象（多态方式）
        //Fu f = new Zi();
        Animal a = new Dog();
        //调用成员变量：编译看左边，运行也看左边
        //编译看左边：javac编译代码的时候，会看左边的父类中有没有这个变量，如果有，编译成功，如果没有编译失败。
        //运行也看左边：java运行代码的时候，实际获取的就是左边父类中成员变量的值
        System.out.println(a.name);//动物

        //调用成员方法：编译看左边，运行看右边
        //编译看左边：javac编译代码的时候，会看左边的父类中有没有这个方法，如果有，编译成功，如果没有编译失败。
        //运行看右边：java运行代码的时候，实际上运行的是子类中的方法。
        a.show();///Dog --- show方法

        //理解：
        //Animal a = new Dog();
        //现在用a去调用变量和方法的呀？是的
        //而a是Animal类型的，所以默认都会从Animal这个类中去找

        //成员变量：在子类的对象中，会把父类的成员变量也继承下的。父：name  子：name
        //成员方法：如果子类对方法进行了重写，那么在虚方法表中是会把父类的方法进行覆盖的。
    }
}


class Animal{
    String name = "动物";

   public void show(){
        System.out.println("Animal --- show方法");
    }
}

class Dog extends Animal{
    String name = "狗";

    @Override
    public void show() {
        System.out.println("Dog --- show方法");
    }

}

class Cat extends Animal{
    String name = "猫";

   @Override
    public void show() {
        System.out.println("Cat --- show方法");
    }
}

泛型

• 泛型接口
• 泛型方法
• 泛型类
• E T K V在定义泛型的时候使用
• ? 通配符在使用泛型的时候使用
  ** ? extends 类名 : 代表泛型上限, ?必须是类的子类或其本身
  ** ? super 类名 : 代表泛型下线限, ?必须是类的父类或其本身

Objects

System API

• arraycopy​(Object src, int srcPos, Object dest, int destPos, int length) 将指定源数组中的数组从指定位置开始复制到目标数组的指定位置。

BigDecimal API

• 对浮点型数据类型进行一系列操作的保证其精度准确的类

        double a = 0.1;
        double b = 0.2;
        System.out.println(a + b);
        BigDecimal aBig = BigDecimal.valueOf(a);
        BigDecimal bBig = BigDecimal.valueOf(b);

        System.out.println(aBig.add(bBig));

        //转化为double类型
        double rs = aBig.doubleValue();
        System.out.println(rs);

Date API

• getTime()方法 : 返回自此 Date对象表示的1970年1月1日00:00:00 GMT以来的毫秒数。

SimpleDateFormat API

• 字符串时间转换为Date类型的格式化时间

//计算2021年08月06日 11:11:11 后2天 14小时 49分 06秒的时间
        String dataStr = "2021年08月06日 11:11:11";
        //定义时间规格, 必须与需要转换的字符串格式一致
        SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        //将字符串转换为时间
        Date date1 = simpleDateFormat1.parse(dataStr);

        long l = date1.getTime() + 2L * 24 * 60 * 60 * 1000 + 14 * 60 * 60 * 1000 + 49*60*1000 + 6 * 1000;

        String format1 = simpleDateFormat1.format(l);
        String format2 = simpleDateFormat1.format(date1);
        System.out.println(format2);
        System.out.println(format1);

Calendar API

LocalDate, LocalTime, LocalDateTime

Period API

Duration API

Arrays API

        Student[] students = new Student[3];
        students[0] = new Student("吴磊", 23, '男');     
        students[1] = new Student("谢鑫", 18, '男');
        students[2] = new Student("王亮", 20, '男');

        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) { 
                if (o1.getAge() == 23){
                    System.out.println(o1);
                }else {
                    System.out.println("从第二个开始");
                }
                return o1.getAge() - o2.getAge();
            }
        });

        System.out.println(Arrays.toString(students));

Lambda 表达式

• Lambda 表达式简化匿名内部类, 且匿名内部类必须是函数式接口

package LambdaDemo1;

import org.jcp.xml.dsig.internal.dom.DOMSubTreeData;

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

        Swimming swimming = new Swimming() {
            @Override
            public void swim() {
                System.out.println("跑的很快");
            }
        };

        Swimming swimming1 = () -> {
            System.out.println("跑的很快");
        };


        go(swimming);
        System.out.println("----------------------");
        go(swimming1);
        System.out.println("----------------------");
        go(() -> {
            System.out.println("跑的很快");
        });

    }

    public static void go(Swimming swimming){
        System.out.println("开始...");
        swimming.swim();
        System.out.println("结束...");
    }
}

@FunctionalInterface
interface Swimming{
    void swim();
}

• 进一步代码简化规则
  

Collection 集合体系

Collection API

红黑树规则

LinkedList API

集合遍历且在遍历过程中删除元素

• 使用迭代器删除

Collection<String> arrList = new ArrayList();
        arrList.add("小李");
        arrList.add("小李");
        arrList.add("小李");
        arrList.add("小李");
        arrList.add("小李");
        
Iterator<String> iterator = arrList.iterator();
        while (iterator.hasNext()){
            String next = iterator.next();
            if (Objects.equals(next, "小李")) {
                iterator.remove();
            }
        }

• 使用for循环删除

for (int i = arrList.size() - 1; i >= 0; i--) {
     String s = arrList.get(i);
     if (Objects.equals(s, "小李")){
         arrList.remove(s);
     }
}

for (int i = 0; i < arrList.size(); i++) {
    String s = arrList.get(i);
    if (Objects.equals(s, "小李")){
        arrList.remove(s);
        i--;
    }
}

HashSet中Hash表原理

集合总结和选择标准

可变参数

Collections API

• 批量添加元素 : addAll() 方法
  

Map API

遍历Map集合

        Map<String, Integer> maps = new HashMap<>();

        maps.put("王五",15);
        maps.put("李四",19);
        maps.put("赵六",25);
        
        //第一种遍历方式, 将键值对作为整体拿出
        Set<Map.Entry<String, Integer>> entries = maps.entrySet();
        for (Map.Entry<String, Integer> entry : entries) {
            String key = entry.getKey();
            int value = entry.getValue();
            System.out.println(key + "---->" + value);
        }

		//第二种遍历方式, 推荐
        Set<String> keys = maps.keySet();

        for (String key : keys) {
            int integer = maps.get(key);
            System.out.println(key + "---->" + integer);
        }

		//第三种遍历方式, 推荐
        maps.forEach(new BiConsumer<String, Integer>() {
            @Override
            public void accept(String s, Integer integer) {
                System.out.println(s + "---->" + integer);
            }
        });

不可变集合

集合和数组获取Steam流

Stream流常用方法

• 流只能通过一些操作筛选集合中的元素, 而不能改变集合本身, 其本质是将集合拷贝一份到流中进行操作

• 每个流只能使用一次

自定义异常

• 自定义运行时异常类, 编译阶段不提示,

public class MyRunTimeException extends RuntimeException {
    public MyRunTimeException() {
    }

    public MyRunTimeException(String message) {
        super(message);
    }
}

• 自定义编译时异常, 编一阶段强烈提示, 必须抛出或者捕获异常

public class MyOneException extends Exception{
    public MyOneException() {
    }

    public MyOneException(String message) {
        super(message);
    }
}

• 自定义异常测试类

public class ExceptionTest1 {

    public static void main(String[] args) {

        try {
            chainAge(-19);
        } catch (MyOneException myOneExcetion) {
            myOneExcetion.printStackTrace();
        }

        chainAge1(-59);

    }
    public static void chainAge(int age) throws MyOneException {
        if (age < 0 || age > 200){
            throw new MyOneException(age + " is no!!");
        }else{
            System.out.println("输入合法");
        }
    }

    public static void chainAge1(int age) throws RuntimeException {
        if (age < 0 || age > 200){
            throw new RuntimeException(age + " is no!!");
        }else{
            System.out.println("输入合法");
        }
    }
}

File API

• 常用方法
  

File文件遍历及注意事项

IO流四大类

IO流体系

• 输出字节流只支持字节的输出, 若想将字符输出需先将字符转换为字节数据, 然后在进行输出

        OutputStream fileOut = new FileOutputStream("day18-File-IO/src/out.txt");
        fileOut.write('a');
        fileOut.write(98);
        fileOut.write("散散啊".getBytes());
        fileOut.flush();
        fileOut.close();

IO流拷贝文档

        try { //通过byte字节流拷贝数据, 已淘汰
            InputStream is = new FileInputStream("day18-File-IO//src//a.txt");
            byte[] bt = new byte[1024];
            int len = 0;

            OutputStream os = new FileOutputStream("D://code//a.txt");
            while ((len = is.read(bt)) != -1){
                os.write(bt, 0, len);
            }

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

注意 : 三种资源释放方式

读取输入输出流注意事项

• 不论是读取字符还是字节输入输出流, 将读取的字符/字节放置在char[]/byte[] 数组中, 都应该定义一个整型变量len获取输入/输出的字符/字节长度, 然后在对获取的流封装成字符串的时候指定其读取从0开始到len, 这样才能避免错误且提高代码效率

        try {
            Reader fileReader = new FileReader("day18-File-IO//src//b.txt");

            char[] flRead = new char[1024];
            int len = 0;
            if ((len = fileReader.read(flRead)) != -1){
                String str = new String(flRead, 0, len);
                System.out.print(str);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

缓冲流

缓冲流拷贝数据

• 注意 : 缓冲流读取一行数据后, 再将这一行数据写入到拷贝的文件中, 需要写入换行的命令符

        try (Reader fileReader = new FileReader("day18-File-IO//src//b.txt");
             BufferedReader fr = new BufferedReader(fileReader);
             Writer fileWriter = new FileWriter("day18-File-IO//src//d.txt");
             BufferedWriter fw = new BufferedWriter(fileWriter);
        ) {
            LocalDateTime startTime = LocalDateTime.now();
            String line;
            while ((line = fr.readLine()) != null) {
                fw.write(line);
                fw.newLine();
                //fw.write("\r\n"); 相当于newLine()
            }
            LocalDateTime endTime = LocalDateTime.now();
            System.out.println("文件Copy完成");
            Duration dateTime = Duration.between(startTime,endTime);
            System.out.println(dateTime.toMillis());
        } catch (Exception e) {
            e.printStackTrace();
        }

• 出师表排序并输出到文件中

        try(
                // 1、创建缓冲字符输入流管道与源文件接通
                BufferedReader br = new BufferedReader(new FileReader("io-app2/src/csb.txt"));

                // 5、定义缓冲字符输出管道与目标文件接通
                BufferedWriter bw = new BufferedWriter(new FileWriter("io-app2/src/new.txt"));
                ) {

            // 2、定义一个List集合存储每行内容
            List<String> data = new ArrayList<>();
            // 3、定义循环，按照行读取文章
            String line;
            while ((line = br.readLine()) != null){
                data.add(line);
            }
            System.out.println(data);

            // 4、排序
            // 自定义排序规则
            List<String> sizes = new ArrayList<>();
            Collections.addAll(sizes, "一","二","三","四","五","陆","柒","八","九","十","十一");

            Collections.sort(data, new Comparator<String>() {
                @Override
                public int compare(String o1, String o2) {
                    // o1   八.,....
                    // o2   柒.,....
                    return sizes.indexOf(o1.substring(0, o1.indexOf(".")))
                            - sizes.indexOf(o2.substring(0, o2.indexOf(".")));
                }
            });
            System.out.println(data);

            // 6、遍历集合中的每行文章写出去，且要换行
            for (String datum : data) {
                bw.write(datum);
                bw.newLine(); // 换行
            }

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

//出师表txt文档
十一.出师未捷身先死，长使英雄泪满襟。
三.侍中、侍郎郭攸之、费祎、董允等，此皆良实，志虑忠纯，是以先帝简拔以遗陛下。愚以为宫中之事，事无大小，悉以咨之，然后施行，必得裨补阙漏，有所广益。
八.愿陛下托臣以讨贼兴复之效，不效，则治臣之罪，以告先帝之灵。若无兴德之言，则责攸之、祎、允等之慢，以彰其咎；陛下亦宜自谋，以咨诹善道，察纳雅言，深追先帝遗诏，臣不胜受恩感激。
四.将军向宠，性行淑均，晓畅军事，试用之于昔日，先帝称之曰能，是以众议举宠为督。愚以为营中之事，悉以咨之，必能使行阵和睦，优劣得所。
二.宫中府中，俱为一体，陟罚臧否，不宜异同。若有作奸犯科及为忠善者，宜付有司论其刑赏，以昭陛下平明之理，不宜偏私，使内外异法也。
一.先帝创业未半而中道崩殂，今天下三分，益州疲弊，此诚危急存亡之秋也。然侍卫之臣不懈于内，忠志之士忘身于外者，盖追先帝之殊遇，欲报之于陛下也。诚宜开张圣听，以光先帝遗德，恢弘志士之气，不宜妄自菲薄，引喻失义，以塞忠谏之路也。
九.今当远离，临表涕零，不知所言。
十.今当远离，临表涕零，不知所言。
陆.臣本布衣，躬耕于南阳，苟全性命于乱世，不求闻达于诸侯。先帝不以臣卑鄙，猥自枉屈，三顾臣于草庐之中，咨臣以当世之事，由是感激，遂许先帝以驱驰。后值倾覆，受任于败军之际，奉命于危难之间，尔来二十有一年矣。
柒.先帝知臣谨慎，故临崩寄臣以大事也。受命以来，夙夜忧叹，恐付托不效，以伤先帝之明，故五月渡泸，深入不毛。今南方已定，兵甲已足，当奖率三军，北定中原，庶竭驽钝，攘除奸凶，兴复汉室，还于旧都。此臣所以报先帝而忠陛下之职分也。至于斟酌损益，进尽忠言，则攸之、祎、允之任也。
五.亲贤臣，远小人，此先汉所以兴隆也；亲小人，远贤臣，此后汉所以倾颓也。先帝在时，每与臣论此事，未尝不叹息痛恨于桓、灵也。侍中、尚书、长史、参军，此悉贞良死节之臣，愿陛下亲之信之，则汉室之隆，可计日而待也。

字符输入转换流 InputStreamReader

字符输出转换流 OutputStreamWriter

对象字节输入流 ObjectInputStream

对象字节输出流 ObjectOutputStream

• 对象序列化中被序列化的对象必须实现接口Serializable
• 成员变量加入transient修饰将不再参与序列化

对象序列化代码

//实体类Student
public class Student implements Serializable {
    private String name;
    private char sex;
    private transient int age;

//对象输出流代码
    public static void main(String[] args) throws Exception {
        Student student = new Student("王五", '男', 19);

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day18-File-IO//src//e.txt"));

        oos.writeObject(student);

        oos.close();

        System.out.println("序列化成功");

    }

//对象输入流代码
    public static void main(String[] args) throws Exception {

        FileInputStream oi = new FileInputStream("day18-File-IO//src//e.txt");

        ObjectInputStream ois = new ObjectInputStream(oi);

        Student student = (Student) ois.readObject();
    }

字节/字符打印流

打印流冲定向

• System.out.println实际是一个打印流, 其指向我们的控制台

    public static void main(String[] args) throws Exception {
        System.out.println("锦瑟无端五十弦");
        System.out.println("一弦一柱思华年");

        // 改变输出语句的位置（重定向）
        PrintStream ps = new PrintStream("io-app2/src/log.txt");
        System.setOut(ps); // 把系统打印流改成我们自己的打印流

        System.out.println("庄生晓梦迷蝴蝶");
        System.out.println("望帝春心托杜鹃");
    }

Properties API

commons-io 框架使用