简介

  • Java 是一种高级的、面向对象的编程语言，以其可移植性、健壮性和可扩展性而闻名。

  • Java 由 Sun Microsystems（现为 Oracle）开发，遵循“一次编写，随处运行”原则，允许代码在任何具有 Java 虚拟机 （JVM） 的设备上运行。

  • 它广泛用于构建大型企业应用程序、Android 移动应用程序和 Web 服务。

  • Java 具有自动内存管理（垃圾回收）、庞大的标准库和强大的安全功能，使其成为后端系统、分布式应用程序和基于云的解决方案的热门选择。

版本:

  1. Java SE：标准版

  2. Java ME：小型版（被Android，IOS替代）

  3. Java EE：企业版（开发网站）

跨平台原理: JVM

JVM（Java Virtual Machine），Java虚拟机

JRE（Java Runtime Environment），Java运行环境，包含了JVM和Java的核心类库（Java API）

JDK（Java Development Kit）称为Java开发工具，包含了JRE和开发工具

JDK > JRE > JVM

配置

安装 JDK

  1. 安装JDK

  2. 设置环境变量：1.JAVA_HOME ，2.Path

  3. 第一个Java程序

    1
    2
    3
    4
    5
    public class Main {
        public static void main(String[] args) {
            System.out.println("Hello, World!");
        }
    }

    编译：javac Main.java（带后缀），生成 .class 文件

    运行：java Main（无后缀）

  4. 用IntelliJ IDEA

JDK安装目录:

bin：存放各种工具命令，如javac，java

conf：存放相关配置文件

include：存放一些平台特定的头文件

jmods：存放各种模块

legal：存放各种模块的授权文档

lib：存放了工具的一些补充jar包

Java程序的生命周期：

  1. 编程

    在文本编辑器中键入程序，以.java扩展名保存App

  2. 编译

    javac编译器：输入 Java 源代码，输出字节码（独立于机器或平台），生成.class文件

  3. 执行字节码

    Java虚拟机（JVM）：输入字节码，输出机器码（0和1），由本地机器的 CPU 执行

IDEA

结构：Project > Module > Package > class

一些设置：Settings

  1. 自动导包：Editor -> General -> Auto Import

    勾选 Add... ，Optimize...

  2. 代码补全忽略大小写：Editor -> General -> Code Completion

    取消勾选 Match case

  3. 背景图：Appearance & Behavior -> Appearance -> Background Image…导入图片

    Opacity设置不透明度

-> Apply

语法

基本结构

  • 每一行代码都必须位于class（类）内
  • 类名以大写字母开头
  • Java 区分大小写
  • java 文件的名称必须与类名匹配
  • 注释：
    • 单行：//
    • 多行：/* */
    • 文档：/** */

输出

  • System.out.println()

  • System.out.print() （不换行）

输入

导包：import java.util.Scanner;

创建对象：Scanner scanner = new Scanner(System.in);

读取：String name = scanner.nextLine();

输入类型：

方法 作用
nextLine() 读取一个 String
next() 读取一个 String
nextBoolean() 读取一个boolean
nextByte() 读取一个 byte
nextDouble() 读取一个 double
nextFloat() 读取一个 float
nextInt() 读取一个 int
nextLong() 读取一个 long
nextShort() 读取一个 short

注意点：

  • next()，nextLine() 可以接受任意数据，但都会返回字符串

    1. next()，nextInt()，nextDouble() 在接收数据的时候，会遇到空格，回车，制表符其中一个就会停止接收数据。

    2. 但是这些符号（空格，回车，制表符）和后面的数据还在内存中并没有接收。如果后面还有其他键盘录入的方法，会自动将这些数据接收。

  • nextLine() 方法是把一整行全部接收完毕

**使用：**键盘录入分为两套

  1. next()，nextInt()，nextDouble() 这三个配套使用，如果使用了其中一个，就不要用 nextLine()
  2. nextLine() 单独使用，如果想要整数，那么先接收，再使用 Integer.parseInt 进行类型转换
1
2
3
4
5
Scanner sc = new Scanner(System.in);
String s = sc.next();//键盘录入123
System.out.println("此时为字符串" + s);//此时123是字符串
int i = sc.nextInt();//键盘录入123
System.out.println("此时为整数：" + i);
1
2
3
4
5
Scanner sc = new Scanner(System.in);
String s = sc.nextLine();//键盘录入123
System.out.println("此时为字符串" + s);//此时123是字符串
int i = Integer.parseInt(s);//想要整数再进行转换
System.out.println("此时为整数：" + i);

