CCQDDQ的博客

package StreamT;import java.util.ArrayList;import java.util.stream.Stream;/** * @className: Test01 * @description: Stream流初尝试 * @author: CCQ * @date: 2021/9/12 **/public class Test01 { public static void main(String[] args) { ArrayL

package SimpleTest;import java.util.function.Supplier;/** * @className: Test13 * @description: 函数式接口之Supplier（生产商接口就是只有返回没有入参） * @author: CCQ * @date: 2021/9/11 **/ //此接口是一个生产商接口，传入类型的参数就会返回什么类型的参数 //此接口有一个T get()方法、获得结果public class Test

package SimpleTest;/** * @className: Test10 * @description: //函数式接口 * @author: CCQ * @date: 2021/9/11 **/public class Test10 {}//Java提供了一个注解，表明这个接口是个函数式接口//这个注解是可选的，不写也可以，写了可以规范接口为函数式接口，不写只要接口里面只有一个抽象方法也是函数式接口@FunctionalInterfaceinterface k{

package SimpleTest;/** * @className: Test05 * @description: 方法引用 * @author: CCQ * @date: 2021/9/10 **///一些Java已经有的代码实现，我们可以直接进行引用，引用符为::public class Test05 { public static void main(String[] args) { use_e(s -> System.out.println(s

package SimpleTest;/** * @className: Test02 * @description: 接口中的default方法 * @author: CCQ * @date: 2021/9/10 * * default方法不是抽象方法，是Java新版本特性，它能够让接口添加方法时已经实现了此接口的类不报错，即不必重写default方法。当然也可以选择重写。 * 类似于抽象类里面的非抽象方法。 **/public class Test02 { public s

package SimpleTest;/** * @className: Test01 * @description: lambda表达式 * @author: CCQ * @date: 2021/9/10 **/public class Test01 { public static void main(String[] args) { new Thread(()-> System.out.println("启动线程！")).start();

package ThreadTest.Day3;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;/** * @author CCQ * 线程池 * ExecutorService是一个线程池接口 * Executors是一个实现类。有一个静态方法newFixedThreadPool（int a）实现创建线

package ThreadTest.Day3;/** * @author CCQ * 实现线程之间的通信 * 管程法 * void notify() * 唤醒在此对象监视器上等待的单个线程。 * void notifyAll() * 唤醒在此对象监视器上等待的所有线程。 * void wait() * 在其他线程调用此对象的notify()方法或 notifyAll()方法前，导致当前线程等待。 * void wait(long timeout) * 在其他线程调

package ThreadTest.Day3;import java.util.concurrent.locks.ReentrantLock;/** * @author CCQ * Lock是一个接口，ReentrantLock是这个接口的一个实现类 * lock();加锁 * unlock();解锁，加锁后记得解锁 * 使用lock锁 */public class Test05 { public static void main(String[] args) {

package ThreadTest.Day3;/** * @author CCQ * 死锁问题 */public class Test04 { public static void main(String[] args) { HZ hz1 =new HZ(0); HZ hz2 =new HZ(1); new Thread(hz1,"棋棋").start(); new Thread(hz2,"瑶瑶").start();

1.package ThreadTest.Day3;/** * @author CCQ * 不安全的买票 * 多个线程同时操作一个对象 * synchronized关键字，锁住对象，避免同时操作一个对象 */public class Test01 { public static void main(String[] args) { buy b1 =new buy(); new Thread(b1,"屌丝").start(); new

package ThreadTest.Day2;/** * @author CCQ * 线程停止 * 1.建议线程正常停止->利用次数，不建议死循环 * 2.建议设置使用标志位来停止线程 * 3.不建议使用stop或者destory等过时或者JDK不建议使用的方法 */public class Test01 { public static void main(String[] args) { thread t =new thread(); ne

package ThreadTest.Day1;/** * @author CCQ * lambda表达式：简化代码 * 接口必须是函数式接口 * 函数式接口：只有一个抽象方法的接口。 */public class Test09 { //静态内部类 static class L2 implements like{ @Override public void lambda(int a) { System.out.prin

package ThreadTest.Day1;/** * @author CCQ * 代理模式 * 代理对象要和真实对象实现同一个接口 * 好处：代理对象能做许多真实对象做不了的事情 * 真实对象专注做自己的事情 */public class Test08 { public static void main(String[] args) { DaiLi z =new DaiLi(new me()); z.happymarry();

package ThreadTest.Day1;/** * @author CCQ * 线程不安全问题，多个线程同时操作一个对象。并发问题 */public class test05 { public static void main(String[] args) { buyticket b =new buyticket(); new Thread(b,"棋棋").start(); new Thread(b,"瑶瑶").start();

方式一：package ThreadTest.Day1;/** * @author CCQ * 创建线程的方式一：继承Thread类，重写run()方法，通过start()方法调度， */public class ThreadTest01 extends Thread{ @Override public void run() { for (int i = 0; i < 2000; i++) { System.out.println(

package FileT.Day7;/** * @author CCQ * Properties是一个集合，可用于IO流的集合，此类是hashtable类的子类。 * 构造方法摘要 * Properties() * 创建一个无默认值的空属性列表。 * Properties(Properties defaults) * * 此类的特有方法 * String getProperty(String key) * 用指定的键在此属性列表中搜索属性。创建一个带有指定默认值的空属

package FileT.Day6;import java.io.*;/** * 序列化流与反序列化流 * 序列化需要类实现Serializable接口 * 如果没有显式声明序列化id，当类的对象被序列化后，如果类发生变化，那么在反序列化对象的时候就会报错，因为版本id不一致。 * 如果显式声明了序列化id，则当类的对象被序列化后，即便类发生变化也不会影响反序列化，因为id没有变。 * 显式声明id需要为static final long serialVersionUID。 * 如果某

package FileT.Day6;import java.io.FileWriter;import java.io.IOException;import java.io.PrintStream;import java.io.PrintWriter;/** * @author CCQ * 字节打印流和字符打印流 * * 字节打印流 * print()和println()方法都是字节打印流类的方法 * write()是字节打印流父类的方法，它的父类是FilterOutputS

package FileT.Day6;/** * @author CCQ * 用字符打印流复制文件 */import java.io.*;public class printdemo { public static void main(String[] args) throws IOException { BufferedReader br =new BufferedReader(new FileReader("fox.txt")); PrintWri

package FileT.Day6;/** * System.in跟System.out */import java.io.*;import java.util.Arrays;public class demo { public static void main(String[] args) throws IOException { InputStream in = System.in;// int ch;// while ((ch

package FileT.Day4;/** * @author CCQ * 字符缓冲流复制文件。 */import java.io.*;public class BufferedRWTest { public static void main(String[] args) throws IOException { BufferedReader br =new BufferedReader(new FileReader("fox.txt")); Buf

package FileT.Day4;/** * 字符流的简化写法，用这个类可以不要写这么麻烦 * 但是这个类不能设置编码格式 */import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;public class FileRWTest { public static void main(String[] args) throws IOException { Fil

package FileT.Day4;/** * @author CCQ * 构造方法有两个参数，一个是字节流对象，一个是字符串类型的编码格式。可以只写字节流对象 * * void close() * 关闭该流并释放与之关联的所有资源。 * String getEncoding() * 返回此流使用的字符编码的名称。 * int read() * 读取单个字符。 * int read(char[] cbuf, int

package FileT.Day3;/** * @author CCQ * 字节缓冲流 * 将要读或者要写的数据放入到缓冲区，然后再一次性读或写。能够提高性能。 * BufferedOutputStream();里面共可以有两个参数，一个是原本的字节流对象，一个是int类型的缓冲区长度，不写就是默认大小8192 * BufferedInputStream();里面共可以有两个参数，一个是原本的字节流对象，一个是int类型的缓冲区长度，不写就是默认大小8192 *

package FileT.Day2;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;/** * @author CCQ * int read()方法一次只能读一个字节 * 返回值是读到的字节的int类型。 */public class FileInputTest { pu

package FileT.Day2;/** * @author 朱雀 * */import java.io.File;import java.io.FileOutputStream;import java.io.IOException;public class FileOutputTest { public static void main(String[] args) throws IOException { FileOutputStream f1 =new

package FileT.Day1;/** * File类的其中三个构造方法 * 第一个是输入文件的完整路径 * 第二个是父路径加子路径分开写、子路径就是文件名字。 * 第三个是传入一个Fiel对象作为父路径，再写子路径 */import java.io.File;public class FileTest { public static void main(String[] args) { File f1 =new File("D:\\picture\\捕获

//获取字符串每个字符并输出个数class demo3{ public static void main(String[] args) { Scanner sc =new Scanner(System.in); System.out.print("请输入字符串："); String s =sc.nextLine(); Integer values; HashMap<Character,Integer> h

package CollectionsTest;import java.util.ArrayList;import java.util.Arrays;import java.util.Collections;import java.util.List;public class collectionsTest { public static void main(String[] args) { ArrayList<Integer> a =new ArrayLi

都是一些垃圾笔记，随便写的，没必要看。package map;import java.util.Comparator;import java.util.Map;import java.util.TreeMap;public class treemapTest { public static void main(String[] args) { TreeMap<student,String> t1 =new TreeMap<>(new Compar

package map;import java.util.*;public class hashmapTest { public static void main(String[] args) { HashMap<student,String> h1 =new HashMap<>(); System.out.println("-------------添加元素-----------------"); student s1

package map;import java.util.HashMap;import java.util.Map;import java.util.Set;/** * 1.map是无序的，无下标的，键值对存储。键不可以重复，值可以重复 * @author CCQ */public class mapTest { public static void main(String[] args) { Map<Integer,String> map =new

package Set;import java.util.Comparator;public class Per implements Comparable<Per> { int age; String name; public int getAge() { return age; } public void setAge(int age) { this.age = age; } public

package Set;import java.util.HashSet;import java.util.Iterator;import java.util.Set;public class SetTest { public static void main(String[] args) { Set<String> s1 =new HashSet<>(); System.out.println("---------------添加

import java.util.Iterator;import java.util.LinkedList;import java.util.ListIterator;public class LinkedListTest { public static void main(String[] args) { //添加元素 System.out.println("-------------添加元素---------------"); Float

泛型泛型，即参数化类型。在类型未知的时候，可以使用泛型来代替。通俗点来说，泛型就是一个参数，用来接收数据的类型。定义泛型的符号是<>。需要注意的是泛型的参数不支持多态。注意是参数。泛型类：class fanclass<T>{ private T key; public T getKey() { return key; } public void setKey(T key) { this.key = key;

注解元注解：@Target：表明被注解注解的作用域（类、方法、属性等等）@Retention：表明被注解注解的作用时间。只有三个（只在源文件、编译时保留、运行时保留）。一般自定义的注解都设置为运行时保留@Document：表明被注解的注解会保留在doc文档中@Inherited：表明被注解的注解所在类的子类可以继承该注解注解的变量：注解的变量声明方法是：返回值类型 变量名（）；（可以设置默认值）自定义注解：自定义注解的声明：@interface 注解名{}注解事项：如果注解有参数

获取 Class实例的五个方法：1.使用类名获得Class c1 =类名.class();2.使用对象获得class a =new class();Class c2 =a.getClass();3.通过forName方法获得Class c3 =Class.forName("");//参数填所要获得类的相对路径，从包开始4.包装类的Class实例可以通过Type属性获得Class c4 =Integer.TYPE;5.通过子类的Class实例获得父类的Class实例Class c

元注解：@Target：表明被注解注解的作用域（类、方法、属性等等）@Retention：表明被注解注解的作用时间。只有三个（只在源文件、编译时保留、运行时保留）。一般自定义的注解都设置为运行时保留@Document：表明被注解的注解会保留在doc文档中@Inherited：表明被注解的注解所在类的子类可以继承该注解注解的变量：注解的变量声明方法是：返回值类型 变量名（）；（可以设置默认值）自定义注解：自定义注解的声明：@interface 注解名{}注解事项：如果注解有参数，那么