Java基础入门


Java

配置环境


系统环境变量设置

Name Value
JAVA_HOME D:/Environment/java/jdk-14.0.1
CLASSPATH ;%JAVA_HOME%/lib/dt.jar;%JAVA_HOME%/lib/tools.jar;
Path %JAVA_HOME%/bin;%JAVA_HOME%/jre/bin;

官方技术文档地址

IDEA 设置问题

在Project Structure中

  • 需要在Project指定Project SDK,和文件编译输出路径
  • 需要在Modules哪些可以标记为源码,仅被标记为源码的路径下右键可创建Java类文件

基础概述


HelloWorld

public class HelloWorld{
    public static void main(String[] args){
        System.out.println("HellWorld");
    }
}

**注意文件名和类名需要保持一致


基础


注释

单行注释
//单行注释
多行注释
/*
	多行注释
*/
文档注释
/**
	文档注释
*/

**常用快捷键

Ctrl+/ 单行注释(对当前行进行注释)
Ctrl+Shift+/ 对选中的代码多行注释

变量

  • 需要先声明才能使用,
  • 变量作用范围是当前代码块,同一个范围内不能重复声明同一个变量,
  • 输出前需要给变量赋值。

ASCII表

ASCII码值 控制字符 解释 ASCII码值 字符 解释 ASCII码值 字符 解释 ASCII码值 字符 解释
0 NUT 空字符 32 (space) 空格 64 @ 电子邮件符号 96 ` 开单引号
1 SOH 标题开始 33 ! 叹号 65 A 大写字母A 97 a 小写字母a
2 STX 正文开始 34 双引号 66 B 大写字母B 98 b 小写字母b
3 ETX 正文结束 35 # 井号 67 C 大写字母C 99 c 小写字母c
4 EOT 传输结束 36 $ 美元符 68 D 大写字母D 100 d 小写字母d
5 ENQ 请求 37 % 美元符 69 E 大写字母E 101 e 小写字母e
6 ACK 收到通知 38 & 和号 70 F 大写字母F 102 f 小写字母f
7 BEL 响铃 39 闭单引号 71 G 大写字母G 103 g 小写字母g
8 BS 退格 40 ( 开括号 72 H 大写字母H 104 h 小写字母h
9 HT 水平制表符 41 ) 闭括号 73 I 大写字母I 105 i 小写字母i
10 LF 换行键 42 * 星号 74 J 大写字母J 106 j 小写字母j
11 VT 垂直制表符 43 + 加号 75 K 大写字母K 107 k 小写字母k
12 FF 换页键 44 , 逗号 76 L 大写字母L 108 l 小写字母l
13 CR 回车键 45 减号/破折号 77 M 大写字母M 109 m 小写字母m
14 SO 不用切换 46 . 句号 78 N 大写字母N 110 n 小写字母n
15 SI 启用切换 47 / 斜杠 79 O 大写字母O 111 o 小写字母o
16 DLE 数据链路转义 48 0 字符0 80 P 大写字母P 112 p 小写字母p
17 DC1 设备控制1 49 1 字符1 81 Q 大写字母Q 113 q 小写字母q
18 DC2 设备控制2 50 2 字符2 82 R 大写字母R 114 r 小写字母r
19 DC3 设备控制3 51 3 字符3 83 S 大写字母S 115 s 小写字母s
20 DC4 设备控制4 52 4 字符4 84 T 大写字母T 116 t 小写字母t
21 NAK 拒绝接收 53 5 字符5 85 U 大写字母U 117 u 小写字母u
22 SYN 同步空闲 54 6 字符6 86 V 大写字母V 118 v 小写字母v
23 TB 结束传输块 55 7 字符7 87 W 大写字母W 119 w 小写字母w
24 CAN 取消 56 8 字符8 88 X 大写字母X 120 x 小写字母x
25 EM 媒介结束 57 9 字符9 89 Y 大写字母Y 121 y 小写字母y
26 SUB 代替 58 : 冒号 90 Z 大写字母Z 122 z 小写字母z
27 ESC 换码(溢出) 59 ; 分号 91 [ 开方括号 123 { 开花括号
28 FS 文件分隔符 60 < 小于 92 / 反斜杠 124 | 垂线
29 GS 分组符 61 = 等号 93 ] 闭方括号 125 } 闭花括号
30 RS 记录分隔符 62 > 大于 94 ^ 脱字符 126 ~ 波浪号
31 US 单元分隔符 63 ? 问号 95 _ 下划线 127 DEL 删除

数据类型

数据类型 关键字 取值范围 内存占用
整数 byte -128~127 1
整数 short -32768~32767 2
整数 int(默认) -2147483648~2147483647(10位数) 4
整数 long -9223372036854775808~9223372036854775807(19位) 8
浮点数 float 1.401298e-45~3.402823e+38 4
浮点数 double(默认) 4.9000000e-324~1.797693e+308 8
字符 char 0-65535 2
布尔 Boolean true,false 1

**整数、浮点数在赋值时,需要在值后标记,不标记赋值为默认类型

标识符和关键字

  • 标志符由数字、字母、下划线(_)和美元($)等组成
  • 不能以数字开头、不能是关键字、区分大小写
  • 标识符和类名遵守标识符规范,最好全英文,满足“驼峰模式”。

类型转换

自动类型转换

取值范围小类型的变量,可直接赋值给范围大的变量

**表达式中最终结果类型由表达式中最高类型决定

**表达式中,byte、short、char是直接(默认)转换为int类型参与运算。

强制类型转换

赋值时在变量前标注类型

//强制类型转换
public class Demo{
    public static void main(String[] args){
        int a =1500;
        byte b = (byte)a;
        System.out.println("HellWorld");
    }
}
//运行结果为-36
  • 强制换算超过取值范围会溢出
  • 浮点型强制转换整型,会直接丢弃小数部分,保留整数部分返回。

运算符

基本运算符
符号 作用
+
*
/
% 取余

**默认运算均为int类型

数据拆分案例
//拆分3位数,个位、十位、百位分别输出
public class Demo{
    public static void main(String[] args){
        int data =567;
        int gewei= data % 10 ;
        int shiwei = data / 10 % 10;
        int baiwei = data / 100;
        System.out.println(shiwei);
        System.out.println(gewei);
        System.out.println(baiwei);
    }
}
加符号作为连接运算符

字符串参与运算时,加号为拼接符,其余参与运算符。

自增自减运算符
符号 作用 说明
++ 自增 变量自身值增1
自减 变量自身值减1

自增自减运算符参与运算时放在变量前先自增自减再赋值,在后先赋值再自增自减。

//代码代换
public class Demo{
    public static void main(String[] args){
        int a = 10;
        int b = ++a; 
        /*
        int a = 10;
        a = a + 1;
        int b = a;
        */
        int c = 10;
        int d = c++;
        /*
        int c = 10;
        int d = c;
        c = c + 1;
        */
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
    }  
}
赋值运算符

扩展赋值运算符

符号 作用 说明
+= 加后赋值 a+=b等价于 a = (a的数据类型)(a + b);将a + b的值给a
-= 减后赋值 a-=b等价于 a = (a的数据类型)(a – b);将a – b的值给a
*= 乘后赋值 a*=b等价于 a = (a的数据类型)(a * b);将a * b的值给a
/= 除后赋值 a/=b等价于 a = (a的数据类型)(a / b);将a / b的值给a
%= 取余后赋值 a%=b等价于 a = (a的数据类型)(a % b);将a % b的值给a
关系运算符

关系运算符为条件判断,成立为true,不成立为false,输出结果为Boolean类型。

符号 说明
== a==b,判断a和b是否相等
!= a!=b,判断a和b是否不等
> a>b,判断a是否大于b
>= a>=b,判断a大于等于b
< a<b,判断a小于b
<= a<=b,判断a小于等于b
逻辑运算符
符号 介绍 说明
& 同true为true,其余为false
| 有true为true,其余为false
! 结果取反
^ 异或 不同为true,相同为false
符号 介绍 说明
&& 短路与 与“&”判断结果一致,但是左侧false右侧就停止运算(节省运算资源)
|| 短路或 与“|”判断结果一致,但是左侧true右侧就停止运算(节省运算资源)
三元运算符

格式:条件表达式 ?值1 :值2;条件表达式为true返回值1,false返回值2,

//判断两值是否相等
//代码代换
public class Demo{
    public static void main(String[] args){
        int a=2,b=2;
        String c;
        c = a == b ? "相等" : "不等";
        /*
        int a=2,b=2;
        String c;
        boolean d;
        d = a == b;
        if (d == true) {
            c = "相等";
        }else {
            c ="不等";
        }
	   */
        System.out.println("两值" + c);
    }
}
优先级问题
优先级 运算符
1 ()
2 !、-、++、–
3 *、/、%
4 +、-
5 <<、>>、>>>
6 <、<=、>、>=、instanceof
7 ==、!=
8 &
9 ^
10 |
11 &&
12 ||
13 ?:
14 =、+=、-=、*=、/=、%=、&=

API 介绍

API : Application Programming Interface应用程序编程接口;

调用导入对应包即可

//获取键盘输入内容
//判断两值是否相等
import java.util.Scanner;
public class Demo{
    public static void main(String[] args){
        int a,b;
        String c;
        Scanner Sc = new Scanner(System.in);
        System.out.println("输入一个数个数");
        a = Sc.nextInt();
        System.out.println("输入下一个数");
        b = Sc.nextInt();
        c = a == b ? "相等" : "不等";
        System.out.println("两值" + c);
    }
}

程序流程控制

分支结构

if
//if格式
public class Demo{
    public static void main(String[] args){
        /*true时执行后方代码块,false则跳过,执行一个代码块后结束,
        if (条件表达式) {
        	语句体1;//
        }else if(条件表达式) {
        	语句体2;
        }
        	...
        else{
        	语句体n+1;
        }
        */
    }
}
switch、switch穿透性
//switch格式
public class Demo{
    public static void main(String[] args){
        /*表达式匹配执行对应代码块,无匹配执行default代码块。
        switch (表达式) {
        	case 值1:
        		执行代码1;
        		break;
        	case 值2:
        		执行代码1;
        		break;
        	...
         	case 值n-1:
        		执行代码n-1;
        		break;            
        	default:
        		执行代码n;       		
        }
        */
    }
}

**当switch中case不写break会穿透,实现多值执行一个代码段,消除代码冗余。

循环结构

for循环
//for循环格式
import java.util.Scanner;
public class Demo{
    public static void main(String[] args){
        /*满足条件执行循环语句,不满足结束循环体
        for (初始化语句 ;循环条件 ;迭代语句) {
        	循环语句;
        }
        */
        //循环a次,a通过键盘输入。
        Scanner Sc = new Scanner(System.in);
        System.out.println("循环几次?");
        int a = Sc.nextInt();
        int a = 3;
        for (int i = 0; i < a; i++){
        	System.out.println("hello world");
        }
    }
}
while循环
//while循环
import java.util.Scanner;
public class Demo{
    public static void main(String[] args){
        /*满足条件执行循环语句,不满足结束循环体
        初始化语句;
        while (循环条件){
        	循环语句;
        	迭代语句;
        }
        */
        //循环a次,a通过键盘输入。
        Scanner Sc = new Scanner(System.in);
        System.out.println("循环几次?");
        int a = Sc.nextInt();
        int i = 0;
        while (i < a){
            System.out.println("hello world");
            i++;
        }
    }
}
do-while循环
//do-while循环
import java.util.Scanner;
public class Demo{
    public static void main(String[] args){
        /*先执行语句再判断是否进行循环
        初始化语句;
        do {
        	循环语句;
        	迭代语句;
        } while (循环条件);
        */
        //循环a次,a通过键盘输入。
        Scanner Sc = new Scanner(System.in);
        System.out.println("循环几次?(默认一次)");
        int a = Sc.nextInt();
        int i = 0;
        do {
            System.out.println("hello world");
            i++;
        } while (i < a);
    }
}

**break; 结束当前所在循环执行。(只能在switch和循环中使用,不能单独用于if)

//break循环
import java.util.Scanner;
public class Demo{
    public static void main(String[] args){
        //循环a次,a通过键盘输入。
        Scanner Sc = new Scanner(System.in);
        System.out.println("循环几次?最大为5次");
        int a = Sc.nextInt();
        int i = 1;
        while (i <= a){
            System.out.println("这是第" + i + "次重复hello world");
            i++;
            if ( i == 5) {
                break;
            }
        }
    }
}

**continue; 跳出当前循环的当次循环,进入下一次循环。

//continue循环
import java.util.Scanner;
public class Demo{
    public static void main(String[] args){
        //循环a次,a通过键盘输入。
        Scanner Sc = new Scanner(System.in);
        System.out.println("循环几次?拒绝打印第5次");
        int a = Sc.nextInt();
        int i = 0;
        while (i <= a){
            i++;
            if ( i == 5) {
                continue;
            }
            System.out.println("这是第" + i + "次重复hello world");
        }
    }
}
随机数Random
//生成a组b长度的数字
import java.util.Random;
import java.util.Scanner;
public class Demo{
    public static void main(String[] args){
        Random Number = new Random();
        //a通过键盘输入。
        Scanner Sc = new Scanner(System.in);
        System.out.println("生成几组随机密码?");
        int a = Sc.nextInt();
        System.out.println("每组密码几位数?");
        int b = Sc.nextInt();
        for (int i = 0; i <= a; i++){
            for (int j = 1; j <= b; j++){
                int data = Number.nextInt( 10) ;
                System.out.print(data);
            }
            System.out.println();
        }
    }
}

数组Array

数组定义,访问,注意事项

数组是用来存储一批同种类型数据的内存区域
静态初始化数组

定义

//完整格式
/*
数据类型[] 数组名 = new 数组类型[]{元素1,元素2,元素3,...};
 */
//简化格式
/*
数据类型[] 数组名 ={元素1,元素2,元素3,...};
 */

访问

//数组首位元素编号从0开始
//取值
System.out.println(arr[0]);
//赋值
arr[2] = 1 ;
System.out.println(arr[2]);
//获取数组的长度,数组的元素个数
System.out.println(arr.length);

**数组一但定义长度、类型就固定,访问超出最大个数位置,会报数组索引越界异常错误

**类型定义后,数组内不能存放其他类型数据

动态初始化数组

定义

/*
数据类型[] 数组名 = new 数组类型[长度];
*/
int[] arr = new int[10];

元素默认值

数据类型 明细 默认值
基本类型 byte、short、char、int、long 0
float、double 0.0
boolean false
引用类型 类、接口、数组、String null

*两种初始化格式严格独立,不可混用

数组的遍历
格式
格式
for ( int i = 0; i < array.length ; i++ ){//遍历快捷键-数组名.fori
	a = array[i] +a ;
}
//求a个数的平均数,a通过键盘输入。
import java.util.Scanner;
public class Demo{
    public static void main(String[] args){
        //创建数组,并将每个数存入数组
        Scanner Sc = new Scanner(System.in);
        System.out.println("求几个数的平均数?");
        int a = Sc.nextInt();
        System.out.println("输入所有数字,回车间隔");
        int[] array = new int[ a ];
        for (int i = 0; i < a; i++ ) {
            int b = Sc.nextInt();
            array[i] = b ;
        }
       
        //计算数组所有元素的平均数
        System.out.println("平均数:"); 
        double c = 0;
        for ( int i = 0; i < array.length ; i++ ){//遍历快捷键-数组名.fori
            c = array[i] + c ;
        }
        /*代码代换
        double c = 0;
        for (int value : array) {
        	c = value + c;
        }
        */
        c = c / array.length;
        System.out.println(c);
        //遍历数组取出最高值
        System.out.println("最大值为:");  
        int d = array[0];
        for ( int i = 0; i < array.length ; i++ ){
            if ( d < array[i]){
                d = array[i];
            }
        }
        System.out.println(d);  

    }
}
冒泡排序

每次从数组中找出最大值,最大的元素向后移动

import java.util.Scanner;
public class Demo{
    public static void main(String[] args){
        //创建数组,并将每个数存入数组
        Scanner Sc = new Scanner(System.in);
        System.out.println("几个数排序?");
        int a = Sc.nextInt();
        System.out.println("输入所有数字,回车间隔");
        int[] array = new int[ a ];
        for (int i = 0; i < a; i++ ) {
            int b = Sc.nextInt();
            array[i] = b ;
        }

        //冒泡排序
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - i - 1; j++) {
                if (array[j] > array[j+1]){
                    int temp = array[j+1];
                    array[j+1] = array [j];
                    array[j] = temp;
                }
            }
        }
        //遍历输出数组中元素
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + "/t");
        }
    }
}
数组与内存的存储的关系

数组内容是存在堆内存内,数组变量中存储的是内容的类型和内存地址

Array&Memory

**访问超出最大索引时,会报数组索引越界异常错误ArraylndexOutOfBoundsException,程序会在越界处报错结束。

**如果数组变量中没有存储数组的地址,而是null,在访问数组信息时会出现NullPointerException(空指针异常)

Debug工具

启用断点后可逐行执行代码

方法Method

方法的定义

/*方法格式
修饰符 返回值类型 方法名(形参列表){
	方法体代码(需要执行的代码)
	return 返回值;
}
*/
//示例,加法器
public static int add (int a, int b ){
    int c = a + b;
    return c;
}
//调用 方法名(传入参数)
	int data = add( 10 , 20 );

**无返回值,无参数方法调用

public static void 方法名(){
	System.out.print("hello world!");
}

**方法与方法直接是平行关系,不能嵌套定义

**方法的返回类型为void时,方法内不能使用return返回数据,如果方法的返回值写了具体类型,防范内部必须使用return对应的类型数据

**return语句下方代码不执行,属于无效代码;

**方法不调用时不执行,调用时必须严格匹配方法的参数情况;

**方法返回值可以定义变量接收,也可以直接输出调用,无返回值方法只能直接调用。

方法的内存原理

Method&Memory

** 方法在栈内存运行,方法先进后出

方法参数传递机制

基本类型的参数传递

传输实参给形参时,不是传输实参变量本身,而是将实参变量中储存的值,这就是值传递。

**实参:方法内部定义的变量

**形参定义方法时,”()”中声明的参数

引用类型的参数传递

引用传递时,传递的是引用的堆内存地址Method&Memory2

方法重载

同一个类中,出现多个方法名称相同,但是形参列表不同,那么这些方法就是方法重载

**只要时同一个类中,方法名称相同,形参列表不同,即是方法重载(不考虑如:修饰符,返回值类型等)

**形参列表不同指的是形参的个数、类型、顺序不同,不是形参的名称

return关键字

当单独在时,可以跳出当前执行的方法,并直接结束该方法。

案例

随机密码生成

业务需求:需要根据键盘键入数据确定生成几组多长的随机字符串

package src;
//求a个数的平均数,a通过键盘输入。
import java.util.Random;
import java.util.Scanner;

public class Demo {
    public static void main(String[] args) {
        //创建数组,并将每个数存入数组
        Scanner Sc = new Scanner(System.in);
        System.out.println("随机几位密码?");
        int a = Sc.nextInt();
        System.out.println("随机几组?");
        int b = Sc.nextInt();
        for (int i = 0; i < b ; i++) {
            System.out.println(Randombytes(a));
        }
    }
	//生成一组随机字符
    public static String Randombytes(int HowLong) {
        Random RandomNumber = new Random();
        String Codes = "";
        for (int i = 0; i < HowLong; i++) {
            int type = RandomNumber.nextInt(3);
            switch (type) {
                case 0:
                    char ch = (char) (RandomNumber.nextInt(26) + 65);//随机出一个大写字母
                    Codes += ch;
                    break;
                case 1:
                    char ch1 = (char) (RandomNumber.nextInt(26) + 97);//随机出一个小写字母
                    Codes += ch1;
                    break;
                case 2:
                    Codes += RandomNumber.nextInt(10);//随机出一位阿拉伯数字
                    break;
            }
        }
        return Codes;
    }
}

数组的复制

public static void CopyArrs(int[] arr1,int[] arr2){
    for (int i = 0; i < arr1.length; i++) {
		arr2[i] = arr1[i];
    }
}

双色球系统开发

业务需求:生成一组7位随机数,组内数据不重复,和一个单独数

import java.util.Random;
public class Demo {
    public static void main(String[] args) {
        //输出一组双色球彩票
        System.out.println("本次双色球号码为:");
        for (int i = 0; i < 6; i++) {
            System.out.print(CreateLuckNumbers(6) [i] +"/t");
        }
        System.out.println();
        System.out.println("幸运号码是:");
        Random RandomNumber = new Random();
        int RN = RandomNumber.nextInt(33) + 1;
        System.out.println(RN);
    }
//生成一个HowLong长度的双色球数
    public static int [] CreateLuckNumbers(int HowLong) {
        Random RandomNumber = new Random();
        int[] arr = new int[HowLong];
        for (int i = 0; i < arr.length; i++) {
            int RN = RandomNumber.nextInt(33) + 1;
            boolean flag =true;
            for (int j = 0; j < arr.length; j++) {
                if (arr[j] == RN){
                    flag =false;
                    i -= 1;
                    break;
                }
            }
            if (flag){
                arr [i] = RN;
            }
        }
        return arr;
    }
}

面向对象编程基础Object Oriented Programming

概述

需要创建一个东西后再进行编程,这个东西就是对象

设计对象、注意事项

**先设计类才能创建对象并使用

类:是对象的共同特征的描述。

对象:是真实存在的具体实例。

//设计类
public class 类名 {
	1.成员变量(代表属性,一般是名词)
	2.成员方法(代表行为,一般是动词)
	3.构造器
	4.代码块
	5.内部类   
}
//如何创建类
类名 对象名 = new 类名();
//使用对象
	//访问属性
	对象名.成员变量;
	//访问行为
	对象名.方法名(...);

**类名首字母大写,满足“驼峰模式”,不能用关键字,必须是合法标识符,且有意义

**一个Java文件可以定义多个class类,但是只能有一个是public修饰,且public修饰的类名必须为文件名

**成员变量完整定义格式是:修饰符 数据类型 变量名 = 初始化值;

一般无需指定初始化值,默认规则为

类型 默认值
byte、short、int、long 0
double、folat 0.0
boolran false
String等引用类型 null

内存机制

ObjectOrientedProgramming&Memory

**对象存在于堆内存中,创建引用时,变量名内存储的时对象在堆内存中的地址

垃圾回收机制

当堆内存中引用对象不存在任何内存引用它时(栈内存引用这个对象的变量引用地址设置为null),Java会自动清除堆内存地址内数据.

int[] arr = new int [10];//在堆内存中创建一个长度为10的数组空间,引用为arr
arr = null;//arr堆内存引用地址设置为null;Java会自动释放堆该地址内存

构造器Constructor

//创建构造器
修饰符 类名(形参列表){
    ...
}
//调用构造器
类名 变量名称 = new 构造器;

**无参数构造器初始化时,成员变量数据均采用默认值

**有参数构造器在初始化对象时,同时接受参数为对象进行赋值

**一个类中默认自带无参数构造器,一但定义有参数构造器,无参数构造器就不存在了,如果还想使用无参数构造器,需要单独手写一个

this关键字

**this可用于构造器,方法中,代表当前对象地址。

this.变量名//引用当前构造器中的变量值

封装

private//私有修饰词,修饰的变量只能在本类中,不能在其他类中被引用和赋值
public//修饰的setter和getter方法来获取值和赋值    

标准JavaBean

即为实体类,其对象可以用于在程序中封装数据

** 成员变量必须使用private修饰

**提供成员变量的对应的getter /setter方法

**必须提供一个无参构造器,(有参构造器可有可无)

常用API

String

String被称为不可变字符串类型,他的对象创建后不可被更改

String

**运算时只是定义的String变量储存的引用地址发生变化,指向新的字符串储存地址,以””方式直接给出的字符串对象,在字符串常量池中储存,而且相同的值储存一次

**通过构造器new出来的对象,每new一次都会产生一个新对象存在堆内存中

**String进行比较时使用equias方法进行比较,只要内容一致即返回true(String变量名.equias(要比较的String变量名))

        String a1 = "我";
        String a2 = "爱";
        String a3 = "中";
        String a4 = "国";
        String a5 = "我爱中国";
        String a6 =  a1 + a2 + a3 + a4;
        System.out.println(a6);
        System.out.println(a5 ==a6);//false,比较两个字符串变量的引用地址
        System.out.println(a5.equals(a6));//ture

String常用API

方法名 说明
public int length() 返回字符串长度
public char charAt(int index) 获取某个索引位置处的字符
public char[] toCharArray(): 将当前字符串转换成字符数组返回
public String substring(int beginIndex,int endIndex) 根据开始和结束说因进行截取,得到新的字符串(包前不包后)
public String substring(int beginIndex) 从传入的索引出截取,截取到末尾,得到新的字符串
public String replace(CharSequence target, CharSequence repalcement) 使用新值,将字符串中的旧值替换,得到新的字符串
public String[] split(String regex) 根据传入的规则切割字符串,得到字符串数组返回

String案例

验证码
//用字符串遍历法设计一个验证码生成器
import java.util.Random;
import java.util.Scanner;
public class Demo {
    public static void main(String[] args) {
        Scanner Sc = new Scanner(System.in);
        System.out.println("取多长的字符串?");
        int a = Sc.nextInt();
        System.out.println(CAPTCHA(a));
    }

    //生成一个包含0-9,a-z,A-Z的HowLong长度的验证码
    public static String CAPTCHA(int HowLong) {
        String db = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
        Random r =new Random();
        String codes = "";
        int a = HowLong;
        for (int i = 0; i < a; i++) {
            int index =r.nextInt(db.length());//获取字符串长度,并随机出比长度小的值index
            char c = db.charAt(index);//获取index位置的字符
            codes += c;
        }
        return codes;
    }
}

ArrayList

集合长度不固定,启动后可以动态变化,类型也可以选择不固定,

ArrayList常见功能

创建一个ArrayList对象
	ArrayList list = new ArrayList()
添加元素
	list.add("Java");
	list.add("MySQL");
	list.add("中国");
指定索引位置插入元素(指定位置开始元素后移)
	list.add(1,"世界");
	System.out.println(list);

ArrayList对泛型的支持

ArrayList为泛型类,可在编译阶段约束集合内对象只能操作某种数据类型

	ArrayList<String>//只操作字符串类型的元素
    ArrayList<Integer>//只操作整数类型的元素

集合只能存储引用类型,不支持基本类型(int和Integer是存在区别的,集合中不可使用int类型)

**默认泛型为String,如果希望所有数据类型都支持,泛型要标注为Object。

ArrayList常用API

方法名称 说明
public E get(int index) 返回某个位置处的索引
public int size() 返回集合中元素个数
public E remove(int index) 删除某个索引处的元素,返回被删除的元素
public boolen remove(Object o) 删除指定元素,返回删除是否成功
public E set(int index,E element) 修改索引处的元素返回被修改的元素
import java.util.ArrayList;
public class Demo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList();
        list.add("Java");
        list.add("Java");
        list.add("MySQL");
        list.add("MyBatis");
        list.add("Html");
        //1.获取某个索引处的元素值
        System.out.println(list);
        System.out.println(list.get(2));
        //2.获取集合的大小
        System.out.println(list.size());
        //3.删除某个索引处的元素,并返回这个元素
        System.out.println(list.remove(0));
        System.out.println(list);
        //4.删除指定某个元素,返回是是否删除成功,如果有多个元素,默认删除索引值小的
        System.out.println(list.remove("Java"));
        //5.集合遍历
        for (int i = 0; i <list.size() ; i++) {
            System.out.println(list.get(i));
        }
        	//一般使用倒着遍历,避免寻址溢出
        	for (int i = list.size() - 1; i >= 0 ; i--) {
                System.out.println(list.get(i));
            }
        //修改索引处的元素返回被修改的元素
        System.out.println(list.set(0, "if"));
    }
}

案例

Java的简单的ATM系统实现

原创文章,作者:ItWorker,如若转载,请注明出处:https://blog.ytso.com/282685.html

(0)
上一篇 2022年8月28日
下一篇 2022年8月28日

相关推荐

发表回复

登录后才能评论