变量

  • 类型：String、int、float、char、boolean……
  • 声明：type variableName = value;
  • 命名规则：
    1. 必须由字母、数字、_ 和 $ 组成
    2. 数字不能开头
    3. 区分大小写
    4. 关键字（如 int 或 boolean）不能用作名称
  • 建议：
    1. 小驼峰命名法：方法、变量
    2. 大驼峰命名法：类名

成员变量 vs 局部变量

成员变量：类中方法外的变量

局部变量：方法中的变量

区别 成员变量 局部变量
类中位置不同 类中，方法外 方法内，方法申明上
初始化值不同 有默认初始化值 没有，使用前需要完成赋值
内存位置不同 堆内存（对象里） 栈内存（方法里）
生命周期不同 随着对象的创建而存在，随着对象的消失而消失 随着方法的调用而存在，随着方法的运行结束而消失
作用域 整个类中有效 当前方法中有效

数据类型

  1. 基本数据类型：byte, short, int, long, float, double, boolean,char
    • 变量中存储的是真实数据（数据值存储在自己空间中）
  2. 引用数据类型：String，Array，Class
    • 变量中存储的是地址值（数据值存储在其他空间，自己空间存储地址值）

data

数据类型 描述 大小
byte 2^7~ 2^7 - 1（-128~127） 1B
short -2^15 ~ 2^15 - 1（-32768~32767） 2B
int -2^31 ~ 2^31 - 1（10位数） 4B
long -2^63 ~ 2^63 - 1（19位数） 8B
float $3.4\times10^{38}$，约 7 位小数 4B
double $1.79\times10^{308}$，约 15 位小数 8B
boolean true/false 1B
char 1个字符（ASCII，Unicode） 2B
  • long：以 L 结尾
  • float：以 f 结尾
  • double：以 d 结尾

科学计数法：e或E

进制：

  • 二进制：0b 开头
  • 十进制：默认
  • 八进制：0 开头
  • 十六进制：0x 开头

类型转换：

  1. 自动转换：
    • byte -> short -> char -> int -> long -> float -> double
    • byte，short，char 类型数据在运算时，都直接提升为int，再进行运算
  2. 强制转换：
    • double -> float -> long -> int -> char -> short -> byte（加括号）

运算符

算数运算符：+ - * / %

  1. 小数：直接参与运算，得到的结果有可能是不精确
  2. 相除：整数相除结果只能得到整除，如果结果想要是小数，必须要有小数参数
  3. 字符串 +：当+操作中出现字符串时，此时就是字符串的连接符，会将前后的数据进行拼接，并产生一个新的字符串（从左到右执行）
  4. 字符 +：转成ASCII码

自增自减运算符：先用后加：a++，a-- 先加后用：++a，--a

赋值运算符

比较运算符

逻辑运算符：

  1. & 且 | 或 ^ 异或 ! 非
  2. 短路逻辑运算符：&& 且 || 或

三元运算符：关系表达式 ? 表达式1 : 表达式2;

条件 循环

  • if…else

  • 简写 if： variable = (condition) ? expressionTrue : expressionFalse;

  • switch

  • while

  • do…while

  • for

  • for each：专门用于遍历数组（或其他数据集）中的元素

    1
    2
    for (type variableName : arrayName) {
      // code block to be executed

数组

  1. 创建：用方括号定义

    1
    2
    3
    4
    5
    6
    7
    String[] cars; // 只是声明，没有实际创建
    int[] myNum = {10, 20, 30, 40};
    Man[] mans = {new Man(1, 1), new Man(2, 2)};  //静态初始化

    int[] arrays = new int[2];  //动态初始化
    a[0] = 1;
    a[1] = 2;

  2. 大小：.length

  3. 遍历：

    • for 循环：快速生成 cars.fori
    1
    2
    3
    4
    String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
    for (int i = 0; i < cars.length; i++) {
      System.out.println(cars[i]);
    }
    • for-each 循环
    1
    2
    3
    4
    String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
    for (String i : cars) {
      System.out.println(i);
    }

内存图：

java-arraylist

只要new出来的一定是在堆里面开辟了一个小空间

多维数组

  1. 创建：

    1
    int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };

  2. 遍历：

    • for 循环
    1
    2
    3
    4
    5
    6
    int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };
    for (int i = 0; i < myNumbers.length; ++i) {
      for (int j = 0; j < myNumbers[i].length; ++j) {
        System.out.println(myNumbers[i][j]);
      }
    }
    • for-each 循环
    1
    2
    3
    4
    5
    6
    int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };
    for (int[] row : myNumbers) {
      for (int i : row) {
        System.out.println(i);
      }
    }

