基础语法

一、基本数据类型

Java 有八大基本数据类型，它们分别是：byte、short、int、long、float、double、char、boolean。不同的数据类型有着不同的取值范围和内存占用大小。

也可以在 这里 具体学习到它们

数据类型	关键字	位数	取值范围
整数	byte	8	-128~127
	short	16	-32768~32767
	int	32	-231~231-1 (10位数)
	long	64	-263 ~263_1 (19位数)
浮点数	float	32	大约 -3.4E38~ 3.4E38
	double	64	大约 -1.7E308~1.7E308
字符	char	16	0-65535
布尔	boolean	8	true, false

整数和小数取值范围大小关系：double > float > long > int > short > byte。

long类型变量：需要加入L标识(大小写都可以)

float类型变量：需要加入F标识(大小写都可以)

为什么没有 string 基本数据类型？

八大基本数据类型是由 Java 虚拟机直接支持的，它们是为了解决最基本的存储和计算需求，效率更高，占用更少内存。String 属于引用类型，它本质是一个类（java.lang.String），对象的内存分配和管理由 Java 的垃圾回收机制负责。

字符串在很多编程语言中（包括 Java）通常被设计为类而不是基本数据类型，原因是字符串的功能复杂，涉及到：长度可变、多种操作（如字串、拼接、比较、查找等）、特殊的存储和优化机制（如字符串池，String 会被放入常量池中，重复的字符串字面值只会存储一份）。

总结

Java 中没有基本数据类型 string 是因为字符串是复杂的对象，而基本数据类型是为了高效存储简单值而设计的。通过设计 String 类，Java 提供了一个功能强大且高效的字符串处理方式，同时通过语法糖和优化机制让其使用体验接近基本数据类型。

二、运算符

各类编程语言中都有运算符，相信大家或多或少都有所了解，下面我简单介绍一下。运算符都包括：算术运算符、自增自减运算符、赋值运算符、关系运算符、逻辑运算符、三元运算符、运算符优先级

1. 算数运算符的隐式转换

• 什么时候转换？

数据类型不一样，不能进行计算，需要转成一样的才可以进行计算。

• 转换规则

取值范围小的，和取值范围大的进行运算，小的会先提升为大的，再进行运算。

byte short char 三种类型的数据在运算的时候，都会直接先提升为int，然后再进行运算。

2. 自增自减运算符

// 先用后加
int a = 10;
int b = a++; // b: 10

// 先加后用
int a = 10;
int b = ++a; // b: 11

3. 逻辑运算符

符号	作用	说明
&	逻辑与（且）	并且，两边都为真，结果才是真
l	逻辑或	或者，两边都为假，结果才是假
^	逻辑异或	相同为false，不同为true
!	逻辑非	取反

短路逻辑运算符：&& 和 ||。&& 表示两边都为真结果才是真，|| 表示两边都为假结果才为假。

三、判断和循环

判断

/** if语句 */
if (flag) {}

/** switch语句 */
switch (flag) {
  case 'xx':
    break;
  default:
    break;
}
switch (flag) {
  case 1 -> {}
  default -> {}
}

循环

/** for循环 */
for (int i = 0; i < 5; i++) {
  if (i == 3) {
    // 结束本次循环，继续下次循环
    continue;
    // 结束整个循环
    break;
  }
  System.out.println(i);
}

// 增强for
Collection<String> coll = new ArrayList<>();
coll.add("A");
coll.add("B");
coll.add("C");

for (String s : coll) {
  System.out.println(s);
}

/** while循环 */
int num = 1;
while (num < 2) {
  System.out.println("while");
  num++;
}

四、数组

数组是一种容器，可以用来存储同种数据类型的多个值。数组长度固定。数组容器在存储数据的时候，需要结合隐式转换考虑。

int类型的数组容器（❌boolean、byte、short、int、❌double）

double类型的数组容器（byte、short、int、long、float、double）

静态初始化

/**
 * 完整格式：数据类型 [] 数组名 = new 数据类型[]{元素1, ...};
 * 简化格式：数据类型 [] 数组名 = {元素1, ...};
*/
import java.util.Arrays;

