首页 > 编程语言 >Java基础入门

Java基础入门

时间：2022-08-28 12:45:03浏览次数：74  
标签：Java 入门 int 基础 System String println public out

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,入门,int,基础,System,String,println,public,out
From： https://www.cnblogs.com/undercure/p/16632556.html

相关文章

  • 数字电子技术基础（阎石）课后习题（未完持续更新中）
    第一章：数制和码制1.1为了将600份文件顺序编码，如果采用二进制代码，最少需要用几位？如果改用八进制或十六进制代码，则最少各需要用几位？1.2将下列二进制整数转换为等值的......
  • 6.8 python基础列表元素的添加操作
     #append（）list=[10,20,30,40,50,60,70,80]#列表后面添加元素，可以施单个元素或列表整体list.append(20)#后面添加单个元素print(list)list.append([30,90])#后面......
  • Java synchronized锁升级过程验证
    ​Java对象结构 ​  一个对象包括三部分：对象头实例数据对其填充 对象头：MarkWord：用于存储对象自身运行时的数据，如哈希码(HashCode)，GC分代年龄，锁状态标志，......
  • java反射技术的简单应用
    一.反射介绍java反射技术的应用广泛，能够对类的方法和参数进行配置，完成对象的初始化工作，增加了java的灵活性，SpringIOC也使用了反射技术，下文主要讲解对象的构建和方法的反射......
  • javascript(一) Array对象, Object对象, this关键字，短路操作，Set集合，Map集合和String字
    javascript基础1，主要写(==和===的区别),Array对象,Object对象,this关键字，短路操作，Set集合，Map集合和String字符串操作。1.==,===1.===在js中需要值相等类型相等......
  • JavaScript Window Location
    JavaScriptWindowLocation https://www.w3school.com.cn/js/js_window_location.aspwindow.location对象可用于获取当前页面地址（URL）并把浏览器重定向到新页面。Win......
  • java内部类
    一、基本介绍一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类（innerclass），嵌套其他类的类称为外部类（outerclass）。是我们类的第五大成员类的五大成员：属性......
  • Java – IO
    字节流和字符流的区别字节流是由字节组成的，处理单元为一个字节，操作字节和字节数组。字符流是由字符组成的，处理单元为2个字节的Unicode字符，操作字符，字符数组或字符串......
  • JS基础学习(一)函数和对象
    函数定义方式1.第一种functionabs(x){if(x>=0){returnx;}else{return-x;}}2.第二种变量赋值的形式,注意最后有一个分号";......
  • javascript:void(0) 含义
    javascript:void(0)含义|菜鸟教程 https://www.runoob.com/js/js-void.html我们经常会使用到 javascript:void(0) 这样的代码，那么在JavaScript中 javascript:vo......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99