JAVA注释、字符串类型

Java应用的注释:

一般按照软件工程的要求20%以上的代码量是注释说明，这是合理的。但是实际开发中并没有人写这么多的注释说明，一定要注意不写注释是不合理的

注释的语法:

//开头的整句就是一个单行注释
以/*开头，以*/收尾的多行注释
以/**开头，以*/收尾的文档注释，可以使用javadoc命令生成页面格式的文档说明

系统预定义类

Java 5添加了java.util.Scanner类，这是一个用于扫描输入文本的新的实用程序。

nextInt()只读取int值，就是只能读取整数类型的数据，如果输入了非整型的数据（浮点型字符串等）就会报错。nextFloat、nextDouble这些也是以此类推，只能读取符合该类型的数据。

Scanner sc=new Scanner(System.in);//可以理解为获取标准输入设备的引用，用于接受用户的键盘录入
//为了针对用户优化，所以一般输入之前需要对用户进行提示
System.out.println("您的年龄是多少岁? ");//在控制台上输出提示信息
int age=sc.nextInt();//这里需要接收一个int类型的数据，如果不能转为int类型，则java.uti1.InputMismatchException
System.out.println("年龄:"+age);

注意在class类定义的上方应该添加import java.util.scanner;

System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包。注意，system类不能手动创建对象。
system中包含了in、out和err三个成员变量，分别代表标准输入流（键盘输入)、标准输出流(显示器）和标准错误输出流（显示器)
currentTimeMillis()获取系统当前毫秒值，获取当前系统时间与1970年01月01日00:00点之前的毫秒差值

