java se的部分基础知识_java泛型 unexpect bound-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_61603262/article/details/126789759

本文档详细介绍了Java中的泛型，包括其概念、边界及数组使用；深入讲解了序列化的原理与实现，强调了对象实例化和序列化需求；探讨了文件读写的基本步骤和注意事项；阐述了多线程的两种实现方式，以及线程同步的细节，包括 BlockingQueue 接口的使用；最后，简要说明了反射在Java中的应用，包括获取Class实例的几种方式。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

自己整理：java se的部分知识

文章目录

自己整理：java se的部分知识

1.泛型 GJ（generic java）

泛型是语法，不是数据类型，只在编译阶段被识别，运行时泛型会被擦除
不存在一个叫做泛型类的类

例如：

List<String> list = new ArrayList<>();
if (list instanceof List) {
    // list instanceof List: true
    System.out.println("list instanceof List: " + (list instanceof List));
}
// 下面代码错误，instanceof后面不能使用泛型
if (list instanceof List<String>) {}

Class Gjclass，须要new一个新Gjclass<>对象实例并确定T后才能够实现GJclass中的功能对于泛型方法定义时的类型形参T，不能通过new T()来创建对象，所以要创建类型T对应的对象，需要传递Class clazz参数泛型类可以根据不同T设置多个构造方法
泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型

泛型类：
```
public GJClass<T>{//T 是形参

	//balabla...

}
```
泛型方法：
```
public <T,E> T myMethrod(Classbalabala<E> t){

	//...

};
```
泛型边界：
<?>无界 <? extends Number>上界为Number <? super String>下界为String
例：
```
public void showKeyValue1(Generic<? extends Number> obj；
```
只接收Number的子类;

在泛型方法中添加上下边界限制的时候，必须在权限声明与返回值之间的上添加上下边界，即在泛型声明的时候添加
```
public <T> T showKeyName(Generic<T extends Number> container)
```
，编译器会报错：“Unexpected bound”

public <T extends Number> T showKeyName(Generic<T> container){
    System.out.println("container key :" + container.getKey());
    T test = container.getKey();
    return test;
}

其他：

在java中是”不能创建一个确切的泛型类型的数组”的。

也就是说下面的这个例子是不可以的：

List<String>[] ls = new ArrayList<String>[10];

而使用通配符创建泛型数组是可以的，如下面这个例子：

List<?>[] ls = new ArrayList<?>[10];

这样也是可以的：

List<String>[] ls = new ArrayList[10];

2.序列化

序列化对象必须是一个实例，须是serializable的子类
static方法/属性不会被序列化操作
序列化需要公共无参构造器



import java.io.*;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class  Demo{
    public static void main(String[] args) throws Exception {
        List<User> list=InfReadHandler.InfRead("C:\\Demo\\doc/doc.txt");//待输出的对象,User类型数组
        boolean r=OIO.ObjWriter("C:\\Demo\\doc/OIO.ser",list);
        if(r==true) System.out.println("成功创造文件");
        list=OIO.ObjReader("C:\\Demo\\doc/OIO.ser");
        System.out.println(list.get(0));
    }
}
class OIO{

    static boolean ObjWriter(String path,List<User> list)  {
        File file = new File(path);
        if(file.exists()){System.out.println("文件已存在");return false;}
        else if(file.isDirectory()){System.out.println("输入错误");return false;}
        try {
        FileOutputStream out = new FileOutputStream(file);
        ObjectOutputStream OIS=new ObjectOutputStream(out);
        for(User t:list){
            OIS.writeObject(t);
        }
        } catch (Exception e) {
            if(!(e instanceof EOFException))
            e.printStackTrace();
        }
        return true;
    }
    static List<User> ObjReader(String path) throws IOException {
        File file=new File(path);
        if(!file.exists()||!file.isFile())System.out.println("文件不存在！");

        List<User> list = new ArrayList<>();
        InputStream byin=new FileInputStream(path);
        ObjectInputStream in =new ObjectInputStream(byin);
        int count=0;
        while(true)
        {
            try{Object temp= in.readObject();
            if(temp==null)break;
            list.add((User) temp);
            count++;} catch (Exception e) {               //ObjectInputStream实例扫描到文件末尾时会抛出EOF异常，须要在catch中处理
                if(!(e instanceof  EOFException))
                e.printStackTrace();
                break;
            }
        }
        System.out.println("共读取了"+count+"个文件");


       return list;
    }

}

