每一个追梦的人，付出的努力都不会白费，诸君共勉。
文章目录
目录
5、自增、自减运算符
三、尝试调用简单的api（application program interface）
前言
Java是一门热门的编程语言，在诸多领域Java都有所涉及。
举个栗子:
public class Hello{
public static void main(String[] args){
System.out.println("Hello world!");//输出Hello World
}
}此处罗列出一些idea常用快捷键操作:
psvm->public static void main(){}
sout->System.out.println();
arr.fori=for(i=0;i<arr.length;i++){}
option+command+m->抽取方法
shift+f6->全局变量修改
option command t->把一段代码改为循环
control+fn+回车->构造方法
提示：以下是本篇文章正文内容，下面内容可能有误仅供参考。
一、Java的运行机制
Java将源文件（.java）编译成为字节码（.class）文件,将字节码文件加载在虚拟机（Jvm）中运行，因此Java有很强的跨平台性，常应用于互联网相关服务。
jdk=jvm（虚拟机）+核心类库+开发工具
二、Java的基础知识
1.标识符与关键字
标识符应以英文字母或者下划线组成，不可以与关键字重复定义。所谓的关键字是指系统本身命名使用的名字。例如：public（公开的）、class（类）。
2.数据类型
Java语言中并不像c语言有指针指向地址，它使用一种名为引用数据类型的方法代替了指针的效果。Java的数据类型分为两大类，分别是基本数据类型和引用数据类型。
/*
基本数据类型：
数值类型：byte（字节）、short、int、long。
浮点类型：float、double
boolean（布尔）类型：true、false
注：通常情况下，我们定义使用int和double
引用数据类型：
类
数组
接口
*/
//相信大家看到这块内容应该知道Java怎么用注释了吧（笑）3、数据类型的转换
Java不同类型的数据需要转换成同一类型才可以计算，在实际开发过程中，对数据类型进行转换是我们时常做的一件事情。
1、自动转换：
代码总是自动从数据范围低的转向数据范围高的。
低--------------------------------->高
byte,short,char,int,long,float,double
public class 计算圆的面积 {
public static void main(String[] args) {
getArea(1.5);
}
//***********计算一个圆的面积，半径1.5自动转换成了double类型************
public static void getArea(double radius) {
double result=radius*radius*3.14;
System.out.println(result);
}
}2、强制转换
在一些时候为了达到我们的目的，我们需要对代码进行强制数据类型转换，具体操作方法如下：
格式：（范围小的类型）+范围小的变量名=（范围小的类型）+原本范围大的数据。
class Untitled {
public static void main(String[] args) {
//a从double被强制转换成为int（整数）类型，并赋值给b。
double a=36.12213;
int b=(int) a ;
System.out.println(b);
}
}注意：
（1）转换时可能会出现数据丢失的情况。
（2）布尔类型不可以进行任何的数据转换。
（3）在计算时整数会转换为int，浮点会转换成double。
4、常量和变量的定义
1、常量
定义：在程序运行期间不可修改的量，其存放数据的空间不会随着函数结束调用而释放。
格式： final type varName =value;
例：final double PI=3.14
常量的命名：全用大写字母，单词之间下滑线隔开。
为了更好的区分和表述，一般将1、23'a'b’truefalse "helloWorld等称为字符常量，而使用final修饰的PI等称为符号常量。
2、变量
1、变量的定义
随时都可以发生变化的量，是最基本的存储单元，要素包括变量名，变量类型和作用域。
public class 三数求和 {
public static void main(String[] args) {
System.out.println(getSum(1,2,3));
}
//相信各位都可以看得懂（👀）求三数之和
public static int getSum(int n1,int n2,int n3){
int result=n1+n2+n3;
return result;
}
}2、变量的作用域
变量分为成员变量和局部变量。
成员变量：写在方法的外面类的里面，不需要手动赋予初始值（每个数据类型有自己默认的数据类型）。
局部变量：写在方法里面的变量（包括main方法），必须进行声明和初始化，随着方法被调用创建，随着方法结束调用消失。
5、运算符
1、算数运算符
+、-、*、/、%（取余数）
public class 比较长方形面积 {
public static void main(String[] args) {
int area1=getArea(1,2);
int area2=getArea(4,2);
compare(area1,area2);
}
//比较两个长方形的面积
public static int getArea(int length,int width){
int area=length*width;
return area;
}
public static void compare(int a1,int a2){
if(a1>a2){
System.out.println(a1);
}else{
System.out.println(a2);
}
}
}2、赋值运算符
注：只有变量才可以进行运算
(1)a=b-------->把b的值赋予给a
(2)+=--------->a=a+b------->把a+b的值赋予给a
(3)-=---------->a=a-b------->把a-b的值赋予给a
(4)/=---------->a=a/b------->把a/b的值赋予给a
(5)%=-------->a=a%b------>把a%b的值赋予给a
(6)*=--------->a=a*b------->把a*b的值赋予给a
3、关系运算符
<（小于）、>（大于）、>=（大于等于）、<=（小于等于）、==（相等）、!=（不想等）
关系运算符返回值为boolean类型，且不可以多次连续的判断，如想要多次连续的判断需要使用到逻辑运算符。
4、逻辑运算符
&&（按位于）、||（按位或）、！（非）
（表达式1&&表达式2）：只有表达式1和2都为真的时候结果才为真，由此可见如果表达式1为假那么结果直接为假，计算机不再进行表达式2的判断。
（表达式1||表达式2）：只有表达式1和2都为假的时候结果才为假，由此可见如果表达式1为真那么结果直接为真，计算机不再进行表达式2的判断。
（！表达式1）：与表达式1的boolean值取反。
public class 抢红包 {
public static void main(String[] args) {
//随机抢红包
int[] arr = {2, 588, 888, 8888, 66666};
int[] newarr = new int[arr.length];
Random r = new Random();
for (int i = 0; i < 5; ) {
int RandomInedx = r.nextInt(arr.length);
int prize = arr[RandomInedx];
boolean flag=contains(newarr,prize);
if(!flag){
newarr[i]=prize;
i++;
}
}
for (int i = 0; i < newarr.length; i++) {
System.out.println(newarr[i]);
}
}
public static boolean contains(int[] arr, int prize) {
for (int i = 0; i < arr.length; i++) {
if (arr[i] == prize) {
return true;//抽过被标记为true
}
}
return false;
}
}5、自增、自减运算符
++、--
class Untitled {
public static void main(String[] args) {
int a=10;
//等于a-1
a--;
//等于a+1
a++
//因为加一减一输出的a还等于10
//注：sout是System.out.println()的缩写，为了代码整洁度（懒）后文会采用此种描述方法
sout(a)
}
}三、尝试调用简单的api（application program interface）
1、Scanner
Scanner让用户方便对变量赋值
用法：
（1）导入Scanner类（注意大小写不可以随便改变） import Java.until.*;
（2）创建Scanner对象 Scanner sc=new Scanner（System.in);
(3)创建变量int a=sc.nextInt();注：此处的nextInt和前面的定义的变量有关，如果数据类型改变，所需要调用的方法也不同。
next（）输入字符串
nextInt（）输入整数
nextDouble（）输入小数
import Java.until.*
class Untitled {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int a=sc.nextInt();//输入a的数值
}
}2、Random
Random让用户方便的产生一些随机数
用法
（1）导入Random类（注意大小写不可以随便改变） import java.util.Random;
（2）创建Random对象 Random r=new Random（）;
(3)创建变量int a=r.nextInt(n);注：此处的n表示生成一个从0-n-1的随机数
例：int a=r.nextInt(10);生成一个0到9 的随机数。
如果想要生成一个从1到10的随机数可以采取int a=r.nextInt(10)+1;
import java.util.Random;
import java.util.Scanner;
//模拟双色球中奖情况
//游戏规则：有6个红色球和一个蓝色球。红球数字不会重复，蓝球数字可以和红球重复
//输入七个数字，和中奖号重复的数字越多获得的奖项越靠前，且不计顺序
public class 模拟双色球 {
public static void main(String[] args) {
/*
1、生成中奖号码
*/
int[]arr=create();
System.out.println("******");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
System.out.println();
System.out.println("******");
int[] use=user();
int redCount=0;
int blueCount=0;
int redNumber=redCnt(arr, use, redCount);
int blueNumber=blueCnt(arr[arr.length - 1], use[use.length - 1], blueCount);
System.out.println(redNumber);
System.out.println(blueNumber);
if (redNumber==6&&blueNumber==1){
System.out.println("1000w");
}else if(redNumber==6&&blueNumber==0){
System.out.println("500w");
}else if(redNumber==5&&blueNumber==1){
System.out.println("3000");
}else if((redNumber==5&&blueNumber==0)||(redNumber==4&&blueNumber==1)){
System.out.println("200");
}else if((redNumber==4&&blueNumber==0)||(redNumber==3&&blueNumber==1)){
System.out.println("10");
}else if((redNumber==2&&blueNumber==1)||(redNumber==1&&blueNumber==1)){
System.out.println("5");
}else {
System.out.println("谢谢参与！！！");
}
}
private static int blueCnt(int i, int blueNumber1, int blueCount) {
int blueNumber= blueNumber1;
if(blueNumber== i){
blueCount++;
}
return blueCount;
}
private static int redCnt(int[] arr, int[] use, int redCount) {
for (int i = 0; i < use.length-1; i++) {
int redNumber= use[i];
for (int i1 = 0; i1 < arr.length-1; i1++) {
if(redNumber==arr[i1]){
redCount++;
break;
}
}
}
return redCount;
}
public static int[] user() {
int[] arr = new int[7];
Scanner sc = new Scanner(System.in);
for (int i = 0; i < 6; ) {
System.out.println("输入第" + (i + 1) + "个号码");
int redNumber = sc.nextInt();
if (redNumber >= 1 && redNumber <= 33) {
boolean flag = contains(arr, redNumber);
if (!flag) {
arr[i] = redNumber;
i++;
} else {
System.out.println(false);
}
}
}
System.out.println("输入蓝球号码");
while (true) {
int blueNumber = sc.nextInt();
if (blueNumber >= 1 && blueNumber <= 16) {
arr[arr.length - 1] = blueNumber;
break;
} else {
System.out.println(false);
}
}
return arr;
}
public static int[] create() {
/*
1、创建数组用于添加中奖号码
2、6个红球 1个蓝球 数组长度：7
*/
int[] arr = new int[7];
//红球号码不可以重复，蓝球可以和红球重复
Random r = new Random();
for (int i = 0; i < 6;) {
int redNumber = r.nextInt(33) + 1;
boolean flag=contains(arr,redNumber);//判断重复
if(!flag){
arr[i]=redNumber;
i++;
}
}
int blueNumber=r.nextInt(16)+1;
arr[arr.length-1]=blueNumber;
return arr;
}
public static boolean contains(int[] arr, int number) {
for (int i = 0; i < arr.length; i++) {
if (arr[i] == number) {
return true;
}
}
return false;
}
}四、三种基本条件结构（if、switch、while/for）
1、if选择结构
(1)表达式中判断为true就执行大括号内的语句，false就跳过大括号内的语句，继续执行接下来的代码。
if（表达式）{
语句;
}
(2)表达式1为true执行语句1，结束条件判断；表达式1为假继续判断表达式2，程序同上。
if(表达式1){
语句1;
}else if(表达式2){
语句2;
}
(3)表达式1为true执行语句1，结束条件判断；表达式1为假继续判断表达式2，程序同上。如果所有的判断都是假，那么就执行else中的语句。
if(表达式1){
语句1;
}else if(表达式2){
语句2;
}......else{
语句n;
}
import java.util.Scanner;
public class 卖飞机票 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入机票的原价");
int ticket=sc.nextInt();
System.out.println("当前的月份");
int month=sc.nextInt();
System.out.println("输入仓位0头等1经济");
int seat=sc.nextInt();
int tag=0;
if(month>5&&month<=10){
if(seat==0){
ticket=(int)(ticket*0.9);
}else if(seat==1){
ticket=(int)(ticket*0.85);
}else{
System.out.println(false);
tag=1;
}
}else if((month>=1&&month<=4)||(month>=11&&month<=12)){
if(seat==0){
ticket=(int)(ticket*0.7);
}else if(seat==1){
ticket=(int)(ticket*0.65);
}else{
System.out.println(false);
tag=1;
}
}else {
System.out.println(false);
tag=1;
}
if(tag==0)
System.out.println("您的机票价格为"+ticket);
}
}2、switch选择结构
1、break关键字
break在循环或者选择结构运行中可以进行中断。
2、default关键字
case匹配失败后执行，类似于else。
3、continue关键字
continue可以跳过本次循环，进入下一次循环中。
4、switch的用法
基础用法：
switch(表达式){
case value1 :
语句块 1;
case value2 :
语句块 2;
case value3 :
语句块 3;
…
case valueN :
语句块 N;
}
例：
switch(n){
case 1 :
System.out.println("恭喜你！成绩不错！");
System.out.println("90 ~ 100");
break;
case 2 :
System.out.println("80 ~ 89");
break;
case 3 :
System.out.println("70 ~ 79");
break;
case 4 :
System.out.println("60 ~ 69");
break;
case 5 :
System.out.println("0 ~ 59");
System.out.println("不及格，要加油咯");
break;
default :
System.out.println("输入错误");
break;
}
补充：
博主刚刚发现了switch的新用法。
public static String luoMaGet(int index){
/*String[] str={"","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
return str[index];
*/
//通过->的方式，可以进行选择数值而非语句，在jdk12以后可以直接将switch语句的结果赋值给变量,此种写法相当于一条赋值语句，需要在结尾加分号。
String str=switch (index){
case '1'->"";
case '2'->"";
default -> "";
};
return str;
}3、循环结构
1、while循环
用法：
while（条件判断）{
循环语句;
步进语句; 如：i++;
}
2、do while循环
在执行的时候先执行一遍再进行判断，因而即使不满足条件也至少需要运行一次。
用法：
do{
循环体;
步进语句;
}while(条件判断表达式);
3、for循环（最常用）
确定循环次数时使用。
用法：
for（i=0;i<n;i++）{
语句;
}
public class 找质数 {
public static void main(String[] args) {
int count = 0;
for (int i = 101; i <= 200; i++) {
boolean flag = true;
for (int j = 2; j < i; j++) {
if (i % j == 0) {
flag = false;
break;
}
}
if (flag) {
System.out.println(i + " " + "yes");
count++;
} else {
System.out.println(i + " " + "no");
}
}
System.out.println(count);
}
}
4、for的增强用法
面对实际开发时，我们有时候会遇到一种情况：我们需要进行条件判断，满足条件才让其++。传统的fori无法满足这种需求，因此我们需要小小的改变一下思路。
for(i=0;i<n){
判断{
语句;
i++;
}
}
五、方法的定义和调用
1、方法的定义
修饰符 返回值类型（没有返回值为void）方法名（参数类型 参数名）{
方法体;
return 返回值;
}
具体解释：
（1）修饰符可以有public static final等。
（2）返回值void为空，不需要return。
（3）参数类型包括形参和实参 实参表示实际传来的数据 形参表示方法接受外界的数据
2、方法的调用
int max=getMax(arr[]); （从数组中获得最大值）
import java.util.Scanner;
public class 评委打分 {
public static void main(String[] args) {
int[] scoreArr = getScores();
int max=getMax(scoreArr);
int min=getMin(scoreArr);
int sum=getSum(scoreArr);
int avg=(sum-max-min)/(scoreArr.length-2);
System.out.println(avg);
}
public static int[] getScores() {
int[] scores = new int[6];
Scanner sc = new Scanner(System.in);
for (int i = 0; i < scores.length; ) {
System.out.println("请输入评委的打分");
int score = sc.nextInt();
if (score >= 0 && score <= 100) {
scores[i] = score;
i++;//为了防止数组被空军
} else {
System.out.println("data illegal");
}
}
return scores;
}
public static int getMax(int[] scoreArr) {
int max=scoreArr[0];
for (int i = 1; i < scoreArr.length; i++) {
if(scoreArr[i]>max){
max=scoreArr[i];
}
}
return max;
}
public static int getMin(int[] scoreArr) {
int min =scoreArr[0];
for (int i = 1; i < scoreArr.length; i++) {
if(scoreArr[i]< min){
min =scoreArr[i];
}
}
return min;
}
public static int getSum(int[] scoreArr){
int sum=0;
for (int i = 0; i < scoreArr.length; i++) {
sum+=scoreArr[i];
}
return sum;
}
}3、方法的重载
Java为了方便开发者使用，引入了重载的概念。简单来说就是方法名相同，但是方法内包含的参数类型，或者参数类型的先后顺序不同，和返回值无关。
方法重载的规则：
（1）方法名必须相同。
（2）参数名必须不同（个数不同，数据类型不同，排列顺序不同）
六、数组（引用数据类型）
1、一维数组
1、一维数组的定义
数组是一个存储数据的容器，可以用来存储多个数据，就像是一个酒店，其中数据就是住在一个个房间里的客人，数组的索引对应的则是酒店房间的门牌号。
2、一维数组的特点
（1）数组是一种引用类型数据，调用数组时在堆区开辟一片空间，在对数组修改时我们需要先通过地址找到在堆区的数组再进行修改。
思考：如果把一个数组直接==给一个变量得到的是什么？ 答案：一个地址。
思考：如果通过一个变量改变了数组，用另一个存储相同地址的变量去查看数组是否会发生变化？ 答案：会。
（2）数组中存储的多个数据的数据类型相同。
3、创建数组：动态/静态
（1）静态创建方法：
格式：数据类型[] 数组名称=new 数据类型[]{数据1，数据2，数据3......}
例：int[] arr=new int[]{1,2,3,4,5};
简写可以表示为 int[] arr={1,2,3,4,5};
（2）动态创建方法：
格式：数据类型[] 数组名称=new 数据类型[]{数组长度};
例：int[] arr=new int[]{6};
4、数组的打印和输出
借用fori按照数组下标依次打印和赋值
public class 数组元素的复制 {
public static void main(String[] args) {
int arr[]={1,2,3,4,5,6};
int arr1[]=new int[arr.length];
for (int i = 0; i < arr.length; i++) {
arr1[i]=arr[i];
}
for (int i = 0; i < arr1.length; i++) {
System.out.println(arr1[i]);
}
}
}2、二维数组
二维数组相当于在数组里又嵌套了一个数组，在每个数组的存储单元里存放了一个新数组的地址。主要应用于数据的分组管理。
1、二维数组的静态初始化
public class 二维数组静态初始化 {
public static void main(String[] args) {
int[][] arr={{1,2,3},{3,4,5,6}};
for (int i = 0; i < arr.length; i++) {
for (int i1 = 0; i1 < arr[i].length; i1++) {
System.out.print(arr[i][i1]+" ");
}
System.out.println();
}
}
}2、二维数组的动态初始化
public class 二维数组动态初始化 {
public static void main(String[] args) {
int[][] arr={
{22,44,66},
{77,45,67},
{23,4,55}
};
//数据分组管理时使用
int sum=0;
for (int i = 0; i < arr.length; i++) {
int[] jidu=arr[i];
int sum1=getSum(jidu);
System.out.println(sum1);
sum+=sum1;
}
System.out.println(sum);
}
public static int getSum(int[] arr){
int sum=0;
for (int i = 0; i < arr.length; i++) {
sum+=arr[i];
}
return sum;
}
}七、面向对象
1、面向对象的定义
面向对象是一种编程思维，与面向过程编程不同，面向对象编程更加符合人类的思考模式。
“面向对象的方法主要是把事物给对象化，包括其属性和行为。其本质就是：以类的方式组织代码，以对象的组织封装数据”
类：可以看做图纸，比如说类->手机，包括了手机的几个要素如打电话，解锁，闹钟
对象：是一个真正的物体，用类来描述对象。
暂且跳过，正在总结。绝对不是博主懒，而是在思考怎么写好。
八、字符串
1、String概述
（1）String所在的包为java.lang.String 含有lang的包在使用时不用调包。
（2）字符串的内容是不会发生变化的，它的对象在创建后不可以被更改。
（3）String是一个类，所以String是引用数据类型。
2、创建String的两种方式
（1）直接赋值法
String name="博主好帅";
（2）new关键字法
构造方法
public String（） 创建空白字符串，不含任何内容
public String（String 字符串）根据传入的字符串，创建字符串对象
public String （char[] chs） 根据字符数组，创建字符串对象
public String（byte[] chs）根据字节数组，创建字符串对象
例子：String str=new String( );
import java.util.Scanner;
public class Stringdemo1 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String str1=sc.next();//键盘录入是借用new得到的
String str2="abc";
System.out.println(str1==str2);
}
}（3）联系与区别
（1）他们都是引用数据类型，数据都存储在堆内存。
（2）直接赋值时，会先对串池进行检查，寻找是否已经存入代存储的数据，如果找到了数据，返回该数据的地址。如果没有找到，将所存储的字符串存储在StringTable（串池）中，方便进行存取操作。
类似的，new关键字在堆内存开辟了一个新的存储空间用来存放字符串的信息，因为字符串本身是不可以修改的，所以想要对字符串进行操作就需要开辟一个新空间并对其赋值。
举个栗子：
（1）String str="博主是个大帅哥";
String str1=new String（"博主是个大帅哥"）;
str1不等于str，这是因为他们存储的是地址，进行对比时str存储在串池中，而str1存储在新开辟的空间中。
（2）String str1="博主宇宙第一帅";
String str2=“博主宇宙第一帅”；
str1等于str2，因为str2在串池中找到了想要存入的字符串，获取了目标字符串的地址，该地址和str1的地址相同。
如果想要对两个字符串进行比较，我们可以采用charAT（index）关键字来按位获取字符串的每一个字符，再进行对比，但是这样无疑是比较浪费时间和空间的。
（4）equals关键字
前文我们提到了字符串如果用简单的==来判断是判断他们的地址，实际开发过程中我们需要去对比两个字符串的内容是否相等，因此我们可以使用java内置的关键字。
s1.equals(s2); 比较两个字符串是否相等，返回值是一个boolean
s1.equalsIgnoreCase(s2);和上面的判断相同，但是忽略大小写的差异。
import java.io.OutputStream;
public class StringDemo {
public static void main(String[] args) {
String s1=new String("abc");//在堆区开辟空间
String s2="Abc";//在字符串常量池赋值，简称串池
//==号比较
//基本数据类型，比较数据值
//引用数据类型，比较地址
System.out.println(s1==s2);
boolean result1=s1.equals(s2);
System.out.println(result1);
//比较字符串对象中的内容是否相等，忽略大小写
boolean result2=s1.equalsIgnoreCase(s2);
System.out.println(result2);
}
}补充：
替换字符串中某一小段字符串
.replace（目标字符串，替换成何物）;
获取一小段字符串
.substring(开始位置m，结束位置n) ; 从m 到n-1
.substring(开始位置m);从m到结尾
注意：此截取行为并不会破坏字符串，只能将截取到的内容赋值使用。
截取的区间规则：包左不包右
获取字符串的单个字符，按照索引获得
.charAt（i）;
3、字符串基础练习
用户登陆判断
如果用户名和密码相同，返回登录成功。
import java.util.Scanner;
public class StringDemo2 {
public static void main(String[] args) {
String rightUsername="zhangsan";
String rightPassword="123456";
Scanner sc=new Scanner(System.in);
for (int i=0;i<3;i++) {
System.out.println("输入用户名");
String username=sc.next();
System.out.println("请输入密码");
String password= sc.next();
if(username.equals(rightUsername)&&password.equals(rightPassword)){
System.out.println("用户登录成功");
}else {
if(i==2){
System.out.println("账号"+username+"被锁定，请联系客服");
}else{
System.out.println("用户登录失败，用户名或密码有误,您还剩下"+(2-i)+"次机会");
}
}
}
}
}
字符串的遍历
（使用到了charAT关键字）
import java.util.Scanner;
public class 遍历字符串 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入一个字符串");
String str= sc.next();
for (int i = 0; i < str.length(); i++) {
char c=str.charAt(i);
System.out.println(c);
}
}
}统计字符次数
import java.util.Scanner;
public class 判断字符串大小写个数 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("输入一个字符串");
String str= sc.next();
int bigCount=0;
int smallCount=0;
int numberCount=0;
for (int i = 0; i < str.length(); i++) {//这里的length（）调用的是一个方法，所以需要有括号（）
char c=str.charAt(i);
if(c>='a'&&c<='z'){
smallCount++;
}else if(c>='A'&&c<='Z'){
bigCount++;
}
//此处的0和9代表字符，如果换成整数类型的0和9会在ASCALL表中查询
else if(c>='0'&&c<='9'){
numberCount++;
}
}
System.out.println(smallCount);
System.out.println(bigCount);
System.out.println(numberCount);
}
}字符串的拼接
public class 数组拼接成为字符串 {
public static void main(String[] args) {
int[] arr={1,2,3};
String str=arrToString(arr);
System.out.println(str);
}
public static String arrToString(int[] arr){
if(arr==null){
return "";
}
if(arr.length==0){
return "[]";
}
String result="[";
for (int i = 0; i < arr.length; i++) {
if(i==arr.length-1){
result+=arr[i];
}else {
result+=arr[i]+", ";
}
}
result+="]";
return result;
}
}
字符串反转
public class 字符串的反转 {
public static void main(String[] args) {
String result=reverse("abcdef");
System.out.println(result);
}
public static String reverse(String str){
String result="";
for (int i = str.length()-1; i >=0; i--) {
char c=str.charAt(i);//按照索引获取字符
result+=c;
}
return result;
}
}
字符串-数字转化为银行账单金额
import java.util.Scanner;
public class 金额转换 {
public static void main(String[] args) {
//1键盘录入一个金额
Scanner sc = new Scanner(System.in);
int money;
while (true) {
System.out.println("输入金额");
money = sc.nextInt();
if (money >= 0 && money <= 9999999) {
break;
} else {
System.out.println("金额无效");
}
}
String moneystr = "";
while (true) {
int ge = money % 10;
String capitalNumber = getCapitalNumber(ge);
moneystr = capitalNumber + moneystr;
money /= 10;
if (money == 0) {
break;
}
}
//在前面补0，补齐七位。
int count = 7 - moneystr.length();
for (int i = 0; i < count; i++) {
moneystr = "零" + moneystr;
}
//插入单位，定义一个数组表示单位
String[] arr = {"佰", "拾", "万", "仟", "佰", "拾", "元"};
//遍历moneystr，分别插入单位。
String result="";
for (int i = 0; i < moneystr.length(); i++) {
char c = moneystr.charAt(i);
result=result+c+arr[i];
}
System.out.println(result);
}
public static String getCapitalNumber(int number){
String[] arr={"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
return arr[number];
}
}字符串敏感词屏蔽
.replace（目标，替换成何物）;
public class 敏感词替换 {
public static void main(String[] args) {
//获取对方说的话
String talk = "你玩的真好，tmd不要再玩cnm了sb";
//获取一个敏感词库
String[] arr = {"tmd", "cnm", "nmlgb", "sb"};
for (int i = 0; i < arr.length; i++) {
talk = talk.replace(arr[i], "***");
}
System.out.println(talk);
}
}手机号中间四位屏蔽
.substring(开始位置m，结束位置n) ; 从m 到n-1
.substring(开始位置m);从m到结尾
注意：此截取行为并不会破坏字符串，只能将截取到的内容赋值使用。
截取的区间规则：包左不包右
public class 手机号屏蔽 {
public static void main(String[] args) {
String phoneNUmber="13072349832";
String begin=phoneNUmber.substring(0,3);
String end=phoneNUmber.substring(7);
String result=begin+"****"+end;
System.out.println(result);
}
}4、StringBuilder
（1）概述
（1）StringBuilder可以看做一个可操作的容器，创建完成之后内部的内容是可以改变的，常用于字符串的反转和拼接操作。
（2）作用：提高字符串的操作效率
（3）StringBuilder是一个类，调用后想要使用String类，需要将StringBuilder转换成String再操作。
（2）StringBuilder的一些操作
（1）增加元素
.append("");
(2)反转字符串
.reverse();
(3)转换成为String
.toString();
（4）替换某一段的字符串
.replace(start,end,String)
（3）字符串的拼接与反转
public class 字符串的拼接 {
public static void main(String[] args) {
int[] arr={1,2,3};
String result=arrToString(arr);
System.out.println(result);
}
public static String arrToString(int[] arr){
StringBuilder sb=new StringBuilder();
sb.append("[");
for (int i = 0; i < arr.length; i++) {
if (i== arr.length-1){
sb.append(arr[i]);
}else {
sb.append(arr[i]).append(", ");
}
}
sb.append("]");
return sb.toString();
}
}public class 字符串的反转 {
public static void main(String[] args) {
StringBuilder sb=new StringBulider("abcd");
String result=sb.reverse().toString();
public System.out.println(result);
}(4)判断字符串是否为对陈字符串
对陈字符串的特点是反转过后与原来的字符串相等。
import java.util.Scanner;
//String builder使用场景
//字符串的拼接 字符串的反转
public class 判断是否为对称字符串 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入一个字符串");
String str= sc.next();
/* StringBuilder sb=new StringBuilder();
sb.append(str);
sb.reverse();
String result=sb.toString();
*/
String result=new StringBuilder().append(str).reverse().toString();
if(str.equals(result)){
System.out.println("该字符串为对陈字符串");
}else{
System.out.println("不是");
}
}
}5、Stringjoiner
（1）概述
Stringjoiner 从jdk8出现，因此目前来说被应用的较少，但是作为新时代的我们应该学会这种偷懒的操作。主要用于应用于需要插入间隔符号的字符串拼接。
（2）构造方法
public Stringjoiner（间隔符号） 创建一个Stringjoiner对象，制定拼接时的间隔符号。
public Stringjoiner（间隔符号，开始符号，结束符号）与上面相同，多增加了开始和结束符号。
（3）关键字
.add("")增加元素
.tostring（）;转换为String类。
import java.util.StringJoiner;
public class joiner的使用 {
public static void main(String[] args) {
StringJoiner sj=new StringJoiner("@","=","。");
sj.add("aaa").add("asa").add("fnoanf");
String str= sj.toString();
System.out.println(sj.length());//所有字符的总个数
System.out.println(sj);
System.out.println(str);
}
}6、String的底层原理和注意事项
（1）字符串存储内存原理
（1）直接赋值会复用字符串常量池中的字符串，如果没有找到会在串池中新增字符串。
（2）new出来的字符串不会复用，而是开辟一个新的空间
（2）==号比较的是什么
（1）基础数据类型（在栈内存中创建的）比较数据值。
（2）引用数据类型比较地址。
（3）字符串拼接的底层原理
（1）如果没有变量参与，都是字符串直接相加，会触发优化机制，编译过后相当于拼接的结果，会复用字符串常量池中的内容。
（2）如果有变量参与会创建新的字符串浪费空间。
在jdk8以前的版本会调用StringBuilder辅助拼接，至少需要两个空间（new和tostring）。
在jdk8及以后的版本会预估字符串长度并且按字节组成数组，再将数组转换成字符串，同样需要至少两个空间。
（4）StringBuilder提高效率原理
（1）所拼接的内容都放入在容器内不会浪费很多空间。
（5）StringBuilder源码分析
（1）默认是一个长度为16的字节数组。
（2）默认添加的内容小于16时，可以直接存储。
（3）内容大于16时，会扩容至34（*2+2）。
（4）如果扩容还不够，以实际长度为准。
九、集合
增 boolean add(E e)添加元素，返回布尔值表示是否添加成功。
删 boolean remove(E e)删除指定元素，返回值表示是否删除成功。 E remove（int index） 删除指定索引的元素，返回被删除的元素。
改 E set（int index，E e）根据指定索引修改元素，返回被修改的元素。 E get（int index）获取制定索引的元素。
查 int size（）返回集合的长度，也就是集合中元素的个数
<>指泛型，集合内只能存储引用数据类型。
import java.util.ArrayList;
public class 创建集合并且遍历 {
public static void main(String[] args) {
ArrayList<String> list=new ArrayList<>();
list.add("anc");
list.add("vevw");
list.add("aeecv");
list.add("afqfa");
System.out.print("[");
for (int i = 0; i < list.size(); i++) {
if(i==list.size()-1){
//是最后一个
System.out.print(list.get(i));
}else {
System.out.print(list.get(i)+",");
}
}
System.out.println("]");
}
}
总结
Java是一门超好用的语言，大家快来一起学习吧！
以上就是今天要讲的内容，本文仅仅简单介绍了Java的基础内容，更多的Java进阶知识博主会边学习边整理，欢迎大家指正错误！！！
6924
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