public class Test2 {
	public static void main(string[] args) {
	long start = System.currentTimeMi77is();//获取代码运行到这里的时间，这个时间是从1970-1-1 0:0:0到当前时间的毫秒值
//经常用于统计某段代码的执行时间
        
//输出99乘法口诀表
	for (int i = 1; i < 10; i++) {
		for (int k = 1; k <= i; k++) {
			System.out.print(k + "☆”+ i + "=” +(i * k) + "\t");
			// print1n表示输出完成后自动换行,print输出完成后不会换行
		}
	System. out.print1n();
}
	long end =system.currentTimeMillis() ;
	System.out.println("代码执行时间为:" + (end - start) + "ms");
}

​ getProperties()确定当前的系统属性system.getProperties().list(system.out);，如果需要了解其中含义，可以使用百度查询
​ exit()退出虚拟机。exit(int)方法是终止当前正在运行的java虚拟机。参数是状态码。根据惯例非0的状态码表示异常终止，O表是终止。而且，该方法永远不会正常返回。
​ arraycopy(Object src, int srcPos, Object dest, int destPos, int length)可以调用当前操作系统来实现数组拷贝，用来实现将源数组部分元素复制到目标数组的指定位置
​ Object src:要复制的原数组
​ int srcPos:数组源的起始索引

​ Object dest:复制后的目标数组

​ int destPos:目标数组起始索引

​ int length，指定复制的长度;

int[] arr1=new int[10];
//数组中每个元素都有默认值，如果元素是简单数值类型则0, boolean为fa1se，字符'\O'
	for(int i=o ; i<arr1.length;i++)
	System.out.print(arr1[i]+"\t");
System.out.println();
//针对数组填充一组随机值
for(int i=o ; i<arr1.length;i++){
int num=(int)(Math.random() *100);//生成0-100之间的随机数
    arr1[i]=num;
}
for(int i=o ; i<arr1.1ength;i++)
		 System.out.print(arr1[i]+"\t");	
		 System.out.println(;
int[] arr2=new int[30];
System.arraycopy(arr1，0，arr2，5，arr1.length);
    for(int i=0 ; i<arr2 .length; i++)
		System.out.print(arr2[i]+"\t");

冒泡排序

Java提供了7种常见的排序方法:冒泡、插入、选择、快速、希尔、归并和堆衡量一固排序算法的相開圈性:时间复杂度、空间复杂度、稳定性

public class Test6 {
	public static void main(string[] args） {
	int[] arr1 = generateArray(10);
	showArray(arr1);
	bubblesort(arr1);
	showArray(arr1);
}
//使用冒泡排序封数撼魋行原地排序
                            /*
*畤間祯F度o(n**2)空間褛雄度o(1)不鲁交换相等值的位置，所以算法是稳定的*/
public static void bubb1esort(int[] arr) {
	for (int i = 1; i < arr.length; i++) { // 9
		for (int k = 0; k < arr.length - i; k++) {
			if (arr[k] > arr[k + 1]) {
				int tmp = arr[k];
                  arr[k] = arr[k + 1];
                  arr[k + 1] = tmp;
			}
		}
	}
}
//生成一个指定长度的包含随机数的数组
public static int[] generateArray(int len) {
	int[] res = new int[len];
	for (int i = 0; i < 1en;i++) {
		int num = (int) (Math.random() *100);
        res[i] = num;
	}
	return res;
}
//显示数组内容
public static void showArray(int[] arr) {
	for (int i = 0; i < arr.length; i++)
	System.out.print(arr[i] + "\t");
    System.out.println(;
}

字符串类型

字符：简单类型String,标准格式为单引号

字符串：复合类型String,标准格式为双引号

在Java中字符串属于对象，Java提供了String类来创建和操作字符串。当对字符串进行频繁修改的时候，需要使用StringBuffer和StringBuilder类。和String类不同的是，StringBuffer和StringBuilder类的对象能够被多次的修改，并且不产生新的未使用对象。

String、StringBuffer、StringBuilder

string s1="ab"+"c";
string s2="abc ";
System.out.println(s1==s2);//true

字符串常量拼接，在方法区的常量池中完成

string s0="ab" ;
string s1=s0+"c";
string s2="abc ";
System.out.println(s1==s2); //false

注意: String类是不可改变的，所以你一旦创建了String对象，那它的值就无法改变了。如果修改String种的内容则会导致对象的新建

String类型的拼接是通过StringBuilder类中的append方法实现的，然后返回toString的结果。是在堆中的新对象

//String类型的基本使用public class Test2 {
public static void main(string[] args) {
	String s1="ab中c";//定义变量，String一般用于字符串常量，如果修改内容则会导致对象的新建
//获取字符串种的字符个数
int len=s1.length();//字符串中的1ength是一个方法，数组中的1ength是一个属性
	System.out.println(len);//获取指定下标位置上的字符
    for(int i=0;i<len;i++) {
	char cc=s1.charAt(i);
    System.out.println(cc);
}
//字符串拼接
		Strings2=s1+"123";
    System.out.println(s2);
    s2=s1.concat(s2);
	System.out.println(s2);
	s2+="ddd";
	System.out.println(s2);
//查询子字符串的位置
	s1="abcdefabdasdfasab" ;//从左向右查询
	int pos1=s1.indexof("ab");
System.out.println(pos1);
	//从左向右查询，从指定的下标位置开始
    pos1=s1.indexof("ab",2);
	System.out.println(pos1) ;
	//从右向左查询
int pos2=s1.1astIndexof("ab");
    System.out.println(pos2);
	pos2=s1.1astIndexof("ab",13);
    System.out.println(pos2);
//获取字符串中的一部分内容:子字符串
	String s3=s1.substring(3);//从指定下标开始到字符串末尾的全部内容
    System.out.println(s3);
s3=s1.substring(3,6);//从指定下标开始到指定下表结束，这两个位置之间的内容，含左不含右
System. out.print1n(s3);
//字符串内容替换
	s1="abcdefabdasdfasab";
	s2=s1.replace("ab"，"3s3");//将字符串中指定的子字符串替换为新内容
    System.out.println(s2);
//使用指定的字符将字符串分割为字符串数组【实际上是正则式】
    s1="sad ,fasdf, sadfsaf,safsa,dfsvx , vx";
	String[] arr=s1.split(", ");
	for(int i=0;i<arr.length;i++)
		System.out.println(arr[i]);
}

String和StringBuffer的基本用法

/*
*string一般用于常量字符串，如果需要频繁修改则可以使用stringBuilder或stringBuffer*/
public class Test3 {
	public static void main(string[] args) {
//构建对象
StringBuilder sb1=new stringBui1derO;
StringBuffer sb2=new stringBuffer("abcd");
//拼接字符串
		sb2.append("123");//在字符串末尾拼接
        System.out.println(sb2);
		sb2.insert(1，"rst");//在指定下标位置上插入字符串
        System.out.println(sb2);
		sb2.delete(1，3);//删除指定位置上的内容start=1,end=3
        System.out.println(sb2);
		sb2.deletecharAt(1);//只删除指定下标上的字符
        System.out.println(sb2);
		sb2.replace(1,2，"新的内容");//将指定下标位置上的内容替换为新内容
        System.out.println(sb2);
//反转字符串
		sb2.reverse();
		System.out.println(sb2);
//获取字符个数
		int len=sb2 .length(;system.out.println(len) ;
//查找位置
		int pos=sb2 .indexof("容内");                     							System.out.println(pos);
//其余方法基本和string一致
		String s1=sb2.substring(pos);
       	System.out.println(s1);
	}
}

数据类型转换
String–Integer或者其他类型，基本语法:包装类名称.parsexxX

String s1="123";
int kk=Integer.parseInt(s1);//返回值intsystem.out.print7n(kk+1);
int k2=Integer.valueOf(s1);//返回值Integer,自动拆箱system. out-print1n(k2+10) ;

Integer或者简单类型或者其它数据类型—String

int kk=123;
String ss=""+kk;//自动转换

特殊方法: String类使用静态方法format()返回一个String对象，是用来创建可复用的格式化字符串最常见的格式符号:浮点数%f、整型%d、字符串%s，特殊符号不用记忆临时查

String s1="这是一个用于测试的模板，其中整数值为%d ,八进制为%o";
System.out.println(String.format(s1,123,123));//替代规则为位置对应,具体的数据应该和特殊符号%x对应

特殊方法:

String ss=nu11;
//字符串的判空處理
//trim方法的含義是去掉字符串前後兩端的空格
if(ss==nu11 | ss.trim(.1ength()<1) {
System. out. println("字符串内容為空!");
}
///判斷相等的推薦寫法
String ss=nu11;
//如果使用普通方法進行判斷ss . equals("bbb")時會出現異常中斷，使用objects . equals可以
避免空指針異常
if(objects. equals(ss，"bbb")) {
System.out.println("字符串内容為bbb");
}

可变与不可变

​ String类中使用字符数组保存字符串，如下就是，因为有"final”修饰符, 所以可以知道string对象是
不可变的。private final char value[ ];
​ StringBuilder 与StringBuffer都继承自AbstractStringBuilder类,在AbstractStringBuilder中也是
使用字符数组保存字符串，可知这两种对象都是可变的。char[] value;

是否多线程安全

​ String中的对象是不可变的，也就可以理解为常量,显然线程安全。
​ AbstractStringBuilder是StringBuilder与StringBuffer的公共父类, 定义了一-些字符串的基本操
作,如expandCapacity. append. insert、 indexOf等公共方法。
​ StringBuffer对方法加了同步 锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder
并没有对方法进行加同步锁，所以是非线程安全的。

StringBuilder与StringBuffer共同点

​ StringBuilder与StringBuffer有 公共父类AbstractStringBuilder抽象类。抽象类与接口的其中-个
区别是:抽象类中可以定义- -些子类的公共方法，子类只需要增加新的功能，不需要重复写已经存
在的方法;而接口中只是对方法的申明和常量的定义。
​ StringBuilder. StringBuffer的方法都会调用AbstractStringBuilder中的公共方法, 如
super.aepn…].只是StringBuffer会在方法 上加synchronized关键字,进行同步。

如果程序不是多线程的，那么使用StringBuilder效率高于 StringBuffer

包装类

java并不是纯面向对象的语言，java语言是一个面向对象的语言，但是java中的基本数据类型却不是面向对象的，但是我们在实际使用中经常将基本数据类型转换成对象，为了使用java封装好的方法，以便于操作。例如获取int的最大值或者最小值Integer.MAX_VALUE或Integer.MIN_VALUE

Java中支持自动装拆箱操作，可以自动在简单类型和包装类型之间进行转换

8种简单类型及其包装类
byte----Byte short–Short int—Integer long–Long

​ float—Float double—Double
​ boolean—Boolean
​ char—Character

int kk = 123;
Integer k2=kk;//自动装箱
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
System.out.println(k2.toString();//将Intger转换为string类型
String s1=Integer.toBinarystring(123);//十进制转二进制
String s2=Integer.toocta1string(123);//十进制转八进制
String s3=Integer.toHexstring(123);//十进制转十六进制
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
int k3=k2 ;//自动拆箱

日期类型

java.util包提供了Date类来封装当前的日期和时间
Date: getTime()、 setTime()

Date now=new DateO;//横建一佃日期封象，默韶封装系縯富前畤system.out.print1n(now) ;
/指定年月日构建日期对象，需要注意参数规则
Date d1=new Date(2000-1900,2-1,3);//参数分别是year、month、date，注意传入年-1900,月份-1
System.out.println(d1);
//日期类型对象中并不是直接封装年月日具体值，而是存储了一个1970-1-1 0:0:0到指定日期的毫秒值
long 11=now.getTime(;//获取毫秒值system.out.print1n(11);
//日期中的减法now-d1;
long s1=now.getTime(-d1.getTime(;/两个日期之间的天数差
System.out.println(s1/1000/60/60/24);
//日期对象中提供了获取年月日时分秒的方法
System.out.println(now.getYear()+1900);//年份
                               System.out.println(now. getMonth()+1);//月份
                                System.out.println(now.getDate(();//日期
System.out.println(now.getDay();//星期
System.out.println(now. getHours();//小时
                   System.out.println(now.getMinutes());//分钟
                   System.out.println(now.getseconds();//秒

​ DateFormat: getInstance()、 getDateInstance()、getDateTimelnstance()、 getTimeInstance()

​ SimpleDateFormate: formate(Date)、parse(String s)

Date now = new Date(); 
DateFormat df=new simp1eDateFormat("yyyy年MM月d日E hh点mm分ss秒");
       //自定义日期的格式
//将日期頫型数掾按照指定格式聘换刹字符串
      String s1=df.format(now) ;
System.out.println(s1);//2021年11月7日周日11点54分21秒
//将字符串按照指定的格式解析急日期頫型
try {
//可能鲁出现畏常，必须选行虚理Date 
    dd=df.parse(s1);
    System.out.println(dd);
}catch (ParseException e) {
	e.printstackTrace();
}

​ Calendar: getInstance()、set(). get()、add()、gettime()、 setTime(Date)
java.util.Date是java.sqlDate,Time,Timestamp的父类，Java中的时间使用标准类库的java.util.Date,其表示特定的瞬间，精确到毫秒。是用距离一个固定时间点的毫秒数（可正可负，long类型)表达一个特定的时间点。从JDK 1.1开始，应该使用Calendar类实现日期和时间字段之间转换，使用DateFormat类来格式化和分析日期字符串。因为Date的设计具有"千年虫"“以及”"时区"的问题，所以Date中的大部分方法已经不建议使用了，它们都被java.util.Calendar类所取代

DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并分析日期或时间。日期/时间格式化子类(如SimpleDateFormat)允许进行格式化(日期→文本)、分析(文本→>日期)和标准化。将日期表示为Date对象，或者表示为从GMT(格林尼治标准时间)1970年1月1日00:00:00这一刻开始的毫秒数。不过DateFormat的格式化Date的功能有限，没有SimpleDateFormat强大;但DateFormat是SimpleDateFormat的父类。

SimpleDateFormat是一个以与语言环境相关的方式来格式化和分析日期的具体类。SimpleDateFormat使得可以选择任何用户定义的日期-时间格式的模式。但是，仍然建议通过DateFormat 中的
getTimelnstance、getDateInstance或getDateTimelnstance来新的创建日期-时间格式化程序。

​将Date格式化为String	String format(Date d)
将String解析为Date	Date parse(String s)

java.util.Calendar类用于封装日历信息，其主要作用在于其方法可以对时间分量进行运算。Calendar类是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH、HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期)提供了一些方法。瞬间可用毫秒值来表示，它是距历元（即格林威治标准时间1970年1月1日的O0:00:00.000，格里高利历)的偏移量。与其他语言环境敏感类一样，Calendar提供了一个类方法getInstance，以获得此类型的一个通用的对象。Calendar的getInstance方法返回一个Calendar对象，其日历字段已由当前日期和时间初始化。
Calendar.getInstance().getTime()即可获取一个Date对象
Calendar.getInstance().add(时间的一个部分，正数代表加，负数代表减)

​ 获取当前时间的前一年时间

//根据现在时间计算
calendar now = calendar. getInstance();
now.add(calendar.YEAR，1);//现在时间是1年后

now.add(calendar.YEAR,-1);//现在时间是1年前
//根据某个特定的时间date (Date型)计算
calendar specia1Date = calendar.getInstance(;
specialDate.setTime(new Date();//注意在此处将 specialDate 的值改为特定日期
specialDate.add(calendar.YEAR,1);//特定时间的1年后
specialDate.add(calendar.YEAR,-1);//特定时间的1年前