---

前言

学了一学期Java了现在开始复习吧

---

一、Java开发入门

1.1 Java概述

Java 是由 Sun Microsystems 公司于 1995 年 5 月推出的 Java 面向对象程序设计语言和 Java 平台的总称。
由 James Gosling和同事们共同研发，并在 1995 年正式推出。

后来 Sun 公司被 Oracle （甲骨文）公司收购，Java 也随之成为 Oracle 公司的产品。

Java分为三个体系：

JavaSE (J2SE) (Java2 Platform Standard Edition，java平台标准版）
JavaEE (J2EE) (Java 2 Platform,Enterprise Edition，java平台企业版)
JavaME (J2ME) (Java 2 Platform Micro Edition，java平台微型版)

1.2 JDK, JRE, JVM

JDK(Java Development Kit)又称J2SDK(Java2 Software Development Kit)

是Java开发工具包，它提供了Java的开发环境(提供了编译器javac等工具，用于将java文件编译为class文件)和运行环境(提 供了JVM和Runtime辅助包，用于解析class文件使其得到运行)。如果你下载并安装了JDK，那么你不仅可以开发Java程序，也同时拥有了运行Java程序的平台。JDK是整个Java的核心，包括了Java运行环境(JRE)，一堆Java工具tools.jar和Java标准类库 (rt.jar)。

JRE(Java Runtime Enviroment)是Java的运行环境

面向Java程序的使用者，而不是开发者。如果你仅下载并安装了JRE，那么你的系统只能运行Java程序。JRE是运行Java程序所必须环境的集合，包含JVM标准实现及 Java核心类库。它包括Java虚拟机、Java平台核心类和支持文件。它不包含开发工具(编译器、调试器等)。

JVM（Java Virtual Machine）Java 虚拟机

是整个 Java 实现跨平台的最核心的部分，能够运行以 Java 语言写作的软件程序。

二、Java编程基础

2.1 基本语法

/*** 文档注释* * (类注释)* * 文件First.java* * 主类名必修和文件名一致*/
public class First {static int sCnt = 0; // 类变量int cnt = 0;// 实例变量final int SIZE = 10; // conststatic String name = "Quanwei";public void printArray(int[] array) {System.out.print(array);}public void addCnt() {++sCnt;++cnt;}public void showCnt() {System.out.println(cnt);}public static void showName(boolean isOn) {if (isOn)System.out.println(name);}public static void convert() {/* 英制到公制 */int foot;int inch;// 两个整数的运算结果一定是整数Scanner in = new Scanner(System.in);// 惯用foot = in.nextInt();inch = in.nextInt();System.out.println((foot + inch / 12f) * 0.3048);in.close();}public static void main(String[] args) {// showName(true);// int age1 = 10;// 局部变量convert();}
}

2.2 数据类型

八种基本数据类型

public class Type {/* 基本类型 默认值 */byte y; // byte: 0short s; // short: 0int i; // int: 0long l; // long: 0double d; // double: 0.0float f; // float: 0.0boolean b; // boolean: falsechar c; // char:void show() {System.out.println("byte: " + y);System.out.println("short: " + s);System.out.println("int: " + i);System.out.println("long: " + l);System.out.println("double: " + d);System.out.println("float: " + f);System.out.println("boolean: " + b);System.out.println("char: " + c);}void assign() {y = -1;s = 1;i = 2;l = 3L;d = 12.5;f = 6.25F;b = true;c = 'c';}public static void main(String[] args) {// type是引用类型Type type = new Type();type.assign();type.show();}
}

2.3 运算符

类型	运算符
成员访问运算符	.
下标运算符	[ ]
函数调用运算符	( )
算数运算符	* 乘  / 除  % 取余  +  -
按位运算	& 与 | 或  ~ 取反  ^ 异或  << 左移  >> 右移  >>> 无符号右移
逻辑运算	&  |  !非  && 短路与  || 短路非
条件运算	< >  <=  >=  ==  !=
条件运算符	? :
赋值运算符	=  +=  -=  *=  /=  <<=  >>=  >>>= &=  |=  ^=

2.4 选择结构

        boolean condition=true;// if-elseif (condition) {//todo}else{//todo}// if-else if-elseif (condition){// todo}else if(!condition){//todo}else{//todo}//switchswitch (key) {case value://todobreak;default:break;}

2.5 循环结构

        boolean condition = true;while (condition) {// todobreak;//跳出循环}do {// todocontinue;//进入下次循环} while (condition);for (int i = 0; i < 100; i++) {// todo}

三、面向对象

面向对象的优点:
可重用性：代码重复使用，减少代码量，提高开发效率。
可扩展性：指新的功能可以很容易地加入到系统中来，便于软件的修改。
可管理性：能够将功能与数据结合，方便管理。

3.1 概念

Java 是面向对象的编程语言，对象就是面向对象程序设计的核心。
所谓对象就是真实世界中的实体，对象与实体是一一对应的，也就是说现实世界中每一个实体都是一个对象，它是一种具体的概念。对象有以下特点：

 1. 对象具有属性和行为。2. 对象具有变化的状态。 3. 对象具有唯一性。 4. 对象都是某个类别的实例。 5. 一切皆为对象，真实世界中的所有事物都可以视为对象。

3.2 特性(封装, 继承, 多态)

3.2.1 封装

为什么要封装?

 1. 保护类中的信息，它可以阻止在外部定义的代码随意访问内部代码和数据。 2. 隐藏细节信息，一些不需要程序员修改和使用的信息，用户不需要知道。3. 有助于建立各个系统之间的松耦合关系，提高系统的独立性。当一个系统的实现方式发生变化时，只要它的接口不变，就不会影响其他系统的使用。4. 提高软件的复用率，降低成本。每个系统都是一个相对独立的整体，可以在不同的环境中得到使用

怎样封装? (将类中属性设为私有, 公开获取属性值的接口)

public class User {/* 私有属性 */private int id;private String username;private String passpord;/*** 构造函数*/public User() {}/*** @return the passpord*/public String getPasspord() {return passpord;}/*** @param passpord the passpord to set*/public void setPasspord(String passpord) {this.passpord = passpord;}/*** @return the id*/public int getId() {return id;}/*** @param id the id to set*/public void setId(int id) {this.id = id;}/*** @return the username*/public String getUsername() {return username;}/*** @param username the username to set*/public void setUsername(String username) {this.username = username;}@Overridepublic String toString() {return "id: "+getId()+"\tusername: "+getUsername()+"\tpassword: "+getPasspord();}
}

访问修饰符:

default (即默认，什么也不写）:

在同一包内可见，不使用任何修饰符。

使用对象：类、接口、变量、方法。

public :

对所有类可见。

使用对象：类、接口、变量、方法 protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。

private :

在同一类内可见。

使用对象：变量、方法。 注意：不能修饰类（外部类）

protected :

对同一包内的类和所有子类可见。

使用对象：变量、方法。 注意：不能修饰类（外部类）

注意：

父类中声明为 public 的方法在子类中也必须为 public。 父类中声明为 protected的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private 父类中声明为 private的方法，不能够被继承

3.2.2 继承

什么是继承?

程序中的继承性是指子类拥有父类的全部特征和行为，这是类之间的一种关系。Java 只支持单继承。

如何继承? (使用关键字 extends)

public class VipUser extends User {public static void main(String[] args) {VipUser vip = new VipUser();vip.setUsername("Quanwei");System.out.println(vip.getUsername());// Quanwei}
}

3.2.3 多态

什么是多态?

面向对象的多态性，即“一个接口，多个方法”。

为什么要使用多态?

多态性体现在父类中定义的属性和方法被子类继承后，可以具有不同的属性或表现方式。
多态性允许一个接口被多个同类使用，弥补了单继承的不足。

如何使用多态? ( 重写父类方法)

package lang.aboutclass;public class VipUser extends User {private int vipNum;@Overridepublic String toString() {return super.toString() + "\tvipNum: " + getVipNum();}/*** @return the vipNum*/public int getVipNum() {return vipNum;}/*** @param vipNum the vipNum to set*/public void setVipNum(int vipNum) {this.vipNum = vipNum;}public static void main(String[] args) {User user = new VipUser();user.setUsername("Quanwei");if (user instanceof VipUser vip) {vip.setVipNum(5432);System.out.println(vip.getUsername());// QuanweiSystem.out.println(vip);}}
}

非访问修饰符

static 修饰符
静态变量：
static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。

静态方法：
static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

final 修饰符
final 变量:
final 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。
final 修饰符通常和 static 修饰符一起使用来创建类常量。

final 方法:
父类中的 final 方法可以被子类继承，但是不能被子类重写。

final 类:
final 类不能被继承，没有类能够继承 final 类的任何特性。

abstract 修饰符
抽象类：
抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。
抽象类可以包含抽象方法和非抽象方法。

抽象方法
抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。
抽象方法不能被声明成 final 和 static。
任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。
抽象方法的声明以分号结尾，例如：public abstract sample();。

3.3 特殊类

3.3.1 抽象类 ( Abstract Class)

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
抽象类不能用于实例化对象

如何定义? (使用abstract关键字)

// 抽象类
public abstract class Human {String name;int age;String language;// 抽象方法public abstract void say();
}

如何使用? (继承)

class Chinese extends Human {Chinese(String name, String language) {this.name = name;this.language = language;}@Overridepublic void say() {System.out.println(name + " says " + language);}
}

3.3.2 接口 (Interface)

是一个抽象类型，是抽象方法的集合。一个类通过继承接口的方式，从而来继承接口的抽象方法。
接口并不是类，类描述对象的属性和方法。接口则包含类要实现的方法。
除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法。

如何定义? (使用interface关键字)

/**1. 可以跑的接口 :)*/
public interface Runnable {// 跑的方法void run();
}

如何使用? (使用implements关键字实现接口)

class Chinese extends Human implements Runnable{Chinese(String name, String language) {this.name = name;this.language = language;}@Overridepublic void say() {System.out.println(name + " says " + language);}/*** 实现接口须重写run方法*/@Overridepublic void run() {System.out.println("I am Running...");        }
}

3.3.3 内部类 ( Inner Class )

Java 一个类中可以嵌套另外一个类, 即内部类
如何定义?

class OuterClass {String infomation = "Outer class";class InnerClass {String information = "Inner class";class InsiderClass {String information = "Insider class";}}
}

如何使用? ( 外部类.new 内部类名() )

package lang.aboutclass;import lang.aboutclass.OuterClass.InnerClass;
import lang.aboutclass.OuterClass.InnerClass.InsiderClass;class Main {public static void main(String[] args) {OuterClass outer = new OuterClass();InnerClass inner = outer.new InnerClass();InsiderClass insider = inner.new InsiderClass();System.out.println(outer.infomation);// Outer classSystem.out.println(inner.information);// Inner classSystem.out.println(insider.information);// Insider class}
}

3.3.4 枚举类 ( Enum )

Java 枚举是一个特殊的类，一般表示一组常量
如何定义? (使用 enum 关键字来定义，各个常量使用逗号 , 来分割)

public enum Weekday {SUN, MON, TUE, WED, THU, FRI, SAT;
}

如何使用? (枚举类名.常量)

System.out.println(Weekday.FRI);//FRI

3.3.6 记录类

// 定义一个Point类，有x、y两个变量，同时它是一个不变类
public record Point(int x, int y) {}

相当于:

public final class Point extends Record {private final int x;private final int y;public Point(int x, int y) { this.x = x; this.y = y; }public int x() { return this.x; }public int y() { return this.y; }public String toString() { return String.format("Point[x=%s, y=%s]", x, y); }public boolean equals(Object o) { //... } public int hashCode() { //... } }

也可以在里面写构造函数

public record Point(int x, int y) {// Compact Constructor，它的目的是让我们编写检查逻辑 public Point {if (x < 0 || y < 0) {throw new IllegalArgumentException();}}
}

3.3.6 注解类（Annotation）

Java 语言中的类、方法、变量、参数和包等都可以被标注。
和 Javadoc 不同，Java 标注可以通过反射获取标注内容。在编译器生成类文件时，标注可以被嵌入到字节码中。Java 虚拟机可以保留标注内容，在运行时可以获取到标注内容 。 当然它也支持自定义 Java 标注。

如何定义? ( 使用@interface关键字 )

package lang.annotation;import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;// 3.用元注解配置注解
// 必须设置@Target和@Retention，@Retention一般设置为RUNTIME，因为我们自定义的注解通常要求在运行期读取
@Target(ElementType.LOCAL_VARIABLE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Report {// 1.用@interface定义注解// 2.添加默认参数int type() default 0;String level() default "info";String value() default "";// 把最常用的参数定义为value()，推荐所有参数都尽量设置默认值
}
// 注解定义后也是一种class，所有的注解都继承自java.lang.annotation.Annotation，因此，读取注解，需要使用反射API

元注解（meta annotation） 有一些注解可以修饰其他注解，这些注解就称为元注解

最常用的元注解是@Target。
使用@Target可以定义Annotation能够被应用于源码的哪些位置：
类或接口：ElementType.TYPE；
字段：ElementType.FIELD；
方法：ElementType.METHOD；
构造方法：ElementType.CONSTRUCTOR；
方法参数：ElementType.PARAMETER

另一个重要的元注解@Retention定义了Annotation的生命周期：
仅编译期：RetentionPolicy.SOURCE；
仅class文件：RetentionPolicy.CLASS； (默认)
运行期：RetentionPolicy.RUNTIME

如何使用? ( 通过反射获取注解信息 )

@MyAnnotation(value = 20, name = "Quanwei")
public class MyAnnoTest {public static void main(String[] args) {MyAnnotation anno = MyAnnoTest.class.getDeclaredAnnotation(MyAnnotation.class);System.out.println(anno.name());// QuanweiSystem.out.println(anno.value());// 20}
}

在注解的定义中使用注解:

@Target({ ElementType.TYPE, ElementType.FIELD, ElementType.METHOD })//注解使用位置
@Retention(RetentionPolicy.RUNTIME)// 保留时间
public @interface MyAnnotation {int value() default 12;String name() default "quanwei";Report report()default @Report ;
}

3.4 反射 Reflection

是什么?

反射就是一种能在程序 运行 时获取类、接口、方法和变量等信息的能力。

有什么用?

解决在运行期，对某个实例一无所知的情况下，调用其方法

如何使用? (类名.class)

public class Main {public static void main(String[] args) throws Exception {Class<Student> stdClass = Student.class;// 获取public方法getScore，参数为String:System.out.println(stdClass.getMethod("getScore", String.class));// 获取继承的public方法getName，无参数:System.out.println(stdClass.getMethod("getName"));// 获取private方法getGrade，参数为int:System.out.println(stdClass.getDeclaredMethod("getGrade", int.class));}
}class Student extends Person {public int getScore(String type) {return 99;}@SuppressWarnings("unused")private int getGrade(int year) {return 1;}
}class Person {public String getName() {return "Person";}
}

还有多种情况,参考

3.5 lambda表达式

lambda表达式也即匿名函数, 允许把函数作为一个方法的参数（函数作为参数传递进方法中）
在java中lambda表达式本质上是一个对象

基本的语法像这样:

(parameters) ->{ statements; }

基本使用

new Thread(() -> {try {Thread.sleep(1000);} catch (Exception e) {e.printStackTrace();}}).start();

3.6 异常

异常主要指程序运行的时候，会发生各种错误, 不包括编译时发生的

异常可以捕获:

     try{int i=10/0;}catch(Exception e){e.printStackTrace();}finally{// todo}

也可以抛出

 // 自动抛出public static void test() throws IOException {testException(10,0);}// 手动抛出public static void testException(int a, int b) throws RuntimeException {if (b > 0) {System.out.println(a / b);} else {throw new RuntimeException("除数不能为零");}}

还可以自定义异常 (继承Exception类)

public class MyException extends Exception {public MyException(String msg) {super(msg+" from MyException");}
}

四、常用类

4.1 数组 & Arrays

数组的定义和使用

        // 1.创建array对象int[] array=new int[10];// 赋值for (int i = 0; i < array.length; i++) {array[i]=i+1;}// 使用for (int i : array) {System.out.print(i+" ");}// 其他int[] a2={1,2,2,3,4};String[] strings={"asd","sdas"};

Arrays 类是一个工具类，其中包含了数组操作的很多方法。 Arrays 类里均为 static 修饰的方法可以直接通过类名调用。
例如使用Arrays对数组排序

        // 1.创建array对象, 并赋值String[] strings = { "hello", "thank", "you", "are", "ok" };// 顺序Arrays.sort(strings);System.out.println(Arrays.toString(strings)); // [are, hello, ok, thank, you]// 逆序Arrays.sort(strings, Comparator.reverseOrder());System.out.println(Arrays.toString(strings)); // [you, thank, ok, hello, are]

4.2 String, StringBuffer和StringBuilder

4.2.1 String

String 是 final 修饰的，无法被继承。且 String 不是 Java 的基本数据类型
通过new创建的String对象,和直接赋值的String对象稍有不同:

/*** TestString* * 可以和八种基本数据类型做运算*/
public class TestString {public static void main(String[] args) {}public void testStringJoint() {// 字面量定义,s1指向方法区中的静态常量池String s1 = "Quanwei";String s2 = "Quanwei";// s2->堆空间地址值String s3 = new String("Quanwei");System.out.println("s1 == s2: " + (s1 == s2)); // trueSystem.out.println("s1 == s3: " + (s1 == s3)); // falseSystem.out.println("s1.equals(s2): " + (s1.equals(s2)));// trueSystem.out.println("s1.equals(s3): " + (s1.equals(s3)));// trueString s4 = "TangQuanwei";String s5 = "Tang" + "Quanwei"; // 常量与常量拼接在静态常量池System.out.println("s4 == s5: " + (s4 == s5)); // trueString s6 = "Tang" + s1; // 常量与引用拼接->堆空间地址值System.out.println("s4 == s6: " + (s4 == s6)); // false}public void testToCharArray() {String s1 = "Quanwei";char[] charArray = s1.toCharArray();System.out.println(Arrays.toString(charArray));String s2 = "权威";char[] charArray2 = s2.toCharArray();System.out.println(Arrays.toString(charArray2));}public void testGetBytes() {String s1 = "Quanwei";byte[] bytes = s1.getBytes();System.out.println(Arrays.toString(bytes));String s2 = "权威";byte[] bytes2 = s2.getBytes();// 默认utf-8System.out.println(Arrays.toString(bytes2));try {byte[] bytes3 = s2.getBytes("gbk");System.out.println(Arrays.toString(bytes3));byte[] bytes4 = s2.getBytes("utf-8");System.out.println(Arrays.toString(bytes4));} catch (UnsupportedEncodingException e) {e.printStackTrace();}}
}

String 是不可变的，而 StringBuffer 和 StringBuilder 是可变类

4.2.2 StringBuffer和StringBuilder

二者区别就是:

StringBuffer	StringBuilder
线程安全	非线程安全
同步	非同步
慢	快

所以在非多线程环境中的字符串操作，我们一般用 StringBuilder , 因为二者的方法都是差不多的
它们为字符串操作提供了 append、insert、delete 和 substring 方法

    public void testStringBuilder() {var sb1 = new StringBuilder("Tang");var sb2 = new StringBuilder("t");System.out.println(sb1.capacity());// 20System.out.println(sb1.length());// 4sb1.ensureCapacity(40);System.out.println(sb1.capacity());// 42System.out.println(sb2.capacity());// 17sb1.append("Quawnei");System.out.println(sb1);//TangQuawneisb1.insert(4, "->");System.out.println(sb1);//Tang->Quawneisb1.delete(0, 4);System.out.println(sb1);//->Quawnei}

4.3 System类和Runtime类

4.3.1 静态字段

System 类有 3 个静态成员变量，分别是 PrintStream out、InputStream in 和 PrintStream err
out跟err的区别大概是:
System.out.println可能会被缓冲,而System.err.println不会，由于err不需要缓冲即可输出

PrintStream out

System.out.println("quanwei);

InputStream in

    try {int read = System.in.read();// 读一个字符的ascii码} catch (IOException e) {e.printStackTrace();}

4.3.2 静态方法

public static void main(String[] args) {// 获取系统属性String jversion = System.getProperty("java.version");String oName = System.getProperty("os.name");String user = System.getProperty("user.name");System.out.println("Java 运行时环境版本：" + jversion);// Java 运行时环境版本：17.0.1System.out.println("当前操作系统是：" + oName);// 当前操作系统是：Windows 10System.out.println("当前用户是：" + user);// 当前用户是：QUANWEI// 时间的格式为当前计算机时间与 GMT 时间（格林尼治时间）// 1970 年 1 月 1 日 0 时 0 分 0 秒所差的毫秒数Date date = new Date(System.currentTimeMillis());//System.out.println(date); // Mon Jan 10 20:20:43 CST 2022int[] a = { 1, 2, 3, 4, 5 };int[] b = { 2, 3, 4, 5, 6 };// 合并数组int[] marge = marge(a, b);System.out.println(Arrays.toString(marge));// [1, 2, 3, 4, 5, 2, 3, 4, 5, 6]// 请求系统进行垃圾回收System.gc();// 终止当前正在运行的 Java 虚拟机System.exit(0);}public static int[] marge(int[] a, int[] b) {int[] ret = new int[a.length + b.length];System.arraycopy(a, 0, ret, 0, a.length);System.arraycopy(b, 0, ret, a.length, b.length);return ret;}

4.4 包装类

基本类	包装类
byte	Byte
short	Short
int	Integer
long	Long
char	Character
float	Float
double	Double
boolean	Boolean

常用方法 :
包装类名.parseXxx(String );
包装类名.valueOf(String );
包装类名.toString();

4.5 Math和Random

Math类就是用来进行数学计算的，它提供了大量的静态方法来便于我们实现数学计算
比如:

// 数学常量：
double pi = Math.PI; // 3.14159...
double e = Math.E; // 2.7182818...// 求绝对值：
Math.abs(-100); // 100
Math.abs(-7.8); // 7.8// 取最大或最小值：Math.max(100, 99); // 100
Math.min(1.2, 2.3); // 1.2// 计算xy次方：
Math.pow(2, 10); // 2的10次方=1024// 计算√x：
Math.sqrt(2); // 1.414...// 计算ex次方：
Math.exp(2); // 7.389...// 计算以e为底的对数：
Math.log(4); // 1.386...// 计算以10为底的对数：
Math.log10(100); // 2// 三角函数：
Math.sin(3.14); // 0.00159...
Math.cos(3.14); // -0.9999...
Math.tan(3.14); // -0.0015...
Math.asin(1.0); // 1.57079...
Math.acos(1.0); // 0.0

4.6 BigInteger类和BigDecimal类

在Java中，由CPU原生提供的整型最大范围是64位long型整数。使用long型整数可以直接通过CPU指令进行计算, 如果我们使用的整数范围超过了long型就只能用软件来模拟一个大整数。java.math.BigInteger就是用来表示任意大小的整数。BigInteger内部用一个int[]数组来模拟一个非常大的整数

由于Java不支持运算符重载, 在对BigInteger做运算的时候，只能使用对象的方法，例如，

BigInteger i1 = new BigInteger("1234567890");
BigInteger i2 = new BigInteger("12345678901234567890");
BigInteger sum = i1.add(i2); // 12345678902469135780

BigDecimal和BigInteger类似，可以用来表示一个任意大小且精度完全准确的浮点数

BigDecimal d1 = new BigDecimal("9876543210.0123456789");
BigDecimal d2 = new BigDecimal("123.45000000000000000");
System.out.println(d1.scale()); // 10,两位小数
System.out.println(d1.add(d2));
System.out.println(d1.subtract(d2));
System.out.println(d1.multiply(d2));
// 无法除尽时，就必须指定精度以及如何进行截断
System.out.println(d1.divide(d2, 10, RoundingMode.HALF_UP));// 四舍五入

4.7 时间和日期类

JDK8以前

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
/*** JDK 8 以前 时间日期API* * 1.System.currentTimeMillis()* * 2.java.util.Calendar;  java.util.Date;* * 3.SimpleDateFormat* * 4.Calender*/
public class TestBefer8 {public void testTime() {// 获取当前时间的毫秒数时间戳System.out.println("TestDateTime.testTime()");long currentTimeMillis = System.currentTimeMillis();System.out.println(currentTimeMillis);}public void testDate() {// java.util.DateDate d1 = new Date();System.out.println(d1);System.out.println(d1.getTime());// 毫秒数时间戳var d2 = new Date(1631504736660L);System.out.println(d2);// java.sql.Date 是 java.util.Date 的子类var d3 = new java.sql.Date(0L);System.out.println(d3);// java.sql.Date -> java.util.DateDate d4 = (Date) d3;System.out.println(d4);// java.util.Date -> java.sql.Datejava.sql.Date d5 = new java.sql.Date(d4.getTime());System.out.println(d5);}/*** SimpleDateFormat对Date类的格式化和解析* * 1.格式化: 日期 --> 字符串* * 2.解析:格式化的逆过程: 字符串 --> 日期*/public void testFormat() {System.out.println("TestDateTime.testFormat()");// 格式化SimpleDateFormat sdf = new SimpleDateFormat();Date date = new Date();String format = sdf.format(date);System.out.println(format);// 指定格式final String parttern = "yyyy-MM-dd hh:mm:ss:SSS z";SimpleDateFormat sdf2 = new SimpleDateFormat(parttern);System.out.println(sdf2.format(date));try {// 解析String str = "2021/9/13 下午2:58";String s2 = "2002-10-09 08:31:12:234 CST";Date d1 = sdf.parse(str);System.out.println(d1);} catch (ParseException e) {e.printStackTrace();}}/*** Calender 抽象基类* * 主要用于完成日期字段之间相互操作的功能* */public void testCalender() {// 1.调用静态方法获取实例Calendar cal = Calendar.getInstance();Calendar instance2 = Calendar.getInstance();System.out.println(cal.getClass());// class java.util.GregorianCalendarSystem.out.println(cal.equals(instance2));//false//getSystem.out.println(cal.get(Calendar.DAY_OF_MONTH));System.out.println(cal.get(Calendar.DAY_OF_YEAR));}
}

JDK8以后

import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.OffsetDateTime;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.time.temporal.TemporalAccessor;
/*** JDK 8 中的时间日期API* * 1.LocalDate* * 2.LocalTime* * 3.LocalDateTime* * 4.Instant 机器时间* * 5.DateTimeFormater*/
public class TestIn8 {public void testDate() {LocalDate now = LocalDate.now();System.out.println(now);}public void testTime() {LocalTime now = LocalTime.now();System.out.println(now);}public void testLocalDateTime() {// now 获取当前的日期和时间LocalDateTime now = LocalDateTime.now();System.out.println(now);// of 获取指定的日期时间 没有偏移量LocalDateTime of = LocalDateTime.of(2002, 10, 9, 16, 34, 35);System.out.println(of);// getXxxSystem.out.println(now.getDayOfMonth());System.out.println(now.getDayOfYear());System.out.println(now.getChronology());}public void testInstant() {// now() 获取本初子午线对应的标准时间Instant now = Instant.now();System.out.println(now);// 慢八个小时// 添加时间偏移量OffsetDateTime offSet = now.atOffset(ZoneOffset.ofHours(8));System.out.println(offSet);// 1970(UTC)->现在 经过的毫秒数long epochMilli = now.toEpochMilli();System.out.println(epochMilli);// 1631521135573// 毫秒数->instantInstant ofEpochMilli = Instant.ofEpochMilli(1631521135573L);System.out.println(ofEpochMilli);}public void testDateTimeFormater() {LocalDateTime now = LocalDateTime.now();// 格式化1DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;String format = formatter.format(now);System.out.println(format); // 2021-09-13T16:56:14.4738222// 解析TemporalAccessor parse = formatter.parse("2021-09-13T16:56:14.4738222");System.out.println(parse);// 格式化2: 本地格式化DateTimeFormatter formatter2 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM);String format2 = formatter2.format(now);System.out.println(format2);// 格式化3: 自定义格式化final String pattern="GG yyyy年MM月dd日 EE a hh时mm分ss秒";DateTimeFormatter formatter3 = DateTimeFormatter.ofPattern(pattern);String format3 = formatter3.format(LocalDateTime.now());System.out.println(format3);}
}

五、集合

Java Collection Framework (JCF) Java集合框架是一组提供现成架构的类和接口。为了实现一个新特性或一个类，不需要定义一个框架。然而，一个最佳的面向对象设计总是包含一个具有类集合的框架，这样所有的类都执行相同类型的任务。

5.1 Collection和Collections

Collections

    public static void main(String[] args) {List<String> ls = new ArrayList<>();ls.add("reverse");ls.add("shuffle");ls.add("sort");ls.add("swap");ls.add("rotate");System.out.println(ls);// [reverse, shuffle, sort, swap, rotate]// 反转Collections.reverse(ls);System.out.println(ls);// [rotate, swap, sort, shuffle, reverse]// 按升序进行排序Collections.sort(ls);System.out.println(ls);// [reverse, rotate, shuffle, sort, swap]// 根据指定 Comparator排序Collections.sort(ls, new Comparator<String>() {@Overridepublic int compare(String o1, String o2) {return -o1.compareTo(o2);}});System.out.println(ls);// [swap, sort, shuffle, rotate, reverse]// 按下标交换Collections.swap(ls, 0, ls.size() - 1);System.out.println(ls);// [reverse, sort, shuffle, rotate, swap]// 将 list 集合的后 distance 个元素整体移到前面Collections.rotate(ls, 2);System.out.println(ls);// [rotate, swap, reverse, sort, shuffle]// 将 list 集合的前 distance 个元素整体移到后面Collections.rotate(ls, -3);System.out.println(ls);// [sort, shuffle, rotate, swap, reverse]// 返回指定集合中指定元素的出现次数ls.add("sort");int frequency = Collections.frequency(ls, "sort");System.out.println(frequency);// 2// 将指定集合中的所有元素复制到另一个集合中,目标集合的长度至少和源集合的长度相同List<String> l2 = new LinkedList<>();// ArrayList -> LinkedListl2.add("reverse1");l2.add("shuffle1");l2.add("sort1");l2.add("swap1");l2.add("rotate1");Collections.copy(ls, l2);System.out.println(ls);// [reverse1, shuffle1, sort1, swap1, rotate1, sort]// LinkedList -> ArrayList// ! IndexOutOfBoundsException Source does not fit in destCollections.copy(l2, ls);System.out.println(ls);}

5.2 常用类, 接口

    /*** 列表*/public void testList() {// <> 中的类型只能是引用类型List<Integer> al = new ArrayList<>();List<Integer> ll = new LinkedList<>();}/*** 队列*/public void testQueue() {Queue<Integer> ad = new ArrayDeque<>();Queue<Integer> ll = new LinkedList<>();Queue<Integer> pq = new PriorityQueue<>();}/*** 集合*/public void testSet() {Set<Object> hs = new HashSet<>();Set<Object> ts = new TreeSet<>();}/*** 映射*/public void testMap() {Map<Integer, String> hm = new HashMap<>();Map<Integer, String> tm = new TreeMap<>();}

5.5 Stream API

在 Java 8 中引入的 Stream API 用于处理对象的集合。流是支持各种方法的对象序列，这些方法可以流水线化以产生所需的结果。
Java 流的特点是:

流不是数据结构，而是从集合、数组或 I/O 通道获取输入。
流不会更改原始数据结构，它们仅根据流水线方法提供结果。
每个中间操作都被延迟执行并返回一个流作为结果，因此可以对各种中间操作进行流水线化。终端操作标记流的结束并返回结果。

    public void testStream() {// 创建List<Integer> number = Arrays.asList(2, 3, 4, 5);// 使用map将number的元素平方List<Integer> square = number.stream().map(x -> x * x).collect(Collectors.toList());System.out.println(square);// [4, 9, 16, 25]// 创建List<String> names = Arrays.asList("Reflection", "Collection", "Stream");// 过滤List<String> result = names.stream().filter(s -> s.startsWith("S")).collect(Collectors.toList());System.out.println(result);// [Stream]// 排序List<String> show = names.stream().sorted().collect(Collectors.toList());System.out.println(show);// [Collection, Reflection, Stream]// 创建List<Integer> numbers = Arrays.asList(2, 3, 4, 5, 2);// 收集Set<Integer> squareSet = numbers.stream().map(x -> x * x).collect(Collectors.toSet());System.out.println(squareSet);// [16, 4, 9, 25]// forEachnumber.stream().map(x -> x * x).forEach(y -> System.out.print(y + " "));// 4 9 16 25// reduceint even = number.stream().filter(x -> x % 2 == 0).reduce(0, (ans, i) -> ans + i);// 0+2+4System.out.println(even);// 6}

5.6 泛型

泛型意味着参数化类型。这个想法是允许类型（整数、字符串等，以及用户定义的类型）作为方法、类和接口的参数。使用泛型，可以创建使用不同数据类型的类。 对参数化类型进行操作的实体（例如类、接口或方法）称为泛型实体。

与 C++ 一样，我们使用 <> 来指定泛型类创建中的参数类型。要创建泛型类的对象

class Pair<T, U> {private T first;private U second;public Pair(T first, U second) {this.setFirst(first);this.setSecond(second);}/*** @return the second*/public U getSecond() {return second;}/*** @param second the second to set*/public void setSecond(U second) {this.second = second;}/*** @return the first*/public T getFirst() {return first;}/*** @param first the first to set*/public void setFirst(T first) {this.first = first;}@Overridepublic String toString() {return "( " + first + ", " + second + ")";}
}

六、I/O流

IO是指Input/Output，即以内存为中心的输入和输出。

6.1 BIO

BIO即 Blocking Input/Output, 即阻塞的I/O

6.1.1 Flie

用于文件和目录的创建、文件的查找和文件的删除等

package lang.io;import java.io.File;
import java.io.IOException;import org.junit.jupiter.api.Test;/*** File表示一个文件或一个文件夹 在java.io包下*/
public class TestFile {// 构造一个File对象，并不会导致任何磁盘操作// 文件夹File floder = new File("D:\\workspaceFolder\\CODE_JAVA");// 文件File file = new File("D:\\workspaceFolder\\CODE_JAVA\\a.txt");@Testpublic void testGet() {// 返回绝对路径，System.out.println(file);// 返回构造方法传入的路径，System.out.println(file.getPath());// 返回绝对路径，System.out.println(file.getAbsolutePath());try { // 返回绝对路径，System.out.println(file.getCanonicalPath());} catch (IOException e) {e.printStackTrace();}// 输出文件夹下文件for (var i : floder.listFiles()) {System.out.println(i);}}@Testpublic void testCreate() {File f = new File("test.file");if (!f.exists()) {try {// 创建f.createNewFile();} catch (IOException e) {e.printStackTrace();}}}@Testpublic void testDelete() {File f = new File("test.file");if (f.exists()) {// 删除boolean delete = f.delete();System.out.println(delete?"delete":"not exist");}}}

6.1.2 ByteStream

即字节流, InputStream和OutputStream都是抽象类在里面分别定义了read()和write()方法
我们使用它们的子类, FileInputStream和FileOutputStream

package lang.io;import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;import org.junit.Test;public class TestByteStream {public void copyPng() {File file = new File("D:\\workspaceFolder\\CODE_JAVA\\猫咪.png");File fileB = new File("D:\\workspaceFolder\\CODE_JAVA\\猫咪2.png");FileInputStream fileInputStream = null;FileOutputStream fileOutputStream = null;try {fileInputStream = new FileInputStream(file);fileOutputStream = new FileOutputStream(fileB);int len;byte[] bbuf = new byte[10];while ((len = fileInputStream.read(bbuf)) != -1) {fileOutputStream.write(bbuf, 0, len);}} catch (IOException e) {e.printStackTrace();} finally {try {if (fileInputStream != null)fileInputStream.close();if (fileOutputStream != null)fileOutputStream.close();} catch (IOException e) {e.printStackTrace();}}}@Testpublic void read() {File file = new File("D:\\workspaceFolder\\CODE_JAVA\\lang\\io\\TestByteStream.java");FileInputStream fis = null;try {fis = new FileInputStream(file);int data;while ((data = fis.read()) != -1) {System.out.print((char) data);}} catch (IOException e) {e.printStackTrace();} finally {if (fis != null) {try {fis.close();} catch (IOException e) {e.printStackTrace();}}}}public static void main(String[] args) {new TestByteStream().copyPng();}
}

6.1.3 CharStream

CharStream即字符流

Reader是Java的IO库提供的另一个输入流接口。和InputStream的区别是，InputStream是一个字节流，即以byte为单位读取，而Reader是一个字符流，即以char为单位读取

我们使用Reader的子类FileReader来演示向文件写入数据和从文件读出数据

package lang.io;import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;import org.junit.Test;/*** 内存的角度* * 输入:外部数据->内存* * 输出:内存->外部数据* * 字节流(8bit): InputStream, OutPutStream* * 字符流(16bit): Reader, Writer*/
public class TestCharStream {// 1.File对象指明文件private final File file = new File("data.txt");/*** Read from file and print to console*/public void Read() {// 2.Reader对象FileReader fileReader = null;try {// 3.读fileReader = new FileReader(file);// 读入的文件一定要存在int read;while ((read = fileReader.read()) != -1)System.out.print((char) read);} catch (IOException e) {e.printStackTrace();} finally {// 4.关闭资源if (fileReader != null)try {fileReader.close();} catch (IOException e) {e.printStackTrace();}}}/*** Write String to file* * @param toBeWrite*/public void Write(String toBeWrite) {FileWriter fileWriter = null;try {fileWriter = new FileWriter(file);fileWriter.write("By_Quanwei\n");fileWriter.append(toBeWrite);} catch (IOException e) {e.printStackTrace();} finally {if (fileWriter != null)try {fileWriter.close();} catch (IOException e) {e.printStackTrace();}}}/*** Copy fileA to fileB*/public void copyFile(String fileA, String fileB) {FileReader fileReader = null;FileWriter fileWriter = null;try {fileReader = new FileReader(fileA);fileWriter = new FileWriter(fileB);int len;char[] cbuf = new char[10];while ((len = fileReader.read(cbuf)) != -1) {fileWriter.write(cbuf, 0, len);}} catch (IOException e) {e.printStackTrace();} finally {try {if (fileReader != null)fileReader.close();if (fileWriter != null)fileWriter.close();} catch (Exception e) {e.printStackTrace();}}}public static void main(String[] args) {new TestCharStream().copyFile("data.txt", "file.txt");}@Testpublic void testFileReadWite() {TestCharStream testIO = new TestCharStream();testIO.Write("""public void Read() {try {FileReader fileReader = new FileReader(file);int read;while ((read = fileReader.read()) != -1)System.out.print((char)read);fileReader.close();} catch (IOException e) {e.printStackTrace();}}public void Write(String toBeWrite) {try {FileWriter fileWriter = new FileWriter(file);fileWriter.append(toBeWrite);fileWriter.close();} catch (IOException e) {e.printStackTrace();}}""");testIO.Read();}
}

Socket与网络编程

1.网络编程的两个主要问题 1)如何定位网络上的一台或多态主机,定位主机上的特定应用(IPhe端口) 2)找到主机后如何高效可靠的传输数据(TCP/IP)

本地回环地址: (hostAddress):127.0.0.1

主机名: (hostName):localhost

局域网地址: 192.168.~

端口号: 运行的程序(0-65535)

Sockst = ip + 端口号

TCP 可靠, 大量(三次握手, 四次挥手)

UDP 快速

Url类

package lang.net;import java.net.URL;/*** url https://www.bilibili.com/video/BV1Kb411W75N?p=629* * <协议>//:<主机名>:<端口号>/<文件名/>#<片段名?><参数列表>*/public class MyUrl {public static void main(String[] args) {try {URL url = new URL("https://www.bilibili.com/video/BV1Kb411W75N?p=629");System.out.println(url.getAuthority());// www.bilibili.comSystem.out.println(url.getDefaultPort());// 443System.out.println(url.getFile());// /video/BV1Kb411W75N?p=629System.out.println(url.getPath());// /video/BV1Kb411W75NSystem.out.println(url.getProtocol());// https} catch (Exception e) {e.printStackTrace();}}
}

InetAddress类

        try {InetAddress Aliyun = InetAddress.getByName("39.99.54.127");InetAddress localHost = InetAddress.getLocalHost();InetAddress loopbackAddress = InetAddress.getLoopbackAddress();boolean reachable = localHost.isReachable(10);System.out.println(reachable);//trueSystem.out.println(localHost);//DESKTOP-V9EL4A5/192.168.0.193System.out.println(Aliyun);///39.99.54.127String canonicalHostName = Aliyun.getCanonicalHostName();String hostName = Aliyun.getHostName();//39.99.54.127System.out.println(hostName);//39.99.54.127System.out.println(canonicalHostName);System.out.println(loopbackAddress);//localhost/127.0.0.1} catch (Exception e) {e.printStackTrace();}

UDP网络编程

 /*** 接收端*/@Testpublic void UDPReciver() {DatagramSocket server = null;try {server = new DatagramSocket(8900);byte[] buf = new byte[1024];// <=8KDatagramPacket datagramPacket = new DatagramPacket(buf, buf.length);System.out.println("waiting...");while (true) {server.receive(datagramPacket);String string = new String(datagramPacket.getData(), 0, datagramPacket.getLength());System.out.println(datagramPacket.getAddress() + ":" + datagramPacket.getPort() + "send: " + string);}} catch (SocketException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {if (server != null)server.close();}}/*** 发送端*/@Testpublic void UDPSender() {DatagramSocket client = null;try {client = new DatagramSocket();String str = "hello Quanwei";DatagramPacket datagramPacket = new DatagramPacket(str.getBytes(), str.getBytes().length,InetAddress.getLocalHost(), 8900);System.out.println("start send...");client.send(datagramPacket);} catch (SocketException | UnknownHostException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {if (client != null)client.close();}}

TCP网络编程

package lang.net;import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
import java.time.LocalDateTime;public class TCP {public void clientResive() {Socket socket = null;InputStream inputStream = null;ByteArrayOutputStream byteArrayOutputStream = null;try {// get from serverInetAddress ip = InetAddress.getByName("127.0.0.1");socket = new Socket(ip, 8899);inputStream = socket.getInputStream();byte[] buf = new byte[1024];int len;byteArrayOutputStream = new ByteArrayOutputStream();while ((len = inputStream.read(buf)) != -1) {byteArrayOutputStream.write(buf, 0, len);}System.out.println(LocalDateTime.now() + " get from server: " + byteArrayOutputStream);} catch (UnknownHostException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {if (byteArrayOutputStream != null)try {byteArrayOutputStream.close();} catch (IOException e) {e.printStackTrace();}if (inputStream != null)try {inputStream.close();} catch (IOException e1) {e1.printStackTrace();}if (socket != null)try {socket.close();} catch (IOException e) {e.printStackTrace();}}}public void clientSend() {Socket socket = null;InetAddress ip;OutputStream outputStream = null;try {ip = InetAddress.getByName("127.0.0.1");socket = new Socket(ip, 8899);// send to serveroutputStream = socket.getOutputStream();outputStream.write("权威 Quanwei".getBytes());} catch (Exception e) {e.printStackTrace();} finally {if (outputStream != null)try {outputStream.close();} catch (IOException e) {e.printStackTrace();}if (socket != null)try {socket.close();} catch (IOException e) {e.printStackTrace();}}}public void serverRevive() {ServerSocket server = null;Socket accept = null;InputStream inputStream = null;ByteArrayOutputStream byteArrayOutputStream = null;FileOutputStream fileOutputStream = null;try {server = new ServerSocket(8899);accept = server.accept();// client inputinputStream = accept.getInputStream();byteArrayOutputStream = new ByteArrayOutputStream();byte[] buf = new byte[1024];int len;while ((len = inputStream.read(buf)) != -1) {byteArrayOutputStream.write(buf, 0, len);}// 控制台输出System.out.println(LocalDateTime.now() + " get from client: " + byteArrayOutputStream);// 保存到本地fileOutputStream = new FileOutputStream(new File("D:\\workspaceFolder\\CODE_JAVA\\lang\\net\\file"));fileOutputStream.write(byteArrayOutputStream.toByteArray());} catch (IOException e) {e.printStackTrace();} finally {if (byteArrayOutputStream != null)try {byteArrayOutputStream.close();} catch (IOException e) {e.printStackTrace();}if (inputStream != null)try {inputStream.close();} catch (IOException e) {e.printStackTrace();}if (accept != null)try {accept.close();} catch (IOException e) {e.printStackTrace();}if (server != null)try {server.close();} catch (IOException e) {e.printStackTrace();}}}public void serverSend() {ServerSocket server = null;Socket accept = null;OutputStream outputStream = null;try {server = new ServerSocket(8899);accept = server.accept();// server outputoutputStream = accept.getOutputStream();outputStream.write("接收成功".getBytes());} catch (Exception e) {e.printStackTrace();} finally {if (outputStream != null)try {outputStream.close();} catch (IOException e1) {e1.printStackTrace();}if (accept != null)try {accept.close();} catch (IOException e) {e.printStackTrace();}if (server != null)try {server.close();} catch (IOException e) {e.printStackTrace();}}}public static void main(String[] args) {TCP tcp = new TCP();new Thread(() -> {tcp.serverSend(); // 先启动服务器}).start();// new Thread(() -> {//     tcp.clientResive();// }).start();new Thread(() -> {tcp.clientResive();}).start();// new Thread(() -> {//     tcp.clientSend();// }).start();}
}

6.2 NIO

6.3 AIO

七、多线程

多线程是Java最基本的一种并发模型

一个线程不能独立的存在，它必须是进程的一部分。
进程：一个进程包括由操作系统分配的内存空间，包含一个或多个线程。

创建多线程

package lang.thread;import org.junit.jupiter.api.Test;public class CreateThreadDemo {@Testpublic void testLambda() {new Thread(() -> {String name = Thread.currentThread().getName();System.out.println(name);// Quanwei's thread}, "Quanwei's thread").start();}@Testpublic void testExtends() {new Thread() {public void run() {String name = Thread.currentThread().getName();System.out.println("Extends" + name);// ExtendsThread-0 也可能不是0}}.start();;}@Testpublic void testImplements() {Runnable runnable = new Runnable() {@Overridepublic void run() {String name = Thread.currentThread().getName();System.out.println(name);// Implements}};new Thread(runnable,"Implements").start();}public static void main(String[] args) {new CreateThreadDemo().testLambda();// mainSystem.out.println(Thread.currentThread().getName());}}

多线程通信
同步代码块

synchronized(同步监视器){//同步监视器可用: 类.class(保证唯一)
//要同步的代码
}

不需要synchronized的操作 JVM规范定义了几种原子操作：

1. 基本类型（long和double除外）赋值，例如：int n = m； 引用类型赋值，例如：List list = anotherList。
2. long和double是64位数据，JVM没有明确规定64位赋值操作是不是一个原子操作，不过在x64平台的JVM是把long和double的赋值作为原子操作实现的
3. 单条原子操作不需要线程同步,多条需要

public class Ticket {public static void main(String[] args) {var w = new Windows1();var w1 = new Thread(w, "w1");var w2 = new Thread(w, "w2");var w3 = new Thread(w, "w3");w2.setPriority(Thread.MAX_PRIORITY);w1.start();w2.start();w3.start();}
}class Windows1 implements Runnable {private int tickets = 50;Object obj = new Object();@Overridepublic void run() {while (true) {synchronized (Windows1.class) {if (tickets > 0) {try {Thread.sleep(100);} catch (Exception e) {}System.out.println(Thread.currentThread().getName() + " : " + tickets);--tickets;} elsebreak;}}}}

八、JDBC

什么是JDBC?

DBC是Java DataBase Connectivity的缩写，它是Java程序访问数据库的标准接口。

使用Java程序访问数据库时，Java代码并不是直接通过TCP连接去访问数据库，而是通过JDBC接口来访问，而JDBC接口则通过JDBC驱动来实现真正对数据库的访问。

我们在Java代码中如果要访问MySQL，那么必须编写代码操作JDBC接口。注意到JDBC接口是Java标准库自带的，所以可以直接编译。而具体的JDBC驱动是由数据库厂商提供的，。因此，访问某个具体的数据库，我们只需要引入该厂商提供的JDBC驱动，就可以通过JDBC接口来访问，这样保证了Java程序编写的是一套数据库访问代码，却可以访问各种不同的数据库，因为他们都提供了标准的JDBC驱动

如何使用? (以连接PostgreSQL为例)

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
import org.postgresql.Driver;public class Postgresql {private static String url = "jdbc:postgresql://localhost:5432/quanwei";private static String user = "postgres";private static String password = "password";private static String driver = "org.postgresql.Driver";public static void main(String[] args) throws SQLException {// 1. 创建驱动程序类对象Driver driver = new org.postgresql.Driver();// 2. 设置用户名和密码Properties prop = new Properties();prop.setProperty("user", user);prop.setProperty("password", password);// 3. 连接数据库，返回连接对象Connection conn = null;try {conn = driver.connect(url, prop);} catch (SQLException e) {e.printStackTrace();}Statement s = conn.createStatement();// 测试ResultSet rs = s.executeQuery("select * from login");while(rs.next()){String string = rs.getString(2);System.out.println(string);}}
}

九、GUI

9.1 AWT

即抽象窗口工具包

package lang.gui;import java.awt.*;
import java.awt.event.*;public class HelloAWT {public static void main(String[] args) {// 1.创建窗体Frame frame = new Frame("AWT");// 2.创建标签组件Label label = new Label("Hello Quanwei");// 3.设置相关属性label.setBackground(Color.GREEN);label.setSize(20, 10);// 4.将组件添加到窗体上frame.add(label);// 5.设置窗体关闭事件frame.addWindowListener(new WindowAdapter() {@Overridepublic void windowClosing(WindowEvent e) {System.exit(0);}});// 6.设置窗体大小frame.setSize(500, 200);// 7.显示窗体frame.setVisible(true);}
}

9.2 Swing

package lang.gui;import java.awt.*;
import java.awt.event.*;
import java.util.HashMap;import javax.swing.*;
import javax.swing.event.*;public class Main {public void window1() {// 1.创建窗体JFrame frame = new JFrame("Swing");// 2.设置关闭事件frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 3.设置大小位置frame.setSize(500, 500);frame.setLocation(500, 200);// 4.设置事件监听处理frame.addMouseListener(new MouseInputAdapter() {@Overridepublic void mouseClicked(MouseEvent e) {int x = e.getX();int y = e.getY();frame.setTitle("点击坐标为(" + x + ", " + y + ")");}});// 5.显示窗体frame.setVisible(true);}
}

总结

比我想象的要多得多

Java笔记--实时更新相关推荐

1. 数据结构与算法-java笔记一 更新中

   数据结构与算法-java笔记一 更新中 数据结构与算法 什么是数据结构.算法 数据结构学了有什么用: 线性结构 数组 特点 应用 链表 存储结构 链表类型 单链表 双向链表 双向循环链表 链表与数组的 ...

2. java数据实时更新_Java连载137更新数据和删除数据

   一.数据更新语句的命令格式如下: UPDATE SET column_name = 'xxx' WHERE 在更新数据的时候既可以使用Statement实例通过UPDATE语句完成,也可以利用Prep ...

3. Django入门+实战教程+个人笔记+实时更新+基础知识 -＞（个人学习记录笔记）

   文章目录 1.初识 2.登录,登录首页实现步骤 3.GET方式_登录功能 1.post请求的请求报文 2.post响应报文 3.GET和POST请求区别 4.GET请求方式 5.POST请求方式 6. ...

4. Java笔记-Java日常笔记-Java核心语言-史上最全Java笔记-Java烂笔头-实时更新（~v~）

   阿一的日常Java笔记,实时更新,有什么问题可以留言交流一下,大家一起共同进步!!! 1.Java基础 1.1.基本语法 1.1.1.关键字 ​ 定义:被java赋予特殊含义的字符串(单词): ​ 关 ...

5. 初学Oracle的笔记(2)——基础内容(实时更新中..)

   续 初学Oracle的笔记(1)--基础内容(实时更新中..) 1.oracle中创建一张表,写法与sql server中的一样. SQL> create table Course 2 ( cn ...

6. MongoDB学习笔记（四）使用Java进行实时监控与数据收集（空间使用量、连接数）

   目录: MongoDB学习笔记(一)环境搭建与常用操作 MongoDB学习笔记(二)使用Java操作MongoDB MongoDB学习笔记(三)使用Spring Data操作MongoDB Mongo ...

7. 数据库数据显示在java表中_实现 从数据库读取数据显示在前台echarts图表里，图表可根据数据库数据实时更新。效果如图...

   实现 从数据库读取数据显示在前台echarts图表里,图表可根据数据库数据实时更新.效果如图 实现步骤 - 1.创建数据表 - 2.建立Java Web Project - 3.创建Bean对象 - ...

8. 【Java笔记+踩坑】SpringBoot基础3——开发。热部署+配置高级+整合NoSQL/缓存/任务/邮件/监控

     导航: [黑马Java笔记+踩坑汇总]JavaSE+JavaWeb+SSM+SpringBoot+瑞吉外卖+SpringCloud/SpringCloudAlibaba+黑马旅游+谷粒商城 目录 ...

9. 博客文章内容导航（实时更新）

   博客文章内容导航(实时更新)   大家好,我是亓官劼(qí guān jié),在博客中分享数据结构与算法.Python全栈开发.Java后端开发.前端.OJ题解及各类报错信息解决方案等经验.一起加油 ...

最新文章

1. python学习 爬取亚马逊网页，失败后。修改HTTP报文头部后成功！
2. 城市智慧停车系统方案的产品设计体系介绍
3. C++ 深浅拷贝 01
4. 浅谈Opencl之Image和Buffer 区别
5. oracle里子连接查询,pc端页面滚动到底部加载更多数据......
6. 【java】java 关键字: synchronized详解
7. idea常用图标总结
8. 微信群机器人管理系统源码+支持同登陆多号
9. ANSYS有限元分析
10. UE4 碰撞射线检测
11. 淘宝电商需求文档的书写
12. C++面试 select poll epoll之间的区别
13. maven项目，pom.xml文件变成小虫子（蜘蛛）解决办法
14. 数据准备 ——报表开发中的深层次问题
15. 计算机屏幕出现条纹w7,电脑屏幕出现条纹,教您电脑屏幕出现条纹怎么办
16. 微服务——通用分销系统设计
17. 记录一个问题：$router.push在setTimeout中的使用，显示找不到push
18. duda+显卡驱动+pytorch版本对应
19. 用Powershell命令批量获取域客户端某个补丁是否安装
20. Android 媒体库图片，音频，视频，文件的查询

热门文章

1. WebLogic下WAR方式部署获取文件路径问题
2. SpringSecurity认证流程回顾
3. 常用IOC注解按照作用分类
4. Stream流中的常用方法_count
5. Spring--@within和@target的区别
6. 白苹果了怎么强制开机_iphone X 手机进水开机卡白苹果怎么回事？
7. 【小题目】输入三个数字表示年月日，输出这一天在这一年是第几天
8. 11. Container With Most Water
9. Python 中的模块和包
10. Linux驱动之Input子系统要点分析