Java 自学笔记(自用)

已于 2023-02-17 15:37:33 修改
阅读量136 收藏
点赞数
文章标签： java
于 2022-12-29 15:29:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_70695547/article/details/128482737
版权

JRE和JDK和JVM关系

JRE：JVM+JavaSE核心类库（Api文档查看）

JDK：JRE+开发工具包（Java、Javac）

注释

文档注释：

 

 标识符（类名、方法名等）定义规则：

1.不可以数字开头

2.由字母数字和_或者$组成

3.不能有空格

命名规范：（建议遵守，调用方便）

小驼峰：开头字母小写，其余首字母大写（方法或者变量）

大驼峰：所有首字母大写（类名）

Java基本语法：

内部类

 

成员变量和局部变量

1.成员变量有默认值，局部变量没有默认值，必须初始化才能引用。

2.成员变量包括静态和非静态：

        静态成员变量：它是在加载当前这个类的时候，就在方法区的静态区中存在。

        非静态成员变量：当创建这个类的对象的时候，随着对象的产生在堆中出现。

2.同一作用域内不能使用定义名字相同的变量

数据类型

8种基本数据类型，3种引用数据类型，字符串属于类的数据类型

超出范围会编译错误！！！ 

float精度为7；数字后面要带f或者F。

char的默认值为'\u0000';为unicode表值

基本数据类型的默认转换：

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

  • 前三个类型相互或自我运算结果都为int！！！
  • 强制类型转换（截断操作）可能会有精度损失

long字节比float大为啥还转float？

因为float存储的数字范围比long大

二进制的原码、补码与反码：

计算机最终识别的是补码！！

正数的补码、原码、反码都一样

枚举类：

  1. 自定义枚举类
  2. jdk5.0之后可以使用enum定义枚举类，enum父类为Enum
  3. Enum不是Object子类！？
  4. 以后全都用enum关键字定义枚举类，主要用于定义已知元素个数的常量组！！

JAVA集合：

Collection

  1. List：有序可重复
  2. Set：无序不可重复

Collection常见方法：

注意：asList里面放基本数据类型数组会被判断为一个元素，包装类型就不会。

迭代器遍历方法，调用hasNext()和next(),但还是推荐使用foreach遍历，底层也是iterator！！

 contains()、containsAll()、remove()等方法调用，需要先重写对象obj类中的equals()方法！！！

List

  ArrayList源码分析：

jdk8的优化就是将数组初始化改到第一次调用add()时

 LinkedList源码分析：

底层使用了双向链表。 增删改比起ArrayList更快。

Vector源码分析：

初始和ArrayList相同，默认扩容为原来的2倍，线程安全，但效率低

 List常见方法：

Set

  1.  HashSet:（基于HashMap的底层原理实现，元素存放再Key，将value全部指向同一obj）

    class Test {
    public static void main(String[] args) {
        Solution s = new Solution("lg",23);
        HashSet<Solution> set = new HashSet<>();
        set.add(s);
        System.out.println(set);
        s.age=24;
        set.add(s);
        System.out.println(set);
        s.age=25;
        set.add(s);
        System.out.println(set);
    }
}

    1. 主要实现类，线程不安全，可以存null；
    2. 底层为数组加链表存储；
    3. 要重写equals和hashCode
    4. 引用类型元素在添加进HashSet后不要再修改成员属性！否则会发生重复添加！

  2. LinkedHashSet：

    1. HashSet子类，可以按添加顺序遍历！！
    2. 在hashSet的基础上增加了头尾指针；
    3. 要重写equals和hashCode

  3. TreeSet：

    1. 必须放同类型元素，可自行排序；

Map

 HashMap:

反射：

动态代理和Aop的应用例子：

package proxy;


import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class proxDemo {
    public static void main(String[] args) {
        //创建Good的子类对象
        Food food = new Food();
        Game game = new Game();

        //获得对应的动态代理对象，并用接口Good接收。
        Good proxyInstance = (Good) proxyFactory.getProxyInstance(food);
        Good proxyInstance2 = (Good) proxyFactory.getProxyInstance(game);
        proxyInstance.buy(10);
        System.out.println("==================================");
        proxyInstance2.buy(100);
    }
}

//接口
interface Good{
    void buy(int i);
}

//被代理类
class Food implements Good{
    @Override
    public void buy(int i) {
        System.out.println("旺旺大礼包一共"+i+"元");
    }
}

class Game  implements Good{
    @Override
    public void buy(int i) {
        System.out.println("新款游戏:"+i+"元");
    }
}

//工具类
class GoodUtil{
    //通用方法一
    public void begin(){
        System.out.println("买单！");
    }
    //通用方法二
    public void after(){
        System.out.println("结账！");
    }
}