int[] arr1 = {11, 12, 13};
String[] arr2 = {"张三", "李斯"};
double[] arr3 = {1.93, 1.78};

System.out.println(arr1[2]);
System.out.println(Arrays.toString(arr));

动态初始化

String[] arr = new String[10];

arr[0]="张三";

// 数组默认初始化值的规律
// 整数类型:默认初始化值e
// 小数类型:默认初始化值0.0
// 字符类型:默认初始化值'u0000'空格
// 布尔类型:默认初始化值 false
// 引用数据类型:默认初始化值nu1I

1. 数组遍历

数组遍历方法

for (int i = 0; i < arr.length; i++) {
  System.out.println(arr[i]);
}

for (int j : arr) {
  System.out.println(j);
}

五、集合

集合的长度可变。集合只能存储引用类型，基础类型存储需要进行包装类。

import java.util.ArrayList;

public class Main {
  public static void main(String[] args) {
    /**
     * ArrayList<泛型> list = new ArrayList<>();
     * 包装类：Integer可以存储int。Character存储字符
     * 存储类：泛型 替换为 类名
     */
    ArrayList<String> list = new ArrayList<>();

    // 增
    list.add("zeming");
    list.add("bbb");
    // 删
    list.remove(1);
    // 改
    list.set(0, "哥哥");
    // 查
    String a = list.get(0);
    int a1 = list.size();

    System.out.println(list);
    System.out.println(a);
    System.out.println(a1);
  }
}

六、方法

简单的方法定义

public class Main {
  public static void main(String[] args) {
    playGame();
  }

  public static void playGame() {
    System.out.println("这里是plyGame方法");
  }
}

带参数的方法定义

public class Main {
  public static void main(String[] args) {
    playGame("张三", 25);
  }

  public static void playGame(String name, int age) {
    System.out.println("这里是plyGame方法");
    System.out.println("姓名：" + name);
    System.out.println("年龄：" + age);
  }
}

带返回值的方法定义

public class Main {
  public static void main(String[] args) {
    int sum = getSum(1, 2, 3);
    System.out.println(sum);
}

  public static int getSum(int a, int b, int c) {
    return a + b + c;
  }

  public static int[] copy(int[] arr, int from, int to) {
    int[] temp = new int[to-from];
    return temp;
  }
}

七、String 拓展

String 字符串的内容是不会发生改变的，它的对象在创建后不能被更改。

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

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

String

// 当使用双引号直接赋值时，系统会检查该字符串在串池中是否存在。
// 不存在：创建新的
// 存在：复用
String name = "asfsdffsf";
System.out.println(name);

String a = new String("sdfs");
System.out.println(a);

char[] chs = {'a', 'b', 'c'};
String b = new String(chs);
System.out.println(b);


/** 判断是否相等 */
String s1 = "abc";
String s2 = "Abc";
System.out.println(s1.equals(s2)); // 不忽略大小写

StringBuilder

StringBuilder sb = new StringBuilder("Zm");

System.out.println(sb.append("zzzzz")); // 添加元素
System.out.println(sb.reverse()); // 反转

// 再把 StringBuilder 变回字符串
String str = sb.toString();
System.out.println(str);

StringJoiner

/**
 * public StringJoiner (间隔符号)
 * public StringJoiner (间隔符号, 开始符号, 结束符号)
 */
import java.util.StringJoiner;

public class Main {
  public static void main(String[] args) {
    StringJoiner sj = new StringJoiner("---");
    sj.add("sd").add("sdf");

    System.out.println(sj.toString());

    StringJoiner sj2 = new StringJoiner(",", "[", "]");
    sj2.add("1").add("2");
    System.out.println(sj2.toString());
  }
}

1. 字符串存储的内存原理

直接赋值会复用字符串常量池中的。new出来不会复用，而是开辟一个新的空间。

2. == 号比的到底是什么？

答：基本数据类型比较的是数据值；引用数据类型比较的是地址值。

总结

这里是简单的总结