2023年之我拿起“java“ java基础

爱被打了一巴掌 2024-03-23 22:18 83阅读 0赞

#### 文章目录 ####

*  java
 *  java基础
 *   *   了解 j a v a 的语法，从 H e l l o W o r l d 开始 \\color\{red\}\{了解java的语法，从HelloWorld开始\} 了解java的语法，从HelloWorld开始
     *   j a v a 语言的注释 \\color\{red\}\{java语言的注释\} java语言的注释
     *   *  单行注释 //
         *  多行注释 /\* \*/
     *   一个类中的 p u b l i c c l a s s 和 c l a s s 的区别 \\color\{red\}\{一个类中的public class 和 class的区别\} 一个类中的publicclass和class的区别
     *   j a v a 中的标识符 \\color\{red\}\{java中的标识符\} java中的标识符
     *   *  什么是标识符
         *  标识符可以标识什么元素
         *  标识符的命名规则
         *  标识符的命名规范
     *   j a v a 中的关键字 \\color\{red\}\{java中的关键字\} java中的关键字
     *   j a v a 中的字面值 \\color\{red\}\{java中的字面值\} java中的字面值
     *   j a v a 中的变量 \\color\{red\}\{java中的变量\} java中的变量
     *   *  什么是变量
         *  数据类型的作用
         *  变量的要求
         *  声明格式
         *  什么是作用域
         *  变量的分类
     *   数据类型 \\color\{red\}\{数据类型\} 数据类型
     *   *  数据类型的主要作用
         *  基本数据类型
         *   *  整数型
         *  浮点型
         *  布尔型
         *  字符型
         *  引用数据类型
         *  基本数据类型之间的相互转换
     *   键盘录入 \\color\{red\}\{键盘录入\} 键盘录入
     *   *  关键字 Scanner
         *  接受不同的数据，只需要修改步骤三 接受数据这一步
     *   生成随机数 \\color\{red\}\{生成随机数\} 生成随机数
     *   *  创建不同的数据，只需要修改步骤三 接受数据这一步
         *   *  随机数扩展
     *   循环 \\color\{red\}\{循环\} 循环
     *   *  for 循环
         *   *  带索引的for循环
             *   *  快速结束嵌套循环
             *  增强for循环
         *  while循环
         *  do while循环
     *   j a v a 的 M a t h 包 \\color\{red\}\{java的Math包\} java的Math包
     *   一维数组 \\color\{red\}\{一维数组\} 一维数组
     *   *  定义
         *  格式
         *  数组初始化
         *   *  数组动态初始化
             *   *  格式
             *  动态数组初始化取值
             *  静态数组初始化取值
         *  数组求长度
         *  数组遍历
         *  查看数组
     *   二维数组 \\color\{red\}\{二维数组\} 二维数组
     *   *  二维数组动态初始化
         *  二维数组遍历
         *  数组中不同数据类型的默认值
         *  升序排序的数组函数
     *   冒泡排序 \\color\{red\}\{冒泡排序\} 冒泡排序
     *   初识方法 \\color\{red\}\{初识方法\} 初识方法
     *   *  概述
         *  特点
     *   初识类和对象 \\color\{red\}\{初识类和对象\} 初识类和对象
     *   *  面向对象和面向过程的思想对比
         *  什么是类
         *  类的组成
         *  类和对象的关系
         *  类的定义
         *  创建对象
         *  使用方法
     *   构造方法 \\color\{red\}\{构造方法\} 构造方法
     *   *  格式：
         *   *  无参构造：
             *  有参构造：
         *  特点
         *  标准类的编写
     *   成员变量和局部变量的区别 \\color\{red\}\{成员变量和局部变量的区别\} 成员变量和局部变量的区别
     *   *  代码中的位置
         *  在内存中的位置
         *  生命周期不一样
         *  初始化值
     *   初始引用类型 S t r i n g \\color\{red\}\{初始引用类型 String\} 初始引用类型String
     *   *  next和nextLine
         *   *  next()
             *  nextLine()
         *  new String();
         *   *  传输byte类型的数组
             *  传输byte类型的数组，索引，长度
             *  传输 char类型的数组
             *  传输 char类型的数组，索引，长度
         *  String类型对应同一字符串，是否相等
         *  创建空的字符串
     *   基本类型和字符串之间的转化 \\color\{red\}\{基本类型和字符串之间的转化\} 基本类型和字符串之间的转化
     *   *  String类型转基本类型
         *   *  byte
             *  short
             *  int
             *  long
             *  double
             *  float
         *  基本类型转化为String类型
         *   *  方法1
             *  方法2
     *   字节码 \\color\{red\}\{字节码\} 字节码
     *   字符串常用方法 \\color\{red\}\{字符串常用方法\} 字符串常用方法
     *   *  equals
         *  charAt
         *  endWith
         *  startWith
         *  isEmpty
         *  length()
         *  replace
         *  split
         *  substring
         *  toCharArray
         *  toLowerCase
         *  toUpperCase
         *  equalsIgnoreCase
         *  trim
     *   S t r i n g B u i l d e r \\color\{red\}\{StringBuilder\} StringBuilder
     *   *  构造一个没有字符的字符串构建器，初始容量为16个字符。
         *  append
         *  reverse
     *   模拟用户登录 \\color\{red\}\{模拟用户登录\} 模拟用户登录
     *   A r r a y L i s t \\color\{red\}\{ArrayList\} ArrayList
     *   *  构造方法
         *   *  构造一个具有指定初始容量的空列表
             *  构造具有指定初始容量的空列表
         *  常用方法
         *   *  add
             *  get
             *  remove
             *  isEmpty
             *  set
         *  泛型
         *  迭代器
         *  ArrayList存储特点，有序可存储