class InfReadHandler{
    static public List<User> InfRead(String path) throws Exception {
        File file=new File(path);
        if(!file.exists()||!file.isFile()){
            System.err.println("输入错误");
            return null;
        }
        List<User> list=new ArrayList<>();
        //构造user所需参数
        String id;
        String name;
        int age;
        String gender;
        Date date;
        //Input所需变量
        String[] buffer=new String[1024];
        String temp=new String();//用于接收每行字符的字符串

        InputStream in=new FileInputStream(path);
        FileReader r=new FileReader(path);
        BufferedReader br = new BufferedReader(r);
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
        int count=-1;
        while(true){
            System.out.println("Reading...");

            temp=br.readLine();
            if(temp==null)break;
            buffer=temp.split("\\s+");
            if(count==-1){count++;continue;}
            id=buffer[0];
            name=buffer[1];
            age= Integer.valueOf(buffer[2]);
            gender=buffer[3];
            date=sdf.parse(buffer[4]);
            User u=new User(id,name,age,gender,date);
            list.add(u);
            System.out.println("读取到信息，id:"+id);
        }
        return list;
    }

}

class User implements Serializable{
    @Serial
    private static final long serialVersionUID = -637343524733100954L;//为保证文件版本一致、须引入serialVersionUID
    String id;
    String name;
    int age;
    String gender;
    Date date=new Date();
    User(String Uid,String Uname, int uAge,String uGender,Date uDate){
        id=Uid;
        name=Uname;
        age=uAge;
        gender=uGender;
        date.setTime(uDate.getTime());
    }
    public User(){

    }
}

3.文件读写

File是唯一表示硬盘文件或者目录的类型。通过方法可以判断目录File 对象是文件还是且录
流的分类

按照方向:输入 (读取)和输出(写入)

按照处理数据方式:字节流和字符流

流的功能:基于且标文件建立的普通节点流和基于某个节点流建立的处理
文件读写过程

1 建立目标文件

2基于且标文件建立文件流

3进行读写操作

4关闭相关文件流对象，释放资源(要注意文件的读写操作异常处理)


/***********************************************文件复制程序***********************************************/
import java.io.*;
import java.nio.charset.StandardCharsets;
class Demo{
    public static void main(String[] args) throws Exception {
        String str=IOM.readFile("C:\\Demo\\doc/doc.txt");
        IOM.outPut("C:\\Demo\\doc/.copy.txt",str);
    }
}
class IOM{


    static String readFile(String path) throws Exception {
    FileInputStream in ;
    StringBuffer buf=new StringBuffer();
    byte[] buffer = new byte[1024];
    File file=new File(path);
    in = new FileInputStream(file);

    while (1==1) {
        int temp=in.read(buffer);
        if(file.isDirectory()||!file.exists()||temp==-1)
        {
            if(file.isDirectory())System.out.println("输入错误 输入对象非文件");
            if(!file.exists())System.out.println("输入错误 文件不存在");
            if(in.read()==-1){System.out.println("复制完毕");}
            break;
        }
        String a=new String(buffer,0,temp);//按照读入字节数转换字符串，避免乱码
        buf.append(a);



    }
        in.close();
    return new String(buf);
}


    /***
     *
     * @param path:目标文件目录
     * @param content：写入字符串内容
     * @return 写入是否成功
     * @throws Exception
     */
    static boolean  outPut(String path, String content) throws Exception {
        File file=new File(path);

        if(file.exists()||content==null) {
        System.out.println("输入了错误的目录或空的字符串");
        return false;
        }
        while(true){
        OutputStream out=new FileOutputStream(file);
        byte[] buffer=content.getBytes(StandardCharsets.UTF_8);
        out.write(buffer);
        return true;
        }
    }

}

4.多线程

4.1两种方式实现多线程：

1.继承thread重写run

2.实现runnable实例（方便共享run方法）

//run thread/timetask
//call

