Java应用的注释:

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

注释的语法:

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

系统预定义类

Java 5添加了java.util.Scanner类，这是一个用于扫描输入文本的新的实用程序。
nextInt()只读取int值，就是只能读取整数类型的数据，如果输入了非整型的数据（浮点型、字符串等）就会报错。nextFloat、nextDouble这些也是以此类推，只能读取符合该类型的数据。

Scanner sc=new Scanner(System.in);//可以理解为获取标准输入设备的引用，用于接受用户的键盘录入
//为了针对用户优化，所以一般输入之前需要对用户进行提示
System.out.print1n("请问您的年龄是多少岁? ");//在控制台上输出提示信息
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 static void main(string[] args) {
long start = System.currentTimeMillis();//获取代码运行到这里的时间，这个时间是从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[] arr=new int[10];
//数组中每个元素都有默认值，如果元素是简单数值类型则0, boolean为fa1se，字符'\O'for(int i=0 ; i<arr.length;i++)System.out.print(arr[i]+"\t");
System.out.println();
//针对数组填充一组随机值
for(int i=0 ; i<arr.length;i++){
int num=(int)(Math.random() *100);//生成0-100之间的随机数arr[i]=num;
}
for(int i=0 ; i<arr.length;i++)System.out.print(arr[i]+"\t");	System.out.print1n(;
int[] arr1=new int[30];
System.arraycopy(arr，0，arr1，5，arr.length);for(int i=0 ; i<arr1 .length; i++)System.out.print(arr1[i]+"\t");

排序方式

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

冒泡排序

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++) { // 9for (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.print1n(;
}

字符串类型

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

字符串：复合类型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.print1n(s1==s2); //false

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

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

String类型的基本使用

//String类型的基本使用
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.print1n(s2);s2+="ddd";System.out.println(s2);
//查询子字符串的位置s1="abcdefabdasdfasab" ;//从左向右查询int pos1=s1.indexof("ab");System.out.print1n(pos1);//从左向右查询，从指定的下标位置开始pos1=s1.indexof("ab",2);System.out.print1n(pos1) ;//从右向左查询int pos2=s1.1astIndexof("ab");System.out.print1n(pos2);pos2=s1.1astIndexof("ab",13);system.out.print1n(pos2);
//获取字符串中的一部分内容:子字符串String s3=s1.substring(3);//从指定下标开始到字符串末尾的全部内容System.out.print1n(s3);s3=s1.substring(3,6);//从指定下标开始到指定下表结束，这两个位置之间的内容，含左不含右System. out.print1n(s3);
//字符串内容替换s1="abcdefabdasdfasab";s2=s1.replace("ab"，"3s3");//将字符串中指定的子字符串替换为新内容System.out.print1n(s2);
//使用指定的字符将字符串分割为字符串数组【实际上是正则式】s1="sad ,fasdf, sadfsaf,safsa,dfsvx , vx";String[] arr=s1.split(", ");for(int i=0;i<arr.length;i++)System.out.print1n(arr[i]);
}

String和StringBuffer的基本用法

/*
*string一般用于常量字符串，如果需要频繁修改则可以使用stringBuilder或stringBuffer*/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=3System.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.print1n(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. print1n("字符串内容为空!");
}
///判断相等的推广算法
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 = 108;
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日的00: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年前

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！