## java ##

## java基础 ##

java是一门面向对象的语言

###  了解 j a v a 的语法，从 H e l l o W o r l d 开始 \\color\{red\}\{了解java的语法，从HelloWorld开始\} 了解java的语法，从HelloWorld开始 ###

//此处写类体
    public class Test {
        
        //此处是主函数
        public static void main(String[] args) {
        
            //输出语句
            System.out.println("HelloWorld");
        }
    }

###  j a v a 语言的注释 \\color\{red\}\{java语言的注释\} java语言的注释 ###

#### 单行注释 // ####

//这是单行注释

#### 多行注释 /\* \*/ ####

注意：多行注释本可以嵌套使用

/*
    这是多行注释
    */

###  一个类中的 p u b l i c c l a s s 和 c l a s s 的区别 \\color\{red\}\{一个类中的public class 和 class的区别\} 一个类中的publicclass和class的区别 ###

1. 一个 java 源文件中可以定义多个 class。  
  2. 一个 java 源文件中 public 的 class 不是必须的。  
  3.一个 class 会定义生成一个class字节码文件。  
  4.一个 java 源文件中定义公开的类的话，只能有一个，并且该类名必须和 java 源文件名称一致。  
  5.每一个 class 当中都可以设定程序的入口。

###  j a v a 中的标识符 \\color\{red\}\{java中的标识符\} java中的标识符 ###

#### 什么是标识符 ####

1.在 Java 源文件中凡是程序员有权利自己命名的单词都是标识符。

#### 标识符可以标识什么元素 ####

1.类名  
  2.方法名  
  3.变量名  
  4.接口名  
  5.常量名

这些名称我们在下面的知识中会介绍到的。

#### 标识符的命名规则 ####

1.一个合法的标识符只能由 数字、下划线、字母、美元符号组成，无其他符号。  
  2.不能数字开头。  
  3.严格区分大小写.  
  4.关键字不能做标识符.  
5.理论上不能太长，但是 java 无长度限制。

#### 标识符的命名规范 ####

1.最好见名知意。  
  2.遵守驼峰命名方式。  
    例如：UserService;SystemService;  
  3.类名、接口名：首字母大写，后面每个单词首字母大写。  
  4.变量名、方法名：首字母小写，后面每个单词首字母大写。  
  5.变量名：全部大写。

###  j a v a 中的关键字 \\color\{red\}\{java中的关键字\} java中的关键字 ###

关键字在 java 语言中全部小写。  
    例如：int, double.

###  j a v a 中的字面值 \\color\{red\}\{java中的字面值\} java中的字面值 ###

字面值就是数据。  
    例如：10.00；“abc”；‘a’;

###  j a v a 中的变量 \\color\{red\}\{java中的变量\} java中的变量 ###

#### 什么是变量 ####

1.变量本质上来说是内存中的一块空间，这快空间有数据类型、有名字、有面值。  
  2.变量包含三部分：数据类型、名称、字面值【数据】。  
  3.变量是内存中存储数据的结构的最基本单元。