//Example
//这是一个农民干活地主监视，当农民摸鱼地主就会将其唤醒的故事
class Demo {
    public static void main(String[] args) {

    class r implements Runnable{
        @Override
        public void run() {
            try {
                System.out.println("check");
            Thread.sleep(1000);
                System.out.println("OK");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
        r MyRun=new r();
        Thread t0=new Thread(MyRun);
        Thread t1=new Thread(MyRun);
        t0.start();
        t1.start();
    }
}
//进程的生命周期(STATE)
//新建——运行——阻塞——死亡
//
import java.util.Random;

public class Demo implements Runnable {
    public void setFarmer(Thread farmer) {
        this.farmer = farmer;
    }

    private Thread farmer;

    public void setLord(Thread lord) {
        this.lord = lord;
    }

    private Thread lord ;
    @Override
    public void run() {
                //农民
        if(Thread.currentThread()==farmer){
            System.out.println("开工");
            for(int count=0;count<=1000;count++){
                if(count==1000){count=0;System.out.println("rua");}
                Random r=new Random();
                if(r.nextInt(1000)<800) {
                    try {
                        Thread.sleep(999*60*60);
                        System.out.println("摸了");
                    } catch (InterruptedException e) {
                        System.out.println("起了");
                    }
                }
            }
        }
        //地主
        if(Thread.currentThread()==lord){
                    System.out.println("开始监视");
                    while(1==1){
                        if(farmer.getState()==Thread.State.BLOCKED||farmer.getState()==Thread.State.WAITING){
                            farmer.interrupt();
                            System.out.println("不准摸");
                        }
                    }
                }


            }

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

            Demo test=new Demo();
            Thread farmer=new Thread(test,"001");
            Thread lord=new Thread(test,"002");
            test.setFarmer(farmer);
            test.setLord(lord);
            farmer.start();
            lord.start();
        }

    }

运行上述程序，发现lord的中断功能仅能执行一次
加入

farmer.getState() == Thread.State.TIMED_WAITING

程序正常运行。

4.2线程联合、队列

4.2.1线程同步相关细节

线程同步：

synchronized(this){//执行动作}

对象锁
重入
synchronized修饰的方法：同步方法，指调用方法对象会被同步锁定
wait()线程同步，sleep()非同步；sleep不放弃锁，wait放弃锁
注意：jdk的解释中，说wait()的作用是让“当前线程”等待，而“当前线程”是指正在cpu上运行的线程！唤醒不会放弃当前线程对监视器的所有权，当前线程放弃监视器后其他线程才会醒来（发信号并继续）

4.2.2BlockingQueue接口

ArrayBlockingQueue：基于数组的阻塞队列实现，在ArrayBlockingQueue内部，维护了一个定长数组，以便缓存队列中的数据对象，其内部没实现读写分离，也就意味着生产和消费不能完全并行，长度是需要定义的，可以指定先讲先出或者先讲后出，也叫有界队列，在很多场合非常适合使用。

LinkedBlockingQueue：基于链表的阻塞队列，同ArrayBlockingQueue类似，其内部也维持着一个数据缓冲队列〈该队列由一个链表构成），LinkedBlockingQueue之所以能够高效的处理并发数据，是因为其内部实现采用分离锁（读写分离两个锁），从而实现生产者和消费者操作的完全并行运行,他是一个无界队列。

SynchronousQueue：一种没有缓冲的队列，生产者产生的数据直接会被消费者获取并消费。

PriorityBlockingQueue：基于优先级的阻塞队列（优先级的判断通过构造函数传入的Compator对象来决定，也就是说传入队列的对象必须实现Comparable接口），在实现PriorityBlockingQueue时，内部控制线程同步的锁采用的是公平锁，他也是一个无界的队列。

DelayQueue：带有延迟时间的Queue，其中的元素只有当其指定的延迟时间到了，才能够从队列中获取到该元素。DelayQueue中的元素必须实现Delayed接口，DelayQueue是一个没有大小限制的队列，应用场景很多，比如对缓存超时的数据进行移除、任务超时处理、空闲连接的关闭等等。

4.2.3ConcurrentLinkedQueue

概念理解
ConcurrentLinkedQueue：是一个适用于高并发场景下的队列，通过无锁的方式，实现了高并发状态下的高性能，通常ConcurrentLinkedQueue性能好于BlockingQueueo它是一个基于链接节点的无界线程安全队列。该队列的元素遵循先讲先出的原则。头是最先加入的，尾是最近加入的，该队列不允许null元素。
ConcurrentLinkedQueue重要方法：

Add()和offer()都是加入元素的方法（在ConcurrentLinkedQueue中，这两个方法没有任何区别）

Poll()和peek()都是取头元素节点，区别在于前者会删除元素，后者不会

//线程池使用实例
import java.util.concurrent.*;

public class Demo{
    public static void main(String[] args) {
        LinkedBlockingQueue q0=new LinkedBlockingQueue(5);
        ThreadPoolExecutor pool=new ThreadPoolExecutor(2,12,60,TimeUnit.SECONDS,q0);
        Runnable work=new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<=1000000;i++){
                    if(i%10000==0)System.out.println("输出");
                }
            }
        };
        pool.execute(work);
    }
}

5.反射

//反射
//Class实例构建：
Class clazz=person.class;
//or:
person p=new person;
p.getclass();
//or:
Class clazz=Class.forName("dir")
//or：使用一个classloader

//
package Main;
 
import java.lang.reflect.Constructor;
 
public class Main {
    public static void main(String[] args)  throws Exception{
 
        //当我不想 newInstance初始化的时候执行空参数的构造函数的时候
        //可以通过字节码文件对象方式 getConstructor(paramterTypes) 获取到该构造函数
        String classname="demo2.Person";
        //寻找名称的类文件，加载进内存 产生class对象
        Class cl=Class.forName(classname);
        //获取到Person(String name,int age) 构造函数
        Constructor con=cl.getConstructor(String.class,int.class);
 
        //通过构造器对象 newInstance 方法对对象进行初始化 有参数构造函数
        Object obj=con.newInstance("神奇的我",12);
    }
}