class proxyFactory{
    /**
     * 生成一个动态代理对象
     * @param obj 被代理的对象
     * @return  返回代理对象
     */
    public static Object getProxyInstance(Object obj){
        InvocationHandler handler = new MyInvocationHandler(obj);
        //获取obj的类，接口和返回一个代理对象
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),handler);
    }
}

class MyInvocationHandler implements InvocationHandler{
    private  Object obj;
    public MyInvocationHandler(Object obj) {
        this.obj = obj;
    }

    /**
     * 返回被代理对象调用的方法a的结果
     * @param proxy 代理类
     * @param method   被代理类调用的方法a，通过反射获得
     * @param args  方法a的参数
     * @return 方法a的返回值
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        GoodUtil G = new GoodUtil();
        G.begin();
        Object res = method.invoke(this.obj, args);
        G.after();
        return res;
    }
}

线程与进程: 

进程：

  • 进程就是用来加载指令，管理内存，管理IO的
  • 当一个程序被运行，从磁盘加载到这个程序的代码至内存，就开启了一个进程。
  • 进程可以看成一个程序的实例，如（记事本、画图）

线程：

  • 一个进程由多个线程组成
  • 一个线程就是一个指令流，将指令流中一条条指令以一定顺序交给CPU执行。
  • Java中，线程时最小调度单位，进程时最小资源分配单位

对比：

  • 进程相互独立，线程可以相互协作
  • 进程间通信复杂
    • 同一台计算机通信称为IPC（Inter-process communication）
    • 不同计算机之间的进程通信，需要通过网络协议
  • 线程通信简单，因为有共享的内存
  • 线程更轻量，上下文切换开销小

并发：单核CPU，线程轮流使用CPU的做法，同一时间应对多件事情

并行：多核CPU同一时刻执行多个线程，同一时间做多件事情

多线程的创建：

1.使用一个类继承Thread类，重写run方法，然后在主线程中多次实例化并运行对应的start()方法即可启动多线程。

2.使用runnable接口实现

3.使用FutureTask创建线程，接受Callable类型的参数，可处理返回值！

FutureTask<Integer> f = new FutureTask<Integer>(()->{
    System.out.println("线程创建成功");
    return 520;
});
Thread t = new Thread(f,"线程一");
t.start();
//处理返回值
System.out.println(f.get());

总结：

推荐使用runnable实现多线程！！

//使用Lambda表达式简化
Thread t = new Thread(()->{System.out.println("创建线程成功");},"线程一");
t.start();

原因：1.没有类单继承的局限性

             2.适合处理多个线程又共享数据的情况：抢票，订桌等

查看和杀死进程的方法：

 线程私有内存区：

虚拟机栈、本地方法栈、程序计数器

为什么私有？

  • 虚拟机栈：每个java方法执行时都会创建一个栈帧存储局部内存变量等信息
  • 方法栈：与虚拟机栈类似，但服务于Native方法。私有化保证了变量不会被别的线程访问到。
  • 程序计数器：记录当前线程目前执行到的位置。私有是为了上下文切换后能恢复到正确位置继续执行。

 线程优先级

      

 线程的优先级越高只是在抢占时间片的概率越大，并不是一定能抢到

线程常用方法：

  • start()：启动一个线程，进入ready状态等待cpu分配时间片。
  • run()：运行方法，线程获得时间片进入running状态。
  • join()：等待某个线程运行结束，再运行后面的代码。
  • join(long n)：等待n毫秒。
  • getId()：获取线程长整形的唯一id。
  • get/setName()：获取线程名字。
  • get/setPriority()：获取线程优先级。
  • getState()：获取线程的状态。
  • sleep()：让线程进入睡眠状态。
  • yield()：让线程让出时间片，线程返回ready状态。
  • interupt()：打断sleep、wait、yield阻塞状态的线程，抛出InterruptedException异常

join的应用：

实现多线程的同步运行~~

 利用interrupt方法停止线程：用两阶段终止模式替代stop（）来停止线程的运行

优点：不会破坏代码块，可以释放锁

Thread t = new Thread(()->{
    while (true){
        Thread thread = Thread.currentThread();
        //判断是否被打断
        if (thread.isInterrupted()){
            //关闭线程的操作
            System.out.println("安全关闭线程");
            break;
        }
        try {
            //监控是否被停止
            thread.sleep(1000);
            System.out.println("监控ing~~");
        } catch (InterruptedException e) {
            //sleep被打断后会清空打断记录
            e.printStackTrace();
            //重新设置打断记录
            thread.interrupt();
        }
    }
});
t.start();
Thread.sleep(3500);
//打断线程t
t.interrupt(); 

 利用关键字volatile优化

//定义全局停止标识
static boolean stop = false;
private static void stop() throws InterruptedException {
    Thread t = new Thread(() -> {
        while (true) {
            Thread thread = Thread.currentThread();
            if(stop){
                System.out.println("料理后事");
                break;
            }
            try {
                thread.sleep(1000);
                System.out.println("监控记录...");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    },"monitor");
    t.start();
    Thread.sleep(3500);
    //打断线程monitor的sleep状态
    stop = true;
    t.interrupt();
}

 保护性暂停-超时设置：join的原理

public  final synchronized void myJoin(Long time) throws InterruptedException {
    //是否满足退出条件
    boolean isOk = false;
    //记录开始时间戳
    long start = System.currentTimeMillis();
    //记录当前线程运行时长
    long now = 0;
    //记录剩余等待时间
    long delay = time - now;
    //循环等待
    while (true){
        System.out.println("正在等待");
        //运行超时执行退出
        if (delay <= 0) break;
        Thread.currentThread().wait(delay);
        //唤醒后执行代码
        if (isOk){
            System.out.println("收到啦");
        }else {
            System.out.println("还没收到啊");
        }
        //更新运行时长
        long end = System.currentTimeMillis();
        now = end - start;
    }
}

 park和unpark

作用和wait-noticfy类似，但有区别：

  • unpark可以在park之前调用，执行park之后线程不会暂停
  • unpark调用多次与一次效果一样，执行park效果一样

同步模式之Balking（犹豫模式） 

应用场景一：统一设置每个线程中得监控器。利用到了volatile（保护有序性）和synchronized（保护原子性）。

应用场景二：单例模式双重交校验锁

第一个if：提高效率。第二个if：保证多个线程情况下只创建一个对象！

为什么要加volatile?

防止synchronized中构造方法的指令重排序：并发情况下，另一个线程获取第一个线程的中还未初始化完成的INSTANCE的引用地址。

public class Lock2Singleton {
  	private volatile static Lock2Singleton INSTANCE;    // 加 volatile
  
  	private Lock2Singleton() {}
  
  	public static Lock2Singleton getSingleton() {
      	if (INSTANCE == null) {                         // 双重校验：第一次校验
          	synchronized(Lock2Singleton.class) {        // 加 synchronized
              	if (INSTANCE == null) {                 // 双重校验：第二次校验
                  	INSTANCE = new Lock2Singleton();
                }
            }
        }
      	return INSTANCE;
    }
}

volatile原理

volatile的底层实现原理是内存屏障（memory Barrier  , memory Fence）

  • 对volatile变量的写入指令在写屏障之前
  • 对volatile变量的读取指令在读屏障之后

享元模式 ：对同一对象进行重用。（最小化内存的使用）

应用场景：

包装类(Boolean，Integer，Short等）的valueOf（）方法，如Long会缓存-127-128之间的Long对象，范围内会重用，范围外会新建对象。主要依靠保护性拷贝实现。

不可变和无状态对象线程安全！

不可变对象：成员变量使用static final修饰。

无状态对象：没有定义成员变量。

AQS原理：

读写锁原理：

读写锁可以写锁降级为读锁，不可以读升级写！ 

锁状态的高16位表示读，低16位表示写。

写锁：可重入排他的独占锁，若当前状态存在读锁或者写锁为其他线程则阻塞，反之则获取成功。并发艺术p143.

读锁：可重入的共享锁，每次获取和释放，高位修改状态（±1<<16），当前现线程获取读锁时，其他线程获取了写锁则阻塞。

LG。357
关注
JAVA 自学笔记（自用）
weixin_44250010的博客
10-09 212
JAVA语法格式 首先 JAVA中程序可分为结构定义语句 和功能执行语句： 结构定义语句：用于声明一个类或者方法； 功能执行语句：用于实现具体的功能； 功能执行语句结尾必须用英文分号【;】结束；如下 System.out.println("我的ph<7"); 正题开始 编写JAVA代码时必须先声明一个类； 类的定义用关键字class 定义； 在定义类时，可以在class前加修饰符【修饰符...
Java-Spring自学笔记
知梦的博客
11-20 1669
Spring 自用，所以很多知识点不全 是一个轻量级控制反转（IoC）和面向切面编程（AOP）的框架 之前主动权在业务层（程序员）手上，现在主动权在dao层（用户）手上 IoC 隐式的自动装配 ​ <!--byName: 会自动在容器上下文中查找，和自己对象set方法后面的值对应的bean id--> <beanid=".."class=".."autowire="byName"> <propertyname=""value=""> <...
泛型（自学笔记。自用）
boilll的博客
10-18 84
自用笔记
Beetlsql自学笔记
someoneinheaven的博客
11-26 2346
自用为主，beetlsql是现在实习公司里用的，官网的文档有点乱。。然后找到了个比较好的文档，大部分来源于那篇文档，不过这里也加入了一些我自己的理解 # BeetlSQL 1、简介 BeetlSqk是一个数据访问框架，目标是提供开发敏捷，维护边界，运行告诉的数据库访问框架，目标是代替传统的JPA、Mybatis、Hibernate 传统数据库：MySQL,MariaDB,Oralce,Postgres,DB2,SQL Server，H2,SQLite,Derby，神通，达梦，华为高斯，人大金..
Java笔记
weixin_58849529的博客
02-04 36
自学自用
java基础语法(自学笔记，边学边更新，自用）
weixin_45774615的博客
01-18 122
目录Hello world数据类型标识符修饰符变量关键字参考： Hello world 如下图 > 其中： Hello_World 为类名 并且类名要与文件名相同，即文件名要为Hello_World.java String args[] 与 String[] args 都可以执行，但推荐使用 String[] args，这样可以避免歧义和误读。 运行结果 代码 public class Hello_World { public static void main(String[] a
Java常用类学习笔记
爱吃小香葱的博客
08-19 131
2021-5-19 1.字符串 String：字符串，使用一对 “” 括起来 String声明为final的，不可被继承 String实现了Serializable接口，表示字符串是支持序列化的 实现了Comparable接口，表示String可以比较大小 String内部定义了final char[] value用于存储字符串数据 String代表不可变的字符序列。简称：不可变性 当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值 当对现有的字符串进行连接操作时，也需要
通过缓冲流（区）提高读写效率 （自用自学笔记，不足补充谢谢！）
2301_76786135的博客
06-07 85
2.也是创建一个字节数组，不同的是相对于第一种方式是直接打包带走（第一种方式是分批次打包带走）通过流对象方法available（）方法获得文件的预估长度 赋给数组长度 在一次读写操作中完成文件的读写，注意：如果文件过大，那么内存的占用也是比较大的！1.通过创建一个指定长度的字节数组作为缓冲区（适用于读写较大图片时缓冲区的定义 ，相当于把文件分批次打包带走，相对于普通的效率快）。注意：缓冲区的长度一定是2的整数幂。
【Python自学笔记（自用）】Day02
weixin_51913949的博客
07-10 26
f为填充字符，*是对齐的填充字符，^8表示居中填充8位。第一行的结果说明使用format并不改变a这个对象。结果：名字是:{name},年龄是:{age}常见的对齐符号，^居中，<左对齐，>右对齐。名字是:hdy,年龄是:22,hdy是人。我叫hdy，我的薪水是3.14。1、format()填充作用。名字是:hdy,年龄是:22。2、填充和对齐通常一起出现。我叫hdy，我的薪水是34。浮点数有. 整数没有。import io模块。
SSM文档学习资源，自用
06-20
首先，Spring框架是Java开发中的基石，12.2-Spring课件与笔记部分将带你走进Spring的世界，了解其依赖注入、AOP（面向切面编程）和IoC（控制反转）的核心概念。Spring的事务管理、Bean的生命周期管理等重要特性也会...
【python自学笔记】selenium常用的一些命令合集
XiaoqiangClub的博客
02-02 447
文章目录selenium常用命令整理（自用）selenium安装（python）selenium常用代码调用浏览器访问网站关闭浏览器:driver.close()与driver.quit()的区别选择元素（定位元素）find_element 和 find_elements 的区别等待界面元素的出现操控元素点击获取元素信息frame切换切换回 主html窗口切换切换回主窗口选择框radio框chec...
【Python自学笔记】logging模块的常用方法（程序日志）
XiaoqiangClub的博客
02-21 397
文章目录logging模块最简单的使用方法部分名词解释logging.basicConfig()函数basicConfig()函数的参数说明format格式字符串logging在scrapy中的使用参考文章 logging模块 logging模块简单点说就是我们经常提到的日志 最简单的使用方法 logging最简单的使用方式就是在终端显示程序运行日志，它有几个等级，如下图 import ...
01-尚融宝项目介绍
不再的blog
06-07 1444
金融项目，尚融宝自学相关笔记，自用
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 414
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 757
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
spring-boot 整合 mybatis
m0_72168501的博客
09-29 518
spring boot 整合 mybatis
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1202
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
Java内存布局
阿呆的专栏
10-01 790
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
Java自学笔记：从基础到高级特性
"这是一份全面的Java自学笔记，涵盖了从基础到高级的诸多知识点，适合初学者系统学习。笔记内容包括JAVA的特点、运行原理、环境配置、基本概念，以及深入讲解了定义、关键字和类型，如注释、数据类型、命名规则。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值