#### 数据类型的作用 ####

1.不同的数据类型有不同的类型，不同的数据类型底层分配不同的大小空间。  
  2.数据类型是指导程序运行阶段应该分配多大的内存空间。

#### 变量的要求 ####

1.数据与数据类型一致。

#### 声明格式 ####

1.数据类型 变量名；  
    例如：int a = 10;

#### 什么是作用域 ####

1.变量出了大括号就消失了

#### 变量的分类 ####

1.局部变量：在方法体中声明的变量叫局部变量。  
  2.成员变量：在方法体外【类体之内】声明的变量叫成员变量。  
  3.java遵循就近原则。  
类体中不能直接编写 Java 语句【除声明变量之外】。

###  数据类型 \\color\{red\}\{数据类型\} 数据类型 ###

#### 数据类型的主要作用 ####

1.数据类型的主要作用是指导JVM(java 虚拟机)在运行程序的时候给该数据分配多大的空间。

#### 基本数据类型 ####

1.基本数据类型包括四大类八大种。

##### 整数型 #####

b y t e ( 1 ) , s h o r t ( 2 ) , i n t ( 4 ) , l o n g ( 8 ) \\color\{red\}\{byte(1),short(2),int(4),long(8)\} byte(1),short(2),int(4),long(8)

#### 浮点型 ####

f l o a t ( 4 ) , d o u b l e ( 8 ) \\color\{red\}\{float(4),double(8)\} float(4),double(8)

#### 布尔型 ####

b o o l e a n ( 1 ) \\color\{red\}\{boolean(1)\} boolean(1) 只有true,false两种值。

#### 字符型 ####

c h a r ( 2 ) \\color\{red\}\{char(2)\} char(2) 取值范围 0 - 65535

#### 引用数据类型 ####

1.类。  
  2.接口。  
  3.数组。  
  等等……

#### 基本数据类型之间的相互转换 ####

1.八种数据类型除了 布尔值 之外，剩下的7种数据类型之间都可以相互转换。  
  2.小容量向大容量转化，称为自动类型转换，容量从小到大的排序。

b y t e < s h o r t ( c h a r ) < i n t < l o n g < f l o a t < d o u b l e \\color\{red\}\{byte<short(char)<int<long<float<double\} byte<short(char)<int<long<float<double

任何浮点型不管占用多少个字节，都比整数型容量大。  
char 和 short 可表示的种类相同，但是char 可以取更加大的整数。  
  3.大容量转化为小容量，叫做强制类型转换，需要加强制类型转换符，程序才能通过编译，但在运行阶段可能损失精度，所以谨慎使用。  
  4.当整数字面值没有超出 byte,short,char的取值范围，可以直接赋值给 byte,short,char 类型的变量。  
  5.byte,short,char混合运算的时候，先各自转化成 int 类型在做运算。  
  6.多种数据类型混合运算，先转换成容量最大的那种类型在做运算。  
  7.关系运算符的结果一定是布尔类型：true\\flase。  
  8.byte和short 不能直接转换成char类型。

消化一下知识在接着往下看吧！！！ \\color\{red\}\{消化一下知识在接着往下看吧！！！\} 消化一下知识在接着往下看吧！！！

###  键盘录入 \\color\{red\}\{键盘录入\} 键盘录入 ###

#### 关键字 Scanner ####

需要使用关键字了，不同数据类型的录入，代码也会有些许差异。

//导包
    import java.util.Scanner;
    
    //此处写类体
    public class Test {
        
        //此处是主函数
        public static void main(String[] args) {
        
            // 创建对象 需要使用关键字 Scanner 
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入数据");
            //这里我们录入 int 类型的数据
            int result =sc.nextInt();
            //打印我们录入的数据
            System.out.println("你录入的数据式："+result);
            //这里的 "+" 用于字符串的拼接
        }
    }

分析以上代码：键盘录入的步骤  
  1.导包

import java.util.Scanner;

2.创建对象

Scanner sc = new Scanner(System.in);

3.接受数据

int result =sc.nextInt();

#### 接受不同的数据，只需要修改步骤三 接受数据这一步 ####

//接受byte类型的数据
     byte num = sc.nextByte();
     //接受short类型的数据
    short num1 = sc.nextShort();
     //接受int类型的数据
    int num2 = sc.nextInt();
    //接受long类型的数据
    long num3 = sc.nextLong();
    //接受float类型的数据
    float num4 = sc.nextFloat();
    //接受double类型的数据
    double num5 = sc.nextDouble();
    //接受String类型的数据
    String num6 = sc.next();

