Java基础入门

2022/8/28 14:22:47

编程Tag： string 基础入门 Java int out system public println

本文主要是介绍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系统实现

这篇关于Java基础入门的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！