常用类（更新ing）
字符串相关类
String类
Java.lang.String类代表不可变的字符序列
“XXXX”为该类的一个对象
常见的构造方法
public class Test1 {
public static void main(String[] args) {
String s1 = "hello";
String s2 = "world";
String s3 = "hello";
System.out.println(s1 == s3); //true
s1 = new String ("hello");
s2 = new String ("hello");
System.out.println(s1==s2); //false
System.out.println(s1.equals(s2)); //true
char c[]= {'s','u','n',' ','j','a','v','a'};
String s4 = new String(c);
String s5 = new String(c,4,4);
System.out.println(s4); //sun java
System.out.println(s5); //java
}
}
public class Test1 {
public static void main(String[] args) {
String s1 = "sun java";
String s2 = "Sun Java";
System.out.println(s1.charAt(1)); //u
System.out.println(s2.length());//8
System.out.println(s1.indexOf("java")); //4
System.out.println(s1.indexOf("Java")); //-1
System.out.println(s1.equals(s2)); //false
System.out.println(s1.equalsIgnoreCase(s2)); //true
String sr = s1.replace('j', 'J');
System.out.println(sr);
}
}
public class Test1 {
public static void main(String[] args) {
String s = "Welcome to Java World!";
String s1 = " sun java ";
System.out.println(s.startsWith("Welcome")); //true
System.out.println(s.endsWith("World")); //false
String sL = s.toLowerCase();
String sU = s.toUpperCase();
System.out.println(sL);
System.out.println(sU);
String subS = s.substring(11);
System.out.println(subS);
String sp = s1.trim();
System.out.println(sp);
}
}
静态重载方法
public static String valueOf(...)可以将基本类型数据转化为字符串；
eg: public static String valueOf(double d)
public static String valueOf(int i);
public String[] split(String regex)可以将一个字符串按照指定的分隔符分隔，然后返回分隔后的字符串数组。
public class Test1 {
public static void main(String[] args) {
int j = 1234567;
String sNumber = String.valueOf(j);
System.out.println("j 是" + sNumber.length()+"位数");
String s = "Mary,F,1976";
String[] sPlit = s.split(",");
for(int i = 0;i<sPlit.length;i++) {
System.out.println(sPlit[i]);
}
}
}
StringBuffer 类和StringBuilder类
可变的字符序列
String一旦被定义，就不可以被改变，s1+=s2是另外开辟了一片内容，s1,s2拷贝到新的内存中，效率低。
StringBuffer类，可变的，可以直接在后面开辟内存。
常用方法：
重载方法public StringBuffer append(...)可以为该StringBuffer对象添加字符序列，返回添加后的该StringBuffer对象引用。
重载方法public StringBuffer insert(...)可以为该StringBuffer对象在指定位置插入字符序列，返回修改后的该StringBuffer对象引用。
方法public StringBuffer delete(int start,int end)可以删除从start到end-1的一段字符串
方法public StringBuffer reverse()用于将字符序列逆序，返回修改后的该StringBuffer对象
【当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。
和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。
StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。
由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。】
---------------------
作者：Chin_style
来源：****
原文：https://blog.****.net/weixin_41101173/article/details/79677982
版权声明：本文为博主原创文章，转载请附上博文链接！
基本数据类型包装类
基本数据类型是不具备对象的特性的，比如基本类型不能调用方法、功能简单。。。，为了让基本数据类型也具备对象的特性， Java 为每个基本数据类型都提供了一个包装类，这样我们就可以像操作对象那样来操作基本数据类型。
包装类（如：Integer，Double等）这些类封装了一个相应的基本数据类型数值，并为其提供了一系列操作。
以Java.lang.Integer类为例：构造方法
public class Test1 {
public static void main(String[] args) {
Integer i = new Integer(100);
Double d = new Double("123.456");
int j = i.intValue() + d.intValue();
float f = i.floatValue()+d.floatValue();
System.out.println(j + " " + f);
double pi = Double.parseDouble("3.1415926");
double r = Double.valueOf("2.0").doubleValue();
double s = pi*r*r;
System.out.println(s);
try {
int k = Integer.parseInt("1.25");
}catch (NumberFormatException e) {
System.out.println("数据格式不对");
}
System.out.println(Integer.toBinaryString(123)+"B");
System.out.println(Integer.toHexString(123)+"H");
System.out.println(Integer.toOctalString(123)+"O");
}
}
Java 中基本类型和包装类之间的转换
自动装箱和拆箱的机制，包装类和基本类型之间可以轻松转换
装箱：把基本类型转换成包装类，使其具有对象的性质，又可分为手动装箱和自动装箱
拆箱：把包装类对象转换成基本类型的值，又可分为手动拆箱和自动拆箱
Math类
public class Test1 {
public static void main(String[] args) {
double a = Math.random();
double b = Math.random();
System.out.println(a +" "+ b);
System.out.println(Math.sqrt(a*a+b*b));
System.out.println(Math.pow(a, 8));
System.out.println(Math.round(b));
System.out.println(Math.log(Math.pow(a, b)Math.E, 15));
double d = 60.0, r=Math.PI/4;
System.out.println(Math.toRadians(d));
System.out.println(Math.toDegrees(r));
}
}
File类
java.io.File类用于表示文件（目录）
File类只用于表示文件（目录）的信息（名称，大小等），不能用于文件内容的访问
代表系统文件名（路径和文件名）
File类的常见构造方法：
public File(String pathname)
以pathname为路径创建File对象，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储
public File(String parent,String child)
以parent为父路径，child为子路径创建file对象
File的静态属性string separator存储了当前系统的路径分隔符
package com.imooc.collection;
import java.io.File;
public class testFile {
public static void main(String args[]) {
//创建或删除目录
File file = new File("D:\\A");
if(!file.exists())
file.mkdirs();
else
file.delete();
//是否是一个目录
System.out.println(file.isDirectory());
}
}
//以树状结构展现特定的文件夹及其子文件
import java.io.*;
public class FileList {
public static void main(String[] args) {
File f = new File("d:/A");
tree(f);
}
private static void tree(File f) {
File[] childs = f.listFiles();
for(int i=0;i<childs.length;i++) {
System.out.println(childs[i].getName());
if(childs[i].isDirectory())
tree(childs[i]);
}
}
}
RandomAccessFile java提供的对文件内容的访问，既可以读文件也可以写文件。
RandomAccessFile支持随机访问文件，可以访问文件的任意位置
(1)Java文件模型
在硬盘上的文件是byte存储的，是数据的集合
(2)打开文件
有两种模式“rw"”r"
RandomAccessFile raf = new RandomAccessFile(file,"rw“)
文件指针，打开文件时指针在开头 pointer = 0;
(3)写方法
raf.write(int)--->只写一个字节（后8bit),同时指针指向下一个位置，准备重新写入
(4)读方法
int b = raf.read()------>读一个字节
(5)文件读写完成之后一定要关闭
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.Arrays;
public class rafDemo {
public static void main(String[] args) throws IOException {
File demo = new File("demo");
if(!demo.exists())
demo.mkdir();
File file = new File(demo,"raf.dat");
if(!file.exists())
file.createNewFile();
RandomAccessFile raf = new RandomAccessFile(file,"rw");
//指针的位置
System.out.println(raf.getFilePointer());
raf.write('A'); //一次只写A的后八位
System.out.println(raf.getFilePointer());
raf.write('B');
int i = 0x7fffffff;
//每次只写一个字节，写8次
raf.write(i >>>24); //高八位
raf.write(i >>> 16);
raf.write(i >>> 8);
raf.write(i);
System.out.println(raf.getFilePointer());
//可以直接写一个int
raf.writeInt(i);
String s = "中";
byte[] gbk = s.getBytes("gbk");
raf.write(gbk);
System.out.println(raf.length());
//读文件，必须把指针移到头部
raf.seek(0);
//一次性读取,把文件内容读到字节数组中
byte[] buf = new byte[(int)raf.length()];
raf.read(buf);
System.out.println(Arrays.toString(buf));
raf.close();
}
}
枚举类
public class TestEnum {
public enum MyColor{ red, green, blue }; //与c不同，不能与0，1，对应和替换
public static void main(String[] args) {
MyColor m = MyColor.red;
switch(m) {
case red:
System.out.println("red");
break;
case green:
System.out.println("green");
break;
case blue:
System.out.println("blue");
break;
default:
System.out.println("XX");
}
System.out.println(m);
}
}
Date 和 SimpleDateFormat 类
在程序开发中，经常需要处理日期和时间的相关数据，此时我们可以使用 java.util 包中的 Date 类。这个类最主要的作用就是获取当前时间，我们来看下 Date 类的使用：
使用Date类的默认无参构造方法创建出的对象就代表当前时间，我们可以直接输出Date对象显示当前的事件
若想按指定格式输出，就需要SimpleDateFormat
1. 使用 format() 方法将日期转换为指定格式的文本
yyyy-MM-dd HH:mm:ss” 为预定义字符串， yyyy 表示四位年， MM 表示两位月份， dd 表示两位日期， HH 表示小时(使用24小时制)， mm 表示分钟， ss 表示秒，这样就指定了转换的目标格式，最后调用 format() 方法将时间转换为指定的格式的字符串。
2. 使用 parse() 方法将文本转换为日期
代码中的 “yyyy年MM月dd日 HH:mm:ss” 指定了字符串的日期格式，调用 parse() 方法将文本转换为日期。
package com.imooc.test;
import java.util.*;
import java.text.*;
public class TestDate {
public static void main(String[] args) {
Date d = new Date();
System.out.println(d);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String today = sdf.format(d);
System.out.println(today);
String day = "2018年10月20日 11:10:10";
SimpleDateFormat df = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
Date date = null;
try {
date = df.parse(day);
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("当前时间:"+ date);
}
}
1、 调用 SimpleDateFormat 对象的 parse() 方法时可能会出现转换异常，即 ParseException ，因此需要进行异常处理
2、 使用 Date 类时需要导入 java.util 包，使用 SimpleDateFormat 时需要导入 java.text 包
Calendar类的应用
Date 类最主要的作用就是获得当前时间，同时这个类里面也具有设置时间以及一些其他的功能，但是由于本身设计的问题，这些方法却遭到众多批评，不建议使用，更推荐使用 Calendar 类进行时间和日期的处理。
java.util.Calendar 类是一个抽象类，可以通过调用 getInstance() 静态方法获取一个 Calendar 对象，此对象已由当前日期时间初始化，即默认代表当前时间，如 Calendar c = Calendar.getInstance();
其中，调用Calendar类的getInstance()方法获取一个实例，然后通过调用get()方法获取日期时间信息，参数为需要获得的字段的值
Calendar类还提供了getTime()方法，用来获取Date对象，完成Calendar和Date的转换，还可以通过getTimeInMillis()方法，获得以毫秒为单位的时间