###  生成随机数 \\color\{red\}\{生成随机数\} 生成随机数 ###

需要使用关键字，生成不同的数据类型的数据，代码也会有所差异

//导包
    import java.util.Random;
    //此处写类体
    public class Test {
        
        //此处是主函数
        public static void main(String[] args) {
        
            //创建对象需要使用Random关键字
            Random random = new Random();
            //创建整数类型随机数
            int result = random.nextInt();
            
        }
    }

分析以上代码：键盘录入的步骤  
  1.导包

import java.util.Random;

2.创建对象

Random random = new Random();

3.接受数据

int result = random.nextInt();

#### 创建不同的数据，只需要修改步骤三 接受数据这一步 ####

具体方法参考上面Scanner的方法。

##### 随机数扩展 #####

生成区间的随机数：【最小值，最大值】

//导包
    import java.util.Random;
    
    //此处写类体
    public class Test {
        
        //此处是主函数
        public static void main(String[] args) {
        
            //创建对象需要使用Random关键字
            Random random = new Random();
            //创建0 -10 的整数类型  [0,11)
            int result = random.nextInt(11);
        }
    }

###  循环 \\color\{red\}\{循环\} 循环 ###

#### for 循环 ####

##### 带索引的for循环 #####

int n = 10;
    for(int i = 0; i < n; i++){
        
    	System.out.println(i);
    }

###### 快速结束嵌套循环 ######

//外层循环起名 out
    out:
    for (int i = 0; i < 10; i++) {
        
        //内存循环起名 in
        in:
        for (int j = 0; j < 10; j++) {
        
            //当j等于5时，结束外层循环
            if(j==5){
        
                break out;
            }
        }
    }

##### 增强for循环 #####

//ArrayList集合 这里不需要了解，我们重点看for循环
    ArrayList<String> list  = new ArrayList<>()
    for(String s : list){
        
        System.out.println(s);
    }

#### while循环 ####

//括号里面放boolean类型的值
    while(true){
        
    	System.out.println("这里是while循环");
    }

#### do while循环 ####

特点：循环至少循环一次

do{
        
    	System.out.println("这里是do while循环");
    }while(true)
    //括号里面放boolean类型的值

###  j a v a 的 M a t h 包 \\color\{red\}\{java的Math包\} java的Math包 ###

1.导入包

import static java.lang.Math.*;

2.列举几个常用方法

~求绝对值

int num = 10;
    int result = Math.abs(num);

~求开方

double = 3.0;
    double result = Math.sqrt(num);

等等等，还有很多方法，这里我们不一一列举。

###  一维数组 \\color\{red\}\{一维数组\} 一维数组 ###

#### 定义 ####

数组是一个容器用来储存相同数据类型数据的容器。

#### 格式 ####

数据类型[] 数组名；
    int[] arr;

#### 数组初始化 ####

##### 数组动态初始化 #####

###### 格式 ######

数据类型[] 数组名 = new 数据类型[长度];
    int[] arr = new int[3];

##### 动态数组初始化取值 #####

数组数据类型 变量名 = 数组名[索引];
    int a = arr[0];

索引就是数组中每个初始化空间的编号。

##### 静态数组初始化取值 #####

数据类型[] 数组名 = new 数据类型[]{
        ……};
    int [] arr = new int[]{
        1,2,3,4,5,6,7,8,9};
    
    数据类型[] 数组名 = {
        ……};
    int[] arr = {
        1,2,3,4,5,6,7,8,9};

#### 数组求长度 ####

数组名.length;
    int len = arr.length;

#### 数组遍历 ####

int[] arr = new int[10];
    for (int i = 0; i < arr.length; i++) {
        
    	   int result1 = arr[i];
    	   System.out.println("这是遍历数组");
    }

#### 查看数组 ####

System.out.println(Arrays.toString(arr));

###  二维数组 \\color\{red\}\{二维数组\} 二维数组 ###

#### 二维数组动态初始化 ####

数据类型 [][] 变量名 = new 数据类型 [m][n];

#### 二维数组遍历 ####

int[][] arr1 = new int[3][4]; //3行4列的二维数组
    for (int i = 0; i < arr1.length; i++) {
        
        for (int j = 0; j < arr1[i].length; j++) {
        
            System.out.println("这是二维数组的遍历");
        }
    }