字符串

  1. String 是Java定义好的一个类，定义在java.lang包中，所以使用的时候不需要导包
  2. Java程序中的所有字符串文字（例如”abc”）都被视为此类的对象
  3. 字符串不可变，它们的值在创建后不能被修改

创建

  1. 直接赋值
  2. 构造方法
构造方法 说明
public String() 创建空白字符串对象，不含有任何内容
public String(char[] chs) 根据字符数组，创建字符串对象
public String(byte[] bys) 根据字节数组，创建字符串对象
public String(String original) 根据传入的字符串，创建字符串对象 
1
2
3
4
5
6
7
String s1 = "abc"; //推荐
String s2 = new String(); //空参构造：空字符串 不推荐
String s3 = new String("abc"); //有参构造：不推荐
char[] chs = {'a', 'b', 'c'};
String s4 = new String(chs); //通过字符数组创建：可以修改字符串内容
byte[] bytes = {97, 98, 99};  
String s5 = new String(bytes); //abc 通过字节数组创建：转换字节信息

使用双引号赋值：系统会检查该字符串在串池中是否存在：

  • 不存在：创建新的
  • 存在：复用

String-direct

使用构造方法赋值：在堆内存中创建一个个对象

键盘录入也是在堆内存中new一个对象

String-new

比较

完全一样：equals

忽略大小写：equalsIgnoreCase

==：

  • 比较基本数据类型：比较的是具体的值（数据值）
  • 比较引用数据类型：比较的是对象地址值

API

**字符串长度: **length()

拼接：+（数字相加）

**大小写转换: **

  • 转换为大写：toUpperCase()

  • 转换为小写：toLowerCase()

**根据索引返回字符: **charAt()（返回char类型）

**截取: **substring(.., ..) （左闭右开）

类型转换:

  • 转换为字符串：String.valueOf()
  • 转换为其他类型：Integer.parseInt，Boolean.parseBoolean
  • 转换为 char[]：.toCharArray()

去除首尾空白字符:

  • .trim() （\t，\r，\n）

  • .strip()

**包含: **.contains()

**是否为空: **isEmpty()

**替换: **s.replace('l', 'w');

**分割: **split()

**拼接: **join("...", arr);

格式化:

  • formatted()
  • format()

**连接两个字符串: **concat()

返回字符串中指定文本首次出现的索引（包括空格）：indexOf("...")

**转义: **

  • \：转换为普通字符串字符
  • \n：换行
  • \t：制表符（把前面的字符串长度补齐到8，或者8的整数倍。最少补1个空格，最多补8个空格）
  • \r：回车
  • \b：退格
  • \f：换页符

StringBuilder

StringBuilder 可以看成是一个容器，创建之后里面的内容是可变的

作用：提高字符串操作效率

创建：StringBuilder sb = new StringBuilder();

构造方法 说明
public StringBuilder() 创建一个空白可变字符串对象，不含有任何内容
public StringBuilder(String str) 根据字符串内容，来创建可变字符串对象

常用方法：

方法名 说明
public StringBuilder append(任意类型) 添加数据，并返回对象本身
public StringBuilder reverse() 反转容器中的内容
public int length() 返回长度（字符出现的个数）
public String tuString() 通过toString()就可以实现把StringBuiler转换为String

ps：因为StringBuilder是Java已经写好的类，java在底层对他做了一些特殊处理，打印对象不是地址值而是属性值。

**链式编程: **调用一个方法时，不需要用变量接受它的结果，可以继续调用其他方法

1
2
StringBuilder sb = new StringBuilder();
sb.append("aaa").append("bbb").append("ccc").append("ddd");

StringJoiner

  • StringJoiner跟StringBuilder一样，也可以看成是一个容器，创建之后里面的内容是可变的。
  • 作用：提高字符串的操作效率，而且代码编写特别简洁，但是目前市场上很少有人用。

创建：

构造方法 说明
public StringJoiner(间隔符号) 创建一个StringJoiner对象，指定拼接时的间隔符号
public StringJoiner(间隔符号，开始符号，结束符号) 创建一个StringJoiner对象，指定拼接时的间隔符号、开始符号、结束符号

方法：

方法名 说明
public StringJoiner add(添加内容) 添加数据，并返回对象本身
public int length() 返回长度（字符出现的个数，算空格）
public String toString() 返回一个字符串（该字符串就是拼接之后的成果）

原理

StringTheory

拼接原理：

  1. 没有变量参与：

    string-concat1

  2. 有变量参与：

    string-concat2

  3. JDK8优化：预估最终字符串长度，并创建一个数组

    string-concat3