#### 数组中不同数据类型的默认值 ####

1.整数数据类型  
byte,short,int,long默认值为**0**。

2.浮点数据类型  
float,double 默认值**0.0**

3.char数据类型  
char 默认值 **\\u0000**。

4.boolean数据类型  
boolean默认值**false**。

5.引用数据类型  
String 默认值时**null**。

#### 升序排序的数组函数 ####

Arrays.sort(arr);

###  冒泡排序 \\color\{red\}\{冒泡排序\} 冒泡排序 ###

int[] arr = {
        4,2,5,1,3};
    //排序只需要排序 总长度减1次
    for (int i = 0; i < arr.length-1; i++) {
        
        //每次排序都会确定一个数据的位置
        for (int j = 0; j < arr.length-1-i; j++) {
        
            if(arr[j]>arr[j+1]){
        
                //创建一个中间遍历 tmp进行交换两个数据
                int tmp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=tmp;
            }
        }
    }

###  初识方法 \\color\{red\}\{初识方法\} 初识方法 ###

#### 概述 ####

1.方法就是解决问题的方法。

2.编程中的方法，具有特定功能的代码快。

#### 特点 ####

1.方法和方法之间时平行关系，不能嵌套定义。

2.方法定义后不会自己执行，需要调用后才能执行。

3.方法定义的先后顺序和方法执行的顺序无关，和方法调用的顺序有关，谁先调用，谁先执行。

这里我们浅做了解，具体在后面的学习中理解强化。

###  初识类和对象 \\color\{red\}\{初识类和对象\} 初识类和对象 ###

#### 面向对象和面向过程的思想对比 ####

1.面向过程：是一种以过程为中心的编程思想，实现功能的每一步，都是自己实现的。

2.面向对象：是一种以对象为中心的编程思想，通过指挥对象实现具体的功能。

对象：指的是客观存在的食物，万物皆对象。

#### 什么是类 ####

1.类是对现实生活中一类具有共同属性的行为的事物的抽象。

2.类是事物，也就是对象的一种描述，可以将类理解为一张设计图，根据设计图，可以创造除具体存在的事物。

#### 类的组成 ####

1.属性：该事物的各种特征。  
在类中通过成员变量来体现。（类中方法外的变量）。

2.行为：该事物存在的功能（能够做的事情）。  
在类中通过成员方法来体现（和前面的方法想比较去掉static关键字就可以）。

#### 类和对象的关系 ####

1.类：类是对现实生活中一类具有共同属性和行为的事物的抽象。

2.对象：是能够看得到摸得到的真实存在的实体。

类是对象的描述。  
对象是类的实体。

#### 类的定义 ####

public class 类名{
        
    	成员变量
        成员方法
    }

public class Student{
        
    	//成员变量
    	String name;
    	int age;
        //成员方法 行为
        public void study(){
        
    		 System.out.println("这是成员方法");
    	}
    }

#### 创建对象 ####

类名 对象名 = new 类名();
    
    Student stu = new Student();

#### 使用方法 ####

对象名.变量名
    stu.name;

//此处写类体
    public class Test {
        
        //此处是主函数
        public static void main(String[] args) {
        
            Student stu = new Student();
            stu.age = 18;
            stu.name = "张三";
            stu.study();
        }
    }

消化一下知识在接着往下看吧！！！ \\color\{red\}\{消化一下知识在接着往下看吧！！！\} 消化一下知识在接着往下看吧！！！

###  构造方法 \\color\{red\}\{构造方法\} 构造方法 ###

作用：用来创建对象和new 一起。

#### 格式： ####

##### 无参构造： #####

public 类名(){
        
    }
    
    public Price(){
        
    	System.out.println("无参构造方法被调用");
    }

##### 有参构造： #####

public 类名(参数列表){
        
    	……
    	……
    	……
    }
    
    public Price(String brand){
        
    	this.brand = brand;
    	System.out.println("有参构造方法被调用 brand");
    }

#### 特点 ####

1.如果本类中没有构造方法，JVM会默认提供一个无参的构造方法。

2.构造方法可以重载。

3.构造方法没有返回值，不能使用void。

4.构造方法没有return关键字，可以写，但是没必要。

#### 标准类的编写 ####

1.成员变量私有化，得到getXxx 和 setXxx方法。

2.提供空参满参的构造方法。

###  成员变量和局部变量的区别 \\color\{red\}\{成员变量和局部变量的区别\} 成员变量和局部变量的区别 ###

#### 代码中的位置 ####

1.成员变量：类中方法外。

2.局部变量：在方法的声明上，或者方法内部。

#### 在内存中的位置 ####

1.成员变量：在堆中。

2.局部变量：在栈中。

#### 生命周期不一样 ####

1.成员变量：随着对象的创建而存在，随着对象的消失而消失。

2.局部变量：随着方法的调用而存在，随着方法的弹栈而消失。

#### 初始化值 ####

1.成员变量：有默认值。  
默认值在上面的知识点中提到过。

2.局部变量：没有默认值。

###  初始引用类型 S t r i n g \\color\{red\}\{初始引用类型 String\} 初始引用类型String ###

#### next和nextLine ####

##### next() #####

==next()==只能录入连续的字符串，这里的连续值没有空格的字符串。  
换而言之：当遇到空格或者回车就会结束键盘录入

//创建Scanner对象
    Scanner sc = new Scanner(System.in);
    //键盘录入
    String s = sc.next();
    //比如我们想录入 welcome to CSDN
    
    //但是实际的s为 welcome

##### nextLine() #####

nextLIne() 当遇到回车的时候才会结束键盘录入，遇到空格不会结束键盘录入。

//创建Scanner对象
    Scanner sc = new Scanner(System.in);
    //键盘录入
    String s = sc.nextLine();
    //比如我们想录入 welcome to CSDN
    
    //但是实际的s为 welcome to CSDN

#### new String(); ####

##### 传输byte类型的数组 #####

byte[] arr = {
        65,66,67,68,69};
    String s = new String(arr);
    System.out.println(s);
    //打印结果ABCDE

分析一下代码，为什么传输进去的整数类型，但是打印的ABCDE呢？

其实是将整数类型转化为ASCLL值打印输出。

##### 传输byte类型的数组，索引，长度 #####

byte[] arr = {
        65,66,67,68,69};
    String s1 = new String(arr,    1,   3);
    //                     数组  索引  长度
    //打印结果 BCD

代码含义，将数组arr从 1 索引开始，向后数 3 个长度，交给字符串S1。

##### 传输 char类型的数组 #####

char[] chars = {
        'a','b','c','d','e','f'};
    String s = new String(chars);
    System.out.println(s);
    // 打印结果 abcdef

将字符数组转化成字符串。

##### 传输 char类型的数组，索引，长度 #####

char[] chars = {
        'a','b','c','d','e','f'};
    String s = new String(chars,    1,   3);
    //                    数组  索引  长度
    System.out.println(s);
    //打印结果bcd

#### String类型对应同一字符串，是否相等 ####

String name1 = "张三";
    String name2 = "张三";
    //true

值创建后不能更改，是对象的话，一般放在堆内存中，这就意味者地址值是相等的，比较的是同一快内存地址，所以相等。

String name1 = new String("张三");
    String name2 = new String("张三");
    //false

在这里“张三”的地址值是一样的，但是这里new 的对象，但是“张三”重复了，为了节省内存，new的对象指向了“张三”。但是这里比较的是new的地址，地址内存不一样。

#### 创建空的字符串 ####

String s = "";
    
    String s1 = new string();
    
    //s和s1都是空的字符串。

###  基本类型和字符串之间的转化 \\color\{red\}\{基本类型和字符串之间的转化\} 基本类型和字符串之间的转化 ###

#### String类型转基本类型 ####

##### byte #####

public class test {
        
        public static void main(String[] args){
        
            String s = "123";
            byte b = Byte.parseByte(s);
        }
    }

##### short #####

public class test {
        
        public static void main(String[] args){
        
            String s = "123";
            short sh = Short.parseShort(s);
        }
    }

##### int #####

public class test {
        
        public static void main(String[] args){
        
            String s = "123";
            int result = Integer.parseInt(s);
        }
    }

##### long #####

public class test {
        
        public static void main(String[] args){
        
            String s = "123";
            long result = Long.parseLong(s);
        }
    }

##### double #####

public class test {
        
        public static void main(String[] args){
        
            String s = "123";
            double result = Double.parseDouble(s);
        }
    }

##### float #####

public class test {
        
        public static void main(String[] args){
        
            String s = "123";
            float result = Float.parseFloat(s);
        }
    }

#### 基本类型转化为String类型 ####

##### 方法1 #####

直接拼接一个空的字符串。

int num = 10;
    String s1 = num + "";

##### 方法2 #####

int num = 10;
    
    String s2 = String.valueOf(num);

###  字节码 \\color\{red\}\{字节码\} 字节码 ###

关键：getBytes();

String name = "张三";
     byte[] arr = name.getBytes();
     System.out.println(Arrays.toString(arr));
     //打印的字节码[-27, -68, -96, -28, -72, -119]

可以使用字节码反推字符串

byte[] arr1 = {
        -27, -68, -96, -28, -72, -119};
    //这里我们运用上面介绍的知识
    String name1 = new String(arr1);
    System.out.println(name1);
    //打印的结果为 张三

###  字符串常用方法 \\color\{red\}\{字符串常用方法\} 字符串常用方法 ###

#### equals ####

查看字符串是否相等.返回值是boolean类型的数据

String s1 = "abc";
    String s2 = "abc";
    if(s1.equals(s2)){
        
        System.out.println("相等");
    }else{
        
        System.out.println("不相等");
    }
    
    //打印的结果 相等

因为**s1**和**s2**相等，所以s1.equals(s2) 结果为true。

#### charAt ####

返回指定索引处的值。返回值是char类型的数据。

String s = "abcdef";
    char ch = s.charAt(1);
    System.out.println(ch);
    //打印结果 b

字符串**s** 1索引的值为 **b**。

#### endWith ####

测试字符串是否以指定后缀结尾，返回值是boolean类型的数据

String s = "2023年01月16日";
    //判断字符串是否以 日 结尾
    boolean result = s.endsWith("日");
    System.out.println(result);
    //打印结果 true

#### startWith ####

测试字符串是否以指定前缀开头，返回值是boolean类型的数据

String s = "2023年01月16日";
    //判断字符串是否以 2023 开头
    boolean result = s.startsWith("2023");
    System.out.println(result);
    //打印结果 true

#### isEmpty ####

判断字符串是否为空，返回值是boolean类型的数据

//空的字符串
    String s = new String();
    boolean result = s.isEmpty();
    System.out.println(result);
    //打印结果为true

#### length() ####

求字符串长度，返回值是int类型的数据

String s = "abcdef";
    int len = s.length();
    System.out.println(len);
    //打印结果为 6

#### replace ####

指定字符串的替代，返回值是String类型的数据。

String s = "你真是TMD";
    String result = s.replace("TMD","***");
    //                        替换   被替换
    System.out.println(result);
    //打印结果 你真是***
    
    //将TMD替换为***

#### split ####

指定字符串拆分，返回值是==String\[\]==类型的数组。

String s = "李四,23";
    String[] result = s.split(",");
    //指定,分割
    System.out.println(Arrays.toString(result));
    // 打印结果 [李四, 23]

#### substring ####

返回一个字符串，该字符串是此字符串的子字符串，返回值是String类型的数据。

String s = "abcdef";
    String result = s.substring(1);
    //返回从索引1开始的字符串
    System.out.println(result);
    //打印结果  bcdef

String s = "abcdef";
    String result = s.substring(1,3);
    //返回从索引1开始,到索引（3-1）的字符串
    //最大索引取不到
    System.out.println(result);
    //打印结果  bc

#### toCharArray ####

将字符串转化为新的字符数组，返回值是==Char\[\]==类型的数组。

String s = "abcdef";
    char[] result = s.toCharArray();
    System.out.println(Arrays.toString(result));
    //打印结果 [a, b, c, d, e, f]

#### toLowerCase ####

将所有字符串转化为小写，返回值是String类型的数据。

String s = "ABCDEF";
    String result = s.toLowerCase();
    System.out.println(result);
    //打印结果 abcdef

#### toUpperCase ####

将所有字符串转化为大写，返回值是String类型的数据。

String s = "abcdef";
    String result = s.toUpperCase();
    System.out.println(result);
    //打印结果 ABCDEF

#### equalsIgnoreCase ####

两个字符串比较 忽略大小写，返回值是Boolean 类型的数据

String s1 = "abcdef";
    String s2 = "ABCDEF";
    boolean result = s1.equalsIgnoreCase(s2);
    System.out.println(result);
    //打印结果 true

#### trim ####

去掉前导和尾随的空格，返回值是String 类型的数据

String s3 = "   abcdef    ";
    String result3 = s3.trim();
    System.out.println(result3);
    //打印结果 abcdef

###  S t r i n g B u i l d e r \\color\{red\}\{StringBuilder\} StringBuilder ###

#### 构造一个没有字符的字符串构建器，初始容量为16个字符。 ####

//构造一个没有字符的字符串构建器，初始容量16个字符
    StringBuilder sb = new StringBuilder();
    // int capacity返回当前容量
    int capacity = sb.capacity();
    System.out.println(capacity);
    //打印结果 16

#### append ####

将参数添加到序列中。

StringBuilder sb = new StringBuilder();
    StringBuilder sb1 = sb.append(100);
    System.out.println(sb1);
    //打印结果 100
    System.out.println(sb);
    //打印结果 100
    System.out.println(sb==sb1);
    //打印结果 true

#### reverse ####

反转字符串。

String line = "abcdef";
    StringBuilder result = new StringBuilder(line);
    System.out.println(result.reverse());

###  模拟用户登录 \\color\{red\}\{模拟用户登录\} 模拟用户登录 ###

public static void main(String[] args) {
        
    
        //登录名和密码
        String username = "root";
        String password = "123456";
        //创建一个输入的对象
        Scanner sc = new Scanner(System.in);
        //只允许最多输入3次密码
        for (int i = 0; i < 3; i++) {
        
            System.out.println("请输入用户名：");
            //在我们输入时去掉用户名前面的空格和末尾的空格
            String userName = sc.next().trim();
            System.out.println("请输入密码：");
            //在我们输入时去掉密码 前面的空格和末尾的空格
            String pwd = sc.next().trim();
            if(userName.equals(username)&&pwd.equals(password)){
        
                System.out.println("登录成功");
                break;
                //登录成功，结束循环
            }else{
        
                System.out.println("登录失败");
                System.out.println("还有"+(2-i)+"次机会");
            }
        }
    
    }

###  A r r a y L i s t \\color\{red\}\{ArrayList\} ArrayList ###

#### 构造方法 ####

##### 构造一个具有指定初始容量的空列表 #####

ArrayList arrayList = new ArrayList();
    System.out.println(arrayList);
    // 打印结果 []

##### 构造具有指定初始容量的空列表 #####

ArrayList arrayList = new ArrayList(20);
    System.out.println(arrayList);
    // 打印结果 []

#### 常用方法 ####

##### add #####

指定的元素追加到此集合的末尾。

ArrayList arrayList = new ArrayList();
    arrayList.add("张三");
    arrayList.add(100);
    arrayList.add(true);
    arrayList.add(3.14);
    System.out.println(arrayList);
    // 打印结果 [张三, 100, true, 3.14]

在此集合的指定位置插入指定的元素。

ArrayList arrayList = new ArrayList();
    arrayList.add(1,"李四");
    //在1索引处添加李四

##### get #####

返回此集合中指定位置的元素。

String result = arrayList.get(2);
    //返回的是 集合中2索引处的值。

##### remove #####

删除此集合指定位置的元素。

arrayList.remove(2);
    //删除集合中2索引处的元素。

删除此集合第一次出现的指定元素。

arraylist.remove("李四");
    //传入要删除的元素
    //如果存在就会删除，不存在不会影响其他的

##### isEmpty #####

判断此集合是否为空，返回值是boolean类型的数据。

boolean result = arrayList.isEmpty();
    //如果集合为空 ，返回true
    //如果集合不为空，返回false

##### set #####

用指定的元素替换此集合中指定位置的元素。

arrayList.set(1,"张三");
    //将此集合索引为1的元素替换为 张三

#### 泛型 ####

用来约束集合中存储数据的数据类型。

//格式：类名<数据类型>
    ArrayList<String> Lists = new ArrayList<>();
    //这里的String说明只能存储String类型的数据
    Lists.add("张三");
    Lists.add("100");
    System.out.println(Lists);
    //打印结果 [张三, 100]

#### 迭代器 ####

以正确的顺序返回该列表中元素的迭代器。

ArrayList<String> l = new ArrayList<>();
    //Iterator<E> iterator() 以正确地顺序返回该列表中元素地迭代器
    Iterator<String> iterator = l.iterator();
    while(iterator.hasNext()){
        
    	//当指针
        String s = iterator.next();
        System.out.println(s);
    }

#### ArrayList存储特点，有序可存储 ####